xkcd에서 영감을 얻었습니다 .

당신의 도전은 숫자가 게임 2048 에서 좋은 조합을 만들지 여부를 결정하는 것 입니다. 입력 한 내용은 다음과 같습니다.

8224

그리고 출력은 그 수가이 입력 될 좋은 2048 콤보 만들 것이라는 것 true또는 yes또는 1또는 긍정적 인 결과를 나타내는의 다른 방법.

게임에 익숙하지 않은 사람들을 위해 간단한 설명이 있습니다. 2의 거듭 제곱은 다음과 같이 그리드에 배열됩니다 [2] [2]. 타일은 어느 방향으로나 이동할 수 있으며, 두 개의 동일한 타일이 만나면 두 개의 다음 파워가됩니다 ( [2] [2]왼쪽 또는 오른쪽으로 이동하면 [4]). 또는 여기서 게임을 시도해 볼 수도 있습니다 .

"좋은 2048 조합"이란 무엇입니까? "2048"게임에있는 경우 하나의 단일 숫자로 결합 될 수있는 모든 숫자를 의미합니다. 0은 빈 공간을 의미하며 필요한 경우 무시할 수 있습니다. 숫자는 여러 자릿수 일 수 있습니다. 그러나 이동간에 숫자가 변경 되어서 는 안됩니다 . 다음은 몇 가지 예 / 테스트 사례입니다 ( "양호"는 좋은 조합을 나타내고 "나쁨"은 좋지 않음).

• 양호 : 8224 (8224-> 844-> 88-> 16)
• 좋음 : 2222 (2222-> 44-> 8)
• 양호 : 22048 (22048-> 448-> 88-> 16)
• 나쁨 : 20482 (외부 2를 결합하거나 2048과 2를 결합 할 수 없음)
• 양호 : 20482048 (20482048-> 4096)
• 나쁨 : 210241024 (210241024-> 22048). 이제는 [2] [2048]이며 숫자는 이동간에 변경할 수 없으므로 결합 할 수 없습니다.
• 좋음 : 2048 (이미 하나의 숫자 임)
• 나쁘다 : 2047 (2의 거듭 제곱이 아니다)
• 나쁨 : 11 (게임에 1이 없습니다)
• 양호 : 000040000000 (0은 빈 공간 임)

기타 규칙 :

• 입력은 STDIN, 함수 인수, 파일 등 합리적인 곳이면 어디든 가능합니다.
• STDOUT, 함수 반환 값, 파일 등과 같이 합리적인 위치에 출력 할 수도 있습니다.
• 격자 크기를 무시하십시오- 22222222여전히 true를 출력해야합니다.
• 2의 거듭 제곱이면 s의 최대 수는 없습니다. 따라서 가능한 숫자는 0보다 큰 2의 거듭 제곱입니다.
• 모호성을 유발하는 제로에 대해 걱정하는 사람들에게는 그렇지 않습니다. 예를 들어 또는 22048로 구문 분석 할 수 있습니다 . 첫 번째는 작동하지 않지만 두 번째는 작동하므로 true를 출력해야합니다.[2] [2048][2] [2] [0] [4] [8]
• 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이길 것입니다!

GolfScript, 137 자

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

STDIN에 입력해야합니다. 출력은 0/ 1나쁜 / 좋은 번호를. 가능한 입력을 구문 분석하려면 대부분의 코드가 필요합니다.

이 짧은 버전 (113 자)은 간단한 시프트 테스트를 수행하여와 같은 입력에 대해 올바르게 작동하지 않습니다 224422.

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

모든 테스트 사례는 온라인 으로 확인할 수 있습니다 .

파이썬 : 457422 자

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

함수 f (s)는 문자열을 가져 와서 'good'또는 'bad'를 출력합니다. 게임에서 공백이 의미가 없기 때문에 0을 공백으로 사용하지 않기로 선택했으며 문자열을 구문 분석 할 때 모호성을 만듭니다 (22048이 좋거나 나쁩니 까?). 최대 2048 개의 숫자 만 사용하지만 문자를 추가하지 않고도 변경할 수 있습니다. 10 자 정도의 비용으로 숫자를 결합하는 모든 단계를 인쇄 할 수도 있습니다. 이 코드는 아직 충분히 골프화되지 않았다는 것을 알고 있습니다. 걱정하지 마십시오. 수정 내용이 제공됩니다.

하스켈 : 285 254 253 237 230 227

사용법-그냥 ghci에로드하고 문자열을 h에 전달하십시오.

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

암호:

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)

해설 : i숫자가 2의 거듭 제곱인지 확인하면 비트 twiddling을 사용하는 언어로 표시됩니다. %재귀 적으로 2 또는 0의 거듭 제곱 목록 인 모든 구문 분석을 생성합니다 c. 타일을 축소합니다. l타일이 왼쪽 또는 접을 수 있는지 재귀 적으로 테스트합니다. g타일이 왼쪽 또는 오른쪽으로 접을 수 있는지 테스트합니다. 타일 ​​수에는 제한이 없습니다. 예를 들어 h ((show (2^200))++(show (2^200)))"1606938044258990275541962092341162602522202993782792835301376"으로 표시된 2 개의 타일에 대해서는 true를 반환합니다.

오른쪽으로 "88222288888"을 올바르게 접을 수 없었던 버그를 수정하여 더 많은 골프 기회를 발견했습니다.

Perl, 175-336 바이트

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}

필수 요소 만 그대로 유지 :

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

우 .. 1 .. 좋아 ..

2

어 ... 2 ... 좋아 ...

22

어 ... 22 ... 4 ... 좋아 ...

42

우 .. 아무것도 ..

422

우 .. 422 .. 44 .. 8 .. 좋은 ..

322

오. 아무것도.

336

오. 아무것도.

4224

우 .. 아무것도 ..

4228

우 .. 4228 .. 448 .. 88 .. 16 .. 좋은 ..

16022481602248

우 .. 1604481602248 .. 16088160448 .. 1601616088 .. 3216016 .. 3232 .. 64 .. 좋은 ..

[ 64와 256은 욕심 많은 매칭에 대처할 수없는 해결 불가능한 모호성을 야기하지만 ... 이것은 좋은 바이트 수입니다. ]

2048

어 ... 2048 ... 좋아 ...

델파이 572 582 자

편집 된 코드, 한계는 2 ^ 30으로 설정되어 Delphi의 MaxInt 값을 초과하지 않습니다.

골프

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.

언 골프

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.

편집하다

그래서 궁금한 점이 많으며이 조합 중 몇 개가 퍼즐에 적합하고 테스트를 수행했는지 궁금했습니다.

호기심이 많은 다른 사람들도 테스트를 해보십시오.)

그러나 결과는 다음과 같습니다.
20736 combinations were tested and 1166 were great combinations

나는 (차종를 잘 감지?) 3 개 이상의 제로와 조합을 건너 뛴 말을해야
조합이 조합을 의미 거의 유일하다 2248, 8224, 8422그리고 4228모든 훌륭한 조합으로 간주되었다.

수학-218 바이트

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

언 골프 버전 :

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

Internal\PartitionRagged` 마법이에서 가져옵니다 이 질문에 .

이 솔루션은 임의의 그리드 크기와 임의로 큰 수를 처리합니다.

여기입니다 195 바이트 만 4 개 타일 (지금까지와 실제 게임처럼 작동하는 버전 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}]&

내가 교체 한 곳

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

와

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

하스켈 -260263

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기능입니다. 예 :

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

작은 설명 :
p목록을 나누는 모든 방법을 반환합니다.
q2의 거듭 제곱 (1 제외, 0 포함)으로 구성된 필터를 필터링합니다.
c줄을 무너 뜨리려고합니다.
r왼쪽에 요소가 하나만 있거나 문자열이 축소 될 때까지 오른쪽 및 왼쪽 축소를 반복합니다.