Lấy cảm hứng từ xkcd .

Thử thách của bạn là xác định xem một con số có tạo ra sự kết hợp tốt trong trò chơi 2048 hay không . Đầu vào của bạn sẽ là một số, chẳng hạn như:

8224

Và đầu ra sẽ được cho dù con số đó sẽ làm cho 2048 kết hợp tốt, mà cho đầu vào này sẽ là truehoặc yeshoặc 1hoặc bất kỳ cách nào khác cho thấy một kết quả tích cực.

Đối với những người không quen thuộc với trò chơi, đây là một lời giải thích đơn giản: quyền hạn của hai được sắp xếp trên một lưới, như thế này : [2] [2]. Gạch có thể được di chuyển theo bất kỳ hướng nào, và nếu hai gạch giống nhau gặp nhau, chúng trở thành sức mạnh tiếp theo của hai (vì vậy [2] [2]khi di chuyển sang trái hoặc phải trở thành [4]). Hoặc, bạn chỉ có thể thử trò chơi ở đây .

"Một sự kết hợp 2048 tốt" nghĩa là gì? Nó có nghĩa là bất kỳ số nào, nếu trong trò chơi "2048", nó có thể được kết hợp thành một số duy nhất. (Số không có nghĩa là một khoảng trống và có thể bỏ qua nếu cần.) Lưu ý rằng các số có thể có nhiều chữ số! Tuy nhiên, các con số không được thay đổi giữa các lần di chuyển. Dưới đây là một số ví dụ / trường hợp thử nghiệm (với "Tốt" cho thấy sự kết hợp tốt và "Xấu" có nghĩa là không tốt):

• Tốt: 8224 (8224 -> 844 -> 88 -> 16)
• Tốt: 2222 (2222 -> 44 -> 8)
• Tốt: 22048 (22048 -> 448 -> 88 -> 16)
• Xấu: 20482 (không thể kết hợp 2 bên ngoài và bạn cũng không thể kết hợp 2048 và 2)
• Tốt: 20482048 (20482048 -> 4096)
• Xấu: 210241024 (210241024 -> 22048, nhưng giờ đây là [2] [2048] và không thể kết hợp do các số không thể thay đổi giữa các lần di chuyển)
• Tốt: 2048 (đã là một số)
• Xấu: 2047 (nó không phải là sức mạnh của 2)
• Xấu: 11 (không có số 1 nào trong trò chơi)
• Tốt: 000040000000 (số không là khoảng trống)

Quy tắc khác:

• Đầu vào có thể từ bất cứ nơi nào hợp lý, ví dụ STDIN, đối số chức năng, tệp, v.v.
• Đầu ra cũng có thể là bất cứ nơi nào hợp lý, ví dụ STDOUT, giá trị trả về của hàm, tệp, v.v.
• Bỏ qua kích thước lưới - 22222222vẫn nên xuất đúng.
• Số này không tối đa với số s có thể là bao nhiêu, miễn là nó có sức mạnh bằng hai. Do đó, các số có thể là bất kỳ lũy thừa nào của hai lớn hơn 0.
• Đối với những người lo lắng về số không gây ra sự mơ hồ, đó không phải là trường hợp. Ví dụ, 22048có thể được phân tích cú pháp dưới dạng [2] [2048]hoặc [2] [2] [0] [4] [8]. Cái đầu tiên không hoạt động, nhưng cái thứ hai thì không, vì vậy nó sẽ xuất ra đúng.
• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ giành chiến thắng!

GolfScript, 137 ký tự

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

Đầu vào phải được đưa ra trên STDIN. Đầu ra là 0/ 1cho số xấu / tốt. Hầu hết các mã là cần thiết để phân tích cú pháp đầu vào có thể.

Phiên bản ngắn hơn này (113 ký tự) thực hiện kiểm tra dịch chuyển đơn giản, không hoạt động chính xác cho đầu vào như thế nào 224422.

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

Tất cả các trường hợp thử nghiệm có thể được kiểm tra trực tuyến .

Con trăn 457 422 ký tự

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

Hàm f (s) nhận được một chuỗi các chữ số và xuất ra 'tốt' hoặc 'xấu' tương ứng. Tôi đã chọn không sử dụng 0 làm khoảng trắng vì khoảng trắng là vô nghĩa trong trò chơi và chúng tạo ra sự mơ hồ khi phân tích chuỗi (là 22048 tốt hay xấu?). Điều này chỉ sử dụng số đến 2048, nhưng có thể thay đổi mà không cần thêm ký tự. Với chi phí 10 ký tự hoặc hơn, tôi cũng có thể in tất cả các bước kết hợp các số. Và tôi nhận ra rằng mã này chưa đủ để chơi golf; đừng lo lắng, chỉnh sửa đang đến.

Haskell: 285 254 253 237 230 227

cách sử dụng - chỉ cần tải nó vào ghci và truyền chuỗi cho h.

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

Mã số:

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)

Bình luận: ilà kiểm tra nếu một số có lũy thừa bằng 2, điều này sẽ bị vượt qua bởi các ngôn ngữ có một chút thay đổi. %đệ quy tạo ra tất cả các phân tích là danh sách quyền hạn của 2 hoặc 0. thu cgọn các ô. lkiểm tra đệ quy nếu gạch có thể đóng mở trái hoặc tốt.gkiểm tra nếu gạch có thể đóng mở trái hoặc phải. Không có giới hạn đối với các số trên các ô - ví dụ: h ((show (2^200))++(show (2^200)))trả về true cho 2 ô được đánh dấu "1606938044258990275541962092341162602522202993782792835301376".

Đã chỉnh sửa để sửa một lỗi mà nó không sụp đổ chính xác "88222288888" sang bên phải, nhưng cũng tìm thấy nhiều cơ hội chơi gôn hơn.

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}

Giữ nguyên các yếu tố cần thiết:

$_=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 .. tốt đẹp ..

2

oooh ... 2 ... tốt đẹp ...

22

oooh ... 22 ... 4 ... tốt đẹp ...

42

Ồ .. không có gì ..

422

ooh .. 422 .. 44 .. 8 .. tốt đẹp ..

322

Oh. không có gì.

336

Oh. không có gì.

4224

Ồ .. không có gì ..

4228

ooh .. 4228 .. 448 .. 88 .. 16 .. tốt đẹp ..

16022481602248

ooh .. 1604481602248 .. 16088160448 .. 1601616088 .. 3216016 .. 3232 .. 64 .. tốt đẹp ..

[ 64 và 256 dẫn đến một số sự mơ hồ có thể giải quyết kém mà kết hợp tham lam không thể đối phó với ... nhưng đây là những số byte đẹp . ]

2048

oooh ... 2048 ... tốt đẹp ...

Delphi 572 582 ký tự

Mã đã chỉnh sửa, giới hạn được đặt thành 2 ^ 30 để nó không vượt quá giá trị MaxInt trong Delphi.

Chơi gôn

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.

Ung dung

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.

BIÊN TẬP

Vì vậy, tôi đã tò mò và tự hỏi có bao nhiêu trong số các kết hợp này sẽ phù hợp với câu đố và chạy thử nghiệm nó.

Đối với những người khác cũng tò mò, hãy làm một bài kiểm tra quá;)

Nhưng ok đây là kết quả:
20736 combinations were tested and 1166 were great combinations

Tôi phải nói kết hợp với 3 hoặc nhiều hơn zero đã bị bỏ qua (có ý nghĩa phải không?)
Kết hợp gần như độc đáo, có nghĩa là sự kết hợp 2248, 8224, 8422và 4228tất cả đều được tính là một sự kết hợp tuyệt vời.

Toán học - 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}]&

Phiên bản bị đánh cắp:

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

Các Internal\PartitionRagged` ma thuật được lấy từ câu hỏi này .

Giải pháp này xử lý kích thước lưới tùy ý và số lượng lớn tùy ý.

Đây là một 195 byte phiên bản hoạt động như các trò chơi thực tế lên đến chỉ có 4 gạch (như vậy f[22222222]là 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}]&

nơi tôi đã thay thế

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

với

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

flà chức năng. Ví dụ:

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

Một lời giải thích nhỏ:
ptrả về tất cả các cách để chia một danh sách.
qcác bộ lọc chỉ bao gồm quyền hạn 2 (không bao gồm 1 nhưng bao gồm 0).
ccố gắng thu gọn một chuỗi.
rlặp lại sự sụp đổ phải và trái cho đến khi chỉ còn 1 phần tử hoặc chuỗi không thể tách rời.