तार्किक डॉट आकृतियाँ

खेल

हाल ही में, मेरा बहुत समय मेरे फोन पर एक व्यसनी खेल द्वारा लिया गया है, जिसे लॉजिक डॉट्स कहा जाता है, जिसने मुझे इस चुनौती को लिखने के लिए प्रेरित किया। यदि मैं आपको खेल प्रदर्शन दिखाता हूं तो नियमों की व्याख्या करना आसान है, इसलिए यहां एक अनसुलझी और सुलझी हुई पहेली का स्क्रीनशॉट है:

अब यहाँ, तीन मुख्य बातें हैं।

खेल बोर्ड (केंद्र में चौकों का 4x4 ग्रिड)
आवश्यक आकृतियाँ (स्कोर और मेनू के तहत ऊपर से दूसरी पट्टी में लिंक किए गए डॉट्स), जो सभी पंक्तियाँ हैं, या a1 आयतों द्वारा।
पंक्तियों और स्तंभों पर संख्याएँ, जो यह बताती हैं कि एक समाधान के लिए कॉलम में कितने डॉट्स होने चाहिए

खेल का उद्देश्य आवश्यक आकार को ग्रिड में फिट करना है। आप आकृतियों को घुमा सकते हैं, लेकिन वे तिरछे नहीं जा सकते।

समाधान में, ध्यान दें कि सभी आकार बिल्कुल एक बार बनाए जाते हैं (क्योंकि वे केवल एक बार आवश्यक आकृतियों में होते हैं), और इस मामले में वे सभी क्षैतिज हैं लेकिन वे ऊर्ध्वाधर भी हो सकते हैं। वर्गों में भरे गुलाबी वर्गों का उपयोग न करने के लिए दर्शाते हैं।

यहाँ एक बड़ा और थोड़ा अधिक जटिल ग्रिड है:

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

नोटेशन

इस पोस्ट के बाकी हिस्सों के लिए, मैं निम्नलिखित प्रतीकों का उपयोग करके बोर्ड का उल्लेख करूंगा:

<,>, ^, v - बिंदु की दिशा में फैली हुई पूंछ के साथ पूर्व-स्थित डॉट को दर्शाता है
* - एक बिंदु को दर्शाता है। यदि एक अनसुलझी ग्रिड (इनपुट) पर दिया जाता है, तो यह एक व्यक्तिगत आकार है। यदि आउटपुट में है, तो यह इसके चारों ओर डॉट्स से जुड़ा हुआ है।
# - एक अवरुद्ध ग्रिड वर्ग को दर्शाता है (जहाँ आप डॉट नहीं लगा सकते हैं)
-, | (हाइफ़न और बार) - दाईं और बाईं पूंछ के साथ एक बिंदु और क्रमशः ऊपर और नीचे की पूंछ के साथ एक बिंदु को चिह्नित करें
** (अंतरिक्ष चरित्र) - ** एक खाली स्थान का प्रतीक है

इन प्रतीकों का उपयोग करते हुए, बाद के उदाहरण के मामले (अनसुलझी) को निम्नानुसार दर्शाया जा सकता है:

और समाधान के रूप में प्रतिनिधित्व किया जा सकता है:

*< * *
   *  
     *
 *   *
 * *#*
 ^ # *

ध्यान दें कि कोई भी दो आकृतियाँ क्षैतिज, लंबवत या तिरछे स्पर्श नहीं कर सकती हैं , इसलिए निम्नलिखित मामला मान्य नहीं है:

 *** 
**   
  **

चुनौती

आपकी चुनौती किसी भी लॉजिक डॉट्स पहेली को हल करना है, 4x4 से 9x9 तक समावेशी। आपको इनपुट की चार लाइनें मिलेंगी, फिर गेम बोर्ड। लाइनें इस प्रकार होंगी:

पहली पंक्ति, आकृतियाँ - आकृतियों को खोजने के लिए, प्रत्येक को प्रपत्र में दिया गया है sizexquantity(उदाहरण के 3x2लिए, लंबाई तीन की दो आकृतियों के लिए) और एक स्थान द्वारा अलग किया गया। उदाहरण पंक्ति:3x1 2x1 1x1
दूसरी पंक्ति, कॉलम - प्रत्येक कॉलम के लिए आवश्यक डॉट काउंट की एक अलग सूची। उदाहरण पंक्ति:1 1 2 2
तीसरी पंक्ति, पंक्तियाँ- प्रत्येक पंक्ति के लिए आवश्यक डॉट काउंट की एक अलग सूची। उदाहरण पंक्ति:3 0 3 0
4 वीं पंक्ति, बोर्ड का आकार - एक पूर्णांक, बोर्ड का आकार, B

बोर्ड को तब दिया गया है, और Bऊपर उल्लिखित संकेतन का उपयोग करते हुए बोर्ड का प्रतिनिधित्व करने वाली इनपुट की लाइनें हैं। उदाहरण के लिए, बाद के उदाहरण के मामले के लिए पूरा इनपुट निम्नानुसार है:

4x1 3x1 2x2 1x2
1 4 0 3 0 5
4 1 1 2 3 2
6
 <    



    # 
 ^ #

आपका प्रोग्राम तब हल किए गए बोर्ड को आउटपुट करेगा, उसी संकेतन में। उपरोक्त इनपुट के लिए मिलान आउटपुट निम्नानुसार है:

** * *
   *  
     *
 *   *
 * *#*
 * # *

ध्यान दें कि गेम बोर्ड में कई समाधान हो सकते हैं। इस मामले में, बस एक वैध समाधान का उत्पादन करें। साथ ही, आपके प्रोग्राम को 10 सेकंड के भीतर एक जटिल डेस्कटॉप 10x10 ग्रिड के लिए एक उचित समाधान का उत्पादन करना चाहिए।

यह कोड गोल्फ है, इसलिए कम से कम बाइट्स जीतता है।

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

इनपुट 1

आउटपुट 1

*** *

 ***#
  #  
* * *

इनपुट 2

आउटपुट 2

* * *
  *  
  * *
*  # 
  * *

इनपुट 3

5x1 4x1 2x1 1x2
1 2 3 3 2 2
0 5 0 4 0 4
6
#     
  -   


 #    
   <

आउटपुट 3

#     
 *****

 **** 
 #    
* ** *

code-golf puzzle-solver

— globby
स्रोत

हाँ, यह सही @flawr है

— globby

@ फ़्लावर t no two shapes can touch horizontally, vertically or diagonally(यह शुरुआत में होना चाहिए, लगभग अंत के करीब नहीं खोया, लेकिन वैसे भी ...)

— edc65

@globby हर खाली जगह को # से बदला नहीं जाएगा, मुझे लगता है कि जब आप खेल में खाली जगह पर टैप करते हैं तो # होता है। जब आप एक स्तर खत्म करते हैं तो यह सभी खाली कोशिकाओं को भर देता है।

— त्यूण प्रैंक

@TeunPronk नंबर # ऐसे स्थान हैं जो पूर्व निर्धारित हैं कि आप स्तर में एक डॉट नहीं रख सकते हैं, जैसे दूसरे उदाहरण में ग्रे वर्ग।

— ग्लोबली

एक इनाम देने की तुलना में बेहतर है, आपको अधिक दिलचस्प परीक्षण मामलों को जोड़ना चाहिए और अपने प्रश्न में त्रुटियों को ठीक करना चाहिए। उदाहरण के लिए, वर्तमान परीक्षण मामलों से पहले अंतिम आउटपुट में अभी भी <और ^

— edc65

जवाबों:

पायथन 2: 766 739 696 663 633 बाइट्स

def f(B,S,o=0):
 if[]==S:print'\n'.join(B);exit()
 s=S[0]
 for i in r:
  for j in R(Z-s+1):
   if(B[i][j]in' '+'>v'[o])*(B[i][j+s-1]in' '+'<^'[o])*({' ','-|'[o]}>=set(B[i][j+1:j+s-1]))*all(B[x][y]in'# 'for x,y in [(x,y)for y in R(j-1,j+s+1)for x in i-1,i+1]+[(i,j-1),(i,j+s)]if 0<=x<Z>y>=0):q=B[:];q[i]=q[i][:j]+'*'*s+q[i][j+s:];q=(q,t(q))[o];any((t(q)+q)[k].count('*')>m[k]for k in R(Z+Z))or f(q,S[1:])
 o or f(t(B),S,1)
y=raw_input;S=[];s=str.split
for i in s(y()):u,v=map(int,s(i,'x'));S+=[u]*v
m=map(int,s(y())+s(y()));Z=input();R=range;r=R(Z);B=[y()for _ in r];J=''.join;t=lambda x:map(J,zip(*x))
f(B,S[:len(S)-J(B).count('*')])

इसे ऑनलाइन काम करते देखें: Ideone.com (ऑनलाइन संस्करण बड़े और कठिन ग्रिड के लिए बहुत धीमा हो सकता है, ऑफ़लाइन यह ठीक होना चाहिए)

इनपुट स्टड के माध्यम से है, बस ओपी से लाइनों को कॉपी और पेस्ट करें (लेकिन सावधान रहें, स्टैकएक्सचेंज कभी-कभी रिक्त स्थान या रेखाओं को हटा देता है)।

इस कोड के कुछ बुनियादी विचार: यह एक पुनरावर्ती फ़ंक्शन का उपयोग करता है f। fबोर्ड पर एक आकार रखने की कोशिश करता है। प्रत्येक संभावित स्थान के लिए यह खुद को संशोधित बोर्ड के साथ कहता है। इसमें 3 लूप हैं। oअभिविन्यास निर्धारित करता है (2 - क्षैतिज, 3 - ऊर्ध्वाधर)। यह हमेशा आकार को क्षैतिज रखेगा, इसलिए, इसके अंत में o=2, यह फ़ंक्शन के साथ बोर्ड को स्थानांतरित करेगा t। iपंक्ति है और jसभी संभव शुरुआती कॉलम हैं। तब बहुत सारी जाँचें होती हैं, यदि आकृति के सिरों के पास वैध वर्ण हैं, यदि आकृति के मध्य में वैध वर्ण हैं और यदि आस-पास खाली है।

— Jakube
स्रोत

मैं अंतिम 6 बाइट्स में कटौती करने के लिए संघर्ष कर रहा था, जब मैंने आपका अंतिम संपादन (-30) देखा और छोड़ दिया ... आपके पास मेरा वोट है जो इसके लायक है

— edc65

जावास्क्रिप्ट (ईएस 6) 661 667 695 702 745 755 786 790 784 798

~~कार्य प्रगति पर है, छोटा किया जा सकता है।~~ संभवतः एक जटिल ग्रिड पर बहुत धीमी गति से। शायद नहीं।

थोड़ी देर संपादित करें , बहुत तेज।
2 बग फिक्स, कॉलम / पंक्तियों की जांच संपादित करें। संयोग से, अब यह तेज है

एम फ़ंक्शन मुख्य है। डब्ल्यू पैरामीटर सभी इनपुट के साथ एक बहुस्तरीय स्ट्रिंग है। फ़ंक्शन इनपुट को पार्स करता है और एक प्रारंभिक बोर्ड तैयार करता है। <>^v|-*शुरुआती बोर्ड में अक्षरों को बदल दिया जाता है ,, प्रत्येक ,को *सही समाधान के साथ बदलना पड़ता है ।

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

P फंक्शन टेस्ट यदि किसी आकृति को दिए गए स्थिति और अभिविन्यास के लिए रखा जा सकता है। यह सभी कॉस्ट्रेन्स (बोर्ड के अंदर, कोई ओवरलैप, नो टच, वैलिड रो और कॉलम काउंट) की जाँच करता है

M=w=>(
  [x,c,r,z]=w=w[S='split'](n='\n'),
  (b=[...w.slice(4).join(n)])
  .map((c,p)=>~(k='*<>-*^v|'.indexOf(c))&&[(q=k>3?z:1,0),k&1&&-q,k&2&&q].map(o=>b[p+o]=0),
    c=c[S](e=' '),r=r[S](e),w=z++,f='*',s='',x[S](e).map(v=>s+=v[0].repeat(v[2]))),
  R=(s,b,x=0,y=0,n=s[0],V=i=>b[i]>'#',
    P=(p,o,q,t,g,l,d=[...b])=>{
        if(l<z-n&!V(p+o*l-o)&!V(p+o*l+o*n))
        {
          for(i=-1;v=d[p],++i<w;p+=o,t-=v==f)
            if(i>=l&i-n<l)
              for(v!=e&v!=0|[q,w,~z].some(w=>V(p+w)|V(p-w))?t=0:d[p]=f,j=o*i,u=k=0;
                  ++k<z;(u+=d[j]==f)>g[i]?t=0:j+=q);
          return t>=n&&d.join('')
        }
    })=>{
    if(b){
      if(!n)return~b.search(0)?0:b;
      for(s=s.slice(1);y<w||(y=0,++x<w);++y)
        if(h=R(s,P(y*z,1,z,r[y],c,x))||n>1&&R(s,P(x,z,1,c[x],r,y)))return h
    }
  })(s,b)

FireFox / FireBug कंसोल में टेस्ट करें

;['3x2 1x4\n2 2 3 1 2\n4 0 3 0 3\n5\n     \n     \n    #\n  #  \n    *\n'
,'3x1 1x6\n2 0 4 0 3\n3 1 2 1 2\n5\n*    \n     \n     \n   # \n     \n'
,'5x1 4x1 2x1 1x2\n1 2 3 3 2 2\n0 5 0 4 0 4\n6\n#     \n  -   \n      \n      \n #    \n   <  \n'
,'4x1 3x1 2x2 1x2\n1 4 0 3 0 5\n4 1 1 2 3 2\n6\n <    \n      \n      \n      \n    # \n ^ #  \n']
.forEach(x=>console.log(x,M(x).replace(/ /g,'`'))) // space replaced with ` for clarity

आउटपुट (कुल निष्पादन समय <1sec)

3x2 1x4
2 2 3 1 2
4 0 3 0 3
5


    #
  #  
    *

***`*
`````
`***#
``#``
*`*`*

3x1 1x6
2 0 4 0 3
3 1 2 1 2
5
*    


   # 


*`*`*
``*``
``*`*
*``#`
``*`*

5x1 4x1 2x1 1x2
1 2 3 3 2 2
0 5 0 4 0 4
6
#     
  -   


 #    
   <  

#`````
`*****
``````
`****`
`#````
*`**`*

4x1 3x1 2x2 1x2
1 4 0 3 0 5
4 1 1 2 3 2
6
 <    



    # 
 ^ #  

**`*`*
```*``
`````*
`*```*
`*`*#*
`*`#`*

— edc65
स्रोत

लगता है @globby उस इनाम के बारे में भूल गया। वैसे भी, इस दौड़ में बहुत मज़ा आया।

— जकूबे