10

_{यह चुनौती इस ऐप से प्रेरित है ।}

यह इस चुनौती का बहुत आसान संस्करण है । यह चुनौती कोड-गोल्फ है , जबकि दूसरा सबसे तेज़-कोड है ।

तुम एक वर्ग इनपुट ग्रिड दिया जाएगा, आयामों की 6 बटे 6 जो में बांटा गया है 6 क्षेत्रों, जहां प्रत्येक क्षेत्र की कोशिकाओं एक अद्वितीय पहचानकर्ता (मैं से लोअर केस अक्षरों का उपयोग करेंगे है वायुसेना यहां पाठ में, लेकिन आप जो चाहें पसंद कर सकते हैं, उदाहरण के लिए पूर्णांक 1-6 )।

इनपुट इस तरह दिख सकता है (वैकल्पिक इनपुट प्रारूप):

aabbbb
aabbbb
aaccbb
acccdb
ecccdb
eeefff

या, कल्पना करना आसान है:

चुनौती:

आप इस पार्क में 6 पेड़ लगाने जा सकते हैं, निम्नलिखित नियमों के अनुसार:

प्रति स्तंभ में ठीक 1 पेड़ और प्रति पंक्ति 1 पेड़ होगा
सभी क्षेत्रों में ठीक 1 पेड़ होगा।
कोई भी पेड़ दूसरे पेड़ के पास, लंबवत, क्षैतिज या तिरछे नहीं हो सकता है

ऊपर दिए गए लेआउट का समाधान है:

नोट: प्रत्येक पहेली का केवल एक ही समाधान है

अतिरिक्त नियम:

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

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

aabbbb
aabbbb
aaccbb
acccdb
ecccdb
eeefff
---
aAbbbb
aabbbB
aaCcbb
acccDb
Ecccdb
eeeFff
----------
aabccc
aacccc
aaddce
aeeeee
aeeefe
eeeeee
---
aaBccc
aacccC
aadDce
Aeeeee
aeeeFe
eEeeee
----------
aaaabb
aacbbb
aadddb
addeef
ddddee
dddeee
---
aaaaBb
aaCbbb
Aadddb
addeeF
dDddee
dddEee
----------
abbbcd
abebcd
addddd
dddddd
effdff
eeffff
---
abBbcd
abebCd
Addddd
dddDdd
effdfF
eEffff

एक प्रारूप पर समान परीक्षण के मामले जो पार्स करना थोड़ा आसान है:

Test case 1:
[1,1,2,2,2,2;1,1,2,2,2,2;1,1,3,3,2,2;1,3,3,3,4,2;5,3,3,3,4,2;5,5,5,6,6,6]
Test case 2:
[1,1,2,3,3,3;1,1,3,3,3,3;1,1,4,4,3,5;1,5,5,5,5,5;1,5,5,5,6,5;5,5,5,5,5,5]
Test case 3:
[1,1,1,1,2,2;1,1,3,2,2,2;1,1,4,4,4,2;1,4,4,5,5,6;4,4,4,4,5,5;4,4,4,5,5,5]
Test case 4:
[1,2,2,2,3,4;1,2,5,2,3,4;1,4,4,4,4,4;4,4,4,4,4,4;5,6,6,4,6,6;5,5,6,6,6,6]

code-golf grid game

— स्टीवी ग्रिफिन
स्रोत

एक सुडोकू सॉल्वर की तरह लगता है लेकिन अलग है।

— juniorRubyist

2

सी, 223 182 बाइट्स

O[15],U;main(y,v)char**v;{if(y>7)for(;y-->2;printf("%06o\n",O[y]));else for(int*r,x=1,X=8;X<14;U&x|*r|O[10-y]*9&x*9?0:(U^=O[9-y]=*r=x,*r=main(y+1,v),U^=x),x*=8)r=O+v[1][y*7-++X]-88;}

प्रश्न में दिए गए प्रारूप में एक तर्क के रूप में इनपुट लेता है। 1s के ग्रिड के रूप में स्टडआउट करने के लिए आउटपुट लिखता है, जहां पेड़ जाते हैं।

./TreesMin 'aabbbb
aabbbb
aaccbb
acccdb
ecccdb
eeefff'

नमूना उत्पादन:

टूट - फूट

O[15],                                  // Tree positions & region usage
U;                                      // Column usage (bitmask)
main(y,v)char**v;{                      // Recursive main function
  if(y>7)                               // Finished grid?
    for(;y-->2;printf("%06o\n",O[y]));  //  Print it (rows are padded octal)
  else                                  // Not finished:
    for(int*r,x=1,X=8;X<14;             //  Loop over columns
      U&x|*r|O[10-y]*9&x*9              //   Current cell violates rules?
        ?0                              //    Do nothing
        :(U^=O[9-y]=*r=x,               //   Else: mark cell
          *r=main(y+1,v),               //    Recurse
          U^=x)                         //    Unmark cell
      ,x*=8)                            //   Advance to next column
      r=O+v[1][y*7-++X]-88;             //   Region pointer for current iteration
}

यह इस प्रश्न के सबसे तेज़-संस्करण संस्करण के लिए मेरे उत्तर का एक रूपांतर है । ज्यादा शॉर्ट-सर्कुलेटिंग नहीं है, लेकिन यह 6x6 ग्रिड के लिए काफी तेज है।

— डेव
स्रोत

1

क्लिंगो , 66 बाइट्स

1{t(X,Y):c(X,Y,Z)}:-Z=1..n.:-t(X,Y),2{t(X,J;I,Y;X-1..X+1,Y..Y+1)}.

ग्रिड आकार clingo plant.lp - -c n=<n>कहां <n>है, इसके साथ चलाएँ । इनपुट प्रारूप की एक सूची है c(X,Y,Z).(प्रत्येक कोशिका के लिए बयान X, Y) रंग Z, के साथ 1 ≤ X, Y, Z≤ n, वैकल्पिक खाली स्थान के द्वारा अलग कर दिया। आउटपुट में t(X,Y)प्रत्येक पेड़ के लिए ( X, Y) शामिल हैं।

डेमो

$ clingo plant.lp - -c n=6 <<EOF
> c(1,1,1). c(2,1,1). c(3,1,2). c(4,1,2). c(5,1,2). c(6,1,2).
> c(1,2,1). c(2,2,1). c(3,2,2). c(4,2,2). c(5,2,2). c(6,2,2).
> c(1,3,1). c(2,3,1). c(3,3,3). c(4,3,3). c(5,3,2). c(6,3,2).
> c(1,4,1). c(2,4,3). c(3,4,3). c(4,4,3). c(5,4,4). c(6,4,2).
> c(1,5,5). c(2,5,3). c(3,5,3). c(4,5,3). c(5,5,4). c(6,5,2).
> c(1,6,5). c(2,6,5). c(3,6,5). c(4,6,6). c(5,6,6). c(6,6,6).
> EOF
clingo version 5.1.0
Reading from plant.lp ...
Solving...
Answer: 1
c(1,1,1) c(2,1,1) c(3,1,2) c(4,1,2) c(5,1,2) c(6,1,2) c(1,2,1) c(2,2,1) c(3,2,2) c(4,2,2) c(5,2,2) c(6,2,2) c(1,3,1) c(2,3,1) c(3,3,3) c(4,3,3) c(5,3,2) c(6,3,2) c(1,4,1) c(2,4,3) c(3,4,3) c(4,4,3) c(5,4,4) c(6,4,2) c(1,5,5) c(2,5,3) c(3,5,3) c(4,5,3) c(5,5,4) c(6,5,2) c(1,6,5) c(2,6,5) c(3,6,5) c(4,6,6) c(5,6,6) c(6,6,6) t(1,5) t(2,1) t(6,2) t(3,3) t(5,4) t(4,6)
SATISFIABLE

Models       : 1+
Calls        : 1
Time         : 0.045s (Solving: 0.00s 1st Model: 0.00s Unsat: 0.00s)
CPU Time     : 0.000s

इससे निपटने के लिए इनपुट / आउटपुट प्रारूप को आसान बनाने के लिए, यहां से और चुनौती में दिए गए प्रारूप में बदलने के लिए पायथन प्रोग्राम हैं।

इनपुट

import sys
print(' '.join("c({},{},{}).".format(x + 1, y + 1, ord(cell) - ord('a') + 1) for y, row in enumerate(sys.stdin.read().splitlines()) for x, cell in enumerate(row)))

उत्पादन

import re
import sys
for line in sys.stdin:
    c = {(int(x), int(y)): int(z) for x, y, z in re.findall(r'\bc\((\d+),(\d+),(\d+)\)', line)}
    if c:
        t = {(int(x), int(y)) for x, y in re.findall(r'\bt\((\d+),(\d+)\)', line)}
        n, n = max(c)
        for y in range(1, n + 1):
            print(''.join(chr(ord('aA'[(x, y) in t]) + c[x, y] - 1) for x in range(1, n + 1)))
        print()

— एंडर्स कसीगोर
स्रोत

एक गोल्फ कोर्स पर पेड़ लगाएं!