53

2048 est un jeu incroyablement amusant et addictif dans lequel le but est de créer une tuile avec 2048 dessus.

Voici une brève description du jeu:

Appuyez sur une touche fléchée pour faire glisser tous les blocs de la scène dans cette direction. Par exemple, si xreprésente un bloc et que vous avez appuyé sur la flèche vers le haut dans ce cas:

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

Alors le conseil deviendrait

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

De plus, les blocs sont numérotés à partir de 2. Si deux blocs identiques numérotés sont déplacés ensemble, ils seront fusionnés dans le prochain nombre. Par exemple, en appuyant sur "up" sur ce forum:

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

Créerait ceci:

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

Et ensuite, après avoir appuyé sur "right", il deviendrait ..44, et donc appuyer à nouveau sur créerait un bloc "8", et ainsi de suite.

Chaque tour, un nouveau bloc "2" est créé sur une case ouverte aléatoire. (Ce n’est pas toujours un "2", mais pour des raisons de simplicité, gardons-le.) S'il ne reste plus aucun mouvement possible (le tableau est plein et vous ne pouvez rien fusionner), la partie est perdue et si un bloc 2048 est créé, vous gagnez!

Votre défi est de recréer ce jeu, joué au golf!

Pour les cas extrêmes, comme appuyer sur "droite" sur ce tableau:
```
....
.222
....
....
```
vous devez fusionner les tuiles les plus proches du bord de la touche fléchée enfoncée. Par exemple, cela deviendrait ..24, car les deuxième et troisième "2" sont les plus proches du bord droit.
Si le joueur appuie sur un coup invalide (comme "haut" sur un tableau 2.2. / .... / .... / ...., par exemple), vous devez ignorer le coup.
Les déplacements peuvent être acceptés de quelque manière que ce soit, tels que cliquer, flèches ULRD, etc.
Les carreaux doivent tous avoir la même forme - un carreau "1024" doit avoir la même taille qu'un carreau "2".
Les tuiles doivent être séparées d'une manière ou d'une autre. Par exemple, |1024| 2|1024|1024|est un exemple valide de ligne (en supposant que les carreaux sont des carrés), alors qu’il 1024 210241024ne l’est pas.
Vous devez indiquer "vous gagnez" si le joueur crée une tuile 2048, ou "vous perdez" s'il ne reste plus aucun coup valide.
C'est du code-golf , donc le code le plus court en octets va gagner!

code-golf game sliding-puzzle Poignée de porte
la source

Au lieu d'accepter des rangées de caractères uniques (les cinq premiers exemples) et / ou des mosaïques séparées (la dernière), pourquoi ne pas attribuer des puissances croissantes de deux à des caractères individuels pour normaliser la sortie?

Millinon

@millinon Parce que c'est supposé être aussi similaire que possible au jeu actuel de 2048 (cela rendrait le titre vide de sens), et cela supprimerait une partie du défi.

Poignée de porte

1

" S'il ne reste plus aucune fusion possible, le jeu est perdu " Ne devrait-il pas y avoir un "et le tableau est plein" quelque part?

Peter Taylor

l'espace suffit-il comme séparateur de tuiles?

John Dvorak

5

C'est drôle comme toutes vos questons obtiennent une tonne de votes, mais peu de réponses.

TheDoctor

7

APL (Dyalog APL) , 153 150 167 156 octets

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

Invite au déménagement; 0 = gauche, 1 = haut 2 = droite, 3 = bas

Essayez-le en ligne!

Ungolfed, avec des espaces

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 4⍴0

Explication

Les lignes vides indiquent une nouvelle ligne, tandis que les blocs de lignes appartiennent à une seule ligne

C ← ⎕UCSattribuer les points de conversion vers / de points UCS au nom C (pour C odepoint)

'you ',"vous" ajouté au résultat de la fonction {...

2048 ∊ ⍵: 'win' si l'argument (le tableau) contient 2048, alors retournez "win"

n ← ⍵assigne le bon argument à n (il peut donc être modifié sur place)

z ← 0 = ∊n z obtient la liste booléenne où z aplati est 0

(z / ∊n) z filtre les n aplatis (pour obtenir uniquement les zéros),
[? +/z]utilisez un nombre aléatoire compris entre 1 et le nombre de zéros (somme de la valeur booléenne z ) pour sélectionner la position contenant
← 2un zéro

⎕ ←affiche
4 ↑¨chaque
⍕¨nreprésentation de chaîne étendue à la longueur 4 (avec espaces)

1 ∊si l'un des éléments suivants est trouvé;
(⍉2=⌿n)Égalités verticales par paires (transposées pour être concaténables)
,ou (concaténées à)
(2=/n)égalités horizontales par paires
,ou (concaténées à)
0=nzéros,
:puis:
∇appelez cette fonction sur le résultat de la fonction {...

R ← R (pour R ux de R otated) est
↓la scission en-rangées d'
⍉∘⌽⍣⎕ invite pour l' entrée numérique, puis une rotation (miroir littéralement horizontalement, puis transposer) l'argument (la carte) -90 ° fois le numéro entré

r ← r (pour r esult) reçoit
R⍣¯1l'inverse de R (rotation en arrière, puis la fusion des lignes dans la matrice) appliquée sur le résultat de la fonction {...

t ← 2 * ⍳11 t obtient 2¹, 2², 2³, ... 2¹¹

4↑pavé avec zéros à droite jusqu'à la longueur 4
Cconvertir les caractères UCS suivants en points de code
(C¨2/¨t)⎕R(C¨,¨2×t)regex remplace les paires de chaque t par 2 fois chaque t , mais convertit d'abord les nombres en caractères UCS correspondants afin que la regex traite
C ⍵~0l'argument sans zéros (compactés à gauche), puis convertis en points de code UCS

}¨[end of function] appliqué à chacune des
U↓lignes (mais les combiner ensuite) de
R ⍵ R appliqué à l'argument (le tableau)

⍵ ≡ r:si l'argument (l'ancien état de la carte) est identique à r (nouvel état de la carte), alors:
∇⍵appelez cette fonction sur l'argument non modifié (parce que l'utilisateur a effectué un déplacement non valide), sinon

rrenvoyer r (le nouvel état du tableau)

} n[fin de fonction] appliqué à n (le nouvel état de la carte), sinon

'lose' retourner "perdre"

} 4 4 ⍴ 0 [end of function] appliqué à une table de zéros 4-sur-4 (l'état initial)

Adam
la source

20

GolfScript, 323 caractères

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;

Les clés que vous devez utiliser sont, wasdmais vous pouvez modifier la constante du code pour obtenir les clés de votre choix. Il ignore gracieusement toute clé inconnue ou tout mouvement illégal. Malheureusement, vous devez appuyer sur Entrée après chaque touche.

Exemple 2048ascii

Solution de 256 caractères

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;

Ici, la sortie est logarithmique hexadécimale, c’est-à-dire 0, pour ., 1pour 2, 2pour 4, 3pour 8... Bpour 2048. Puisque nous connaissons tous les hexadécimaux et les pouvoirs de deux, cela ne devrait pas être une limitation du tout.

Exemple d'exécution (premiers coups):

Howard
la source

Tuiles devrait être séparé si, mais bon travail.

Teun Pronk

@TeunPronk J'y travaille. Malheureusement, ça casse le beau pouvoir de deux points.

Howard

7

+ illimité pour être exactement 256 caractères

SztupY

oui ... 2 ^ 7 caractères !!

Mukul Kumar

1

Agréable! Je ne savais pas comment faire une entrée dans golfscript auparavant. Personnellement, j'aime mieux la solution 256 caractères, plus facile à lire. Et je dirais que les tuiles sont séparées car chaque tuile ne fait qu'un caractère. il n'y a jamais d'ambiguïté.

Claudiu

12

J - 240 230 216 char

Cela compte la fin de ligne, car vous en avez besoin pour lancer le jeu sur la console. Jouez en tapant l'un des udlrpuis en appuyant sur Entrée. Les mouvements qui ne font rien au tableau sont gérés correctement, mais le programme se fâchera contre vous si vous lui donnez une mauvaise entrée.

'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

La version lisible et l'explication sont un peu trop volumineuses pour s'intégrer facilement dans le message: vous pouvez trouver un résumé sur ce lien .

Usage:

   '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|
+----+----+----+----+

algorithmeshark
la source

Génial. Malheureusement, la taille des carrés diffère lorsque le contenu change et c'était l'une des exigences énoncées dans la question.

Howard

@Howard Je suis persuadé qu'il est beaucoup plus laid de rendre les carreaux rigoureusement carrés que de les laisser être, mais là, c'est réglé.

algorithmshark

9

Mathematica, 484 caractères

Très laid.

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"}}]

Contrôlé par les touches fléchées.

entrez la description de l'image ici

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

entrez la description de l'image ici

Alephalpha
la source

2

J'aime les regards des non-golfés!

Tomsmeding

7

Delphi XE3 (Waaay to many {whispers}} 2 979 octets -> non golfé 4,560 octets)

J'aime appeler cela "le code 2048 du roman" a
utilisé plus d'octets que je n'aime mais cela fonctionne et c'était amusant à faire.

Je vais encore essayer de le raccourcir plus tard.

Jeu en cours

Le jeu

Golfé

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.

Teun Pronk
la source

2

2.979 octets ? Est-ce censé être en kilo-octets?

Hosch250

9

Certains endroits dans le monde utilisent des virgules en chiffres, comme nous utilisons les points. Je ne serais pas du tout surpris si l'inverse était également vrai.

undergroundmonorail

1

@undergroundmonorail Certes, en Europe, la virgule numéro douze cent six est souvent écrite sous la forme 1.012,6 au lieu de la valeur américaine 1 012,6 :)

tomsmeding

CodeGolf m'a appris que vous pouvez échanger ,et .en chiffres!

Tejas Kale

1

C'est une bonne chose que cette question n'ait pas de classement ...

Patrick Roberts

7

C (norme C89), 881 octets

Utilise les touches WASD pour te déplacer. Compile dans GCC et clang par défaut, sauf si défini sur le standard C99 (je suppose). Utilise termios.h, fonctionne sous Linux et MacOS X. Pas sûr de Windows.

#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");}

Cassé en quelques lignes:

#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");}

Les regards:

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

Cela peut être amélioré à coup sûr.

asr
la source

5

Java: 1346 1269

Modifier Ainsi, bien que ce concours soit terminé, je ne peux parfois pas me laisser aller lorsque des améliorations peuvent être apportées. Cette version offre une fonction de pliage sur place plus mince, plus méchante, l'éviction de la plupart des booleantypes, sauf dans les cas où elle serait plus verbeuse sans eux, et des cellules légèrement plus petites (4x4 au lieu de 5x5) pour y découper quelques caractères supplémentaires.

C'était donc amusant. Merci d'avoir posté! Non, cela faisait 2856 octets, au golf je l'ai réduit à 1346 octets. Étant Java, je ne vais pas gagner, mais je voulais faire une bonne performance. Il était amusant de définir une fonction de remontée "générale" pour gérer les jointures et les déplacements de mosaïques. Vous pouvez bien sûr consulter mes "progrès" en consultant les validations de mon référentiel github pour connaître cette solution .

Golfé:

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: (Consultez le référentiel github de ce projet pour une version mise à jour, incluant un test basé sur les assertions pour les nouvelles fonctions de pliage)

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);
    }
}

Utiliser le programme est simple. Pour construire et exécuter:

javac T.java
java T

Appuyez upour plier, rplier à droite, dplier, lplier à gauche. Toute autre clé est ignorée, les déplacements invalides (aucun résultat) sont ignorés. Étant Java, appuyez sur enteraprès chaque touche pour vider le tampon de ligne. Conformément aux règles, si vous gagnez les sorties du programme you win, si vous perdez les sorties du programme you lose. Les nouveaux 2sont placés au hasard dans les carreaux ouverts. Les fusions suivent les règles énoncées. Les cellules sont des caractères 4x4, avec une bordure entourant chaque cellule. Bien sûr, laissez-moi un commentaire si je me suis trompé et que je serai certain de le réparer.

Exemple de sortie:

$ 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|
|    |    |    |    |
+----+----+----+----+

ProgrammeurDan
la source

2

Lua, 622 616 615 612 592 590 575 octets

Requêtes stdin pour 1,2,3,4 corrélation avec gauche, bas, droite, haut (fait pour la saisie du pavé numérique); se bloque si vous donnez une mauvaise entrée.

Les carrés vierges sont imprimés en tant que '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

Exemple de sortie:

+----+----+----+----+
+    +    +    +    +
+    +    +    +    +
+    +    +    +    +
+   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+
+----+----+----+----+

thumbumbine
la source

0

Clojure: 599

l'exécuter dans un REPL

joué au golf

(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)))

non-golfé

(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))))

Kolja
la source

Créer un simple clone de jeu 2048

Réponses: