चीनी चेकर्स सबसे लंबी चाल

Question

में चीनी चेकर्स , एक टुकड़ा किसी अन्य टुकड़े पर हॉपिंग, द्वारा या इस तरह के हॉप्स की एक दृश्य बनाने के द्वारा स्थानांतरित कर सकते हैं। आपका कार्य हॉप्स का सबसे लंबा संभव अनुक्रम खोजना है।

इनपुट

121 शून्य या एक क्रम, प्रत्येक एक बोर्ड पर एक जगह का प्रतिनिधित्व करता है। एक शून्य का मतलब है कि जगह खाली है; एक का मतलब जगह पर कब्जा है। पदों को बाएं से दाएं सूचीबद्ध किया गया है; ऊपर से नीचे। उदाहरण के लिए, इस सेटअप का इनपुट होगा

1011110011000001000000000000000000000000100000000001000000000000000000000000000001000000000000000000000001000001100111111

स्पष्टीकरण:

शीर्ष-सबसे अधिक स्थान पर एक हरे रंग का टुकड़ा होता है, इसलिए इनपुट में पहला अंक होता है 1। दूसरी पंक्ति में एक खाली स्थिति होती है और फिर एक स्थान पर कब्जा कर लिया जाता है, इसलिए 01अगला स्थान आता है। तीसरी पंक्ति सभी के कब्जे में है, इसलिए 111। चौथी पंक्ति में दो खाली और दो कब्जे वाले स्थान हैं (बाएं से दाएं) 0011। फिर अगली पंक्ति के लिए पाँच , और 0एक 1सात आता है 0।

उस सेटअप की तरह, वहाँ एक कोने है जो सीधा इशारा करता है। बोर्ड पर किसी भी संख्या में टुकड़े हो सकते हैं (1 से 121 तक)। ध्यान दें कि अलग-अलग रंगों के टुकड़ों का अलग-अलग प्रतिनिधित्व नहीं किया जाता है।

उत्पादन

बोर्ड पर किसी भी टुकड़े का उपयोग करते हुए एक कानूनी हॉप की अधिकतम लंबाई। आप एक ही स्थान पर एक से अधिक बार नहीं जा सकते हैं (शुरुआती और समाप्ति की स्थिति सहित)। हालाँकि, आप एक ही टुकड़े पर एक से अधिक बार हॉप कर सकते हैं। यदि कोई कानूनी संभावना नहीं है, तो आउटपुट 0। इस बात पर विचार न करें कि क्या कोई गैर-कानूनी कदम है।

उदाहरण के लिए, ऊपर वर्णित सेटअप का आउटपुट है 3।

इनपुट और आउटपुट स्टड और स्टडआउट के माध्यम से, कमांड-लाइन तर्कों के माध्यम से, फ़ंक्शन कॉल के माध्यम से या किसी भी समान विधि से किया जा सकता है।

परीक्षण के मामलों

इनपुट:

0100000010000000000000000100000000000000000000000000000001010010000000000000000000000101000000000000000000100000000100001

आउटपुट: 0(कोई दो टुकड़े एक दूसरे के बगल में नहीं हैं)

---

इनपुट:

0000000000111100000000011100000000011000000000100000000000000000000000000000000000000000000000000000000000000000000000000

आउटपुट: 1(ऊपरी बाएँ कोने में एक खिलाड़ी के लिए प्रारंभिक सेटअप)

Comments

मैं अपनी महान चाची के साथ यह खेलता हूं; हम दोनों यथोचित अच्छे हैं। यह एक दिलचस्प चुनौती है।

— cjfaure

हो सकता है कि आपको अधिक निर्दिष्ट करना चाहिए कि इनपुट कैसे संग्रहीत किया जाता है / कौन सा बिट्स कहां जाता है।

— TheDoctor

कौन से टुकड़े "होप ओवर" कर सकते हैं? जिस तरह से मेरी माँ और मैं खेला करते थे, आप किसी भी एक टुकड़े को 6 दिशाओं में से किसी भी दूरी पर (जिस स्थान पर आपने कटा हुआ था, उसके विपरीत स्थान पर) तब तक आशा कर सकते हैं, जब तक कोई रास्ता नहीं है उस उम्मीद के लिए रास्ता। अन्य लोग खेलते हैं कि आप केवल आसन्न टुकड़ों पर आशा कर सकते हैं।

— जो जेड

@ TheDoctor मैंने अधिक विस्तृत विवरण जोड़ा।

— यपनिप

क्या आप एक विवरण स्पष्ट कर सकते हैं: क्या मुझे एक ही स्थिति पर दो बार कब्जा करने की अनुमति है? मुझे लगता है कि मैं असीम रूप से लूप नहीं कर सकता, लेकिन अगर मैं बाएं-दाएं चलते हुए किसी स्थान को हिट कर सकता हूं और बाद में इसे फिर से ऊपर-नीचे दाएं-बाएं घुमाता हूं तो यह संभावनाओं को खोलता है।

— डेवोन पार्सन्स

Answer 1

पर्ल, 345 322

संपादित करें: गोल्फ, थोड़ा।

अधिक परीक्षण के मामले अच्छे होंगे, लेकिन अब ऐसा लगता है कि यह काम करता है। यदि आवश्यक हो तो बाद में टिप्पणी जोड़ूंगा। पठनीयता के लिए नई सूचियों और मांगपत्र के साथ:

$_=<>;
$s=2x185;
substr$s,(4,22,unpack'C5(A3)*','(:H[n129148166184202220243262281300')[$i++],0,$_ 
    for unpack A.join A,1..4,13,12,11,10,9..13,4,3,2,1;
$_=$s;
sub f{
    my(@a,%h)=@_;
    $h{$_}++&&return for@a;
    $-+=$#a>$-;
    $s=~/^.{$a[0]}$_/&&f($+[1],@a)
        for map{("(?=.{$_}1.{$_}(0))","(?<=(0).{$_}1.{$_}.)")}0,17,18
}
f$+[0]while/1/g;
print$-

Comments

मैंने कुछ परीक्षण मामलों को जोड़ा।

— यपनीपॉन

वे ठीक काम करते हैं, लेकिन वे बहुत आसान हैं :-)।

— user2846289

Answer 2

सी, 262 260

गोल्फ कोड (डिबगिंग कोड और अनावश्यक व्हाट्सएप हटा दिया गया। इनपुट से स्टैण्ड के माध्यम से कमांड लाइन के माध्यम से इनपुट में बदल गया, और वहाँ मुझे वेरिएबल घोषित करने के अवसर का लाभ उठाया। नवीनतम एडिट: कोड forदो सेमेस्टरोल को बचाने के लिए छोरों के ब्रैकेट में चला गया ।)

t[420],j,l,x,y;f(p,d){int z,q,k;for(k=6;k--;t[q]&!t[p+z]?t[q]=0,f(q,d+1),t[q]=1:0)z="AST?-,"[k]-64,q=p+z*2;l=d>l?d:l;}main(int i,char**s){for(i=840;i--;x>3&y>5&x+y<23|x<13&y<15&x+y>13?i>420?t[i-420]=49-s[1][j++]:t[i]||f(i,0):0)x=i%20,y=i/20%21;printf("%d",l);}

व्याख्या

यह एक 20x21 बोर्ड पर निर्भर करता है, जो इस तरह दिखता है, शुरू में कार्यक्रम शुरू होने पर जीरो से भर जाता है (यह ASCII कला कार्यक्रम के एक संशोधित संस्करण द्वारा उत्पन्न की गई थी, और जैसा कि iलूप नीचे की ओर गिना जाता है, शून्य नीचे दाएं कोने में है:

....................
....................
...............#....
..............##....
.............###....
............####....
.......#############
.......############.
.......###########..
.......##########...
.......#########....
......##########....
.....###########....
....############....
...#############....
.......####.........
.......###..........
.......##...........
.......#............
....................
....................

लूप iइस बोर्ड के माध्यम से दो बार चलता है, एक्स और वाई का उपयोग करके यह गणना करने के लिए कि क्या एक वर्ग वास्तव में चेकबोर्ड से संबंधित है या नहीं (इसके लिए x और y में 6 अलग-अलग असमानताओं की आवश्यकता है)।

यदि ऐसा है, पहली बार यह दौर वर्ग, एक डाल भरता 0(falsy) के लिए एक 1(पर कब्जा कर लिया) और एक 1(truthy) एक के लिए 0(खाली)। यह उलटा महत्वपूर्ण है, क्योंकि सभी आउट-ऑफ-बाउंड वर्गों में पहले से ही एक 0 होता है, जिसका अर्थ है कि वे कब्जे वाले वर्गों से मिलते-जुलते हैं और यह स्पष्ट है कि उन्हें एक विशिष्ट जांच की आवश्यकता के बिना कूद नहीं किया जा सकता है।

दूसरी बार गोल, यदि वर्ग पर कब्जा है (0 शामिल हैं) यह फ़ंक्शन को कॉल करता है fजो चाल की खोज करता है।

fपुनरावर्ती 6 संभावित दिशाओं में +/- 1 (क्षैतिज), +/- 20 (लंबवत) और +/- 19 (विकर्ण) द्वारा खोजा गया अभिव्यक्ति में एन्कोड किया गया "AST?-,"[k]-64। जब यह एक हिट पाता है, तो यह उस सेल को एक 0 (कब्जे वाले) पर सेट करता है, जब वह खुद को पुनरावर्ती कॉल करने से पहले, तब फ़ंक्शन 1 पर वापस आ जाता है (खाली)। सेल वैल्यू को एक से अधिक बार उस सेल में रोकने के लिए पुनरावर्ती कॉल से पहले बदला जाना चाहिए।

अघोषित कोड

char s[999];                           //input string.
t[420],i,j,l,x,y;                      //t=board. i=board counter, j=input counter. l=length of longest hop found so far.

f(p,d){                                //p=position, d= recursion depth.
  //printf("%d,%d ",p,d);              //debug code: uncomment to show the nodes visited.
  int k,z,q;                           //k=counter,z=displacement,q=destination
  for(k=6;k--;)                        //for each direction
    z="AST?-,"[k]-64,                  //z=direction
    q=p+z*2,                           //q=destination cell
    t[q]&!t[p+z]?                      //if destination cell is empty (and not out of bounds) and intervening cell is full
      t[q]=0,f(q,d+1),t[q]=1           //mark destination cell as full, recurse, then mark it as empty again.
      :0;
  l=d>l?d:l;                           //if d exceeds the max recorded recursion depth, update l
}

main(){
  gets(s);                             //get input
  for(i=840;i--;)                      //cycle twice through t
    x=i%20,                            //get x
    y=i/20%21,                         //and y coordinates
    x>3&y>5&x+y<23|x<13&y<15&x+y>13?   //if they are in the bounds of the board
      i>420?
        t[i-420]=49-s[j++]             //first time through the array put 0 for a 1 and a 1 for a 0 ('1'=ASCII49)
        :t[i]||f(i,0)                  //second time, if t[i]=0,call f(). 
       //,puts("")                     //puts() formats debug output to 1 line per in-bounds cell of the board
      :0;
  printf("%d",l);                      //print output
}