Inspirado en xkcd .

Su desafío es determinar si un número sería una buena combinación en el juego 2048 . Su entrada será un número, como:

8224

Y la salida será si ese número sería un buen combo de 2048, que para esta entrada sería trueo yeso 1o cualquier otra forma de indicar un resultado positivo.

Para aquellos que no están familiarizados con el juego, he aquí una explicación sencilla: las potencias de dos están dispuestas en una cuadrícula, como esto: [2] [2]. Las fichas se pueden mover en cualquier dirección, y si dos fichas idénticas se encuentran, se convierten en la siguiente potencia de dos (así que [2] [2]cuando se mueven hacia la izquierda o hacia la derecha [4]). O bien, puedes probar el juego aquí .

¿Qué significa "una buena combinación 2048"? Significa cualquier número que, si estaba en el juego "2048", podría combinarse en un solo número. (Un cero significa un espacio vacío , y puede ignorarse si es necesario). ¡Tenga en cuenta que los números pueden ser múltiples dígitos! Sin embargo, los números no deben cambiar entre movimientos. Aquí hay algunos ejemplos / casos de prueba (con "Bueno" que indica una buena combinación y "Malo" que significa que no es bueno):

• Bueno: 8224 (8224 -> 844 -> 88 -> 16)
• Bueno: 2222 (2222 -> 44 -> 8)
• Bueno: 22048 (22048 -> 448 -> 88 -> 16)
• Malo: 20482 (no puede combinar los 2 externos, ni puede combinar un 2048 y un 2)
• Bueno: 20482048 (20482048 -> 4096)
• Malo: 210241024 (210241024 -> 22048, pero ahora es [2] [2048] y no se puede combinar ya que los números no pueden cambiar entre movimientos)
• Bien: 2048 (ya es un número)
• Malo: 2047 (no es un poder de 2)
• Malo: 11 (no hay 1 en el juego)
• Bueno: 000040000000 (los ceros son espacios vacíos)

Reglas misceláneas:

• La entrada puede ser desde cualquier lugar razonable, es decir, STDIN, argumento de función, archivo, etc.
• La salida también puede ser razonable, es decir, STDOUT, valor de retorno de función, archivo, etc.
• Ignorar el tamaño de la cuadrícula, 22222222aún debería salir verdadero
• No hay un máximo de lo que podría ser un número, siempre que sea una potencia de dos. Por lo tanto, los números posibles son cualquier potencia de dos mayor que 0.
• Para aquellos preocupados por los ceros que causan ambigüedad, ese no es el caso. Por ejemplo, 22048se puede analizar como [2] [2048]o [2] [2] [0] [4] [8]. El primero no funciona, pero el segundo sí, por lo que debería ser verdadero.
• Este es el código de golf , ¡así que el código más corto en bytes ganará!

GolfScript, 137 caracteres

[0`]1$,4*,{2\)?`}%+:W;[]\]][]\{{:A;W{A 1=\?!},{[.A~@,>\@~+\].~!{0-.,/@+\0}*;}%~}%.}do+.{~}%,{{.-1%}%.&{[{.2$={+)}*}*]{1|(}%}%}*{,1=},!!

La entrada debe darse en STDIN. La salida es 0/ 1para números malos / buenos. La mayor parte del código es necesario para analizar las posibles entradas.

Esta versión más corta (113 caracteres) realiza una prueba de cambio simple que no funcionaría correctamente para entradas como 224422.

[0`]1$,4*,{2\)?`}%+:W;[]\]][]\{{:A;W{A 1=\?!},{[.A~@,>\@~+\].~!{0-.,/@+\0}*;}%~}%.}do+{W{~[.:S]/[S.+]*}/,1=},!!

Todos los casos de prueba se pueden verificar en línea .

Python: 457 422 caracteres

z=range
def c(n):
 for x in z(1,12): 
  if int(n)==2**x:return 1
 return 0
def p(s):
 if s=='':return[]
 for i in z(len(s),0,-1):
  if c(s[:i])>0and p(s[i:])!=1:return [int(s[:i])]+p(s[i:])
 return 1
def r(a):
 if len(a)==1:return 1
 i,t=1,a[:1]
 while i<len(a):
  if a[i]==t[-1]:t[-1]*=2
  else:t+=[a[i]]
  i+=1
 if len(t)==len(a):return 0
 return r(t) 
def f(s):
 if p(s)==1or r(p(s))==0:print('bad')
 else:print('good')

La función f (s) obtiene una cadena de dígitos y genera 'bueno' o 'malo' en consecuencia. Elegí no usar 0 como espacios porque los espacios no tienen sentido en el juego y crean ambigüedad al analizar cadenas (¿22048 es bueno o malo?). Esto solo usa números hasta 2048, pero eso se puede cambiar sin agregar caracteres. Al costo de aproximadamente 10 caracteres, también puedo imprimir todos los pasos para combinar los números. Y me doy cuenta de que este código aún no se ha jugado lo suficiente; no te preocupes, las ediciones están por venir.

Haskell: 285 254 253 237 230 227

uso: simplemente cárguelo en ghci y pase la cadena a h.

*Main> h "210241024"
False
*Main> h (replicate 1024 '2') -- very long string
True
*Main> h (replicate 1023 '2') -- odd one out
False

Código:

t=i 0
i n=mod n 2<1&&(n<3||i(div n 2))
a%[]|i a=[[a]]|t=[];a%(b:c)=[a:d|d<-b%c,i a]++(a*10+b)%c
c(0:a)=c a;c(a:b:d)|a==b=(a+a):c d|t=a:c(b:d);c a=a
l a=c a/=a&&(g.c)a
g[a]=t;g a=l a||(l.reverse)a
h b=any g$0%(map(read.(:[]))b)

Comentario: ies la comprobación de si un número es una potencia de 2, esto será superado por los idiomas con un poco de giro. %genera recursivamente todos los análisis que son listas de potencias de 2 o 0. ccontrae los mosaicos. lprueba recursivamente si las fichas son plegables a la izquierda o bien. gprueba si las fichas son plegables a la izquierda o la derecha. No hay límite para los números en los mosaicos, por ejemplo, h ((show (2^200))++(show (2^200)))devuelve verdadero para 2 mosaicos marcados "1606938044258990275541962092341162602522202993782792835301376".

Editado para corregir un error que no colapsó correctamente "88222288888" a la derecha, pero también encontró más oportunidades de golf.

Perl, 175-336 bytes

while(<>){chomp;$n="nothing";$\=("."x(1+/^[2048]+$/+/^((\d+)0*\2)+$/+((sprintf"%b",
$_)!~/1.*1/)))."\n";($o=$\)=~y/.\n/oh/;print$o;$m=length;for$i(1..$m){$a=$_;$r=
qr((\d*[2468])0*\2)0*/;($b=substr$a,0,$i,"")=~s/$r/$2+$2/ge;@n=$"="$b$a";push@n,$"while$"
=~s/$r/$2+$2/ge;($"%2&&next)||($">>=1)while$">1;$n="nice";(print)for@n;last}print$n}

Mantener intactos los elementos esenciales:

$_=shift;$m=length;for$i(1..$m){$a=$_;$r=qr/((\d*[2468])0*\2)0*/;($b=substr$a,0,$i,"")=~
s/$r/$2*2/ge;$"="$b$a";1while$"=~s/$r/$2*2/ge;($"%2&&next)||($">>=1)while$">1;exit}die;

1

ooh .. 1 .. bonito ..

2

oooh ... 2 ... bonito ...

22

oooh ... 22 ... 4 ... agradable ...

42

ooh .. nada ..

422

ooh .. 422 .. 44 .. 8 .. agradable ..

322

Oh. nada.

336

Oh. nada.

4224

ooh .. nada ..

4228

ooh .. 4228 .. 448 .. 88 .. 16 .. agradable ..

16022481602248

ooh .. 1604481602248 .. 16088160448 .. 1601616088 .. 3216016 .. 3232 .. 64 .. bonito ..

[ 64 y 256 conducen a algunas ambigüedades poco resolubles que la codiciosa correspondencia no puede resolver ... pero estos son buenos recuentos de bytes. ]

2048

oooh ... 2048 ... bonito ...

Delphi 572 582 caracteres

Código editado, el límite se establece en 2 ^ 30 para que no supere el valor MaxInt en Delphi.

Golfed

uses SysUtils,Classes;var t,j,c:integer;s,n:string;L:TStringList;function p(x:string):boolean;var r,i:int64;begin if x='0'then exit(1>0);i:=2;r:=StrToInt(x);while i<r do i:=i*2;p:=i=r;end;begin read(s);t:=0;L:=TStringList.Create;j:=1;while j<=Length(s)do begin for c:=9downto 1do begin n:=copy(s,j,c);if p(n)then break;end;if n>'0'then L.Add(n);j:=j+Length(n);end;for j:=0to L.Count-1do t:=t+StrToInt(L[j]);j:=0;repeat if j=L.Count-1then break;if L[j]=L[j+1]then begin L[j]:=IntToStr(StrToInt(L[j])*2);L.Delete(j+1);j:=0;end else inc(j);until L.Count=1;write(strtoint(L[0])=t);end.

Sin golf

uses
  SysUtils,
  Classes;

var
  t,j,c:integer;
  s,n:string;
  L:TStringList;
  function p(x:string):boolean;
  var
    r,i:int64;
  begin
    if x='0'then exit(1>0);
    i:=2;r:=StrToInt(x);
    while i<r do
      i:=i*2;
    p:=i=r;
  end;
begin
    read(s);
    t:=0;L:=TStringList.Create;
    j:=1;
    while j<=Length(s)do
    begin
      for c:=9downto 1do
      begin
        n:=copy(s,j,c);
        if p(n)then break;
      end;
      if n>'0'then L.Add(n);
      j:=j+Length(n);
    end;
    for j:=0to L.Count-1do
      t:=t+StrToInt(L[j]);
    j:=0;
    repeat
      if j=L.Count-1then break;
      if L[j]=L[j+1]then
      begin
        L[j]:=IntToStr(StrToInt(L[j])*2);
        L.Delete(j+1);j:=0
      end
      else
        inc(j);
    until L.Count=1;
    write(strtoint(L[0])=t);
end.

EDITAR

Entonces sentí curiosidad y me pregunté cuántas de estas combinaciones encajarían en el rompecabezas y realicé una prueba.

Para otros que también son curiosos, haga una prueba también;)

Pero bueno, aquí están los resultados:
20736 combinations were tested and 1166 were great combinations

Debo decir combinaciones de 3 o más ceros se omiten (tiene sentido ¿verdad?)
Combinaciones son casi única, es decir, las combinaciones 2248, 8224, 8422y 4228todos fueron contados como una gran combinación.

Mathematica - 218 bytes

f=MemberQ[DeleteCases[Map[FromDigits,l~Internal`PartitionRagged~#&/@Join@@Permutations/@IntegerPartitions@Length[l=IntegerDigits@#],{2}],{___,x_,___}/;!IntegerQ[2~Log~x]||x<2]//.{a___,x_,x_,b___}:>{a,2x,b},{_Integer}]&

Versión sin golf:

f[n_] := MemberQ[
  DeleteCases[
      Map[
        FromDigits, 
        Internal`PartitionRagged[l, #] & /@ 
          Join @@ Permutations /@ IntegerPartitions[Length[l = IntegerDigits[n]]], 
        {2}
      ],
      {___, x_, ___} /; x < 2 || ! IntegerQ[2~Log~x]
    ]
  ] //. {a___, x_, x_, b___} :> {a, 2 x, b}, 
  {_Integer}
]

La Internal\magia PartitionRagged` se toma de esta pregunta .

Esta solución maneja tamaños de cuadrícula arbitrarios y números arbitrariamente grandes.

Aquí hay una versión de 195 bytes que funciona como el juego real con solo 4 mosaicos (así f[22222222]es False):

f=MemberQ[(d=DeleteCases)[d[ReplaceList[IntegerDigits@#,{a__,b___,c___,d___}:>FromDigits/@{{a},{b},{c},{d}}],0,2],{___,x_,___}/;!IntegerQ[2~Log~x]||x<2]//.{a___,x_,x_,b___}:>{a,2x,b},{_Integer}]&

donde he reemplazado

Map[
  FromDigits, 
  Internal`PartitionRagged[l, #] & /@ 
    Apply[
      Join, 
      Permutations /@ IntegerPartitions[Length[l = IntegerDigits@#]]
    ], 
  {2}
]

con

ReplaceList[
  IntegerDigits[n], 
  {a__, b___, c___, d___} :> FromDigits /@ {{a}, {b}, {c}, {d}}
]

Haskell - 260 263

import Data.Bits
p[x]=[[[x]]]
p(x:s)=do r@(h:t)<-p s;[[x]:r,(x:h):t]
q=filter(and.map(\n->(n::Integer)/=1&&n.&.(-n)==n)).map(filter(/=0)).map(map read).p
c(x:y:s)
 |x==y=2*x:c s
 |True=x:(c$y:s)
c x=x
r[x]=True
r l=c l/=l&&(r(c l)||r(c$reverse l))
f=or.map r.q

fEs la función. Ejemplos:

> f"22228"
True
> f"20482044"
False

Una pequeña explicación:
pdevuelve todas las formas de dividir una lista.
qfiltra aquellos que consisten en solo potencias de 2 (excluyendo 1 pero incluyendo 0).
cintenta colapsar una cadena.
ritera la colisión derecha e izquierda hasta que solo queda 1 elemento, o la cadena es incollapsable.