พื้นหลัง

ฉันมีแม่เหล็กที่ทรงพลังหนึ่งแถวและวัตถุโลหะหลายอันที่อยู่ระหว่างพวกมัน แม่เหล็กจะดึงมันไว้ที่ไหน

อินพุต

ข้อมูลที่คุณป้อนเป็นจำนวนเต็มจำนวนเต็มที่ไม่เป็นลบซึ่งจะมีอย่างน้อยหนึ่ง1รายการ คุณสามารถใช้รูปแบบที่เหมาะสม

0ของอาร์เรย์แทนพื้นที่ว่างเปล่าและ1s แทนแม่เหล็กถาวร ตัวเลขอื่น ๆ ทั้งหมดเป็นวัตถุโลหะซึ่งถูกดึงโดยแม่เหล็ก วัตถุทุกชิ้นจะถูกดึงเข้าหาแม่เหล็กที่ใกล้ที่สุด (หากมีการผูกกันวัตถุนั้นจะถูกดึงไปทางขวา) และมันจะเคลื่อนที่ไปในทิศทางนั้นจนกว่าจะชนกับแม่เหล็กหรือวัตถุอื่น ในที่สุดวัตถุทั้งหมดได้รวมตัวกันรอบ ๆ แม่เหล็ก ลำดับของวัตถุถูกเก็บรักษาไว้

เอาท์พุต

เอาต์พุตของคุณคืออาร์เรย์ที่วัตถุทุกชิ้นถูกดึงใกล้กับแม่เหล็กที่ใกล้ที่สุดเท่าที่จะทำได้ ควรมีรูปแบบเดียวกันกับอินพุต

ตัวอย่าง

พิจารณาอาร์เรย์

[0,0,2,0,1,1,0,2,0,3,0,5,0,1,0]

ซ้ายสุดได้รับการดึงต่อคู่แรกของแม่เหล็กเช่นเดียวกับครั้งที่สอง2 มีแม่เหล็กสี่ขั้นตอนไปในทั้งสองทิศทางจึงได้รับการดึงไปทางด้านขวา มันถูกดึงไปทางขวาและมันก็อยู่ระหว่างและแม่เหล็ก ผลลัพธ์ที่ถูกต้องคือ2353

[0,0,0,2,1,1,2,0,0,0,0,3,5,1,0]

กฎและการให้คะแนน

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต

กรณีทดสอบ

[0,1,0] -> [0,1,0]
[1,0,2,0,0,1,0] -> [1,2,0,0,0,1,0]
[7,0,5,0,0,1,0] -> [0,0,0,7,5,1,0]
[1,0,3,0,1,0,3,0,1] -> [1,0,0,3,1,0,0,3,1]
[1,0,0,0,0,0,0,7,3] -> [1,7,3,0,0,0,0,0,0]
[1,2,3,4,5,6,7,8,9,10,11,0,0,0,1] -> [1,2,3,4,5,6,7,0,0,0,8,9,10,11,1]
[12,3,0,0,1,0,1,3,0,0,6,12,0,0,0,1] -> [0,0,12,3,1,0,1,3,6,0,0,0,0,0,12,1]

Pyth, 28 20

o@.e?bhaDk_x1QkQ~hZQ

ขอบคุณ @ThomasKwa สำหรับการเล่นกอล์ฟขนาด 6 ไบต์!

วิธีนี้ละเมิดการเรียงลำดับที่เสถียรโดยการกำหนดให้กับค่าทั้งหมด 1 หรือมากกว่าในรายการดัชนีของ 1 ที่ใกล้ที่สุด (ความสัมพันธ์ที่ขาดไปทางขวาสุด 1) จากนั้นเรียงลำดับรายการตามค่าเหล่านี้ ศูนย์จะได้รับดัชนีของตัวเองเป็นค่าการเรียงลำดับของพวกเขา

ชุดทดสอบ

Verification Suite

คำอธิบาย:

o@.e?bhaDk_x1QkQ~hZQ  ##  implicit: Q = eval(input())
o                  Q  ##  Sort Q using the values of the lambda below
 @              ~hZ   ##  select the value from the matching index of the enumerate
  .e           Q      ##  enumerate with b = value, k = index
    ?b                ##  ternary on b
      haDk_x1Q        ##  if true, this thing
              k       ##  otherwise use the index as the sort weight
          _x1Q        ##  the indices of 1 in Q, given in reverse order 
                      ##  (the reverse makes it sort to the right because of stable sorts)
       aDk            ##  sort those indices by |index - k|
      h               ##  take the first value

ตัวอย่าง:

[1,0,3,0,1,0,3,0,1]ยกตัวอย่างกรณีทดสอบ เมื่อเราใช้การแจงนับเลขศูนย์ทั้งหมดจะได้ดัชนีของตัวเองเป็นค่าการเรียงลำดับดังนั้นฉันจะข้ามสิ่งเหล่านั้นและทำหนึ่งและสาม

[0, 4, 8]สำหรับครั้งแรกที่เราได้รับดัชนีของคนที่: จากนั้นย้อนกลับและจัดเรียงตามค่าสัมบูรณ์ของดัชนีลบดัชนีของหนึ่งซึ่งเกิดขึ้นเป็นศูนย์ที่นี่ ดังนั้นเราจึง[0, 4, 8]กลับมาอีกครั้ง ค่าแรกคือ0เราใช้มัน

สำหรับงวดสามที่เราได้รับดัชนีตรงกันข้ามและทำเรียงลำดับเดียวกัน แต่ใช้สองเป็นดัชนีของทั้งสามเพื่อให้ทั้งสอง0และ4ให้ค่าที่เหมือนกันสำหรับความแตกต่างแน่นอนดังนั้นเราจึงได้รับ: และเราจะใช้[4, 0, 8]4

แล้วสุดท้าย "ค่าการเรียงลำดับ" [0, 1, 4, 3, 4, 5, 8, 7, 8]อาร์เรย์จะ ต้องขอบคุณการเรียงลำดับที่เสถียรความสัมพันธ์จะถูกทำลายโดยลำดับที่ค่าเริ่มต้นปรากฏขึ้นดังนั้นเราจึงได้อาร์เรย์สุดท้ายที่เราต้องการ

เรติน่า , 97 72 ไบต์

+`(?<=\b1(,1*)*?)(\B,(11+)|,(11+))\b(?!(?<-1>,1*)*,1\b)|(11+),\B
$3,$4$5

ข้อมูลที่คาดว่าจะเป็นรายการที่คั่นด้วยจุลภาคของจำนวนเต็ม unary (ตัวคั่นนำหน้าและต่อท้ายเหมือน[...]ทำงานได้ดี)

เรียกใช้กรณีทดสอบทั้งหมดที่นี่ (เพื่อความสะดวกนี่จะดูแลการแปลงจากและเป็นทศนิยมอัตโนมัติ)

นี่เป็นแนวคิดที่แตกต่างอย่างสิ้นเชิงที่จะหลีกเลี่ยงกลุ่มสมดุลราคาแพงโดยใช้หลายขั้นตอน ปัจจุบันใช้เวลานานกว่า 6 ไบต์ แต่อาจจะสามารถเล่นกอล์ฟได้มากกว่า:

,1\b
>1
\b1,
1<
(T`,`<`<1*,
)T`,`>`,1*>
+`(1+>)>
>$1
+`<(<1+\b)(?!>)
$1<
<|>
,

JavaScript (ES6), 108 ไบต์

a=>a.map(_=>a.map((x,i)=>x>1?a[j=(n=a.indexOf(1,i))<0|n-i>i-p?i-1:i+1]?0:a[a[i]=0,j]=x:x<1?0:p=i,p=-1/0))&&a

คำอธิบาย

วนซ้ำในแต่ละเซลล์และหากมันมีโลหะอยู่ให้ตรวจสอบว่าเซลล์ถัดไปในทิศทางของแม่เหล็กที่ใกล้เคียงที่สุดว่างเปล่าหรือไม่และหากเป็นไปนั้นให้เคลื่อนไปที่นั่น กระบวนการนี้ทำซ้ำหลายครั้งจนกระทั่งโลหะทุกชนิดเคลื่อนที่ได้ไกลที่สุด

var solution =

a=>
  a.map(_=>                  // loop a.length times to ensure completeness
    a.map((x,i)=>            // for each cell item x at index i
      x>1?                   // if the cell contains metal
        a[j=                 // j = index of cell to move to
          (n=a.indexOf(1,i)) // n = index of next magnet
          <0|n-i>i-p?i-1:i+1 // set j to previous or next cell based on closest magnet
        ]?0:                 // if cell j is empty
          a[a[i]=0,j]=x      // set it to x and set cell i to 0
      :x<1?0:                // else if the cell contains a magnet
        p=i,                 // set p to the index of this magnet
      p=-1/0                 // p = index of previous magnet, initialise to -Infinity
    )
  )
  &&a                        // return a

<input type="text" id="input" value="1,2,3,4,5,6,7,8,9,10,11,0,0,0,1" />
<button onclick="result.textContent=solution(input.value.split(',').map(n=>+n))">Go</button>
<pre id="result"></pre>

PHP, 337 ตัวอักษร

<?$i=explode(",",$argv[1]);$m=$n=[];foreach($i as$k=>$v)if($v>0)eval("array_push(\$".($v<2?"m":"n").",$k);");for($p=0;$p<count($i);$p++)foreach($i as$k=>$v)if($v>1){$i[$k]=0;$r=-1;foreach($m as$_)if($r<0||abs($k-$r)>abs($_-$k))$r=$_;while($i[$r]>0)$r+=($r<$k?1:-1);$i[$r]=$v;}$s="";foreach($i as$v)$s.=$v.",";echo substr($s,0,-1)."\n";?>

ใช่มันยาวมากเพราะ PHP ไม่ใช่ภาษาสำหรับการเล่นกอล์ฟ แต่มันใช้งานได้และฉันก็สนุกที่ได้ทำมันจึงเป็นเรื่องดีสำหรับฉัน แน่นอนว่าฉันเปิดรับข้อเสนอที่เป็นไปได้

นอกจากนี้ยังมีคุณสมบัติข้อผิดพลาดเล็ก ๆ น้อย ๆที่คิดเช่นที่นี่

root@raspberrypi:~/stack# php magnet.php 12,3,0,0,1,0,1,3,0,0,6,12,0,0,0,1
0,0,3,12,1,0,1,3,6,0,0,0,0,0,12,1

ดูเหมือนว่าทั้ง 12 คนจะได้มาต่อหน้า 3 แต่นั่นไม่จริงเลย!

ทั้งสามเคารพจำนวนที่มากกว่าและปล่อยให้มันเข้าใกล้กับ maget มากขึ้น