बाइनरी पहेली सॉल्वर

10

परिचय

पहेली के नियम:

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

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

आप www.binarypuzzle.com पर खेल खेल सकते हैं यदि आप चाहते हैं।

रणनीति:

नियम 1 के कारण, हम हमेशा एक अंक भर सकते हैं यदि:
- एक ही अंक के दो पहले से ही लंबवत या क्षैतिज रूप से एक दूसरे से सटे हुए हैं, जिस स्थिति में हम दोनों तरफ विपरीत अंक में भर सकते हैं। यानी .11...→ 0110..।
- एक ही अंक के दो लंबवत या क्षैतिज रूप से उनके बीच में केवल एक अंतर होता है। यानी .1.1..→.101..

नियम 1 के कारण, जब तीन अंतराल बचे हैं और हमारे पास एक ही अंक के तीन आसन्न नहीं हो सकते हैं, तो हम अंतराल में से एक को भर सकते हैं। Ie .0.1.0→ 10.1.0(हमें अभी भी दो लोगों को भरना है, और हमारे पास बीच में तीन समीप वाले नहीं हो सकते हैं, इसलिए पहला अंतर एक होना चाहिए 1।)

नियम 2 के कारण, हम हमेशा शेष अंतराल को एक पंक्ति या स्तंभ में भर सकते हैं यदि उनमें से आधा पहले से ही विपरीत अंक के साथ भरा हो। यानी .1.011→010011

नियम 3 के कारण, हम हमेशा विपरीत अंकों को भर सकते हैं यदि केवल दो को समान रूप से आदेशित रेखा पर हल करने के लिए छोड़ दिया जाए। यानी 101100 & 1..100→101100 & 110100

नियम 3 के कारण, हम कभी-कभी एक अंतराल में भर सकते हैं जब तीन अंतराल समान रूप से आदेशित रेखा पर छोड़ दिए जाते हैं। Ie 010011 & .1.01.→ 010011 & .1.010(यहां हम 1अंत में नहीं भर सकते हैं , क्योंकि इसका मतलब है कि हमें अन्य दो अंतरालों पर शून्य में भरना होगा, दोनों पंक्तियों को समान क्रम में बनाना होगा।)

उदाहरण:

हम निम्नलिखित 6x6 ग्रिड के साथ शुरू करते हैं जिसमें कुछ और शून्य से भरे हुए हैं (और डॉट्स अंतराल हैं जिन्हें हमें अभी तक भरना है): 

.1....
.10.0.
1.11..
.1....
...1.0
......

नियम 1 और 2 के कारण हम इन अंकों को भर सकते हैं:

.1.01.
.1010.
101100
010011
.0.1.0
.010..

नियम 1 के कारण हम पंक्ति 5, कॉलम 1 में 1 भर सकते हैं:

.1.01.
.1010.
101100
010011
10.1.0
.010..

नियम 3 के कारण हम पंक्ति 1, कॉलम 6 (जब पंक्ति 4 को देख रहे हैं) में 0 भर सकते हैं:

.1.010
.1010.
101100
010011
10.1.0
.010..

अब हम नियमों 1 और 2 के कारण अंकों के साथ अंतराल को भरना जारी रख सकते हैं:

.1.010
010101
101100
010011
10.1.0
.010.1

अब हम नियम 3 (जब पंक्ति 3 को देख रहे हैं) के कारण पंक्ति 5 को समाप्त कर सकते हैं:

.1.010
010101
101100
010011
100110
.010.1

और फिर हम नियम 1 और 2 के कारण पहेली को समाप्त कर सकते हैं:

011010
010101
101100
010011
100110
101001

चुनौती:

चुनौती बस है: शुरुआती ग्रिड को देखते हुए, हल की गई पहेली को आउटपुट करना।

नोट: आपको ऊपर दिए गए नियमों को लागू करने की आवश्यकता नहीं है। आप निश्चित रूप से कर सकते हैं, और यह आपको इस चुनौती को लागू करने के तरीके पर संकेत देना चाहिए, लेकिन नियमों के साथ समाधान को ध्यान में रखते हुए पूरी तरह से ठीक है।
आप इसे कैसे हल करते हैं यह आपके ऊपर है, लेकिन चुनौती हल की गई पहेली को आउटपुट करना है।

चुनौती नियम:

  • ग्रिड के लिए इनपुट और आउटपुट प्रारूप लचीला है, लेकिन कृपया बताएं कि आप क्या उपयोग करते हैं। (यानी 2D बाइट-ऐरे; स्ट्रींग विद न्यूलाइन्स; आदि)
  • यह ऊपर उपयोग किए गए वर्णों पर भी लागू होता है। उदाहरण में मैंने उपयोग किया है 01., लेकिन यदि आप चाहें तो आप ABxइसके बजाय उपयोग कर सकते हैं । कृपया बताएं कि आपके द्वारा उपयोग किए गए इनपुट / आउटपुट प्रारूप और वर्ण क्या हैं।
  • आप मान सकते हैं कि केवल निम्नलिखित ग्रिड आकारों का उपयोग किया जाएगा 6x6:; 8x8; 10x10; 12x12; 14x14; 16x16।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट लूपोल्स वर्जित हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

डॉट्स केवल पठनीयता के लिए जोड़े जाते हैं, रिक्त स्थान का उपयोग करने के लिए स्वतंत्र महसूस करें या कुछ और जो आप अंतराल के लिए पसंद करते हैं। दोनों में और आउटपुट स्वरूप लचीला है।

Input:
1..0..
..00.1
.00..1
......
00.1..
.1..00

Output:
101010
010011
100101
011010
001101
110100

Input:
.1....
.10.0.
1.11..
.1....
...1.0
......

Output:
011010
010101
101100
010011
100110
101001

Input:
.......1..
.00..0..1.
.0..1..0.0
..1...1...
1.1......1
.......1..
.0..1...0.
....11...0
.0.0..1..0
0...0...1.

Output:
0110010101
1001100110
1001101010
0110011001
1010100101
0101010110
1001101001
0110110100
1010011010
0101001011
code-golf  game  binary  binary-matrix 
— केविन क्रूज़सेन
स्रोत
— केविन क्रूज़सेन
1
— अरनौलद

जवाबों:

4

ब्रेकीलॉग , 34 बाइट्स

{ℕ<2}ᵐ²&≜{d?ọᵐctᵐ=&{ḅlᵐ⌉<3}ᵐ}&\↰₂&

इसे ऑनलाइन आज़माएं!

यह बहुत खराब है, इसलिए टीआईओ पर परीक्षण का मामला 4x4 है। मैं वर्तमान में अपने कंप्यूटर पर 6x6 टेस्ट केस चला रहा हूं, यह देखने के लिए कि इसमें कितना समय लगता है।

यह इनपुट के रूप में सूचियों की एक सूची लेता है। अज्ञात मानों को चर के साथ इंगित किया जाना चाहिए, जो कि सभी अपरकेस स्ट्रिंग्स के साथ है (और वे सभी अलग-अलग होने चाहिए, अन्यथा आप संकेत दे रहे हैं कि कुछ कोशिकाओं का समान मूल्य होना चाहिए)

व्याख्या

हम मूल्यों में बाधा डालते हैं {0,1}, तब हम चर की तत्काल कोशिश करते हैं जब तक कि सभी 3 नियमों का सम्मान नहीं करते। यही कारण है कि यह इतना धीमा है (क्योंकि यह उन सभी को एक खोजने तक की कोशिश करेगा; और क्योंकि उस स्थिति में ब्रैचीग्लो को अच्छी तरह से लागू नहीं किया जाता है ताकि संभावित मैट्रिक्स की कोशिश करने से पहले बाधाएं लगाई जा सकें)।

                                 &  Output = Input
{   }ᵐ²                             Map two levels on the Input (i.e. each cell):
 ℕ<2                                  The cell is either 0 or 1
       &≜                           Assign values to all cells
         {                  }       Define predicate 2:
          d?                          The Input with no duplicates is still the Input
                                        (i.e. all rows are different)
           ?ọᵐctᵐ=                    All occurences of 1s and 0s for each rows are equal
                  &{      }ᵐ          Map on rows:
                    ḅlᵐ                 Get the lengths of runs of equal values
                       ⌉<3              The largest one is strictly less than 3
                             &\↰₂   Apply predicate 2 on the transpose of the Input
                                      (i.e. do the same checks but on columns)
— Fatalize
स्रोत
जिज्ञासा से बाहर, Brachylog पूंजी वर्णमाला से परे चर को कैसे दर्शाता है? तो चलो अपने समाधान के लिए तेजी से काम करेगा मान लीजिए, इसके साथ एक 14x14 ग्रिड पर सभी खाली स्थान को भरने के लिए सक्षम नहीं होगा Aके माध्यम से Y(के साथ Zउत्पादन पैरामीटर के रूप में)। इसके साथ जारी रखने के लिए करता है AA, AB, आदि?
— केविन क्रूज़सेन
2
@ केविनक्रूजसेन कोई भी सर्व-अपरकेस पहचानकर्ता एक चर है, इसलिए हाँ AAएक चर है और KEVINCRUIJSSENएक चर भी है।
— घातक
3
जैसा कि मुझे संदेह था, ब्राचीलॉग के लिए एक चुनौती: डी
— जोनाथन एलन
3

जावास्क्रिप्ट (ईएस 6), 274 270 बाइट्स

एक 2 डी सरणी के रूप में इनपुट लेता है, जहां खाली कोशिकाओं को चिह्नित किया जाता है 2। कंसोल को सभी संभव समाधान प्रिंट करता है।

f=(a,x=0,y=0,w=a.length,p,R=a[y])=>(M=z=>!a.some((r,y)=>/(0|1),\1,\1/.exec(s=r.map((v,x)=>(v=z?v:a[x][y],b-=v&1,c-=!v,m|=v&2,v),b=c=w/2))||b*c<0|o[b*c||s]&(o[s]=1),o={}))(m=0)&M(1)&&(m?R&&[0,1].map(n=>(p=R[x])==n|p>1&&(R[x]=n,f(a,z=(x+1)%w,y+!z),R[x]=p)):console.log(a))

यह काम किस प्रकार करता है

कोड का पहला भाग M()वर्तमान बोर्ड की वैधता की जांच करने के लिए फ़ंक्शन का उपयोग करता है , क्षैतिज और लंबवत दोनों।

M = z =>
  !a.some((r, y) =>
    /(0|1),\1,\1/.exec(
      s = r.map((v, x) =>
        (
          v = z ? v : a[x][y],
          b -= v & 1,
          c -= !v,
          m |= v & 2,
          v
        ),
        b = c = w / 2
      )
    ) ||
    b * c < 0 |
    o[b * c || s] &
    (o[s] = 1),
    o = {}
  )

यह स्ट्रिंग के लिए एक पूर्ण पंक्ति या स्तंभ नक्शे रों । यह वास्तव में एक स्ट्रिंग के लिए एक सरणी है, इसलिए ऐसा दिखता है "1,2,2,0,2,2"।

यह उपयोगकर्ता है:

  • /(0|1),\1,\1/3 या अधिक लगातार समान अंकों का पता लगाने के लिए नियमित अभिव्यक्ति ।
  • काउंटर ख और ग की संख्या का ट्रैक रखने के लोगों को और शून्य । दोनों काउंटरों को w / 2 के लिए आरंभीकृत किया जाता है और हर बार एक या एक शून्य (क्रमशः) का सामना करना पड़ता है। यह या तो होता है:
    • ख = c = 0 → b * c = 0 → लाइन पूर्ण और सही (कई के रूप में है शून्य के रूप में लोगों को )
    • b> 0 और c> 0 → b * c> 0 → लाइन अभी तक पूरी नहीं है लेकिन सही है (हमारे पास w / 2 शून्य से अधिक या w / 2 वाले से अधिक नहीं है )
    • b <0 या c <0 → b * c <0 → लाइन अमान्य है
  • यदि बोर्ड पर कम से कम एक शेष दो हैं तो फ्लैग एम ('लापता' के लिए) गैर-शून्य है ।
  • अब तक सामने आई सभी लाइन पैटर्न का ध्यान रखने के लिए ऑब्जेक्ट ओ ।

यदि बोर्ड अमान्य है, तो हम तुरंत रोक देते हैं। यदि बोर्ड वैध और पूर्ण है, तो हम इसे कंसोल पर प्रिंट करते हैं। अन्यथा, कोड के प्रयास के दूसरे भाग प्रत्येक को बदलने के लिए 2 या तो एक साथ शून्य या एक एक पुनरावर्ती कॉल के साथ:

[0, 1].map(n =>
  (p = a[y][x]) == n |
  p > 1 && (
    a[y][x] = n,
    f(a, z = (x + 1) % w, y + !z),
    a[y][x] = p
  )
)

डेमो

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
स्पष्टीकरण जोड़ने के लिए धन्यवाद। और मुझे पसंद है कि आप केवल एक के बजाय सभी संभावित आउटपुट कैसे प्रिंट करते हैं!
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन यह शायद इष्टतम से बहुत दूर है लेकिन लिखने में मजेदार था। अच्छी चुनौती!
— अरनौलड
1

जेली , 53 51 बाइट्स

ṡ€3ḄFf0,7L
SḤnLṀȯÇ
⁻QȯÇ
Fṣ©2L’0,1ṗż@€®F€s€LÇÐḟZÇ$Ðḟ

ग्रिड का प्रतिनिधित्व सूची, जिसमें की एक सूची ले जाता है 0, 1और 2(रिक्त स्थान)। सूचियों की सूची की एक सूची लौटाता है, सूचियों की प्रत्येक सूची एक ही प्रारूप में होती है (हालांकि बिना 2एस के) और इनपुट के संभावित समाधान का प्रतिनिधित्व करता है।

इसे ऑनलाइन आज़माएं! (यह स्मृति सीमाओं के कारण किसी भी प्रश्न के परीक्षण के मामलों को नहीं चलाता है - सभी 2 nSpaces ग्रिड को पूर्णांकों की सूची की सूची के रूप में बनाया जाता है - लेकिन मैंने एक एकल समाधान के साथ अपेक्षाकृत विषम मामला डाल दिया है)। पाद अलग हो जाता है और ग्रिड को प्रारूपित करता है।

शुद्ध ब्रूट बल विधि - नियमों को लागू करती है और प्रत्येक ग्रिड के लिए जांच करती है जो कि किसी भी एस या एस के 2साथ बदलकर बनाई जा सकती है ।10

ṡ€3ḄFf0,7L - Link 1, # of runs of 3 1s or 3 0s by row: list of lists
ṡ€3        - all contiguous slices of length 3 for €ach list
   Ḅ       - convert all results from binary
    F      - flatten into one list
     f     - filter keep values in:
      0,7  -   0 paired with 7: [0,7]
         L - length

SḤnLṀȯÇ - Link 2, unequal counts of 1s and 0s by column ...or link 1: list of lists
S       - sum (vectorises, hence "by column", counts 1s since only 1s or 0s appear)
 Ḥ      - double
   L    - length (number of rows - OK since square)
  n     - not equal? (vectorises)
    Ṁ   - maximum (1 if any not equal)
     ȯÇ - ... or last link (1) as a monad

⁻QȯÇ - Link 3, rows are unique ...or link 2: list of lists
 Q   - unique
⁻    - not equal?
  ȯÇ - ... or last link (2) as a monad

Fṣ©2L’0,1ṗż@€®F€s€LÇÐḟZÇ$Ðḟ - Main link: list of lists
F                           - flatten
 ṣ©2                        - split at 2s and copy the result to the register
    L                       - length (# of such slices)
     ’                      - decrement (# of 2s)
      0,1                   - 0 paired with 1
         ṗ                  - Cartesian power (all binary lists of length # of 2s)
             ®              - recall value from register (the flat version split at 2s)
          ż@€               - zip (reversed @rguments) for €ach (1s & 0s where 2s were)
              F€            - flatten €ach
                s€L         - split €ach into chunks of length length(input) (into rows)
                    Ðḟ      - filter discard if:
                   Ç        -   call last link(3) as a monad
                         Ðḟ - filter discard if:
                        $   -   last two links as a monad:
                      Z     -     transpose
                       Ç    -     call last link(3) as a monad
— जोनाथन एलन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.