Ispirato da xkcd .

La tua sfida è determinare se un numero farebbe una buona combinazione nel gioco 2048 . Il tuo input sarà un numero, come ad esempio:

8224

E l'output sarà se quel numero farebbe una buona combinazione 2048, che per questo input sarebbe trueo yeso 1o qualsiasi altro modo per indicare un risultato positivo.

Per chi non ha familiarità con il gioco, ecco una spiegazione semplice: potenze di due sono disposti su una griglia, in questo modo: [2] [2]. Le tessere possono essere spostate in qualsiasi direzione, e se due tessere identiche si incontrano, diventano la potenza successiva di due (quindi [2] [2]quando spostate a sinistra o a destra diventano [4]). Oppure, potresti semplicemente provare il gioco qui .

Che cosa significa "una buona combinazione 2048"? Indica qualsiasi numero che, se fosse nel gioco "2048", potrebbe essere combinato in un unico numero. (Uno zero indica uno spazio vuoto e, se necessario, può essere ignorato.) Nota che i numeri potrebbero essere più cifre! Tuttavia, i numeri non devono cambiare tra le mosse. Ecco alcuni esempi / casi di test (con "Buono" che indica una buona combinazione e "Cattivo" che significa non buono):

• Buono: 8224 (8224 -> 844 -> 88 -> 16)
• Buono: 2222 (2222 -> 44 -> 8)
• Buono: 22048 (22048 -> 448 -> 88 -> 16)
• Cattivo: 20482 (non è possibile combinare i 2 esterni, né è possibile combinare un 2048 e un 2)
• Buono: 20482048 (20482048 -> 4096)
• Cattivo: 210241024 (210241024 -> 22048, ma ora è [2] [2048] e non può essere combinato poiché i numeri non possono cambiare tra le mosse)
• Buono: 2048 (è già un numero)
• Cattivo: 2047 (non è un potere di 2)
• Cattivo: 11 (non ci sono 1 nel gioco)
• Buono: 000040000000 (gli zero sono spazi vuoti)

Regole varie:

• L'input può essere ovunque ragionevole, ad esempio STDIN, argomento di funzione, file, ecc.
• L'output può anche essere ovunque ragionevole, ad esempio STDOUT, valore di ritorno della funzione, file, ecc.
• Ignora le dimensioni della griglia: 22222222dovrebbe comunque essere visualizzato true.
• Non c'è il massimo per quello che potrebbe essere il numero, purché sia ​​una potenza di due. Pertanto i numeri possibili sono qualsiasi potenza di due maggiori di 0.
• Per chi è preoccupato per gli zero che causano ambiguità, non è così. Ad esempio, 22048può essere analizzato come uno [2] [2048]o [2] [2] [0] [4] [8]. Il primo non funziona, ma il secondo funziona, quindi dovrebbe essere vero.
• Questo è code-golf , quindi vincerà il codice più breve in byte!

GolfScript, 137 caratteri

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

L'ingresso deve essere dato su STDIN. L'output è 0/ 1per numeri cattivi / buoni. Gran parte del codice è necessario per analizzare i possibili input.

Questa versione più corta (113 caratteri) esegue un semplice test di spostamento che non funzionerebbe correttamente per input simili 224422.

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

Tutti i casi di test possono essere controllati online .

Python: 457 422 caratteri

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 funzione f (s) ottiene una stringa di cifre e genera "buono" o "cattivo" di conseguenza. Ho scelto di non usare 0 come spazi perché gli spazi sono insignificanti nel gioco e creano ambiguità quando analizzano le stringhe (è 22048 buono o cattivo?). Questo utilizza solo numeri fino al 2048, ma può essere modificato senza aggiungere caratteri. Al costo di circa 10 caratteri posso anche stampare tutti i passaggi della combinazione dei numeri. E mi rendo conto che questo codice non è ancora abbastanza golfato; non ti preoccupare, le modifiche stanno arrivando.

Haskell: 285254253 237 230 227

utilizzo - basta caricarlo in ghci e passare la stringa a h.

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

Codice:

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)

Commento: iè il controllo se un numero è una potenza di 2, questo sarà superato da lingue con bit twiddling. %genera ricorsivamente tutti gli analisi che sono elenchi di potenze di 2 o 0. ccomprime le tessere. lverifica ricorsivamente se le tessere sono pieghevoli a sinistra o in buono stato. gverifica se le tessere sono pieghevoli a sinistra oa destra. Non ci sono limiti ai numeri sulle tessere - ad es. h ((show (2^200))++(show (2^200)))Restituisce vero per 2 tessere contrassegnate con "1606938044258990275541962092341162602522202993782792835301376".

Modificato per correggere un bug che non comprimeva correttamente "88222288888" a destra, ma trovava anche maggiori opportunità di golf.

Perl, 175-336 byte

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}

Mantenere intatti solo gli elementi essenziali:

$_=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 .. bello ..

2

oooh ... 2 ... bello ...

22

oooh ... 22 ... 4 ... bello ...

42

ooh .. niente ..

422

ooh .. 422 .. 44 .. 8 .. bello ..

322

Oh. Niente.

336

Oh. Niente.

4224

ooh .. niente ..

4228

ooh .. 4228 .. 448 .. 88 .. 16 .. bello ..

16022481602248

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

[ 64 e 256 portano ad alcune ambiguità scarsamente risolvibili che la corrispondenza avida non può far fronte ... ma questi sono buoni conteggi di byte. ]

2048

oooh ... 2048 ... bello ...

Delfi 572 582 caratteri

Codice modificato, il limite è impostato su 2 ^ 30 quindi non supererà il valore MaxInt in 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.

Ungolfed

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.

MODIFICARE

Quindi mi sono incuriosito e mi sono chiesto quante di queste combinazioni si sarebbero adattate al puzzle e ne ho fatto un test.

Per altri che sono anche curiosi, fai anche un test;)

Ma ok ecco i risultati:
20736 combinations were tested and 1166 were great combinations

Devo dire che le combinazioni con 3 o più zeri sono stati ignorati (ha un senso giusto?)
Combinazioni sono pressoché unico, cioè le combinazioni 2248, 8224, 8422e 4228sono stati tutti considerati come una grande combinazione.

Mathematica - 218 byte

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

Versione non golfata:

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 di PartitionRagged è presa da questa domanda .

Questa soluzione gestisce dimensioni di griglia arbitrarie e numeri arbitrariamente grandi.

Ecco una versione di 195 byte che funziona come il gioco reale con solo fino a 4 tessere (così f[22222222]è 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}]&

dove ho sostituito

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

fè la funzione. Esempi:

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

Una piccola spiegazione:
prestituisce tutti i modi per dividere un elenco.
qfiltra quelli costituiti solo da potenze di 2 (escluso 1 ma compreso 0).
cprova a comprimere una stringa.
ritera la compressione destra e sinistra fino a quando rimane solo 1 elemento o la stringa è incollabile.