एक साधारण 2048 गेम क्लोन बनाएं


53

2048 एक अविश्वसनीय रूप से मज़ेदार और नशे की लत का खेल है जिसमें लक्ष्य 2048 के साथ एक टाइल बनाने का है।

यहाँ खेल का एक संक्षिप्त विवरण दिया गया है:


एक तीर कुंजी दबाने से उस दिशा में चरण के सभी ब्लॉक स्लाइड हो जाएंगे। उदाहरण के लिए, यदि xएक ब्लॉक का प्रतिनिधित्व करता है, और आपने इस मामले में ऊपर तीर दबाया है:

...x
.x..
..x.
xx..

फिर बोर्ड बन जाता

xxxx
.x..
....
....

इसके अलावा, ब्लॉक गिने जा रहे हैं, पर शुरू 2। यदि समान संख्या वाले दो ब्लॉकों को एक साथ स्थानांतरित किया जाता है, तो वे अगले संख्या में विलय कर देंगे। उदाहरण के लिए, इस बोर्ड पर "ऊपर" दबाने पर:

.2..
..22
.2..
....

इसे बनाएंगे:

.422
....
....
....

और फिर "राइट" दबाने के बाद, यह बन जाएगा ..44, और इसलिए दाएं फिर से दबाने से एक "8" ब्लॉक होगा, और इसी तरह।

प्रत्येक मोड़, एक नया "2" ब्लॉक एक यादृच्छिक खुले वर्ग पर बनाया गया है। (यह वास्तव में हमेशा "2" नहीं होता है, लेकिन सादगी के लिए चलो इसे उस पर रखें।) यदि कोई संभावित चालें नहीं बची हैं (यानी, बोर्ड भरा हुआ है और आप कुछ भी विलय नहीं कर सकते हैं), खेल खो गया है, और यदि एक 2048 ब्लॉक बनाया जाता है, आप जीत जाते हैं!


आपकी चुनौती इस खेल को फिर से बनाना है, गोल्फ!

  • किनारे-मामलों के लिए, जैसे कि इस बोर्ड पर "दाएं" दबाएं:

    ....
    .222
    ....
    ....
    

    आपको दबाए गए तीर कुंजी के किनारे के करीब टाइलों को मर्ज करना होगा। उदाहरण के लिए, यह बन जाएगा ..24, क्योंकि दूसरा और तीसरा "2" सही किनारे के सबसे करीब हैं।

  • यदि खिलाड़ी एक अमान्य चाल दबाता है (जैसे कि बोर्ड पर "ऊपर" 2.2. / .... / .... / ....), तो आपको इस कदम को अनदेखा करना चाहिए।

  • मोड़ों को किसी भी तरह से स्वीकार किया जा सकता है, जैसे कि क्लिक करना, तीर कुंजी ULRD, आदि।

  • सभी टाइलों का आकार समान होना चाहिए - "1024" टाइल का आकार "2" टाइल के समान होना चाहिए।

  • टाइल्स को किसी तरह से अलग किया जाना चाहिए। उदाहरण के लिए, |1024| 2|1024|1024|एक पंक्ति का एक वैध उदाहरण है (यह मानते हुए कि टाइल वर्ग हैं), जबकि 1024 210241024नहीं है।

  • यदि खिलाड़ी 2048 टाइल बनाता है, या "आप खो देते हैं" तो आपको "जीतना" आउटपुट करना होगा यदि कोई वैध चालें नहीं बची हैं।

  • यह , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा!


एकल वर्णों की पंक्तियों (पहले पाँच उदाहरणों) और / या अलग टाइलों (पिछले एक) को स्वीकार करने के बजाय, आउटपुट को सामान्य करने के लिए दो से अलग-अलग वर्णों की आरोही शक्तियाँ क्यों नहीं असाइन की जाती हैं?
मिलिनन

@millinon क्योंकि यह वास्तविक 2048 गेम (यह शीर्षक को अर्थहीन बना देगा) के समान संभव है, और यह कुछ चुनौती को हटा देगा।
दरवाज़े

1
" यदि कोई संभावित विलय नहीं बचा है, तो खेल खो गया है " क्या वहां नहीं होना चाहिए "और बोर्ड कहीं भरा हुआ है"?
पीटर टेलर

एक टाइल विभाजक के रूप में अंतरिक्ष पर्याप्त है?
जॉन ड्वोरक

5
मजेदार है कि आपके सभी खोजकर्ताओं को एक टन वोट मिले, लेकिन कई जवाब नहीं।
TheDoctor

जवाबों:


7

APL (Dyalog APL) , 153 150 167 156 बाइट्स

C←⎕UCS
'you ',{2048∊⍵:'win'
(z/∊n)[?+/z0=∊n←⍵]←2
⎕←4↑¨⍕¨n
1∊(⍉2=⌿n),(2=/n),0=n:∇{⍵≡r←R⍣¯1{4↑C(C¨2/¨t)⎕R(C¨,¨2×t2*⍳11)C⍵~0}¨(R←↓⍉∘⌽⍣⎕)⍵:∇⍵⋄r}n
'lose'}4 40

चाल के लिए संकेत; ० = वाम, १ = ऊपर २ = अधिकार, ३ = नीचे

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

व्हॉट्सएप के साथ अनगुल्ड

C  UCS
'you ', {
    2048  ⍵: 'win'
    n  
    z  0 = n
    (z / n)[? +/z]  2
      4 ↑¨ ⍕¨n
    1  (⍉ 2 =⌿ n) , (2 =/ n) , 0 = n:  {
        R←↓⍉∘⌽⍣⎕
        r  R⍣¯1 {
            t  2 * 11
            4  C (C¨ 2 t)⎕R(C¨  2 × t) C  ~ 0
         R 
          r:  
        r
    } n
    'lose'
} 4 40

व्याख्या

खाली लाइनें एक नई रेखा को दर्शाती हैं, जबकि लाइनों के ब्लॉक एक ही रेखा पर होते हैं

C ← ⎕UCSपरिवर्तित आवंटित / नाम के यूसीएस अंक से करने के लिए सी (के लिए सी odepoint)

'you ',"आप" समारोह के परिणाम के लिए तैयार {...

2048 ∊ ⍵: 'win' यदि तर्क (बोर्ड) में 2048 हैं, तो "जीत" लौटें

n ← ⍵n को सही तर्क दें (इसलिए इसे संशोधित किया जा सकता है)

z ← 0 = ∊n z को बूलियन सूची मिलती है जहाँ चपटा z 0 होता है

(z / ∊n) z फ़िल्टर किए हुए n (केवल शून्य प्राप्त करने के लिए)
[? +/z]1 और शून्य की संख्या (बूलियन z का योग ) के बीच एक यादृच्छिक संख्या का उपयोग करते हुए चयन करने के लिए कि शून्य-युक्त स्थिति
← 2को 2 प्राप्त होता है

⎕ ←प्रत्येक नंबर के
4 ↑¨प्रत्येक विस्तारित-से-लंबाई -4 (रिक्त स्थान के साथ)
⍕¨nस्ट्रिंग प्रतिनिधित्व आउटपुट

1 ∊यदि निम्न में से कोई भी पाया जाता है;
(⍉2=⌿n)जोड़ो में खड़ी समानताओं (concatenable होने के लिए स्थानांतरित कर)
,या (करने के लिए श्रेणीबद्ध)
(2=/n)जोड़ो में क्षैतिज समानताओं
,या (करने के लिए श्रेणीबद्ध)
0=nशून्य
:तो:
समारोह के परिणाम पर इस फ़ंक्शन को कॉल करें {...

R ← R ( R Rated के R ows के लिए )  संख्यात्मक इनपुट के लिए विभाजन-में-पंक्तियाँ संकेत है, फिर बारी बारी से (शाब्दिक रूप से दर्पण, फिर स्थानांतरित) तर्क (बोर्ड) –90 ° बार इनपुट संख्या

⍉∘⌽⍣⎕

r ← r ( r esult के लिए) R
R⍣¯1 का व्युत्क्रम हो जाता है (वापस घुमाएं, फिर मैट्रिक्स में पंक्तियों को मर्ज करें) फ़ंक्शन के परिणाम पर लागू होता है ...{

t ← 2 * ⍳11 t को 2¹¹, 2², 2³, ... 2² मिलता है

4↑जब तक लंबाई 4 सही पर शून्य से पैड
Cपरिवर्तित कोड अंक के लिए निम्न यूसीएस पात्रों
(C¨2/¨t)⎕R(C¨,¨2×t)regex प्रत्येक के जोड़े की जगह टी 2 बार प्रत्येक के साथ टी इसी यूसीएस वर्णों के लिए है, लेकिन पहले कन्वर्ट संख्या तो regex काम करेंगे
C ⍵~0बिना तर्क (बोर्ड) शून्य (बाईं ओर संकुचित), फिर यूसीएस कोड बिंदुओं में परिवर्तित हो जाता है

[फ़ंक्शन का अंत] प्रत्येक आर के लिए लागू
U↓(लेकिन बाद में उन्हें मिलाएं)
R ⍵ आर के तर्क (बोर्ड) पर लागू होता है

⍵ ≡ r:यदि तर्क (पुराना बोर्ड राज्य) r (नए बोर्ड राज्य) के समान है , तो:
∇⍵इस फ़ंक्शन को अनमॉडिफाइड तर्क पर कॉल करें (क्योंकि उपयोगकर्ता ने एक अमान्य कदम), अन्य

rरिटर्न आर (नया बोर्ड राज्य)

} n[समारोह का अंत] n (नए बोर्ड राज्य) पर लागू किया गया , और

'lose' वापसी "खो"

} 4 4 ⍴ 0 [समारोह का अंत] शून्य की 4-तालिका -4 (प्रारंभिक स्थिति) पर लागू


20

GolfScript, 323 अक्षर

1,16*{16,{1$=!},.,rand=)/()2++\[]*+4/{.['-----']4*'+'*'++'1/*n+:^\{'|''     ':X'|'+4*n++:Y.@{X\`+-5>'|'\+}%'|'+n+Y+Y+^+}%+puts}:P~"wasd":Q{1$.@{Q\?[{zip}{}{-1%zip-1%}{{-1%}%}]=\1$~{0-[{.2$={+)}*}*0...]4<{1|(}%}%\~}:^~=!},:F{0{;'"#{'9.?rand';STDIN.getc()}"'++~.F\?0<}do^[]*.2048?0<.!{'you win'@@}*}{'you lose'@@*0}if}do 4/P;

आपको जिन कुंजियों का उपयोग करना है, वे हैं, wasdलेकिन आप कोड में निरंतरता को बदल सकते हैं जो भी कुंजी आपको पसंद है। यह किसी भी अज्ञात कुंजी या अवैध कदम को इग्नोर करता है। दुर्भाग्य से आपको प्रत्येक कुंजी के बाद एंटर दबाना होगा।

उदाहरण 2048 वासी

256 चरित्र समाधान

1,16*{16,{1$=!},.,rand=)/())+\[]*+4/{.{{.9>7*+48+}%n+}%puts}:P~"wasd":Q{1$.@{Q\?[{zip}{}{-1%zip-1%}{{-1%}%}]=\1$~{0-[{.2$={;21+}*}*0...]4<{20%}%}%\~}:^~=!},:F{0{;'"#{'9.?rand';STDIN.getc()}"'++~.F\?0<}do^[]*.10?0<.!{'you win'@@}*}{'you lose'@@*0}if}do 4/P;

यहाँ उत्पादन हेक्साडेसिमल लघुगणक, है यानी 0के लिए खड़ा है ., 1के लिए 2, 2के लिए 4, 3के लिए 8... Bके लिए 2048। चूँकि हम सभी हेक्साडेसिमल और दो की शक्तियों को जानते हैं, इसलिए यह एक सीमा नहीं होनी चाहिए।

उदाहरण रन (पहली चाल):

0000
0000
0010
0000
w
0011
0000
0000
0000
a
2000
0000
0001
0000
s
0000
0000
0100
2001
d
0000
0000
1001
0021
w
1022
0000
0001
0000
a
1301
0000
1000
0000
s
0000
1000
0000
2301
d
0000
1001
0000
0231

टाइलों को अलग किया जाना चाहिए, लेकिन अच्छी नौकरी।
त्युन प्रैंक

@TeunPronk मैं इस पर काम कर रहा हूँ। दुर्भाग्य से यह दो अंकों की अच्छी शक्ति को तोड़ता है।
हावर्ड

7
+ बिल्कुल 256 वर्ण होने के लिए असीमित
SztupY

yay ... 2 ^ 7 वर्ण !!
मुकुल कुमार

1
अच्छा! पहले गोल्फ कोर्स में इनपुट कैसे करना है पता नहीं था। व्यक्तिगत रूप से मुझे 256 char समाधान अधिक पसंद हैं, पढ़ने में आसान। और मैं कहूंगा कि टाइलें अलग हो जाती हैं क्योंकि प्रत्येक टाइल केवल 1 वर्ण लंबी होती है। कभी कोई अस्पष्टता नहीं है।
क्लाउडीयू

12

जे - 240 230 216 चार

यह अनुगामी न्यूलाइन को गिनता है, क्योंकि आपको कंसोल पर गेम चलाना शुरू करने की आवश्यकता है। एक टाइप करके udlrऔर फिर एंटर मारकर खेलें । चालें जो बोर्ड को कुछ नहीं करती हैं उन्हें ठीक से संभाला जाता है, लेकिन यदि आप इसे कोई बुरा इनपुट देते हैं तो कार्यक्रम आपके लिए पागल हो जाएगा।

'you ',>lose`win{~$:@".@('o b=:2 t}^:(1-b-:])s ',' b',~1!:1@1:)`w@.((w=:2048 e.,)+(s d-:s u=:l d=:r(&.|:))*s r-:(s=:[:p(2(=/(0,+/^:)@{.,}.),)/@p=:\:=&0)l=:&.|.r=:"1)(o=:[2:1!:2~4<@":"0])b=:2(t=:(?&#{])[:I.0=,)}4 4$0

पठनीय संस्करण और स्पष्टीकरण पोस्ट में आराम से फिट होने के लिए थोड़ा बड़ा है: आप इस लिंक पर एक राइटअप पा सकते हैं ।

उपयोग:

   'you ',>lose`win{~$:@".@('o b=:2 t}^:(1-b-:])s ',' b',~1!:1@1:)`w@.((w=:2048 e.,)+(s d-:s u=:l d=:r(&.|:))*s r-:(s=:[:p(2(=/(0,+/^:)@{.,}.),)/@p=:\:=&0)l=:&.|.r=:"1)(o=:[2:1!:2~4<@":"0])b=:2(t=:(?&#{])[:I.0=,)}4 4$0
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   2|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
r
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   2|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   2|   0|   0|
+----+----+----+----+
u
+----+----+----+----+
|   0|   2|   0|   2|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   2|
+----+----+----+----+
d
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   2|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   2|   0|   4|
+----+----+----+----+
l
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   2|   0|   0|   0|
+----+----+----+----+
|   0|   0|   2|   0|
+----+----+----+----+
|   2|   4|   0|   0|
+----+----+----+----+
d
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   2|   0|   0|
+----+----+----+----+
|   4|   4|   2|   0|
+----+----+----+----+
r
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   2|
+----+----+----+----+
|   0|   0|   0|   2|
+----+----+----+----+
|   0|   0|   8|   2|
+----+----+----+----+
d
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   0|   0|   0|
+----+----+----+----+
|   0|   2|   0|   2|
+----+----+----+----+
|   0|   0|   8|   4|
+----+----+----+----+

महान। दुर्भाग्य से वर्गों का आकार भिन्न होता है जब सामग्री बदलती है और यह एक प्रश्न में कहा गया था।
हावर्ड

@ हाउर्ड मैं अनुनय हूं कि टाइल्स को कठोर रूप से चौकोर बनाने की तुलना में बहुत बदसूरत है, लेकिन वहां, यह तय हो गया है।
एल्गोरिथमशार्क

9

गणितज्ञ, 484 वर्ण

बहुत बदसूरत।

m@l=#//.{{x___,0,a_/;a>0,y___}:>{x,a,0,y},{x___,a_/;a>0,a_,y___}:>{x,2 h@a,0,y}}/.h@a_:>a&;{m@u,m@d,m@r}=Composition[#,m@#2,#]&@@@{{Thread,l},{Reverse,u},{Thread,d}};a=ReplacePart[#,RandomChoice@Position[#,0]->2]&;g=a@ConstantArray[0,{4,4}];EventHandler[Dynamic[GraphicsGrid@Map[Graphics@Text@#&,g,{2}]],(#2<>"ArrowKeyDown":>If[g!=m[#]@g,g=a[m[#]@g];Which[And@@(g==m[#]@g&/@{u,l,r,d}),Print@"you lose",!FreeQ[g,2048],Print@"you win"]])&@@@{{l,"Left"},{r,"Right"},{u,"Up"},{d,"Down"}}]

तीर कुंजी द्वारा नियंत्रित।

यहाँ छवि विवरण दर्ज करें


Ungolfed:

move[Left] = # //. {{x___, 1, a_ /; a > 1, y___} :> {x, a, 1, y},
      {x___, a_ /; a > 1, a_, y___} :> {x, 2 Hold@a, 1, y}} /. 
    Hold@a_ :> a &;
move[Up] = Composition[Transpose, move[Left], Transpose];
move[Down] = Composition[Reverse, move[Up], Reverse];
move[Right] = Composition[Transpose, move[Down], Transpose];
addTile = ReplacePart[#, RandomChoice@Position[#, 1] -> 2] &;
keyDown = If[grid != move[#][grid], grid = addTile[move[#][grid]];
    Which[And @@ (grid == move[#][grid] & /@ {Left, Right, Up, Down}),
      status = "Can't move...",
     ! FreeQ[grid, 2048], status = "2048!"]] &;
grid = addTile@ConstantArray[1, {4, 4}];
status = "";
EventHandler[Dynamic[ArrayPlot[Log2@grid/11,
   ColorFunction -> "StarryNightColors",
   ColorFunctionScaling -> False,
   Mesh -> All,
   Epilog -> {MapIndexed[
      Text[Style[#1, "Section"] //. 1 -> "", #2 - {0.5, 0.5}] &, 
      Transpose@Reverse@grid, {2}],
     Text[Style[status, "Section"], {2, 2}]}]],
 {"LeftArrowKeyDown" :> keyDown[Left],
  "RightArrowKeyDown" :> keyDown[Right],
  "UpArrowKeyDown" :> keyDown[Up],
  "DownArrowKeyDown" :> keyDown[Down]}]

यहाँ छवि विवरण दर्ज करें


2
मैं एक ungolfed के लग रहा है की तरह!
tomsmeding

7

डेल्फी एक्सई 3 (वेय से कई {फुसफुसाते हुए} 2.979 बाइट्स -> 4.560 बाइट्स अपुष्ट)

मैं इस "2048 कोड को उपन्यास" कहना
पसंद करता हूं " मुझे जितना पसंद है उससे अधिक बाइट्स का उपयोग किया है लेकिन यह काम करता है और यह करने के लिए मजेदार था।

Im अभी भी बाद में इसे कम करने की कोशिश करने जा रहा है।

खेल जारी है

खेल

golfed

uses System.SysUtils,Windows;type TDir=(dUp,dDown,dLeft,dRight,dInv);const t='_____________________________';er='|      |      |      |      |';nr='| %s | %s | %s | %s |';br='|______|______|______|______|';fn='%d';procedure mycls;var S:String;H:DWORD;CO:_COORD;begin H:=GetStdHandle(STD_OUTPUT_HANDLE);CO.X:=0;CO.Y:=0;SetConsoleCursorPosition(H,CO);S:=StringOfChar(Chr(32),2000);Writeln(S);SetConsoleCursorPosition(H,CO);end;var a:array[1..4,1..4]of integer;c,rx,ry,i,j:int8;m:string;GameOver,gs:boolean;function hz:boolean;var b,q:int8;begin for b:=1to 4do for q:=1to 4do if a[b,q]=0 then exit(true);end;function HM:boolean;var b,q:int8;begin if hz then exit(true);for b:=1to 4do for q:=1to 4do begin c:=a[b,q];if c in [a[b-1,q],a[b+1,q],a[b,q-1],a[b,q+1]] then result:=true;end;end;procedure rn(out n,m:int8);var z:int8;begin z:=0;repeat n:=Random(4)+1;m:=Random(4)+1;z:=z+1;until(a[n,m]=0)and(z>=3);end;function gn(n:integer):string;begin if n=0 then exit('    ');Result:=IntToStr(n).PadLeft(4,' ');end;procedure pm(d:TDir;score:boolean);var b,q,z:int8;begin case d of dUp:for z:=1to 3do for b:=1to 4do for q:=1to 3do begin if score then begin if a[q,b]=a[q+1,b] then begin a[q,b]:=a[q,b]+a[q+1,b];a[q+1,b]:=0;end;end else if a[q,b]=0 then begin a[q,b]:=a[q+1,b];a[q+1,b]:=0;end;end;dDown:for z:=1to 3do for b:=1to 4do for q:=2to 4do begin if score then begin if a[q,b]=a[q-1,b] then begin a[q,b]:=a[q,b]+a[q-1,b];a[q-1,b]:=0;end;end else if a[q,b]=0 then begin a[q-1,b]:=a[q,b];a[q-1,b]:=0;end;end;dLeft:for z:=1to 3do for q:=1to 4do for b:=1to 3do begin if score then begin if a[q,b]=a[q,b+1] then a[q,b]:=a[q,b]+a[q,b+1];a[q,b+1]:=0;end else if a[q,b]=0 then begin a[q,b]:=a[q,b+1];a[q,b+1]:=0;end;end;dRight:for z:=1to 3do for q:=1to 4do for b:=2to 4do begin if score then begin if a[q,b]=a[q,b-1] then begin a[q,b]:=a[q,b]+a[q,b-1];a[q,b-1]:=0;end;end else if a[q,b]=0 then begin a[q,b]:=a[q,b-1];a[q,b-1]:=0;end;end;end;end;function gd(s:string):TDir;begin s:=lowercase(s);if s='u'then exit(dUp);if s='d'then exit(dDown);if s='l'then exit(dLeft);if s='r'then exit(dRight);exit(dInv)end;procedure dg;var z:int8;begin writeln(t);for z:=1to 4do begin writeln(er);Writeln(Format(nr,[gn(a[z,1]),gn(a[z,2]),gn(a[z,3]),gn(a[z,4])]));Writeln(br);end;end;function hw:boolean;var b,q:int8; begin for b:=1to 4do for q:=1to 4do if a[b,q]=2048 then result:=true;end;function dm:boolean;var d:Tdir;begin d:=gd(m);if d=dInv then if not gs then exit(false)else exit(true);pm(d,false);pm(d,true);pm(d,false);exit(true);end;begin gs:=true;m:='';for j:=1to 4do for i:=1to 4do begin a[i,j]:=0;end;rx:=0;ry:=0;rn(rx,ry);a[rx,ry]:=2;repeat if (dm) then begin if hz then begin rn(rx,ry);a[rx,ry]:=2;end;gs:=false;end;mycls;GameOver:=true;if hw then WriteLn('You have won!')else if HM then begin GameOver:=false;dg;writeln('Direction: [U]=up, [D]=Down, [L]=Left, [R]=Right');readln(m);end else WriteLn('Game Over, no more possible moves :('#13#10'Try again next time')until GameOver;readln;end.

Ungolfed

uses
  System.SysUtils,Windows;
type
  TDir=(dUp,dDown,dLeft,dRight,dInv);
const
  t='_____________________________';
  er='|      |      |      |      |';
  nr='| %s | %s | %s | %s |';
  br='|______|______|______|______|';
  fn='%d';
procedure mycls;
var
  S:String;
  H:DWORD;
  CO:_COORD;
begin
  H:=GetStdHandle(STD_OUTPUT_HANDLE);
  CO.X:=0;
  CO.Y:=0;
  SetConsoleCursorPosition(H,CO);
  S:=StringOfChar(Chr(32),2000);
  Writeln(S);
  SetConsoleCursorPosition(H,CO);
end;
var
  a:array[1..4,1..4]of integer;
  c,rx,ry,i,j:int8;
  m:string;
  GameOver,gs:boolean;
function hz:boolean;
var b,q:int8;
begin
  for b:=1to 4do
    for q:=1to 4do
      if a[b,q]=0 then exit(true);
end;
function HM:boolean;
var b,q:int8;
begin
  if hz then exit(true);
  for b:=1to 4do
    for q:=1to 4do
    begin
      c:=a[b,q];
      if c in [a[b-1,q],a[b+1,q],a[b,q-1],a[b,q+1]] then
        result:=true;
    end;
end;
procedure rn(out n,m:int8);
var z:int8;
begin
z:=0;
  repeat
    n:=Random(4)+1;
    m:=Random(4)+1;
    z:=z+1;
  until(a[n,m]=0)and(z>=3);
end;
function gn(n:integer):string;
begin
  if n=0 then exit('    ');
  Result:=IntToStr(n).PadLeft(4,' ');
end;
procedure pm(d:TDir;score:boolean);
var
  b,q,z:int8;
begin
  case d of
    dUp:
      for z:=1to 3do
        for b:=1to 4do
          for q:=1to 3do
          begin
            if score then
            begin
              if a[q,b]=a[q+1,b] then
              begin
                a[q,b]:=a[q,b]+a[q+1,b];a[q+1,b]:=0;
              end;
            end
            else
              if a[q,b]=0 then
              begin
                a[q,b]:=a[q+1,b];a[q+1,b]:=0;
              end;
          end;
    dDown:
      for z:=1to 3do
        for b:=1to 4do
          for q:=2to 4do
          begin
            if score then
            begin
              if a[q,b]=a[q-1,b] then
              begin
                a[q,b]:=a[q,b]+a[q-1,b];a[q-1,b]:=0;
              end;
            end
            else
              if a[q,b]=0 then
              begin
                a[q-1,b]:=a[q,b];
                a[q-1,b]:=0;
              end;
          end;
    dLeft:
      for z:=1to 3do
        for q:=1to 4do
          for b:=1to 3do
          begin
            if score then
            begin
              if a[q,b]=a[q,b+1] then
                a[q,b]:=a[q,b]+a[q,b+1];a[q,b+1]:=0;
            end
            else
              if a[q,b]=0 then
              begin
                a[q,b]:=a[q,b+1];a[q,b+1]:=0;
              end;
          end;
    dRight:
      for z:=1to 3do
        for q:=1to 4do
          for b:=2to 4do
          begin
            if score then
            begin
              if a[q,b]=a[q,b-1] then
              begin
                a[q,b]:=a[q,b]+a[q,b-1];a[q,b-1]:=0;
              end;
            end
            else
              if a[q,b]=0 then
              begin
                a[q,b]:=a[q,b-1];a[q,b-1]:=0;
              end;
          end;
  end;
end;

function gd(s:string):TDir;
begin
  s:=lowercase(s);
  if s='u'then exit(dUp);
  if s='d'then exit(dDown);
  if s='l'then exit(dLeft);
  if s='r'then exit(dRight);
  exit(dInv)
end;
procedure dg;
var z:int8;
begin
  writeln(t);
  for z:=1to 4do
  begin
    writeln(er);
    Writeln(Format(nr,[gn(a[z,1]),gn(a[z,2]),gn(a[z,3]),gn(a[z,4])]));
    Writeln(br);
  end;
end;
function hw:boolean;
var b,q:int8;
begin
  for b:=1to 4do
    for q:=1to 4do
      if a[b,q]=2048 then
        result:=true;
end;
function dm:boolean;
var
  d:Tdir;
begin
  d:=gd(m);
  if d=dInv then if not gs then exit(false)else exit(true);
  pm(d,false);
  pm(d,true);
  pm(d,false);
  exit(true);
end;
begin
    gs:=true;m:='';
    for j:=1to 4do
      for i:=1to 4do
      begin
        a[i,j]:=0;
      end;
   rx:=0;ry:=0;
   rn(rx,ry);
   a[rx,ry]:=2;
  repeat
    if (dm) then
    begin
      if hz then
      begin
        rn(rx,ry);
        a[rx,ry]:=2;
      end;
      gs:=false;
    end;
    mycls;
    GameOver:=true;
    if hw then
      WriteLn('You have won!')
    else if HM then
    begin
      GameOver:=false;
      dg;
      writeln('Direction: [U]=up, [D]=Down, [L]=Left, [R]=Right');
      readln(m);
    end
    else
      WriteLn('Game Over, no more possible moves :('#13#10'Try again next time')
  until GameOver;
  readln;
end.

2
2.979 बाइट्स ? क्या इसे किलोबाइट होना चाहिए?
होशे

9
दुनिया में कुछ जगहों पर कॉमा का उपयोग संख्याओं में किया जाता है जिस तरह से हम पीरियड्स का उपयोग करते हैं, मैं बिल्कुल भी आश्चर्यचकित नहीं होता अगर रिवर्स भी सच होता।
भूमिगत

1
@undergroundmonorail ट्रू, यूरोप में नंबर एक हजार और बारह अल्पविराम छह अक्सर अमेरिकी 1,012.6 :) के बजाय 1.012,6 के रूप में लिखा जाता है
6:22 पर

कोडगॉल्फ ने मुझे सिखाया कि आप इंटरचेंज कर सकते हैं ,और .संख्या में!
तेजस काले '

1
अच्छी बात है कि इस सवाल में लीडरबोर्ड नहीं है ...
पैट्रिक रॉबर्ट्स

7

सी (C89 मानक), 881 बाइट्स

स्थानांतरित करने के लिए wasd कुंजियों का उपयोग करें। GCC में संकलित करें और डिफ़ॉल्ट रूप से क्लैग करें, जब तक कि C99 मानक (मुझे नहीं लगता) सेट हो। उपयोग करता है termios.h, लिनक्स में काम किया है और MacOS X. विंडोज के बारे में निश्चित नहीं है।

#include<termios.h>
#define R return
#define H while
char t[17],*Q,*W="adws",D,x,y,X;m(x,y){R!D?x+y*4:D==1?3-x+y*4:D==2?y+x*4:y+(3-x)*4;}c(){for(y=0;y<3;++y)for(x=0;x<3;++x){D=t[x+y*4];if(t[x+1+y*4]==D||t[x+4+y*4]==D)x=y=9;}R y>4;}d(){if(strlen(t)==16)R 0;H(t[x=(rand()&15)]);R t[x]=1;}r(x){putchar(x);}b(){y=0;r(10);H(y<21)r(y++%5?45:43);r(10);}f(){for(x=0;x<17;++x)if(X=(t[x]==11))x=32;R x<18;}struct termios z;main(){srand(time(tcgetattr(0,&z)));z.c_lflag&=~ICANON;tcsetattr(0,0,&z);H(f()&&(d()||c())){x=0;H(x<16){if(!(x&3)){b();r('|');}if(y=t[x++])printf("%4u|",1<<y);else printf("    |");}b();r(10);H(!(Q=strchr(W,getchar())));D=Q-W;for(y=0;y<4;++y)for(X=0,x=1;x<4;++x)if(t[m(x,y)]){if(t[m(x,y)]==t[m(X,y)]&&t[m(X,y)]++)t[m(x,y)]=0;X=x;}do{for(y=0;y<4;++y)for(x=0;x<3;++x)if(!t[m(x,y)]&&(X=t[m(x+1,y)])){t[m(x,y)]=X;t[m(x+1,y)]=0;x=y=9;}}H(y>4);}puts(X?"you win":"you lose");}

कुछ लाइनों में टूट गया:

#include<termios.h>
#define R return
#define H while
char t[17],*Q,*W="adws",D,x,y,X;m(x,y){R!D?x+y*4:D==1?3-x+y*4:D==2?y+x*4:y+(3-x)*4;}
c(){for(y=0;y<3;++y)for(x=0;x<3;++x){D=t[x+y*4];if(t[x+1+y*4]==D||t[x+4+y*4]==D)x=y=9;}R y>4;}
d(){if(strlen(t)==16)R 0;H(t[x=(rand()&15)]);R t[x]=1;}
r(x){putchar(x);}
b(){y=0;r(10);H(y<21)r(y++%5?45:43);r(10);}
f(){for(x=0;x<17;++x)if(X=(t[x]==11))x=32;R x<18;}
struct termios z;
main(){srand(time(tcgetattr(0,&z)));z.c_lflag&=~ICANON;tcsetattr(0,0,&z);
H(f()&&(d()||c())){x=0;H(x<16){if(!(x&3)){b();r('|');}if(y=t[x++])printf("%4u|",1<<y);else printf("    |");}
b();r(10);H(!(Q=strchr(W,getchar())));D=Q-W;for(y=0;y<4;++y)for(X=0,x=1;x<4;++x)
if(t[m(x,y)]){if(t[m(x,y)]==t[m(X,y)]&&t[m(X,y)]++)t[m(x,y)]=0;X=x;}
do{for(y=0;y<4;++y)for(x=0;x<3;++x)if(!t[m(x,y)]&&(X=t[m(x+1,y)]))
{t[m(x,y)]=X;t[m(x+1,y)]=0;x=y=9;}}H(y>4);}puts(X?"you win":"you lose");}

लग रहा है:

+----+----+----+----+
|   8|   4|   8|   2|
+----+----+----+----+
|    |  16|    |    |
+----+----+----+----+
|    |   2|    |    |
+----+----+----+----+
|    |    |    |   2|
+----+----+----+----+

यह सुनिश्चित करने के लिए सुधार किया जा सकता है।


5

जावा: 1346 1269

संपादित करें, हालांकि यह प्रतियोगिता पूरी हो गई है, कभी-कभी मैं सुधार नहीं होने पर जाने नहीं दे सकता। इस संस्करण में एक लीनर, माध्यर, इन-प्लेस फोल्डिंग फ़ंक्शन, अधिकांश booleanप्रकारों को बेदखल करने के अलावा जहां यह उनके बिना अधिक क्रियात्मक होगा, और थोड़े छोटे सेल (5x5 के बजाय 4x4) को छोड़कर वहां कुछ अतिरिक्त वर्णों को काटता है।

तो यह एक मजेदार था। पोस्ट करने का शुक्रिया! Ungolfed, यह 2856 बाइट्स था, गोल्फिंग मैंने इसे 1346 बाइट्स तक सिकोड़ दिया। जावा होने के नाते, मैं जीतने वाला नहीं हूं, लेकिन मैं एक अच्छा प्रदर्शन करना चाहता हूं। टाइल के जुड़ने और चाल को संभालने के लिए एक "सामान्य" रोल-अप फ़ंक्शन का पता लगाना मज़ेदार था - आप निश्चित रूप से इस समाधान के लिए मेरे गिटब रिपॉजिटरी पर कमिट्स को देखकर मेरी "प्रगति" की जांच कर सकते हैं

golfed:

import java.util.*;class T{public static void main(String[]a){(new T()).s();}int[][]b=new int[4][4];int d,p,i,j,x,y,v,q,r;boolean I,V;void s(){p();do{d();do{char a=(new Scanner(System.in)).nextLine().charAt(0);y=a=='u'?f(0,1):a=='d'?f(1,1):a=='l'?f(0,0):a=='r'?f(1,0):0;}while(y<1);p();}while((x=n())>0);d();c("you "+(x<0?"win":"lose"));}int h(){for(int[]y:b)for(int x:y)if(x<2)return 1;return 0;}int n(){for(y=0;y<4;y++){for(x=0;x<4;x++){i=b[y][x];if(x<3&&i==b[y][x+1]||y<3&&i==b[y+1][x])return 1;if(i>2047)return -1;}}return h();}int f(int w,int z){I=w>0;V=z>0;for(i=d=0;i<4;i++){p=I?3:0;for(j=1;j<4;){v=V?i:j;x=I?3-v:v;v=V?j:i;y=I?3-v:v;q=V?x:p;r=V?p:y;if(b[y][x]==0||p==(V?y:x))j++;else if(b[r][q]==0){d+=b[r][q]=b[y][x];b[y][x]=0;j++;}else if(b[r][q]==b[y][x]){d+=b[r][q]*=2;b[y][x]=0;p+=I?-1:1;j++;}else p+=I?-1:1;}}return d;}int v(){return(new Random()).nextInt(4);}void p(){if(h()<1)return;do{x=v();y=v();}while(b[x][y]>0);b[x][y]=2;}void c(String a){System.out.println(a);}String l(char n,char m){String s=""+n;for(i=0;i<4;i++){for(j=0;j<4;j++)s+=m;s+=n;}return s;}void d(){c(l('+','-'));String p[]=new String[5];for(int[]y:b){p[0]=p[1]=p[3]=l('|',' ');p[2]="";for(x=0;x<4;)p[2]+=String.format("|%4d",y[x++]);p[2]+="|";p[4]=l('+','-');for(String q:p)c(q);}}}

Ungolfed: ( नए तह कार्यों के लिए अभिकथन-आधारित परीक्षण सहित, एक अद्यतन संस्करण के लिए इस परियोजना के लिए मेरे गीथूब भंडार की जाँच करें )

import java.util.*;
class Twe {
    public static void main(String[] a){
        (new Twe()).start();
    }
    int[][] board=new int[4][4];
    void start(){
        int x;
        placeTwo();
        do{
            drawBoard();
            resolve();
            placeTwo();
        }while((x=notDone())>0);
        drawBoard();
        wrapup(x);
    }
    int hasFree(){
        for(int[]y:board)
            for(int x:y)
                if(x<2)return 1;
        return 0;
    }
    int notDone(){
        int moves,x,y;
        for(moves=y=0;y<4;y++){
            for(x=0;x<4;x++){
                else if(x<3&&board[y][x]==board[y][x+1]||
                        y<3&&board[y][x]==board[y+1][x])moves++;
                if(board[y][x]>2047)return -1;
            }
        }
        return hasFree()+moves;
    }
    void wrapup(int k){
        if(k<0){
            chalk("you win",true);
        }else{
            chalk("you lose",true);
        }
    }
    void resolve(){
        do{
            switch((new Scanner(System.in)).nextLine().charAt(0)){
                case 'u':
                    if (fold(false,true)>0)return;
                    break;
                case 'd':
                    if (fold(true, true)>0)return;
                    break;
                case 'l':
                    if (fold(false,false)>0)return;
                    break;
                case 'r':
                    if (fold(true,false)>0)return;
                    break;
                case 'z':
                    board[0][0]=2048; // instant win;
                    return;
            }
        } while(true);
    }
    // false,true  = up
    // true, true  = down
    // false,false = left
    // true, false = right
    int fold(boolean inv, boolean vert){
        int didMove=0;
        int nextSpot,x,y,v,q,r;
        int[][] nb = new int[4][4];
        for(int i=0;i<4;i++){
            nextSpot=inv?3:0;
            for(int j=0;j<4;j++){
                v=vert?i:j;
                x=inv?3-v:v;
                v=vert?j:i;
                y=inv?3-v:v;
                q=vert?x:nextSpot;
                r=vert?nextSpot:y;
                if(board[y][x]>0){
                    if(nb[r][q]<1){
                        nb[r][q]=board[y][x];
                        didMove+=(inv?-1:1)*(vert?y-r:x-q);
                    }else if(nb[r][q]==board[y][x]){
                        nb[r][q]*=2;
                        nextSpot+=inv?-1:1;
                        didMove++;
                    }else{
                        nextSpot+=inv?-1:1;//suckage
                        q=vert?x:nextSpot;
                        r=vert?nextSpot:y;
                        nb[r][q]=board[y][x];
                        didMove+=(inv?-1:1)*(vert?y-r:x-q);
                    }
                }
            }
        }
        board=nb;
        return didMove;
    }
    int vec(){
        return (new Random()).nextInt(4);
    }
    void placeTwo(){
        if (hasFree()<1) return;
        int x,y;
        do{
            x=vec();y=vec();
        }while(board[x][y]>0);
        board[x][y]=2;
    }
    void chalk(String a, boolean nl){
        System.out.print(a+(nl?"\n":""));
    }
    String fill(char node, char mid){
        String str = ""+node;
        for(int i=0;i<4;i++){
            for(int j=0;j<5;j++)
                str+=mid;
            str+=node;
        }
        return str;
    }
    void drawBoard(){
        chalk(fill('+','-'),true);
        String p[] = new String[6];
        for(int[]y:board){
            p[0]=p[1]=p[3]=p[4]=fill('|',' ');
            p[2]="";
            for(int x=0;x<4;){
                p[2]+=adjust(y[x++]);
            }
            p[2]+="|";
            p[5]=fill('+','-');
            for (String q:p){
                chalk(q,true);
            }
        }
    }
    String adjust(int a){
        return String.format("|%5d",a);
    }
}

कार्यक्रम का उपयोग करना सरल है। बनाने और चलाने के लिए:

javac T.java
java T

दाएं uगुना करने के लिए, rदाईं ओर dमोड़ने के लिए , बाईं ओर मोड़ने के लिए दबाएँ l। किसी भी अन्य कुंजी को अनदेखा किया जाता है, अमान्य (कोई परिणाम नहीं) चाल को अनदेखा किया जाता है। जावा होने के नाते, enterलाइन बफर को फ्लश करने के लिए प्रत्येक कुंजी के बाद दबाएं । नियमों द्वारा अपेक्षित के रूप में, यदि आप इस कार्यक्रम आउटपुट जीत you win, यदि आप प्रोग्राम outputs खोना you lose। नई 2को खुले टाइल्स में बेतरतीब ढंग से रखा गया है। मर्ज बताए गए नियमों का पालन करते हैं। कक्ष 4x4 वर्ण होते हैं, जिसमें प्रत्येक कक्ष के चारों ओर एक सीमा होती है। बेशक, मुझे एक टिप्पणी छोड़ दें अगर मैंने कुछ गड़बड़ की है और मैं इसे ठीक करना निश्चित करूंगा।

उदाहरण आउटपुट:

$ java T
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
u
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   2|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
l
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
u
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   4|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   2|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
l
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   4|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   4|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   2|
|    |    |    |    |
+----+----+----+----+
u
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   8|   2|   0|   2|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
l
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   8|   4|   2|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
l
u
d
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   2|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   8|   4|   2|   0|
|    |    |    |    |
+----+----+----+----+
d
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   2|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   8|   4|   4|   0|
|    |    |    |    |
+----+----+----+----+
l
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   2|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   8|   8|   0|   0|
|    |    |    |    |
+----+----+----+----+
l
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   2|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   2|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|  16|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
d
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   2|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   4|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|  16|   2|   0|   0|
|    |    |    |    |
+----+----+----+----+
d
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   0|   0|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|   4|   2|   0|   0|
|    |    |    |    |
+----+----+----+----+
|    |    |    |    |
|    |    |    |    |
|  16|   4|   0|   0|
|    |    |    |    |
+----+----+----+----+

2

लुआ, 622 616 615 612 592 590 575 बाइट्स

बाएं, नीचे, दाएं, ऊपर (सुन्नत इनपुट के लिए) के साथ सहसंबंधित 1,2,3,4 के लिए क्वेरी; यदि आप इसे बुरा इनपुट देते हैं तो क्रैश हो जाता है।

खाली वर्गों को '0' के रूप में मुद्रित किया जाता है।

b={('\0'):rep(16):byte(1,16)}c=1 a=print h=unpack while{}do if c then c=z
e={}for i=1,16 do e[#e+1]=0==b[i]and i or z end _=#e==0 and
a'you lose'b[e[math.random(#e)]]=2 l=('+----'):rep(4)..'+\n'm=l:gsub('-',' ')for
i=1,13,4 do a(l..m..m..m..('+%4d+%4d+%4d+%4d+'):format(h(b,i)))end a(l)end c=z
u,v,w=h({4,1,-4,1,-4,16,4,-1,1,1,4,-4},3*io.read()-2)for i=1,4 do o=-1 for j=2,4
do if 0~=b[u*i+v*j+w]then for k=1-j,o do p=u*i-v*k+w q=p+v r=b[p]if r==0 then
b[p]=b[q]b[q]=r c=1 o=k elseif r==b[q]then _=r==1024 and a'you win'b[p]=r*2
b[q]=0 c=1 o=k-1 break end end end end end end 

उदाहरण आउटपुट:

+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   2+   0+   0+   0+
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   0+   0+   0+   0+
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   0+   0+   0+   0+
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   0+   0+   0+   0+
+----+----+----+----+

2
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   0+   2+   0+   0+
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   0+   0+   0+   0+
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   0+   0+   0+   0+
+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   2+   0+   0+   0+
+----+----+----+----+

0

क्लोजर: 599

इसे एक REPL में चलाएं

golfed

(defn i[b](let[f(into[](flatten b))z(seq(keep-indexed #(when(zero? %2)%1)f))]
(cond(some #{2048}f)(pr "you win")(empty? z)(pr "game over"):e(partition 4
(assoc f(rand-nth z)2)))))(def r #(remove zero? %))(loop[b(i (partition 4
(repeat 16 0)))](when((fn[v](doseq[l(for[a v](apply str(map #(format "%5d " %)a)))]
(println l "\n"))v)b)(-> b((apply comp(assoc(into[](repeat 5(fn[v]
(map(fn[n](map #(nth % n)v))[3 2 1 0]))))({"h"4 "k"3 "l"2 "j"1}(read-line))
(partial map(comp #(take 4(concat % [0 0 0 0]))(fn[v]
(r(reduce #(let[l(last %1)](if(= %2 l)(conj(pop %1)(+ l %2) 0)
(conj %1 %2)))[]v)))r)))))i recur)))

ungolfed

(defn insert-2 [board]
  (let [flat (into [] (flatten board))
        zero-indices (seq (keep-indexed
                       #(when (zero? %2) %1)
                       flat))]
    (cond
      (some #{2048} flat) (pr "you win")
      (empty? zero-indices) (pr "game over")
      :else (partition 4 (assoc flat (rand-nth zero-indices) 2)))))

(defn rotate [board]
  (map
    (fn [n]
        (map #(nth % n)
             board))
    [3 2 1 0]))

(defn remove-zeros [row]
 (remove zero? row))

(defn fill [row]
 (take 4 (concat row [0 0 0 0])))

(defn sum-up [acc x]
  (let [l (last acc)]
    (if (= x l)
      (conj (pop acc) (+ l x) 0)
      (conj acc x))))

(defn sum-pairs [v]
  (remove-zeros (reduce sum-up [] v)))

(defn render [v]
  (doseq [line (for [row v]
                 (apply str (map #(format "%5d " %) row)))]
    (println line "\n")) v)

(defn slide [board]
 (map (comp
        fill
        sum-pairs
        remove-zeros
        ) board))

(loop [board (insert-2 (partition 4 (repeat 16 0)))]
  (when (render board)
    (let [input ({"h" 4 "k" 3 "l" 2 "j" 1} (read-line))
          command (apply comp
                         (assoc (into [] (repeat 5 rotate))
                                input slide))] ;; (comp rotate rotate slide rotate rotate)
      (-> board command insert-2 recur))))
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.