Inspiriert von xkcd .

Ihre Herausforderung besteht darin, festzustellen, ob eine Zahl im Spiel 2048 eine gute Kombination ergeben würde . Ihre Eingabe wird eine Zahl sein, wie zum Beispiel:

8224

Und die Ausgabe wird sein, ob diese Zahl eine gute 2048-Kombination ergeben würde, die für diese Eingabe trueoder yesoder 1oder irgendeine andere Art der Anzeige eines positiven Ergebnisses wäre.

Für diejenigen , die nicht mit dem Spiel vertraut, hier ist eine einfache Erklärung: Zweierpotenzen sind auf einem Gitter angeordnet sind , wie folgt aus : [2] [2]. Kacheln können in jede Richtung bewegt werden. Wenn sich zwei identische Kacheln treffen, werden sie zur nächsten Potenz von zwei ( [2] [2]wenn also nach links oder rechts bewegt wird [4]). Oder Sie können das Spiel einfach hier ausprobieren .

Was bedeutet "eine gute 2048-Kombination"? Es bedeutet, dass jede Zahl, wenn sie im Spiel "2048" wäre, zu einer einzigen Zahl kombiniert werden könnte. (Eine Null bedeutet ein Leerzeichen und kann bei Bedarf ignoriert werden.) Beachten Sie, dass Zahlen möglicherweise mehrstellig sein können! Die Zahlen dürfen sich jedoch zwischen den Zügen nicht ändern. Hier sind einige Beispiele / Testfälle (wobei "Gut" eine gute Kombination anzeigt und "Schlecht" nicht gut bedeutet):

• Gut: 8224 (8224 -> 844 -> 88 -> 16)
• Gut: 2222 (2222 -> 44 -> 8)
• Gut: 22048 (22048 -> 448 -> 88 -> 16)
• Schlecht: 20482 (kann die äußeren 2en nicht kombinieren, noch kann man eine 2048 und eine 2 kombinieren)
• Gut: 20482048 (20482048 -> 4096)
• Bad: 210241024 (210241024 -> 22048, aber dies ist jetzt [2] [2048] und kann nicht kombiniert werden, da sich die Zahlen zwischen den Zügen nicht ändern können.)
• Gut: 2048 (es ist schon eine Nummer)
• Schlecht: 2047 (es ist keine Potenz von 2)
• Schlecht: 11 (es gibt keine 1en im Spiel)
• Gut: 000040000000 (Nullen sind Leerzeichen)

Verschiedene Regeln:

• Die Eingabe kann von einem beliebigen vernünftigen Ort aus erfolgen, z. B. STDIN, Funktionsargument, Datei usw.
• Die Ausgabe kann auch überall sinnvoll sein, z. B. STDOUT, Funktionsrückgabewert, Datei usw.
• Die Rastergröße ignorieren - 22222222sollte immer noch true ausgeben.
• Das ist kein Maximum für die Anzahl, solange es eine Zweierpotenz ist. Die möglichen Zahlen sind daher Zweierpotenzen größer als 0.
• Für diejenigen, die sich Sorgen machen, dass Nullen Mehrdeutigkeiten verursachen, ist dies nicht der Fall. Beispielsweise 22048kann entweder [2] [2048]oder analysiert werden [2] [2] [0] [4] [8]. Der erste funktioniert nicht, aber der zweite, also sollte er true ausgeben.
• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

GolfScript, 137 Zeichen

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

Die Eingabe muss auf STDIN erfolgen. Die Ausgabe ist 0/ 1für schlechte / gute Zahlen. Der größte Teil des Codes ist zum Parsen der möglichen Eingaben erforderlich.

Diese kürzere Version (113 Zeichen) führt einen einfachen Schichttest durch, der bei Eingaben wie z 224422. B. nicht korrekt funktionieren würde .

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

Alle Testfälle können online überprüft werden .

Python: 457.422 Zeichen

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

Die Funktion f (s) erhält eine Folge von Ziffern und gibt dementsprechend 'gut' oder 'schlecht' aus. Ich habe 0 nicht als Leerzeichen verwendet, da Leerzeichen im Spiel bedeutungslos sind und beim Parsen von Zeichenfolgen Mehrdeutigkeiten verursachen (ist 22048 gut oder schlecht?). Dabei werden nur Zahlen bis 2048 verwendet, dies kann jedoch geändert werden, ohne dass Zeichen hinzugefügt werden müssen. Auf Kosten von ca. 10 Zeichen kann ich auch alle Schritte zum Kombinieren der Zahlen ausdrucken. Und mir ist klar, dass dieser Code noch nicht genug Golf spielt. Keine Sorge, Änderungen kommen.

Haskell: 285 254 253 237 230 227

Benutzung - lade es einfach in ghci und übergebe den String an h.

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

Code:

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)

Kommentar: iIst die Überprüfung, ob eine Zahl eine Zweierpotenz ist, wird dies von Sprachen mit kleinen Abweichungen ausgespielt. %Generiert rekursiv alle Parses, die Potenzen von 2 oder 0 enthalten. cReduziert Kacheln. lrekursiv prüft, ob Fliesen links oder gut zusammenlegbar sind. gprüft, ob Fliesen links oder rechts zusammenklappbar sind. Die Anzahl der Kacheln ist unbegrenzt - z. B. werden h ((show (2^200))++(show (2^200)))2 Kacheln mit der Kennzeichnung "1606938044258990275541962092341162602522202993782792835301376" als wahr zurückgegeben.

Bearbeitet, um einen Fehler zu beheben, der "88222288888" nicht richtig nach rechts reduzierte, sondern auch mehr Möglichkeiten zum Golfen bot.

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}

Nur das Wesentliche intakt halten:

$_=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 .. schön ..

2

oooh ... 2 ... schön ...

22

oooh ... 22 ... 4 ... schön ...

42

ooh .. nichts ..

422

ooh .. 422 .. 44 .. 8 .. schön ..

322

Oh. nichts.

336

Oh. nichts.

4224

ooh .. nichts ..

4228

ooh .. 4228 .. 448 .. 88 .. 16 .. schön ..

16022481602248

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

[ 64 und 256 führen zu einigen schlecht auflösbaren Mehrdeutigkeiten, mit denen gierige Übereinstimmungen nicht fertig werden können ... aber dies sind nette Byte-Zählungen. ]

2048

oooh ... 2048 ... schön ...

Delphi 572 582 Zeichen

Der bearbeitete Code, limit ist auf 2 ^ 30 gesetzt, damit er den MaxInt-Wert in Delphi nicht überschreitet.

Golf gespielt

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.

BEARBEITEN

Also wurde ich neugierig und fragte mich, wie viele dieser Kombinationen zum Puzzle passen würden und führte einen Test durch.

Für andere, die auch neugierig sind, machen Sie auch einen Test;)

Aber ok hier sind die Ergebnisse:
20736 combinations were tested and 1166 were great combinations

Ich muß sagen , Kombinationen mit drei oder mehr Nullen ausgelassen wurden (Marken richtig spüren?)
Kombinationen fast einzigartig sind, die Kombinationen Sinn 2248, 8224, 8422und 4228wurden alle als eine große Kombination gezählt.

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

Ungolfed-Version:

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

Die Internal\Magie von PartitionRagged ist dieser Frage entnommen .

Diese Lösung verarbeitet beliebige Rastergrößen und beliebig große Zahlen.

Hier ist eine 195-Byte- Version, die wie das eigentliche Spiel mit nur bis zu 4 Kacheln funktioniert (so f[22222222]ist 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}]&

wo ich ersetzt habe

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

mit

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

fist die Funktion. Beispiele:

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

Eine kleine Erklärung:
pGibt alle Möglichkeiten zum Teilen einer Liste zurück.
qFiltert diejenigen, die nur aus Potenzen von 2 bestehen (außer 1, aber einschließlich 0).
cversucht, eine Zeichenfolge zu reduzieren.
rDurchläuft die rechte und linke Kollapsion, bis nur noch 1 Element übrig ist oder die Zeichenfolge nicht mehr zusammenklappbar ist.