2048 की तरह सरणी बदलाव


80

मान लें कि हम एक सरणी को शिफ्ट करना चाहते हैं जैसे कि यह 2048 के खेल में किया जाता है : अगर हमारे पास सरणी में दो समान लगातार तत्व हैं, तो उन्हें दो बार मूल्य तत्व में मिला दें। शिफ्ट को एक नया एरे वापस करना चाहिए, जहां लगातार समान तत्वों के प्रत्येक जोड़े को उनकी राशि से बदल दिया जाता है, और जोड़े को अंतर नहीं करना चाहिए। स्थानांतरण केवल एक बार किया जाता है, इसलिए हमें परिणामी मानों को फिर से विलय करने की आवश्यकता नहीं है। ध्यान दें कि यदि हमारे पास लगातार 3 समान तत्व हैं, तो हमें सबसे सही लोगों को योग करना होगा, इसलिए उदाहरण के लिए, [2, 2, 2]बनना चाहिए [2, 4], नहीं [4, 2]

कार्य सबसे छोटा फ़ंक्शन लिखना है जो एक सरणी लेता है और एक स्थानांतरित सरणी देता है।

आप मान सकते हैं कि सभी पूर्णांक सख्ती से सकारात्मक होंगे।

उदाहरण:

[] -> []
[2, 2, 4, 4] -> [4, 8]
[2, 2, 2, 4, 4, 8] -> [2, 4, 8, 8]
[2, 2, 2, 2] -> [4, 4]
[4, 4, 2, 8, 8, 2] -> [8, 2, 16, 2]
[1024, 1024, 512, 512, 256, 256] -> [2048, 1024, 512]
[3, 3, 3, 1, 1, 7, 5, 5, 5, 5] -> [3, 6, 2, 7, 10, 10]

मैं भी कम का उपयोग कर समाधान में बहुत दिलचस्पी हूँ :)


11
यह एक बहुत अच्छी पहली चुनौती है। साइट पर आपका स्वागत है!
DJMcMayhem

1
इनपुट आवश्यक रूप से सॉर्ट नहीं किया गया है और संख्याएं शून्य से अधिक हैं, यह केवल संख्याओं पर प्रतिबंध है। मुझे लगता है कि हम मानक int32 सीमा में सबसे बड़ा मूल्य फिट कर सकते हैं। परिणामस्वरूप रिक्त सरणी खाली सरणी देता है। भागीदारी के लिए धन्यवाद, सराहना करते हैं कि :)
ग्रीनवुल्फ

3
अभी भी अस्पष्ट के रूप में बंद करने के लिए मतदान करने वालों के लिए, चुनौती अनिवार्य रूप से इस पर उबलती है
user2428118

1
@ टिट्स "ध्यान दें कि यदि हमारे पास लगातार 3 समान तत्व हैं, तो हमें सबसे सही लोगों को योग करना होगा, इसलिए उदाहरण के लिए, [2, 2, 2] को [2, 4] बनना चाहिए, न कि [4, 2]।"
मार्टिन एंडर

1
खाली सरणियों पर निर्णय दुर्भाग्यपूर्ण है; इसने मेरे अपने सहित कुछ उत्तरों को अमान्य कर दिया है।
डेनिस

जवाबों:



19

हास्केल, 47 57 50 बाइट्स

e#l|a:b<-l,e==a= -2*a:b|1<2=e:l
map abs.foldr(#)[]

उपयोग reduce(या foldजैसा कि इसे हास्केल में कहा जाता है, यहां दाएं गुना foldr)। प्रयोग उदाहरण: map abs.foldr(#)[] $ [2,2,2,4,4,8]-> [2,4,8,8]

संपादित करें: +10 बाइट्स यह बिना अटके सरणियों के लिए भी काम करता है। मर्ज किए गए नंबर को दूसरे मर्ज को रोकने के लिए नकारात्मक मान के रूप में डाला जाता है। उन्हें एक फाइनल द्वारा ठीक किया जाता है map abs


नकारात्मक के साथ चाल वास्तव में अच्छा है!
xnor

14

ब्रेन-फ्लैक , 158 96

{({}<>)<>}<>{(({}<>)<><(({})<<>({}<>)>)>)({}[{}]<(())>){((<{}{}>))}{}{{}(<({}{})>)}{}({}<>)<>}<>

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

1 सूची को उलट दें (सब कुछ दूसरे स्टैक पर ले जाएं, लेकिन इससे कोई फर्क नहीं पड़ता)

{({}<>)<>}<>
{        }   #keep moving numbers until you hit the 0s from an empty stack
 ({}<>)      #pop a number and push it on the other stack
       <>    #go back to the original stack
          <> #after everything has moved, switch stacks

2 स्टेप 3-6 तब तक करें जब तक कि इस स्टैक पर कुछ न बचे:

{                                                                                         }

3 शीर्ष दो तत्वों को दोहराएं (2 3 -> 2 3 2 3)

(({}<>)<><(({})<<>({}<>)>)>)

(({}<>)<>                   #put the top number on the other stack and back on the very top
         <(({})             #put the next number on top after:
               <<>({}<>)>   #copying the original top number back to the first stack
                         )>)

4 शीर्ष पर 1 रखो अगर शीर्ष दो बराबर हैं, तो एक 0 अन्यथा (विकी से)

({}[{}]<(())>){((<{}{}>))}{}

5 यदि शीर्ष दो समान थे (शीर्ष पर गैर-शून्य) अगले दो को जोड़ते हैं और परिणाम को धक्का देते हैं

{{}(<({}{})>)}{}
{            }   #skip this if there is a 0 on top
 {}              #pop the 1
   (<      >)    #push a 0 after:
     ({}{})      #pop 2 numbers, add them together and push them back on 
              {} #pop off the 0

6 शीर्ष तत्व को दूसरे स्टैक पर ले जाएं

({}<>)<>

7 दूसरे स्टैक पर जाएँ और अंतर्निहित रूप से प्रिंट करें

<>

pls भाषा के नाम के बाद अल्पविराम जोड़ें, अन्यथा यह लीडरबोर्ड को तोड़ता है: P
केवल

9

PHP, 116 बाइट्स

<?$r=[];for($c=count($a=$_GET[a]);$c-=$x;)array_unshift($r,(1+($x=$a[--$c]==$a[$c-1]))*$a[$c]);echo json_encode($r);

या

<?$r=[];for($c=count($a=$_GET[a]);$c--;)$r[]=$a[$c]==$a[$c-1]?2*$a[$c--]:$a[$c];echo json_encode(array_reverse($r));

-4 बाइट्स यदि आउटपुट print_r'json_encode` के बजाय एक सरणी हो सकता है

176 बाइट्स को रेगेक्स के साथ हल करने के लिए

echo preg_replace_callback("#(\d+)(,\\1)+#",function($m){if(($c=substr_count($m[0],$m[1]))%2)$r=$m[1];$r.=str_repeat(",".$m[1]*2,$c/2);return trim($r,",");},join(",",$_GET[a]));

1
आप सॉर्ट का उपयोग नहीं कर सकते क्योंकि परिणाम हमेशा सॉर्ट नहीं किया जाता है: [4, 4, 2, 8, 8, 2] -> [8, 2, 16, 2]
क्रिप्टो

@ क्रिप्टो आप नए परीक्षण मामलों को जोड़ने के बाद सही हैं। इससे पहले कि सॉर्ट का उपयोग ठीक था
10:00 पर Jörg Hülsermann

for($i=count($a=$argv);--$i;)$b[]=($a[$i]==$a[$i-1])?2*$a[$i--]:$a[$i];print_r(array_reverse($b));एक ही विचार लेकिन छोटा
क्रिप्टो

@ क्रिप्टो मैं स्ट्रिंग प्रतिनिधित्व या एक सरणी के रूप में उत्पादन के बारे में निश्चित नहीं हूं। testcase के लिए []मैं की जरूरत है $r=[];आपकी मदद के लिए धन्यवाद
Jörg Hülsermann

9

GNU sed, 41 38 37

शामिल +1 के लिए -r
-3 डिजिटल ट्रॉमा
के लिए धन्यवाद -1 seshoumara के लिए धन्यवाद

:
s,(.*)(1+) \2\b,\1!\2\2!,
t
y,!, ,

इनपुट और आउटपुट अंतरिक्ष अलग तार हैं जो एकात्मक ( इस सर्वसम्मति के आधार पर ) हैं।

इसे ऑनलाइन आज़माएं!


y,!, ,1 बाइट बचाने के लिए उपयोग करें ।
शशमौरा

@seshoumara Duh ... मैंने ऐसा क्यों नहीं सोचा। धन्यवाद!
रिले

8

रेटिना , 32

\d+
$*
r`\b\1 (1+)\b
$1$1
1+
$.&

rऑन लाइन 3 राइट-टू-लेफ्ट रेगेक्स मिलान को सक्रिय करता है। और इसका मतलब यह है कि कैप्चरिंग समूह \1से पहले आने वाले संदर्भ को संदर्भित करने की आवश्यकता है (1+)

इसे ऑनलाइन आज़माएं।


नाइस .. मैच के लिए राइट-टू-लेफ्ट ऑप्शन काफी काम का है! क्या यह .Net रेगेक्स या रेटिना फीचर का हिस्सा है?
दादा

मैं सिर्फ 26 को मेरा पोस्ट करने वाला था, इनपुट फॉर्मेट के रूप में लाइनफीड -सेपरेशन का उपयोग करते हुए: retina.tryitonline.net/… से मुख्य बचत आती है और दूसरे प्रतिस्थापन से छुटकारा पाने के लिए लिप्यंतरण का उपयोग करना।
मार्टिन एंडर

@ डाडा यह एक .NET फीचर है (और इसका इस्तेमाल हुड के तहत किया जाता है ताकि मनमानी-लंबाई लुकबाइंड को सक्षम किया जा सके)। रेटिना में अभी तक कोई अनूठी रेगेक्स विशेषताएं नहीं हैं (हालांकि इसमें कुछ विशिष्ट प्रतिस्थापन विशेषताएं हैं)।
मार्टिन एंडर 20

1
@MartinEnder ठीक है धन्यवाद! .NET रेगेक्स वास्तव में महान हैं! ईर्ष्या perl कोडर देखा
दादा

@MartinEnder I आपका समाधान एक और उत्तर को वारंट करने के लिए पर्याप्त है
डिजिटल ट्रॉमा

8

पर्ल, 41 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट अनुक्रम दें:

shift2048.pl <<< "2 2 2 4 4 8 2"

shift2048.pl:

#!/usr/bin/perl -p
s/.*\K\b(\d+) \1\b/2*$1.A/e&&redo;y/A//d

8

अजगर, 61 बाइट्स

def f(l):b=l[-2:-1]==l[-1:];return l and f(l[:~b])+[l[-1]<<b]

बूलियन यह bजाँच करता है कि क्या अंतिम दो तत्वों की जाँच करके गिरना चाहिए कि वे एक तरह से समान हैं जो कि लंबाई 1 या 0. की सूची के लिए सुरक्षित हैं। अंतिम तत्व यदि 1समान या 2असमान के गुणक के साथ जोड़ा जाता है । यह सूची पर पुनरावर्ती परिणाम से जुड़ा हुआ है जिसके साथ कई तत्व अंत में काट दिए गए हैं। 1 बाइट के लिए डेनिस को धन्यवाद!


[l[-1]<<b]एक बाइट बचाता है।
डेनिस

l[-2:-1]है[l[-2]]
mbomb007

2
मुझे इसकी आवश्यकता है आकार 0 और 1. की सूची के लिए काम करने के लिए
xnor

7

पर्ल, 43 + 1 ( -p) = 44 बाइट्स

टन बगुला 41 बाइट्स उत्तर के साथ आया था , इसे देखें!

-4 @ हॉन्टेड को धन्यवाद!

संपादित करें : जोड़ा गया \b, क्योंकि इसके बिना यह इनपुट पर विफल हो रहा था 24 4जिस पर आउटपुट होता 28

$_=reverse reverse=~s/(\b\d+) \1\b/$1*2/rge

-pध्वज के साथ चलाएँ :

perl -pe '$_=reverse reverse=~s/(\b\d+) \1\b/$1*2/rge' <<< "2 2 2 4 4"


मुझे reverseदो बार दाईं ओर का उपयोग करने की तुलना में दूसरा तरीका नहीं दिखता है (जैसा कि बस s/(\d+) \1/$1*2/geबाएं-गुना, यानी इसके बजाय 2 2 2बन 4 2जाएगा 2 4)। तो 14 बाइट्स के लिए धन्यवाद खो गया reverse... फिर भी मुझे लगता है कि एक और (बेहतर) तरीका होना चाहिए (यह सब के बाद खराब है!), मुझे पता है कि क्या आप इसे ढूंढते हैं!


reverse reverseथोड़ा लंबा लगता है। मैं पर्ल में कोई विशेषज्ञ नहीं हूं, लेकिन क्या कोई ऐसा तरीका है जिससे आप शॉर्टकट बना सकते हैं reverse(यदि और कुछ नहीं, [ab] का उपयोग करके eval)?
साइओस

अच्छा सेक्स करने वाला। ध्यान दें($_)
टन हास्पेल

@ टोनहॉउस धन्यवाद। वास्तव में, reverseजैसे दिखने वाले डॉक्टर reverseको तर्क के बिना नहीं बुलाया जा सकता है ( वैसे उदाहरण यह दिखा सकते हैं कि यह हो सकता है, लेकिन केवल एक ही प्रोटोटाइप है reverse LIST:), इसलिए मैं $_डिफ़ॉल्ट तर्क होने के बारे में भूल गया ;)
दादा

A LISTखाली हो सकता है ...
Ton Hospel

@TonHospel वास्तव में, लेकिन एक ऑपरेटर का उपयोग करता है आमतौर पर जब $_डिफ़ॉल्ट तर्क के रूप में, दस्तावेज़ को कोई पैरामीटर (जैसे के साथ एक प्रोटोटाइप निर्दिष्ट करता है printया lenght...)। या हो सकता है कि मेरे पास सिर्फ एक गलत धारणा है।
दादा

7

जावास्क्रिप्ट (ईएस 6), 68 बाइट्स

f=a=>a.reduceRight((p,c)=>(t=p[0],p.splice(0,c==t,c==t?c+t:c),p),[])
    
console.log([
  [],
  [2, 2, 4, 4],
  [2, 2, 2, 4, 4, 8],
  [2, 2, 2, 2],
  [4, 4, 2, 8, 8, 2],
  [1024, 1024, 512, 512, 256, 256],
  [3, 3, 3, 1, 1, 7, 5, 5, 5, 5],
].map(f))


2
बुरा नहीं है, लेकिन निष्पादित स्निपेट के अनुसार: के [1024, 1024, 512, 512, 256, 256]रूप में हल हो रहा है [2048, 512, 1024]और नहीं [2048, 1024, 512]...?
वैलीवेस्ट

7

पर्ल 5.10, 61 50 बाइट्स ( ध्वज के लिए 49 + 1)

11 बाइट्स बचाने के लिए टोन हास्पेल को धन्यवाद !

-aध्वज के साथ रेगेक्स-मुक्त समाधान :

@a=($F[-1]-$b?$b:2*pop@F,@a)while$b=pop@F;say"@a"

यहाँ कोशिश करो!


अच्छा वैकल्पिक तरीका। एक दया सरणियाँ लगभग हमेशा तार में खो जाती हैं। फिर भी, आप अपने कोड @a=($F[-1]-$b?$b:2*pop@F,@a)while$b=pop@F;say"@a"(50 बाइट्स) में गोल्फ को पास करके थोड़ा और करीब आ सकते हैं
टन हास्पेल

@ टोनहॉस्ट वास्तव में, मैं स्ट्रिंग-आधारित समाधानों से बचने के लिए हूं (केवल यह दिखाने के लिए कि पर्ल अधिक से अधिक कर सकते हैं!)। मैं वैसे भी जीतने के लिए नहीं खेलता हूँ: घ गोल्फ युक्तियाँ के लिए धन्यवाद!
पॉल पिकार्ड

7

जावास्क्रिप्ट (ईएस 6), 68 65 58 57 65 64 बाइट्स

@ L4m2 के लिए 1 बाइट का धन्यवाद सहेजा गया

अनसोल्ड एरेज़ के लिए निश्चित है कि अब यह स्पष्ट कर दिया गया है कि इस तरह के इनपुट की उम्मीद की जानी है।

f=(a,l=[],m)=>(x=a.pop())*!m-l?f(a,x).concat(l):x?f(a,2*x,1):[l]

console.log(f([2, 2, 4, 4]));
console.log(f([2, 2, 2, 4, 4, 8]));
console.log(f([2, 2, 2, 2]));
console.log(f([4, 2, 2]));


1
मैं आपके द्वारा अभी-अभी बनाए गए संपादन का सुझाव देने वाला था :)
ETHproductions

a=>(a.reverse()+'').replace(/(.),\1/g,(c,i)=>i*2).split`,`.reverse()?
l4m2

@ l4m2 जो एकल-अंक के इनपुट के लिए काम करता है, लेकिन उस पर विफल होगा [1024, 1024, 512, 512, 256, 256](मुझे लगता है कि यह परीक्षण मामला बाद में जोड़ा गया है)।
अरनौलद

@ अर्नुलड आपका भी असफल ...
l4m2

f=(a,l=[],m)=>(x=a.pop())*!m-l?f(a,x).concat(l):x?f(a,2*x,1):[l]?
l4m2

6

05AB1E , 26 बाइट्स

D¥__X¸«DgL*ê¥X¸«£vy2ôO})í˜

इसे ऑनलाइन आज़माएं!

सामान्यीकृत कदम

  1. घटाव द्वारा घटाना यह पता लगाने के लिए कि लगातार तत्व कहां भिन्न होते हैं
  2. लगातार तत्वों की लंबाई खोजने के लिए उन स्थानों के सूचकांकों पर घटाव द्वारा कम करें
  3. उन लंबाई के विखंडू में इनपुट विभाजित करें
  4. जोड़ियों में फूट डालो
  5. प्रत्येक जोड़ी को योग करें
  6. प्रत्येक सुन्न हिस्सा उल्टा
  7. 1-आयामी सूची में समतल करें

5

मैथेमेटिका, 53 बाइट्स

Join@@(Reverse[Plus@@@#~Partition~UpTo@2]&/@Split@#)&

व्याख्या

Split@#

समान तत्वों के रनों से मिलकर सब्लिस्ट में इनपुट विभाजित करें। यानी {2, 2, 2, 4, 8, 8}बन जाता है {{2, 2, 2}, {4}, {8, 8}}

#~Partition~UpTo@2

विभाजनों में से प्रत्येक को विभाजन की लंबाई में अधिकतम 2 में विभाजित किया {{2, 2, 2}, {4}, {8, 8}}जाता है {{{2, 2}, {2}}, {{4}}, {{8, 8}}}। यानी बन जाता है ।

Plus@@@

कुल विभाजन। यानी {{{2, 2}, {2}}, {{4}}, {{8, 8}}}बन जाता है {{4, 2}, {4}, {16}}

Reverse

परिणाम उल्टा करें क्योंकि गणितज्ञ की Partitionआज्ञा बाएं से दाएं जाती है, लेकिन हम चाहते हैं कि विभाजन दूसरी दिशा में हो। यानी {{4, 2}, {4}, {16}}बन जाता है {{2, 4}, {4}, {16}}

Join@@

परिणाम को समतल करें। यानी {{2, 4}, {4}, {16}}बन जाता है {2, 4, 4, 16}


हाय JHM! जवाब के लिए धन्यवाद। मुझे गणितज्ञ बहुत अच्छी तरह से समझ में नहीं आता है, तो क्या आप समझ सकते हैं कि क्या चल रहा है?
isaacg

Plus@@@है Tr/@और मुझे लगता है कि आप कोष्ठकों से बच सकते हैं और Join@@यदि आप उपयोग ##&@@के परिणाम पर Reverse(यह, हालांकि परीक्षण नहीं किया)।
मार्टिन एंडर

5

जावा 7, 133 बाइट्स

Object f(java.util.ArrayList<Long>a){for(int i=a.size();i-->1;)if(a.get(i)==a.get(i-1)){a.remove(i--);a.set(i,a.get(i)*2);}return a;}

इनपुट एक ArrayList है, और यह जहां आवश्यक है, वहां से हटाने और दोहरीकरण करने के लिए बस पीछे की ओर लूप करता है।

Object f(java.util.ArrayList<Long>a){
    for(int i=a.size();i-->1;)
        if(a.get(i)==a.get(i-1)){
            a.remove(i--);
            a.set(i,a.get(i)*2);
        }
    return a;
}

आप Longपंक्ति 3 के संदर्भों की तुलना कर रहे हैं ==। विचार करें a.get(i)-a.get(i-1)==0
जैकब

4

पर्ल, 37 बाइट्स

के लिए +4 शामिल है -0n

STDIN पर अलग लाइनों के रूप में इनपुट के साथ चलाएँ:

perl -M5.010 shift2048.pl
2
2
2
4
4
8
2
^D

shift2048.pl:

#!/usr/bin/perl -0n
s/\b(\d+
)(\1|)$//&&do$0|say$1+$2


4

PHP, 86 100 99 94 बाइट्स

for($r=[];$v=+($p=array_pop)($a=&$argv);)array_unshift($r,end($a)-$v?$v:2*$p($a));print_r($r);

PHP 7.0 की आवश्यकता है; कमांड लाइन तर्कों से मान लेता है।

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें


2
[२, २, २] [२,४] के बजाय [४,२] रिटर्न
क्रिप्टो

for($r=[];$v=($p=array_pop)($a=&$_GET[a]);)array_unshift($r,end($a)-$v?$v:2*$p($a));print_r($r);क्या 1 बाइट छोटा है
Jörg Hülsermann

3

जूलिया 205 बाइट्स

t(x)=Val{x}
s(x)=t(x)()
f^::t(1)=f
^{y}(f,::t(y))=x->f(((f^s(y-1))(x)))
g()=[]
g{a}(::t(a))=[a]
g{a}(::t(a),B...)=[a;g(B...)]
g{a}(::t(a),::t(a),B...)=[2a;g(B...)]
K(A)=g(s.(A)...)
H(A)=(K^s(length(A)))(A)

कहा जाने वाला कार्य है H

जैसे H([1,2,2,4,8,2,])

यह किसी भी तरह से जूलिया में सबसे छोटा तरीका नहीं है। लेकिन यह इतना अच्छा है, कि मैं इसे साझा करना चाहता था।

  • t(a) एक मूल्य-प्रकार है, मान (a) का प्रतिनिधित्व करता है।
  • s(a) उस मूल्य प्रकार का एक उदाहरण है
  • gएक ऐसा फ़ंक्शन है जो अंतर मानों (मान प्रकारों का उपयोग करके) और इसके मापदंडों की संख्या पर भेजता है। और वह मस्त है
  • Kबस gइतना है कि लपेटता है

अतिरिक्त ठंडा हिस्सा:

f^::t(1)=f
^{y}(f,::t(y))=x->f(((f^s(y-1))(x)))

यह ^ऑपरेटर को कार्यों पर लागू करने के लिए परिभाषित करता है । इतना K^s(2)(X)ही K(K(X)) ऐसा है Hकि बस समय की एक गुच्छा Kपर बुला रहा है K- निश्चित रूप से किसी भी नेस्टेड मामले को संक्षिप्त करने के लिए पर्याप्त समय

यह बहुत कम किया जा सकता है, लेकिन यह तरीका सिर्फ इतना मजेदार है।


3

PowerShell v2 +, 81 बाइट्स

param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count..0]

एक स्पष्ट सरणी के रूप में इनपुट लेता है $n, इसे उलट देता है $n[$n.count..0], -joinतत्वों को एक अल्पविराम के साथ मिलाता है, फिर -replaceपहले तत्व के साथ regex सा मिलान अंक जोड़ी *2, और, और पार्न्स में घिरा हुआ है। पाइप्स जो परिणाम (जो इनपुट के @(2,2,4,4)लिए दिखेंगे (4*2),(2*2)) पर iex(कम Invoke-Expressionऔर इसी तरह ) के लिए अधिक है eval, जो गुणा को वास्तविक संख्या में परिवर्तित करता है। परिणामी सरणी को स्टोर करता है $b, जो कि पार्सन्स में पाइप लाइन पर रखने के लिए एनकैप्सुलेट करता है, फिर उसके $bसाथ पलटता है [$b.count..0]। पाइप लाइन पर परिणामी तत्वों को छोड़ देता है, और आउटपुट निहित है।


परीक्षण के मामलों

NB-- PowerShell में, खाली सरणी को "वापस" करने की अवधारणा अर्थहीन है -$nullजैसे ही यह गुंजाइश छोड़ता है, इसेबदल दियाजाता है - और इसलिए यह कुछ भी नहीं लौटने के बराबर है, जो कि यहां पहले उदाहरण में किया गया है (कुछ दुष्ट क्रिया त्रुटियों के बाद)। इसके अतिरिक्त, यहां आउटपुट स्पेस-अलग है, क्योंकि यह कड़े हुए सरणियों के लिए डिफ़ॉल्ट विभाजक है।

PS C:\Tools\Scripts\golfing> @(),@(2,2,4,4),@(2,2,2,4,4,8),@(2,2,2,2),@(4,4,2,8,8,2),@(1024,1024,512,512,256,256),@(3,3,3,1,1,7,5,5,5,5)|%{"$_ --> "+(.\2048-like-array-shift.ps1 $_)}
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\2048-like-array-shift.ps1:7 char:67
+   param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count. ...
+                                                                   ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

Cannot index into a null array.
At C:\Tools\Scripts\golfing\2048-like-array-shift.ps1:7 char:13
+   param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count. ...
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

 --> 
2 2 4 4 --> 4 8
2 2 2 4 4 8 --> 2 4 8 8
2 2 2 2 --> 4 4
4 4 2 8 8 2 --> 8 2 16 2
1024 1024 512 512 256 256 --> 2048 1024 512
3 3 3 1 1 7 5 5 5 5 --> 3 6 2 7 10 10

3

जावास्क्रिप्ट - 103 बाइट्स

v=a=>{l=a.length-1;for(i=0;i<l;i++)a[l-i]==a[l-1-i]?(a[l-i-1]=a[l-i]*2,a.splice(l-i,1)):a=a;return a}


यह काम नहीं करता है। [2,2,4,4]पैदावार के साथ परीक्षण [2,2,4,4]
कॉनर ओ'ब्रायन

1
हाँ। नोड v6.2.1
कॉनर ओ'ब्रायन

मेरा बुरा .. मैं इसे एक ही फाइल में एक और जेएस कोड के साथ चला रहा था और वैश्विक चर मिलाया गया।
एलेक्सिस_ए

3

ब्रेन-फ्लैक , 60 बाइट्स

{({}<>)<>}<>{(({}<>)<>[({})]){((<{}>))}{}{({}<>{})(<>)}{}}<>

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

{({}<>)<>}<>   Reverse stack

{   While input exists
  (
    ({}<>)   Push copy of last element to the other stack
    <>[({})] And subtract a copy of the next element
  )   Push the difference
  {   If the difference is not 0
    ((<{}>)) Push two zeroes
  }{}  Pop a zero
  {   If the next element is not zero, i.e the identical element
    ({}<>{})  Add the element to the copy of the previous element
    (<>)      Push a zero
  }{}    Pop the zero
}<>  End loop and switch to output stack


2

जूलिया, 73 82 बाइट्स

f(l)=l==[]?[]:foldr((x,y)->y[]==x?vcat(2x,y[2:end]):vcat(x,y),[l[end]],l[1:end-1])

वापस से सामने की ओर सूची बनाने के लिए दाएं गुना का उपयोग करें (शुरुआत और अंत में सूची को बाईं ओर मोड़ सकते हैं और सूची को उल्टा कर सकते हैं)।

यदि वर्तमान सूची के प्रमुख को प्रस्तुत करने के लिए अगले तत्व के बराबर नहीं है, तो बस इसे प्रस्तुत करें।

सूची के प्रमुख को हटा दें (क्रूर की तरह लग रहा है) और तत्व बार 2 को पूर्व निर्धारित करें।

उदाहरण

f([3,3,3,1,1,7,5,5,5,5]) 
returns a new list:
[3,6,2,7,10,10]

2

रैकेट 166 बाइट्स

(λ(l)(let g((l(reverse l))(o '()))(cond[(null? l)o][(=(length l)1)(cons(car l)o)]
[(=(car l)(second l))(g(drop l 2)(cons(* 2(car l))o))][(g(cdr l)(cons(car l)o))])))

Ungolfed:

(define f
  (λ (lst)
    (let loop ((lst (reverse lst)) 
               (nl '()))
      (cond                            ; conditions: 
        [(null? lst)                   ; original list empty, return new list;
               nl]
        [(= (length lst) 1)            ; single item left, add it to new list
              (cons (first lst) nl)]
        [(= (first lst) (second lst))  ; first & second items equal, add double to new list
              (loop (drop lst 2) 
                    (cons (* 2 (first lst)) nl))]
        [else                          ; else just move first item to new list
              (loop (drop lst 1) 
                    (cons (first lst) nl))]  
        ))))

परिक्षण:

(f '[])
(f '[2 2 4 4]) 
(f '[2 2 2 4 4 8]) 
(f '[2 2 2 2]) 
(f '[4 4 2 8 8 2])
(f '[1024 1024 512 512 256 256]) 
(f '[3 3 3 1 1 7 5 5 5 5])
(f '[3 3 3 1 1 7 5 5 5 5 5])

आउटपुट:

'()
'(4 8)
'(2 4 8 8)
'(4 4)
'(8 2 16 2)
'(2048 1024 512)
'(3 6 2 7 10 10)
'(3 6 2 7 5 10 10)

1

जाप , 12 बाइट्स

ò¦ ®ò2n)mxÃc

इसे ऑनलाइन आज़माएं!

अनपैक्ड और यह कैसे काम करता है

Uò!= mZ{Zò2n)mx} c

Uò!=    Partition the input array where two adjacent values are different
        i.e. Split into arrays of equal values
mZ{     Map the following function...
Zò2n)     Split into arrays of length 2, counting from the end
          e.g. [2,2,2,2,2] => [[2], [2,2], [2,2]]
mx        Map `Array.sum` over it
}
c       Flatten the result

जोनाथन एलन के जेली समाधान से कुछ विचार मिला ।


0

गणितज्ञ, 51 बाइट्स

Abs[#//.{Longest@a___,x_/;x>0,x_,b___}:>{a,-2x,b}]&

{Longest@a___,x_/;x>0,x_,b___}लगातार दो समान सकारात्मक संख्याओं वाली सूची से मेल खाता है और इन दो संख्याओं को बदल देता है -2xLongestमैचों को जितनी देर हो सके करने के लिए मजबूर करता है।

प्रक्रिया चरण दर चरण सचित्र है:

   {3, 3, 3, 1, 1, 7, 5, 5, 5, 5}
-> {3, 3, 3, 1, 1, 7, 5, 5, -10}
-> {3, 3, 3, 1, 1, 7, -10, -10}
-> {3, 3, 3, -2, 7, -10, -10}
-> {3, -6, -2, 7, -10, -10}
-> {3, 6, 2, 7, 10, 10}

0

विम, 28 बाइट्स

G@='?\v(\d+)\n\1<C-@>DJ@"<C-A>-@=<C-@>'<CR>

एक मैक्रो जो रेगेक्स लगातार संख्याओं के मिलान के लिए पिछड़े को खोजता है, और उन्हें एक साथ जोड़ता है।

इनपुट सरणी को प्रति पंक्ति एक नंबर होना चाहिए। यह प्रारूप मुझे स्ट्रोक से बचाता है, जो अच्छा है, लेकिन असली कारण रेगेक्स मैचों को ओवरलैप करने के आसपास काम करना है। स्ट्रिंग को देखते हुए 222, यदि आप /22केवल पहली जोड़ी से मेल खाएँगे , तो दूसरी जोड़ी से ज़्यादा नहीं। जब दो जोड़े अलग-अलग रेखाओं पर शुरू होते हैं, तो ओवरलैप नियम अलग-अलग होते हैं। इसमें चुनौती [2, 2, 2]बन जाती है[2, 4] , तो अतिव्यापी जोड़ी मिलान महत्वपूर्ण है।

ध्यान दें: चुनौती केवल एक ही पास के लिए कहा। उस कारण से, आपके पास होना चाहिए :set nowrapscan। के साथ :set wrapscanमैं एक संस्करण बना सकता है जो कई पासों पर काम पूरा करता है, हालांकि यह समाधान जैसा कि लिखित हमेशा ऐसा नहीं करेगा।

  • <C-@>: आम तौर पर, कमांड लाइन में, कमांड <CR>को चलाने के बिना शाब्दिक टाइप करने के लिए आपको इसके साथ बचना होगा <C-V>। लेकिन आप टाइप कर सकते हैं<C-@> लिखी और इसे <C-J>/ के रूप में माना जाएगा <NL>, जो तब होगा <CR>जब आप मैक्रो चलाते हैं, लेकिन जब आप टाइप कर रहे हों, तब नहीं। पढ़ने की कोशिश करो :help NL-used-for-Nul
  • @=: मैं इस बार आसानी से रिकॉर्ड किए गए मैक्रो का उपयोग नहीं कर सकता क्योंकि संभावना है कि इनपुट में कोई मेल नहीं हो सकता है। यदि मैक्रो को चलाते समय ऐसा होता है, तो असफल खोज मैक्रो को विफल कर देगी। लेकिन अगर यह (पहले निहित) रिकॉर्डिंग पास के दौरान होता है, तो बाकी सामान्य मोड कमांड चलेंगे, फ़ाइल को नुकसान पहुँचाएंगे। का नकारात्मक पक्ष@= कि मैं पुनरावर्ती कॉल पर बाइट खो देता हूं; कभी-कभी आप @@एक पुनरावर्ती कॉल के रूप में उपयोग कर सकते हैं , लेकिन यह @"इस मामले में पहले 4 बाइट्स से चलेगा ।
  • DJ@"<C-A>-: DJलाइन हटाता है और एक रजिस्टर में नंबर (कोई नई पंक्ति नहीं) डालता है, इसलिए मैं इसे एक नंबर तर्क के लिए मैक्रो के रूप में चला सकता हूं<C-A> । मुझे -बाद में जाना है इसलिए मुझे इस तरह के मामलों में दूसरा मैच नहीं मिलेगा [4, 2, 2]

0

पर्ल 6, 92 बाइट्स

{my @b;loop ($_=@^a-1;$_>=0;--$_) {@b.unshift($_&&@a[$_]==@a[$_-1]??2*@a[$_--]!!@a[$_])};@b}

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.