12

Xkcd से प्रेरित है ।

आपकी चुनौती यह निर्धारित करने की है कि क्या कोई संख्या 2048 खेल में अच्छा संयोजन करेगी । आपका इनपुट एक नंबर होगा, जैसे:

और उत्पादन किया जाएगा कि क्या उस नंबर एक अच्छा 2048 कॉम्बो है, जो इस इनपुट के लिए किया जाएगा होगा trueया yesया 1या एक सकारात्मक परिणाम यह दर्शाता है की किसी अन्य तरीके से।

खेल से परिचित न होने वालों के लिए, यहाँ एक सरल स्पष्टीकरण दिया गया है: दो की शक्तियां एक ग्रिड पर व्यवस्थित होती हैं, जैसे [2] [2]:। टाइलों को किसी भी दिशा में ले जाया जा सकता है, और यदि दो समान टाइलें मिलती हैं, तो वे दो की अगली शक्ति बन जाती हैं (इसलिए [2] [2]जब बाएं या दाएं चलती हैं [4])। या, आप बस यहाँ खेल की कोशिश कर सकते हैं ।

"एक अच्छा 2048 संयोजन" का क्या मतलब है? इसका मतलब किसी भी संख्या से है, अगर यह "2048" खेल में था, तो इसे एक एकल संख्या में जोड़ा जा सकता है। (शून्य का मतलब एक खाली जगह है , और ज़रूरत पड़ने पर इसे नज़रअंदाज़ किया जा सकता है।) ध्यान दें कि संख्याएँ संभवतः कई अंक हो सकती हैं! हालाँकि, संख्या को चालों के बीच नहीं बदलना चाहिए । यहाँ कुछ उदाहरण / परीक्षण मामले हैं ("गुड" के साथ एक अच्छे संयोजन का संकेत मिलता है, और "बुरा" का अर्थ अच्छा नहीं है):

गुड: 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 (शून्य खाली स्थान हैं)

विविध नियम:

इनपुट कहीं से भी उचित हो सकता है, यानी STDIN, फ़ंक्शन तर्क, फ़ाइल आदि।
आउटपुट कहीं भी उचित हो सकता है, यानी STDOUT, फ़ंक्शन रिटर्न वैल्यू, फ़ाइल आदि।
ग्रिड आकार पर ध्यान न दें - 22222222अभी भी आउटपुट सही होना चाहिए।
जब तक संख्या दो हो सकती है, तब तक यह अधिकतम नहीं है। इसलिए संभावित संख्या 0 से अधिक दो की कोई शक्ति है।
शून्य के बारे में चिंतित लोगों के लिए अस्पष्टता का कारण बनता है, यह मामला नहीं है। उदाहरण के लिए, या 22048तो पार्स किया जा सकता है [2] [2048]या [2] [2] [0] [4] [8]। पहला काम नहीं करता है, लेकिन दूसरा करता है, इसलिए यह सच होना चाहिए।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा!

code-golf

— Doorknob
स्रोत

2

क्या मेरे पास उत्तर देने वाला सर्वर हो सकता है और इससे केवल इनपुट डाउनलोड उत्तर अपलोड किया जा सकता है? कुल डाउनलोड बाइट्स होंगे1

— ब्रायन चेन

4

@Geobits 2048 पहले से ही एक नंबर या चार के रूप में अस्पष्ट है।

— जॉन ड्वोरक

3

शून्य का मतलब खाली जगह नहीं होना चाहिए; 1024 एक कानूनी संख्या है या नहीं? खाली स्थान अस्पष्ट होना चाहिए ... और इसलिए उनके पास होने पर सवाल का योगदान नहीं होता है, मेरी राय में।

— ताल

7

आपका तीसरा उदाहरण दिखाता है 22048कि आउटपुट होना चाहिए goodलेकिन यह सच नहीं है। आप के 2साथ गठबंधन कर सकते हैं 2048और ग्रिड है 4x4अगर सभी नंबर अलग होना चाहिए तो आपको 5 सेल मिलेंगे। तो शायद आपको हटा देना चाहिए 0? इसके अलावा आपका 5 वां उदाहरण अवैध लगता है क्योंकि खेल बंद हो जाता है 2048:)

— Teun Pronk

2

@undergroundmonorail मैं पुष्टि कर सकता हूं कि खेल में 4096 टाइल है।

— केंडल फ़्री

0

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=},!!

सभी परीक्षण मामलों की ऑनलाइन जाँच की जा सकती है ।

— हावर्ड
स्रोत

3

पायथन: 457 422 वर्ण

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) को अंकों का एक स्ट्रिंग मिलता है और तदनुसार 'अच्छा' या 'खराब' आउटपुट मिलता है। मैंने 0 को रिक्त स्थान के रूप में उपयोग नहीं करने का फैसला किया क्योंकि खेल में स्थान निरर्थक हैं और वे स्ट्रिंग को पार्स करते समय अस्पष्टता पैदा करते हैं (क्या 22048 अच्छा या बुरा है?)। यह केवल 2048 तक संख्याओं का उपयोग करता है, लेकिन वर्णों को जोड़े बिना इसे बदला जा सकता है। 10 वर्णों की लागत पर या तो मैं संख्याओं के संयोजन के सभी चरणों को भी प्रिंट कर सकता हूं। और मुझे पता है कि यह कोड अभी तक पर्याप्त नहीं है; चिंता न करें, संपादन आ रहे हैं।

— ताल
स्रोत

आप इंडेंटेशन पर कुछ पात्रों को बचाने के लिए स्पेस और टैब ट्रिक का उपयोग कर सकते हैं। एसओ मार्कडाउन हालांकि इसे तोड़ देगा।

— gcq

मुझे लगता है कि यह पायथन 3.x पर काम नहीं करता है। वहाँ बहुत कुछ मैं कर सकता हूँ, लेकिन यकीन नहीं है कि मैं उस हास्केल जवाब के साथ प्रतिस्पर्धा कर सकता था :)

— ताल

हां, मैं इसके बारे में भूल गया था।

— 21

2

हास्केल: 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 की शक्ति है, तो इसे बिट ट्विडलिंग के साथ भाषाओं द्वारा हटा दिया जाएगा। %पुनरावर्ती सभी पार्स उत्पन्न करता है जो 2 या 0. cढहने वाली टाइलों की शक्तियों की सूची हैं । lपुनरावर्ती परीक्षण यदि टाइल टूटने योग्य छोड़ दिया या अच्छा कर रहे हैं। gयदि टाइलें टूटी-फूटी या दाईं ओर हैं तो परीक्षण। टाइल्स पर संख्याओं की कोई सीमा नहीं है - उदाहरण के h ((show (2^200))++(show (2^200)))लिए "1606938044258990275541962092341162602522202993782792835301376" चिह्नित 2 टाइलों के लिए रिटर्न।

बग को ठीक करने के लिए संपादित किया गया कि यह "88222288888" को सही ढंग से ढहने नहीं दिया, लेकिन अधिक गोल्फिंग अवसर भी मिला।

— bazzargh
स्रोत

2

पर्ल, 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

ऊँ ।। १ ।। अच्छा ।।

2

ऊह ... 2 ... अच्छा ...

22

ऊह ... 22 ... 4 ... अच्छा ...

42

ऊह .. कुछ नहीं ।।

422

ऊँ ।। ४२२ ।। ४४ .. 44 .. अच्छा ।।

322

ओह। कुछ भी तो नहीं।

336

ओह। कुछ भी तो नहीं।

4224

ऊह .. कुछ नहीं ।।

4228

ऊह .. ४२२ nice .. ४४ .. .. .. .. १६ .. अच्छा ।।

16022481602248

ऊह .. 1604481602248 .. 16088160448 .. 1601616088 .. 3216016 .. 3232 .. 64 .. अच्छा ।।

[ ६४ और २५६ कुछ खराब resolvable अस्पष्टताओं को जन्म देते हैं जो लालची मिलान के साथ सामना नहीं कर सकते ... लेकिन ये अच्छे बाइट मायने रखते हैं। ]

2048

ऊओह… 2048… अच्छा…

— user130144
स्रोत

1

डेल्फी 572 582 वर्ण

संपादित कोड, सीमा 2 ^ 30 पर सेट है, इसलिए यह डेल्फी में अधिकतम मूल्य से अधिक नहीं होगा।

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.

संपादित करें

तो मैं उत्सुक हो गया और सोचा कि इनमें से कितने संयोजन पहेली को फिट करेंगे और एक परीक्षण किया।

दूसरों के लिए भी जो उत्सुक हैं, एक परीक्षण भी करें;)

लेकिन यहाँ ठीक परिणाम हैं:
20736 combinations were tested and 1166 were great combinations

मुझे कहना पड़ेगा 3 या उससे अधिक शून्यों के साथ संयोजन उन्हें छोड़ दिया गया (बनाता है सही भावना?)
युग्म लगभग अद्वितीय हैं, संयोजन जिसका अर्थ है 2248, 8224, 8422और 4228सभी के लिए एक महान संयोजन के रूप में गिना रहे थे।

— तेण प्रुन
स्रोत

1

गणितज्ञ - 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}]&

Ungolfed संस्करण:

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

— मार्टिन एंडर
स्रोत

बस सोच रहा था कि क्या यह वही बग है जो मेरे कोड ने किया था - ऐसा DeleteCasesलगता है कि यह सबसे बाईं जोड़ी को हटाता है, इसलिए f[88222288888]विफल होगा?

— बजरघ

@bazzargh नहीं, DeleteCasesबस शून्य हटाएं और संख्याएँ जो दो की शक्ति नहीं हैं। जोड़ों का वास्तविक ढहना नियम द्वारा किया जाता है //. {a___, x_, x_, b___} :> {a, 2 x, b}, जो उस संख्या और इसके विपरीत के लिए काम करता है। मैं वास्तव में उस आदेश के बारे में पूरी तरह से निश्चित नहीं हूं जो गणितज्ञ उन प्रतिस्थापनों को लागू करता है, लेकिन यह काम करता है।

— मार्टिन एंडर

1

हास्केल - २६० २६३

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किसी सूची को विभाजित करने के सभी तरीके देता है।
qउन लोगों को फ़िल्टर करता है जिनमें केवल 2 की शक्तियाँ होती हैं (1 को छोड़कर, लेकिन 0 सहित)।
cएक स्ट्रिंग को ढहाने की कोशिश करता है।
rदाएं और बाएं ढहने की पुनरावृति तब तक होती है जब तक कि केवल 1 तत्व नहीं बचा है, या स्ट्रिंग असमर्थनीय है।

— mniip
स्रोत

अच्छा लगा। हालांकि इसमें एक बग है c, "222244442222" का प्रयास करें - यह सच है, लेकिन यह गेम में टूटने योग्य नहीं है। के साथ पुनरावृत्ति करने की आवश्यकता है (2*x):c s।

— बाज़रग

@bazzargh फिक्स्ड

— mniip

क्या यह संख्या 2048 का कॉम्बो बना देगी?