Hitori पहेलियाँ हल करें


21

परिचय

कम से कम बाइट्स का उपयोग करते हुए हिटोरी पहेली के लिए एक सॉल्वर लिखें ।

चुनौती

आपके कार्य को होटोरि (と り the, जापानी में "अकेले" के लिए शब्द के लिए एक सॉल्वर लिखा जाता है; खेल के नाम का अर्थ "मुझे अकेला छोड़ दें") तार्किक पहेलियाँ हैं। नियम इस प्रकार हैं:

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

मुझे उम्मीद है कि नियम अब तक स्पष्ट हैं। यदि नियमों के बारे में कुछ भी स्पष्ट नहीं है, तो विकिपीडिया पृष्ठ देखें

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

वे सेल जिनमें से नंबर हटाए गए हैं, उन्हें 0s के साथ दर्शाया जाता है।

Input  ->  Output

4
2 2 2 4      0 2 0 4
1 4 2 3  ->  1 4 2 3
2 3 2 1      2 3 0 1
3 4 1 2      3 0 1 2

4
4 2 4 3      0 2 4 3
4 1 1 2  ->  4 1 0 2
3 1 2 1      3 0 2 1
4 3 1 3      0 3 1 0

5
1 5 3 1 2      1 5 3 0 2
5 4 1 3 4      5 0 1 3 4
3 4 3 1 5  ->  3 4 0 1 5
4 4 2 3 3      4 0 2 0 3
2 1 5 4 4      2 1 5 4 0

8
4 8 1 6 3 2 5 7      0 8 0 6 3 2 0 7
3 6 7 2 1 6 5 4      3 6 7 2 1 0 5 4
2 3 4 8 2 8 6 1      0 3 4 0 2 8 6 1
4 1 6 5 7 7 3 5  ->  4 1 0 5 7 0 3 0
7 2 3 1 8 5 1 2      7 0 3 0 8 5 1 2
3 5 6 7 3 1 8 4      0 5 6 7 0 1 8 0
6 4 2 3 5 4 7 8      6 0 2 3 5 4 7 8
8 7 1 4 2 3 5 6      8 7 1 4 0 3 0 6

9
8 6 5 6 8 1 2 2 9      8 0 5 6 0 1 2 0 9
5 6 2 4 1 7 9 8 3      5 6 2 4 1 7 9 8 3
5 8 2 5 9 9 8 2 6      0 8 0 5 0 9 0 2 0
9 5 6 6 4 3 8 4 1      9 5 6 0 4 3 8 0 1
1 1 6 3 9 9 5 6 2  ->  0 1 0 3 9 0 5 6 2
1 1 4 7 3 8 3 8 6      1 0 4 7 0 8 3 0 6
3 7 4 1 2 6 4 5 5      3 7 0 1 2 6 4 5 0
3 3 1 9 8 7 7 4 5      0 3 1 9 8 0 7 4 5
2 9 7 5 3 5 9 1 3      2 9 7 0 3 5 0 1 0 

ये परीक्षण मामलों से लिया जाता है अवधारणा है पहेलियाँ , PuzzleBooks , अवधारणा है पहेलियाँ , विकिपीडिया , और यूट्यूब , क्रमशः।

चश्मा

  • अपवाद हैंडलिंग के बारे में चिंता करने की कोई जरूरत नहीं है।

  • आप मान सकते हैं कि इनपुट हमेशा एक अद्वितीय समाधान के साथ एक मान्य पहेली है और आप अपना कोड लिखने में इसका लाभ उठा सकते हैं।

  • यह , सबसे कम संख्या में बाइट्स जीतती हैं।

  • 4 <= n <= 9 (मूल रूप से, स्टिव ग्रिफ़िन के सुझाव के बाद 9 को बदल दिया गया, IO में कुछ परेशानी से भी बचा)

  • आप इनपुट ले सकते हैं और किसी भी मानक फॉर्म के माध्यम से आउटपुट प्रदान कर सकते हैं , और आप प्रारूप चुनने के लिए स्वतंत्र हैं।

  • आउटपुट स्वरूप के लिए कुछ सुझाव हैं (लेकिन आप इन तक सीमित नहीं हैं)

    • अंतिम ग्रिड का आउटपुट
    • सभी हटाए गए नंबरों वाले ग्रिड को आउटपुट करना
    • उपरोक्त में से किसी एक के निर्देशांक की सूची को आउटपुट करें
  • हमेशा की तरह, डिफ़ॉल्ट कमियां यहां लागू होती हैं।


संबंधित (इस चुनौती से प्रेरित): जांचें कि क्या सभी तत्व एक मैट्रिक्स में जुड़े हुए हैं

मेरी आखिरी चुनौती: सेवन्स के खेल का विस्तार


2
मेरा सुझाव है कि आपको नियतात्मक रनटाइम की आवश्यकता है, या आवश्यकता है कि सबसे बड़ा परीक्षण मामला 1 मिनट (या शायद अधिक / कम) में हल किया जा सकता है। इसके अलावा, आप कहते हैं कि 4 <= n <= 16, लेकिन सबसे बड़ा परीक्षण मामले के लिए है n=9। मेरा सुझाव है कि आप या तो एक n=16परीक्षण मामला पोस्ट करें , या कहें 4 <= n <= 9। रास्ते से अच्छी चुनौती :)
स्टीवी ग्रिफिन

1
@StewieGriffin कैसे के बारे में सिर्फ एक अलग सबसे तेज एल्गोरिथ्म चुनौती है?
जोनाथन एलन

@StewieGriffin 16x16 जोड़ने की कोशिश की, लेकिन अभी तक काफी तैयार नहीं है। अब 9 में बदल गया।
वीजुन झोउ

@JonathanAllan जैसा आप चाहते हैं।
वीजुन झोउ

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

जवाबों:


3

हास्केल , 374 बाइट्स

import Data.Array;import Data.List;r=range;p=partition
c(e,f)=p(\(b,p)->any(==1)[(b-d)^2+(p-q)^2|(d,q)<-e])f
n#g=[s|(o,(e:f))<-[p((==0).(g!))$indices g],
 null.fst$c(o,o),null.snd$until(null.fst)c([e],f),
 s<-case[((l,c),d)|((l,c),h)<-assocs g,h>0,
 d<-[filter((==h).(g!))$r((l,c+1),(l,n))++r((l+1,c),(n,c))],d/=[]]
 of[]->[g];((c,d):_)->n#(g//[(c,0)])++n#(g//[(c,0)|c<-d])]

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


धन्यवाद। बहुत प्रभावशाली। व्यक्तिगत रूप से मैं एक शुरुआत करने वाला हूं, लेकिन हास्केल का बहुत बड़ा प्रशंसक भी हूं।
वीजुन झोउ


1
उपरोक्त बहुत सारे अक्षर भी एक टिप्पणी छोड़ गए थे। यह सिर्फ कुछ
व्हाट्सएप


2

एपीएल (Dyalog यूनिकोड) , 133 बाइट्स SBCS

{q←{⊢/4 2⍴⍵}⌺3 3g←⍵=⊂∪,⍵⋄⍵×~1⊃{((⌈/q b)⌈b<{2<≢∪0,,(⍵×⊢⌈⌈/∘q)⍣≡⍵×(⍴⍵)⍴1+⍳≢,⍵}¨~b∘⌈¨⊂⍤2∘.≡⍨⍳⍴b)(+/↑w<g×⌈.⌈⍨w×g)⌈w b←⍵}⍣≡×\(⌈/=∘⌽⍨q⍵)0}

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

नियम # 4 का मेरा कार्यान्वयन (कोशिकाओं को एक जुड़ा हुआ घटक बनाना चाहिए) बल्कि बेकार है, लेकिन फिर भी यह TIO के बारे में 10 सेकंड में सभी परीक्षण पास करता है।


समग्र एल्गोरिथ्म: स्टोर दो बूलियन matrices bऔरw क्रमशः काले और सफेद होने वाली कोशिकाओं के लिए । bसभी शून्य के रूप में प्रारंभिक । wउन कोशिकाओं के लिए केवल 1 के रूप में प्रारंभिक , जिनके विपरीत मिलान वाले पड़ोसी हैं।

तक दोहराएं bऔरw निपटाएं:

  • में जोड़े b कोशिकाओं में जो एक ही पंक्ति (क्षैतिज या लंबवत) पर हैं और एक सेल के समान मान हैंw

  • में जोड़े wसभी कोशिकाओं के तत्काल पड़ोसियों मेंb

  • में जोड़े wसभी कटपॉइंट्स में - कोशिकाएं जिनके हटाने से गैर-काली कोशिकाओं का ग्राफ कई जुड़े घटकों में विभाजित हो जाएगा

अंत में, आउटपुट not(b)को मूल मैट्रिक्स से गुणा किया जाता है।


आपकी रुचि और स्पष्टीकरण के लिए बहुत-बहुत धन्यवाद। मुझे लगता है कि आपने जो वर्णन किया है वह भी एक विशिष्ट एल्गोरिथ्म का उपयोग किया जाता है यदि कोई पहेली को हाथ से हल करना है।
वीजुन झोउ

1
ईमानदार होने के लिए, मैंने कभी भी हाथोती को हल करने की कोशिश नहीं की। मुझे ये ट्रिक्स विकिपीडिया से मिलीं और मेरे पास इस बात का कोई प्रमाण नहीं है कि एल्गोरिथम हमेशा (यूनिक) सॉल्यूशन के लिए सभी तरह से जुटेगा।
ngn

2

जेली , 62 बाइट्स

किसी अन्य प्रश्न से user202729 का isConnected monadic लिंक का उपयोग करता है ।


FJṁa@µ«Ḋoµ€ZUµ4¡ÐLFQL<3
ḟ0ĠḊ€
¬T€œ&2\;Ç€FȦ
ZÇȯÇ_1Ŀ
2ḶṗLṗLa⁸ÇÞḢ

सूचियों की सूची का प्रतिनिधित्व करने वाला एक पूरा कार्यक्रम।
पाशविक बल से काम करता है और मूर्खतापूर्ण अक्षम्य है।

इसे ऑनलाइन आज़माएं! - एक 3 से 3, क्योंकि यह 60 सेकंड की TIO सीमा के भीतर भी एक आकार 4 को चलाने के लिए बहुत अक्षम है!

कैसे?

FJṁa@µ«Ḋoµ€ZUµ4¡ÐLFQL<3 - Link 1 isConnected? List of lists
...                     - 1 if connected 0 if not -- see linked answer in the header

ḟ0ĠḊ€ - Link 2, helperFor-AnyRepeatedValues: list
ḟ0    - filter out zeros
  Ġ   - group indices by value (i.e. [[indices of min],...,[indices of max]]
   Ḋ€ - dequeue €ach -- leaving a list of empty lists iff no repeated values
      -                 any remaining values are non-zero (1-based indexing in Jelly)

¬T€œ&2\;Ç€FȦ - Link 3, columnwiseAnyAdjacentZerosOrRowwiseAnyRepeatedValues: list of lists
¬            - logical not (convert all zeros to ones and all others to zeros)
 T€          - for €ach row get a list of truthy indexes (i.e. indexes of original zeros)
     2\      - pairwise reduction (i.e. for neighbouring rows) with:
   œ&        -   intersection (empty if no columnwise adjacent original zeros
             -                 any remaining values are non-zero due to 1-based indexing)
        Ç€   - call last link (1) as a monad for €ach row
       ;     - concatenate
          F  - flatten into a single list (empty iff no columnwise adjacent original zeros
             -                                   AND no rowwise repeated values)
           Ȧ - any and all (0 if empty [or contains any zero -- never] else 1)

ZÇȯÇ_1Ŀ - Link 4, validity check? list of lists
Z       - transpose
 Ç      - call last link (2) as a monad rowwiseAnyAdjacentZerosOrColumnwiseAnyRepeatedValues?
   Ç    - call last link (2) as a monad columnwiseAnyAdjacentZerosOrRowwiseAnyRepeatedValues?
  ȯ     - logical OR
     1Ŀ - call link 1 as a monad (isConnected?)
    _   - subtract
        - this yields -1 for valid, while it yields 0 or 1 if not.

2ḶṗLṗLa⁸ÇÞḢ - Main link: list of lists
2Ḷ          - lowered range of 2 -> [0,1]
   L        - length (number of rows in the input)
  ṗ         - Cartesian power (all lists of zeros and ones of length L)
     L      - length (number of rows in the input again)
    ṗ       - Cartesian power (all grids of zeros and ones of same shape as the input)
       ⁸    - the input
      a     - logical AND -- effectively uses each of the formed grids as a mask
         Þ  - sort by:
        Ç   -   last link (3) as a monad
          Ḣ - head
            - implicit print

एक शुरुआत के रूप में NIce। धन्यवाद। मैं देखूंगा।
वीजुन झोउ

आप 4 वाँ नियम भूल गए। (जुड़ा)
user202729

(जेली में
बीएफएस

ओह ... जब एक कंप्यूटर पर हटा देगा। धन्यवाद।
जोनाथन एलन

हाँ, मुझे नहीं लगता कि यह संभव है, कहते हैं, <60 बाइट्स ऑफ जेली, कहने के लिए नहीं <100 ...
Outgolfer
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.