एक सरणी में चुंबकीय पुल

Question

पृष्ठभूमि

मेरे पास शक्तिशाली मैग्नेट की एक पंक्ति है और उनके बीच धातु की वस्तुओं का एक गुच्छा है। चुम्बक उन्हें कहाँ खींचेंगे?

इनपुट

आपका इनपुट गैर-नकारात्मक पूर्णांक का एक सरणी है, जिसमें कम से कम एक होगा 1। आप किसी भी उचित प्रारूप का उपयोग कर सकते हैं।

0सरणी के रों खाली जगह का प्रतिनिधित्व करते हैं, और 1रों तय मैग्नेट प्रतिनिधित्व करते हैं। अन्य सभी संख्याएं धातु की वस्तुएं हैं, जिन्हें चुम्बकों द्वारा खींचा जाता है। प्रत्येक वस्तु निकटतम चुंबक की ओर खींची जाती है (यदि कोई टाई है, तो वस्तु दाईं ओर खींची जाती है), और यह उस दिशा में यात्रा करती है जब तक कि वह चुंबक या किसी अन्य वस्तु से न टकराए। अंत में, सभी ऑब्जेक्ट मैग्नेट के चारों ओर क्लस्टर हो गए। वस्तुओं का क्रम संरक्षित है।

उत्पादन

आपका आउटपुट वह सरणी है जहां हर वस्तु को निकटतम चुंबक के करीब संभव के रूप में खींचा गया है। इसमें इनपुट के समान प्रारूप होना चाहिए।

उदाहरण

सरणी पर विचार करें

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

बाईं 2ओर मैग्नेट की पहली जोड़ी की ओर खींचा जाता है, जैसा कि दूसरा है 2। 3एक चुंबक चार चरणों दोनों दिशाओं में दूर है, इसलिए यह सही करने के लिए खींच लिया हो जाता है। यह 5भी दाईं ओर खींचा जाता है, और यह 3और चुंबक के बीच चला जाता है । सही आउटपुट है

[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]

Answer 1

Pyth, 28 20

o@.e?bhaDk_x1QkQ~hZQ

6 बाइट्स गोल्फ के लिए @ThomasKwa धन्यवाद!

यह सभी मानों को 1 या उससे अधिक की सूची में निकटतम 1 के सूचकांक (सबसे दाईं ओर तोड़े गए संबंध) और फिर इन मूल्यों द्वारा सूची को क्रमबद्ध करके स्थिर सॉर्टिंग का दुरुपयोग करता है। Zeroes को उनकी तरह के मूल्य के रूप में अपना खुद का सूचकांक दिया जाता है।

परीक्षण सूट

सत्यापन सूट

स्पष्टीकरण:

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]। स्थिर प्रकार के लिए धन्यवाद, इस क्रम से संबंध टूट जाते हैं कि मूल रूप से मान दिखाई देते हैं, इसलिए हमें अंतिम सरणी मिलती है जो हम चाहते हैं।

Comments

निकटतम के सूचकांक द्वारा क्रमबद्ध 1करना एक अच्छा विचार है!

— जर्ग्ब

Answer 2

रेटिना , 97 72 बाइट्स

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

इनपुट से अपेक्षा की जाती है कि यह एक पूर्णांक की अल्पविराम से अलग की गई सूची होगी (प्रमुख और अनुगामी परिसीमन जैसे [...]कार्य ठीक हैं)।

सभी परीक्षण मामलों को यहां चलाएँ। (सुविधा के लिए, यह रूपांतरण को स्वचालित रूप से और दशमलव से ध्यान रखता है।)

यहां एक पूरी तरह से अलग विचार है जो कई चरणों का उपयोग करके महंगे संतुलन वाले समूहों से बचा जाता है। यह वर्तमान में 6 बाइट्स लंबा है, लेकिन अधिक गोल्फ हो सकता है:

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

Comments

जैसे ही मैंने यह चुनौती देखी, मुझे लगा कि रेटिना एक अच्छा फिट (+1) होगा

— माइकल क्लेन

@MichaelKlein धन्यवाद, लेकिन मुझे नहीं लगता कि यह वास्तव में है। मुझे आश्चर्य है कि यह जावास्क्रिप्ट को भी हरा रहा है, लेकिन मुझे पूरा यकीन है कि यह किसी भी गोल्फिंग भाषा के खिलाफ मौका नहीं देगा।

— मार्टिन एंडर

जैसा कि मैंने तुरंत ही सोचना शुरू कर दिया कि रेटिना में कैसे हल किया जाए

— माइकल क्लेन

Answer 3

जावास्क्रिप्ट (ईएस 6), 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

व्याख्या

प्रत्येक कोशिका के ऊपर Iterates होता है और यदि उसमें धातु होती है, तो जांचता है कि क्या निकटतम चुंबक की दिशा में अगली कोशिका खाली है, और यदि वह है, तो उसे वहां ले जाती है। यह प्रक्रिया कई बार दोहराई जाती है जब तक कि सभी धातु जहां तक ​​जा सकती है वहां तक ​​नहीं गई है।

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>

Answer 4

PHP, 337 chars

<?$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 वास्तव में गोल्फिंग के लिए एक भाषा नहीं है, लेकिन यह काम करता है और मुझे FUN बना रहा था इसलिए यह मेरे लिए ठीक है। बेशक, मैं संभावित कमियों के लिए खुला हूँ।

इसके अलावा एक छोटी सी बग सुविधा है जो सोचता है, इसलिए यहां उदाहरण के लिए:

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

ऐसा लगता है कि 3 के सामने 12 जादुई रूप से मिला, लेकिन यह सच नहीं है!

3 बड़ी संख्या का सम्मान करता है और इसे मैग्नेट के करीब जाने देता है!