क्या आप ब्रिटिश इंटेलिजेंस को हरा सकते हैं? (नॉनोग्राम सॉल्वर)

20

यह ब्रिटिश खुफिया को हराने के लिए एक खतरनाक खोज पर लगने का समय है। इस चुनौती का उद्देश्य सबसे छोटा कोड लिखना है जो एक नॉनोग्राम को हल करेगा।

नॉनोग्राम क्या है?

नॉनोग्राम पहेली

नियम सरल हैं। आपके पास चौकों का एक ग्रिड है, जिसे या तो काले या बाएं खाली में भरा जाना चाहिए। ग्रिड की प्रत्येक पंक्ति के बगल में उस पंक्ति पर काले वर्गों के रनों की लंबाई सूचीबद्ध है। प्रत्येक स्तंभ के ऊपर उस स्तंभ में काले वर्गों के रनों की लंबाई सूचीबद्ध है। अपने उद्देश्य के लिए सभी काले वर्गों को खोजने के लिए है। इस पहेली प्रकार में, संख्याएं असतत टोमोग्राफी का एक रूप हैं जो मापती हैं कि भरे हुए वर्गों की कितनी अखंड रेखाएं हैं जो किसी भी पंक्ति या स्तंभ में हैं। उदाहरण के लिए, "4 8 3" के एक क्लू का मतलब होगा कि उस क्रम में चार, आठ और तीन भरे हुए वर्गों के सेट हैं, क्रमिक समूहों के बीच कम से कम एक खाली वर्ग के साथ। [ १ ] [ २ ]

तो उपरोक्त नॉनोग्राम का समाधान होगा:

सॉल्वड नॉनोग्राम

कार्यान्वयन का विवरण

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

यह समस्या बहुत ही एल्गोरिदमिक रूप से चुनौतीपूर्ण (एनपी-पूर्ण) है जिसमें इसका कोई पूर्ण रूप से कुशल समाधान नहीं है और इस तरह, आपको बड़े लोगों को हल करने में सक्षम नहीं होने के लिए दंडित नहीं किया जाएगा, हालांकि यह होने पर आपके उत्तर को भारी पुरस्कृत किया जाएगा। बड़े मामलों को संभालने में सक्षम (बोनस देखें)। एक बेंचमार्क के रूप में, मेरा समाधान 5-10 सेकंड के भीतर लगभग 25x25 तक काम करता है। विभिन्न भाषाओं में लचीलेपन की अनुमति देने के लिए, 25x25 नॉनोग्राम के लिए 5 मिनट से कम समय में समाधान पर्याप्त हैं।

आप हमेशा एक वर्ग NxN नॉनोग्राम में एक पहेली मान सकते हैं।

आप अपने समाधान का परीक्षण करने के लिए इस ऑनलाइन नॉनोग्राम पहेली निर्माता का उपयोग कर सकते हैं।

स्कोरिंग

आप निश्चित रूप से, अपनी इच्छित भाषा का उपयोग करने के लिए स्वतंत्र हैं और चूंकि यह कोड गोल्फ है, प्रविष्टियों को क्रम में क्रमबद्ध किया जाएगा: accuracy -> length of code -> speed.हालांकि, कोड गोल्फिंग भाषाओं द्वारा हतोत्साहित नहीं किया जाता है, सभी भाषाओं में जवाब जो गोल्फिंग में प्रयास दिखाते हैं। एक दिलचस्प तरीके से उत्कीर्ण किया जाएगा!

बक्शीश

मैंने वास्तव में यहां ब्रिटिश इंटेलिजेंस द्वारा जारी एक क्रिप्टोग्राफिक क्रिसमस कार्ड से नॉनोग्राम के बारे में सीखा । पहला भाग मूल रूप से 25x25 नॉनग्राम था। यदि आपका समाधान इसे हल करने में सक्षम है, तो आपको कुदोस मिलेगा :)

डेटा प्रविष्टि के संदर्भ में आपके जीवन को आसान बनाने के लिए, मैंने प्रदान किया है कि कैसे मैंने आपके मुफ्त उपयोग के लिए इस विशिष्ट पहेली के डेटा का प्रतिनिधित्व किया। पहले 25 लाइनें पंक्ति के सुराग हैं, उसके बाद एक '-' विभाजक रेखा, उसके बाद कॉल लाइन की 25 पंक्तियाँ, इसके बाद '#' विभाजक रेखा और उसके बाद भरे हुए वर्ग के साथ ग्रिड का प्रतिनिधित्व होता है।

7 3 1 1 7
1 1 2 2 1 1
1 3 1 3 1 1 3 1
1 3 1 1 6 1 3 1
1 3 1 5 2 1 3 1
1 1 2 1 1
7 1 1 1 1 1 7
3 3
1 2 3 1 1 3 1 1 2
1 1 3 2 1 1
4 1 4 2 1 2
1 1 1 1 1 4 1 3
2 1 1 1 2 5
3 2 2 6 3 1
1 9 1 1 2 1
2 1 2 2 3 1
3 1 1 1 1 5 1
1 2 2 5
7 1 2 1 1 1 3
1 1 2 1 2 2 1
1 3 1 4 5 1
1 3 1 3 10 2
1 3 1 1 6 6
1 1 2 1 1 2
7 2 1 2 5
-
7 2 1 1 7
1 1 2 2 1 1
1 3 1 3 1 3 1 3 1
1 3 1 1 5 1 3 1
1 3 1 1 4 1 3 1
1 1 1 2 1 1
7 1 1 1 1 1 7
1 1 3
2 1 2 1 8 2 1
2 2 1 2 1 1 1 2
1 7 3 2 1
1 2 3 1 1 1 1 1
4 1 1 2 6
3 3 1 1 1 3 1
1 2 5 2 2
2 2 1 1 1 1 1 2 1
1 3 3 2 1 8 1
6 2 1
7 1 4 1 1 3
1 1 1 1 4
1 3 1 3 7 1
1 3 1 1 1 2 1 1 4
1 3 1 4 3 3
1 1 2 2 2 6 1
7 1 3 2 1 1
#
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

और यहां आपकी सुविधा के लिए थोड़ा अलग संस्करण है; अल्पविराम द्वारा अलग किया गया टपल (पंक्ति, कॉल) जहां प्रत्येक तत्व सूचियों की सूची है।

([[7, 3, 1, 1, 7],
  [1, 1, 2, 2, 1, 1],
  [1, 3, 1, 3, 1, 1, 3, 1],
  [1, 3, 1, 1, 6, 1, 3, 1],
  [1, 3, 1, 5, 2, 1, 3, 1],
  [1, 1, 2, 1, 1],
  [7, 1, 1, 1, 1, 1, 7],
  [3, 3],
  [1, 2, 3, 1, 1, 3, 1, 1, 2],
  [1, 1, 3, 2, 1, 1],
  [4, 1, 4, 2, 1, 2],
  [1, 1, 1, 1, 1, 4, 1, 3],
  [2, 1, 1, 1, 2, 5],
  [3, 2, 2, 6, 3, 1],
  [1, 9, 1, 1, 2, 1],
  [2, 1, 2, 2, 3, 1],
  [3, 1, 1, 1, 1, 5, 1],
  [1, 2, 2, 5],
  [7, 1, 2, 1, 1, 1, 3],
  [1, 1, 2, 1, 2, 2, 1],
  [1, 3, 1, 4, 5, 1],
  [1, 3, 1, 3, 10, 2],
  [1, 3, 1, 1, 6, 6],
  [1, 1, 2, 1, 1, 2],
  [7, 2, 1, 2, 5]],
 [[7, 2, 1, 1, 7],
  [1, 1, 2, 2, 1, 1],
  [1, 3, 1, 3, 1, 3, 1, 3, 1],
  [1, 3, 1, 1, 5, 1, 3, 1],
  [1, 3, 1, 1, 4, 1, 3, 1],
  [1, 1, 1, 2, 1, 1],
  [7, 1, 1, 1, 1, 1, 7],
  [1, 1, 3],
  [2, 1, 2, 1, 8, 2, 1],
  [2, 2, 1, 2, 1, 1, 1, 2],
  [1, 7, 3, 2, 1],
  [1, 2, 3, 1, 1, 1, 1, 1],
  [4, 1, 1, 2, 6],
  [3, 3, 1, 1, 1, 3, 1],
  [1, 2, 5, 2, 2],
  [2, 2, 1, 1, 1, 1, 1, 2, 1],
  [1, 3, 3, 2, 1, 8, 1],
  [6, 2, 1],
  [7, 1, 4, 1, 1, 3],
  [1, 1, 1, 1, 4],
  [1, 3, 1, 3, 7, 1],
  [1, 3, 1, 1, 1, 2, 1, 1, 4],
  [1, 3, 1, 4, 3, 3],
  [1, 1, 2, 2, 2, 6, 1],
  [7, 1, 3, 2, 1, 1]])
code-golf  puzzle-solver 
— gowrath
स्रोत
अफसोस की बात है कि मेरी वेबसाइट डाउन हो गई है, लेकिन इसमें काफी तेजी से नॉनोग्राम सॉल्वर का इस्तेमाल किया गया है; 5-10 मिनट अत्यधिक लगता है।
— नील
1
— edc65
1
@dwana आपको बेकार के मामलों के बारे में चिंता करने की जरूरत नहीं है। यादृच्छिक उत्तर के लिए, 25x25 नॉनोग्राम पर, आपके पास 2 ^ 625 संभव कॉन्फ़िगरेशन हैं। संदर्भ में, यह ज्ञात ब्रह्माण्ड में परमाणुओं की संख्या से दोगुने से अधिक है (अर्थात यदि आप ब्रह्माण्ड में प्रत्येक परमाणु को एक बिट के रूप में उपयोग करते हैं, तो आपके पास अभी भी संभावनाओं को संग्रहीत करने के लिए पर्याप्त स्थान नहीं होगा)। समय के संदर्भ में, यदि आपको प्रत्येक कॉन्फ़िगरेशन की वैधता की जांच करने के लिए एक नैनो सेकंड (उदार)
— लगी
1
असुरक्षित मामलों को स्पष्ट करने के लिए Ty। (+ मेरे पास एक जादुई पीसी है, ~ 2.1546362E-186 सेकंड में एक उत्तर को मान्य करता है)
— dwana
1
आपके CSV में कोई वर्ग संकेत नहीं है। यहाँ कुछ जेएस उन्हें उत्पन्न करने के लिए है:s=[].fill([].fill(0,0,25),0,25);s[3][3]=s[3][4]=s3[3][12]=s3[3][13]=s3[3][21]=s[8][6]=s[8][7]=s[8][10]=s[8][14]=s[8][15]=s[8][18]=s[16][6]=s[16][11]=s[16][16]=s[16][20]=s[21][3]=s[21][4]=s[21][9]=s[21][10]=s[21][15]=s[21][20]=s[21][21]=1;
— टाइटस

जवाबों:

5

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

[R:C]hlL~l:L:1f=.:3aR,.z:3aC,
tL,?he##ElL,E:2a
.<2,_1<
@b:4f:la
e.h1,

यह दो सूचियों की सूची लेता है (पहले पंक्तियों के संकेतक, फिर स्तंभ वाले)। प्रत्येक संकेतक अपने आप में एक सूची है ( [3,1]एक पंक्ति पर जैसे बैठने के लिए )।

इस संस्करण को चुनौती के 5 उदाहरण द्वारा 5 को हल करने में लगभग 3 मिनट लगते हैं।

अधिक कुशल संस्करण, 91 बाइट्स

[R:C]hlL~l:L:1f:Cz:3az:Rz:3a=.:4aR,.z:4aC,
tL,?he##ElL,E:2a
.<2,_1<
:+a#=,?h
@b:5f:la
e.h1,

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

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

यह एक चुनौती के 5 उदाहरण के द्वारा 5 पर 0.05 सेकंड लेता है। यह बोनस मामले के लिए अभी भी बहुत धीमा है, क्योंकि मुझे नहीं पता है कि बाधाओं के मामले में एक या एक से अधिक शून्य से अलग हुए ब्लॉकों को कैसे व्यक्त किया जाए।

व्याख्या

मैं नीचे 93 बाइट्स संस्करण के बारे में बताऊंगा। दोनों के बीच एकमात्र अंतर 3 को भविष्यवाणी करने के लिए कॉल है जो 70 बाइट्स संस्करण में मौजूद नहीं है, और विधेय की संख्या (क्योंकि एक कम है)।

  • मुख्य विधेय:

    [R:C]     Input = [R, C]
hlL       The length of R is L
~l        Create a list of length L
:L:1f     Each element of that list is a sublist of length L with cells 0 or 1 (Pred 1)
          %%% Part unique to the 93 bytes version
:Cz       Zip the rows of the list of lists with C
:3a       The sum of 1s in each row is equal to the sum of the indicators (Pred 3)
z         Transpose
:Rz       Zip the columns of the list of lists with R
:3a       The sum of 1s in each column is equal to the sum of the indicators (Pred 3)
          %%%
=.        Assign values to the cells of the list of lists which satisfy the constraints
:4aR,     The blocks of 1s must match the indicators on rows
.z        Transpose
:4aC,     The blocks of 1s must match the indicators on columns

  • विधेय 1: पंक्तियों को एक विशिष्ट लंबाई के लिए मजबूर करता है, और यह कि प्रत्येक कोशिका 0 या 1 है।

    tL,       L is the length given as second element of the input
?he       Take an element from the list
##ElL,    That element E is itself a list of length L
E:2a      The elements of E are 0s and 1s (Pred 2)

  • विधेय 2: किसी चर को 0 या 1 होने के लिए विवश करें

    .<2,      Input = Output < 2
_1<       Output > -1

  • विधेय 3: सूची में 1 s का योग संकेतक के योग के बराबर होना चाहिए (जैसे कि यदि संकेतक [3: 1] है तो सूची में योग 4 होना चाहिए)

    :+a       Sum the elements of the list and sum the indicator
#=,       Both sums must be equal
?h        Output is the list

  • प्रेडिकेट 4: जांचें कि 1s के ब्लॉक संकेतक से मेल खाते हैं

    @b        Split the list in blocks of the same value
:5f       Find all blocks of 1s (Pred 5)
:la       The list of lengths of the blocks results in the indicator (given as output)

  • 5 को समर्पित करें: 1s के ब्लॉक के लिए सही, अन्यथा गलत

    e.        Output is an element of the input
  h1,     Its first value is 1
— Fatalize
स्रोत
नौकरी के लिए एकदम सही उपकरण लगता है। स्पष्टीकरण के लिए आगे देख रहे हैं।
— एमिग्ना
@ जानलेवा यह शानदार है, मैं ऐसा करने के लिए किसी प्रोलॉग-एस्क भाषा का उपयोग करने के लिए इंतजार कर रहा था। क्या आपने इसे 25x25 मामले के साथ आज़माया है? मैंने आपके लिए पहले ही
— gowrath
@gowrath मैं इसे आज दोपहर को अपने कंप्यूटर पर चलाऊंगा, हम देखेंगे कि क्या होता है।
— 9
@ समय-समय पर मुझे लगता है लेकिन मैं इसे गलत कर सकता हूँ। मैं पूरी तरह से अपने डेटा प्रविष्टि कौशल पर निर्भर नहीं होता: D
— gowrath
@gowrath यह TIO पर कई बार निकलता है, लेकिन मैं इसे सीधे अपने कंप्यूटर पर ऑफ़लाइन दुभाषिया पर चलाऊंगा।
— 9
9

हास्केल, 242 230 201 199 177 163 160 149 131 बाइट्स

import Data.Lists
m=map
a#b=[x|x<-m(chunk$length b).mapM id$[0,1]<$(a>>b),g x==a,g(transpose x)==b]
g=m$list[0]id.m sum.wordsBy(<1)

अंत में 200 बाइट्स के तहत, @Bergi को क्रेडिट। आकार को लगभग आधा करने में मदद के लिए @nimi को बहुत धन्यवाद।

वाह। लगभग आधे आकार में, आंशिक रूप से मेरी वजह से लेकिन मुख्य रूप से @nimi के कारण।

जादू समारोह है (#)। यह किसी दिए गए नॉनोग्राम के सभी समाधानों को ढूंढता है ।

यह सभी मामलों को हल करने में सक्षम है, लेकिन यह धीमा हो सकता है, क्योंकि यह जटिलता के बारे में है O(2^(len a * len b))। एक त्वरित बेंचमार्क ने 5x5 नॉनोग्राम के लिए 86GB आवंटित किया।

मजेदार तथ्य: यह सभी नॉनोग्राम्स के लिए काम करता है, न कि केवल वर्ग के लिए।

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

  • a#b: पूर्णांक की सूचियों की सूचियों को देखते हुए जो वर्गों की संख्या का प्रतिनिधित्व करते हैं, सभी ग्रिड उत्पन्न करते हैं ( map(chunk$length b).mapM id$a>>b>>[[0,1]]) और केवल वैध रखने के लिए परिणामों को फ़िल्टर करते हैं।
  • g: एक संभावित नॉनोग्राम को देखते हुए यह 1 के क्षैतिज रूप से चलता है।
— ThreeFx
स्रोत
आपका मतलब O (2 ^ (a * len b) है), O नहीं ((a * len b) ^ 2)।
— एंडर्स कासोर्ग
@AndersKaseorg राइट। मैं लाख गलती से वहां फंसा रहूं। : डी
— थ्री एफएक्स
1
एक और कुछ बाइट्स: m(chunk$l b)औरreplicate(l$a>>b)
— Bergi
@ThreeFx 86GB: O ... Btw आप संक्षेप में बता सकते हैं कि यह कैसे संकलित है? मैंने केवल हैस्केल सीखना शुरू किया है और यह ghc के साथ त्रुटियां दे रहा है। यह परीक्षण करना चाहते हैं :)
— 22
1
import Data.Listsपर्याप्त है, क्योंकि यह फिर से निर्यात दोनों Data.Listऔर Data.List.Split।
— निमि
4

पायथ, 91 72 71 बाइट्स

D:GHdRq@@QdG.nCf.)TrH8V^,01^hQ2=TcNhQ=Y1VhQ=*Y*:H@TH1:H@CTH2)IYjbmjkdTb

एक प्रोग्राम जो फॉर्म की एक सूची का इनपुट लेता है [size, [horizontal clues], [vertical clues]] जहां प्रत्येक सुराग पूर्णांक की एक सूची है (रिक्त सुराग खाली सूची है []), और प्रत्येक समाधान को प्रिंट करता है, नईलाइन अलग की जाती है, बाइनरी ग्रिड के रूप में जहां 1छायांकित और 0अनसेक्ड है ।

यह एक क्रूर बल है, इसलिए मोटे तौर पर है O(2^n^2) । यह बड़ी पहेलियों के लिए बहुत लंबा समय लेने लगता है, लेकिन पर्याप्त समय दिए गए किसी भी आकार के आकार को हल करेगा।

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

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

यह कार्यक्रम प्रत्येक कार्टिजियन उत्पाद के [0, 1]बराबर लंबाई के साथ दोहराकर हर संभव लेआउट उत्पन्न करता है size^2। फिर इसे प्रत्येक क्षैतिज रेखा के लिए एक सूची देते हुए, विखंडू में विभाजित किया जाता है। प्रत्येक पंक्ति रन-लंबाई एन्कोडेड है, की उपस्थिति से फ़िल्टर की गई 1और चपटी हुई, उस रेखा के लिए सुराग छोड़कर। इसके बाद इनपुट के खिलाफ जांच की जाती है। ऊपर की प्रक्रिया को विखंडू के संक्रमण के लिए दोहराया जाता है, ऊर्ध्वाधर लाइनों की जांच करता है। यदि कोई हिट होता है, तो प्रत्येक चंक को संक्षिप्त किया जाता है, और सुरीले विखंडू को नई रेखाओं पर जोड़ दिया जाता है और एक नई अनुगामी के साथ छापा जाता है।

D:GHdRq@@QdG.nCf.)TrH8V^,01^hQ2=TcNhQ=Y1VhQ=*Y*:H@TH1:H@CTH2)IYjbmjkdTb  Program. Input: Q
                            hQ                                           Q[0], size
                           ^  2                                          Square
                        ,01                                              [0, 1]
                       ^                                                 Cartesian product
                      V                                     )            For N in the Cartesian product:
                                 cNhQ                                    Split N into Q[0] chunks
                               =T                                        Assign that to T
                                     =Y1                                 Y=1
                                        VhQ                              For H in range [0, Q[0]-1]:
D:GHd                                                                     def :(G, H, d)
                   rH8                                                     Run-length-encode(H)
               f.)T                                                        Filter by presence of 1 in character part
            .nC                                                            Transpose and flatten, giving the clue
       @@QdG                                                               Q[d][G], the relevant input clue
     Rq                                                                    Return clue==input clue
                                               :H@TH1                     :(H, T, 1)
                                                     :H@CTH2              :(H, transpose(T), 2)
                                           =*Y*                           Y=Y*product of above two
                                                             IY           If Y:
                                                                 mjkdT     Conacatenate each element of T
                                                               jb          Join on newlines
                                                                      b    Add a newline and implicitly print

कुछ युक्तियों के लिए @ Pietu1998 का ​​धन्यवाद

— TheBikingViking
स्रोत
यह अब तक का सबसे लंबा पाइथ कार्यक्रम हो सकता है
— बिजनेस कैट
=ZhZके बराबर है =hZ, और FNके बराबर है V।
— पुरकाकूदरी
@TheBikingViking वास्तव में आपके पास पर्याप्त समय दिए जाने का क्या मतलब है? मुझे पूरा यकीन है कि यह अब तक 25x25 को हल नहीं करेगा यदि आपने इसे ब्रह्मांड के गर्भाधान से शुरू किया था।
— गोवरथ ३१'१६
1
@gowrath मैं भी उस पर काफी यकीन कर रहा हूँ! मैं पाइथ के लिए नया हूं, और समय की लंबाई के बाद यह मुझे ले गया, मैं एक बेहतर एल्गोरिदम को लागू करने की कोशिश करने पर भी विचार नहीं करना चाहता
— TheBikingViking
2

जावास्क्रिप्ट (ईएस 6), 401 386 333 बाइट्स

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

उदाहरण के लिए, यह [3,1]निम्नलिखित नियमित अभिव्यक्ति में सुराग का अनुवाद करेगा :

/^0*1{3}0+1{1}0*$/

अभी, यह संस्करण वर्गाकार सुरागों को ध्यान में नहीं रख रहा है। मैं शायद इसे बाद में जोड़ूंगा।

कोड

(c,r)=>{W=c.length;w=[];S=0;M=(n,p)=>eval(`/^0*${p.map(v=>`1{${v}}`).join`0+`}0*$/`).exec(n);R=(y,i=0)=>S||(w[y]=r[y][i],y+1<W?R(y+1):c.every((c,y)=>(n=0,w.map((_,x)=>n+=w[W-1-x][y]),M(n,c)))&&(S=w.join`
`),r[y][i+1]&&R(y,i+1));r=r.map(r=>[...Array(1<<W)].map((_,n)=>((1<<30)|n).toString(2).slice(-W)).filter(n=>M(n,r)));return R(0)}

उत्पादन

समाधान बाइनरी प्रारूप में प्रदर्शित किया जाता है। जैसे कि:

00110
01110
11100
11101
00001

परीक्षा

यह उदाहरण ग्रिड पर एक सरल परीक्षण है।

let f =
(c,r)=>{W=c.length;w=[];S=0;M=(n,p)=>eval(`/^0*${p.map(v=>`1{${v}}`).join`0+`}0*$/`).exec(n);R=(y,i=0)=>S||(w[y]=r[y][i],y+1<W?R(y+1):c.every((c,y)=>(n=0,w.map((_,x)=>n+=w[W-1-x][y]),M(n,c)))&&(S=w.join`
`),r[y][i+1]&&R(y,i+1));r=r.map(r=>[...Array(1<<W)].map((_,n)=>((1<<30)|n).toString(2).slice(-W)).filter(n=>M(n,r)));return R(0)}

console.log(f(
  [[2],[3],[4],[2],[2]],
  [[2],[3],[3],[3,1],[1]]
));
स्निपेट का विस्तार करें

— Arnauld
स्रोत
अछा सुझाव। मेरे ब्राउज़रों को क्रिसमस की पहेली पर मारता है, हालांकि।
— टाइटस
2

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

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

import Data.List
n=mapM id
a#b=[x|x<-n$(n$" #"<$a)<$b,g x==a,g(transpose x)==b]
g=map$max[0].map length.words

उपयोग उदाहरण: [[2],[3],[3],[3,1],[1]] # [[2],[3],[4],[2],[2]]->[[" ## "," ### ","### ","### #"," #"]]।

पाशविक बल। के सभी संयोजनों का प्रयास करें और #, इंट चंक्स को विभाजित करें #, लंबाई की गणना करें और इनपुट की तुलना करें।

— nimi
स्रोत
1

PHP, 751 833 (720) 753 724 726 710 691 680 682 बाइट्स

मैं एक विशेष अनुक्रम वृद्धि बनाने और अपने कार्टेशियन जनरेटर को एक बार फिर से आज़माने के लिए उत्सुक था;
लेकिन बड़ी पहेली को तेजी से हल करने के लिए कार्ट्रेशियन को बैकट्रैकिंग के पक्ष में गिरा दिया।

$p=[];foreach($r as$y=>$h){for($d=[2-($n=count($h)+1)+$u=-array_sum($h)+$w=count($r)]+array_fill($i=0,$n,1),$d[$n-1]=0;$i<1;$d[0]+=$u-array_sum($d)){$o=$x=0;foreach($d as$i=>$v)for($x+=$v,$k=$h[$i];$k--;)$o+=1<<$x++;if(($s[$y]|$o)==$o){$p[$y][]=$o;$q[$y]++;}for($i=0;$i<$n-1&$d[$i]==($i?1:0);$i++);if(++$i<$n)for($d[$i]++;$i--;)$d[$i]=1;}}
function s($i,$m){global$c,$w,$p;for(;!$k&&$i[$m]--;$k=$k&$m<$w-1?s($i,$m+1):$k){for($k=1,$x=$w;$k&&$x--;){$h=$c[$x];for($v=$n=$z=$y=0;$k&&$y<=$m;$y++)$n=$n*($f=($p[$y][$i[$y]]>>$x&1)==$v)+$k=$f?:($v=!$v)||$n==$h[$z++];if($k&$v)$k=$n<=$h[$z];}}return$k?is_array($k)?$k:$i:0;}
foreach(s($q,0)as$y=>$o)echo strrev(sprintf("\n%0{$w}b",$p[$y][$o]));
  • $rपंक्ति संकेत के लिए सरणियों में संकेत की उम्मीद है , $cस्तंभ संकेत के लिए और$s वर्ग संकेत के लिए है।
  • invalid argument supplied for foreachअगर इसका कोई हल नहीं निकलता है तो फेंकता है ।
  • सही बाइट गिनती प्राप्त करने के लिए, एक भौतिक का उपयोग करें \nऔर अन्य दो पंक्ति विराम को हटा दें।

विवरण

1) पंक्ति संकेत
से संभव पंक्तियाँ उत्पन्न होती हैं जो वर्ग संकेत को संतुष्ट करती हैं
और प्रत्येक पंक्ति सूचकांक के लिए उनकी गिनती को याद करती हैं।

2) पंक्ति संयोजनों पर बैकट्रैक:
यदि संयोजन स्तंभ के संकेतों को संतुष्ट करता है, तो गहरे संयोजन की तलाश करें या सफल संयोजन की वापसी करें,
अन्यथा इस पंक्ति के लिए अगला प्रयास करें

3) प्रिंट समाधान

अंतिम गोल्फ प्रदर्शन पर गंभीर प्रभाव पड़ा;
लेकिन मैंने अंतिम बेंचमार्क के लिए प्रोफाइलिंग असाइनमेंट को हटा दिया।

अंतिम गोल्फिंग चरण को पूर्ववत करने $n=$n*($f=($p[$y][$i[$y]]>>$x&1)==$v)+$k=$f?:($v=!$v)||$n==$h[$z++];
के if(($p[$y][$i[$y]]>>$x&1)-$v){$k=($v=!$v)||$n==$h[$z++];$n=1;}else$n++;
लिए बदलें ।

उदाहरण

छोटे उदाहरण के लिए ( 17 से 21 लगभग 12 8 7 6.7 5.3 एमएस), का उपयोग करें

$r=[[2],[3],[3],[3,1],[1]];$c=[[2],[3],[4],[2],[2]];$s=[0,0,0,0,0];

क्रिसमस पहेली के लिए:

  • पुराने समाधान के साथ मेरे छोटे घर सर्वर को मार डाला
  • परीक्षण आउटपुट के साथ ब्राउज़र को मार दिया
  • अब 50 37.8 45.5 में 36 सेकंड के आसपास हल किया गया है

फ़ाइल से प्रश्न करने के लिए डेटा डालें christmas.nonogramऔर आयात करने के लिए इस कोड का उपयोग करें:

$t=r;foreach(file('christmas.nonogram')as$h)if('-'==$h=trim($h))$t=c;elseif('#'==$h){$t=s;$f=count($h).b;}else
{$v=explode(' ',$h);if(s==$t)for($h=$v,$v=0,$b=1;count($h);$b*=2)$v+=$b*array_shift($h);${$t}[]=$v;}

टूट - फूट

$p=[];  // must init $p to array or `$p[$y][]=$o;` will fail
foreach($r as$y=>$h)
{
    // walk $d through all combinations of $n=`hint count+1` numbers that sum up to $u=`width-hint sum`
    // (possible `0` hints for $h) - first and last number can be 0, all others are >0
    for(
        $d=[2-
            ($n=count($h)+1)+               // count(0 hint)=count(1 hint)+1
            $u=-array_sum($h)+$w=count($r)  // sum(0 hint) = width-sum(1 hint)
        ]                           // index 0 to max value $u-$n+2
        +array_fill($i=0,$n,1)      // other indexes to 1
        ,$d[$n-1]=0;                // last index to 0
                                    // --> first combination (little endian)
        $i<1;   // $i:0 before loop; -1 after increment; >=$n after the last combination
        $d[0]+=$u-array_sum($d) // (see below)
    )
    {
        // A: create row (binary value) from 1-hints $h and 0-hints $d
        $o=$x=0;
        foreach($d as$i=>$v)
            for($x+=$v,$k=$h[$i];$k--;)
                $o+=1<<$x++;
        // B: if $o satisfies the square hints
        if(($s[$y]|$o)==$o)
        {
            $p[$y][]=$o;    // add to possible combinations
            $q[$y]++;       // increase possibility counter
        }
        // C: increase $d
            // find lowest index with a value>min
                // this loop doesn´t need to go to the last index:
                // if all previous values are min, there is nothing left to increase
        for($i=0;$i<$n-1&$d[$i]==($i?1:0);$i++);
        if(++$i<$n)             // index one up; increase $d if possible
            for($d[$i]++        // increase this value
            ;$i--;)$d[$i]=1;    // reset everything below to 1
            // adjust $d[0] to have the correct sum (loop post condition)
    }
}

// search solution: with backtracking on the row combinations ...
function s($i,$m)
{
    global $c,$w,$p;
    for(;
        !$k // solution not yet found
        &&$i[$m]    // if $i[$m]==0, the previous iteration was the last one on this row: no solution
            --;     // decrease possibility index for row $m
        $k=$k&$m<$w-1? s($i,$m+1) : $k      // if ok, seek deeper while last row not reached ($m<$w-1)
    )
    {
        // test if the field so far satisfies the column hints: loop $x through columns
        for($k=1,$x=$w;$k&&$x--;)   // ok while $k is true
        {
            $h=$c[$x];
            // test column hints on the current combination: loop $y through rows up to $m
            for($v=$n=$z=   // $v=temporary value, $n=temporary hint, $z=hint index
                $y=0;$k&&$y<=$m;$y++)
                // if value has not changed, increase $n. if not, reset $n to 1
                // (or 0 for $k=false; in that case $n is irrelevant)
                $n=$n*  
                    // $f=false (int 0) when value has changed, true (1) if not
                    ($f=($p[$y][$i[$y]]>>$x&1)==$v)
                    +$k=$f?:    // ok if value has NOT changed, else
                        ($v=!$v)        // invert value. ok if value was 0
                        || $n==$h[$z    // value was 1: ok if temp hint equals current sub-hint
                        ++]             // next sub-hint
                ;
            // if there is a possibly incomplete hint ($v==1)
            // the incomplete hint ($n) must be <= the next sub-hint ($c[x][$z])
            // if $n was <$h[$z] in the last row, the previous column hints would not have matched
            if($k&$v)$k=$n<=$h[$z];
        }
        // ok: seek deeper (loop post condition)
        // not ok: try next possibility (loop pre condition)
    }
    return$k?is_array($k)?$k:$i:0;  // return solution if solved, 0 if not
}

// print solution
foreach(s($q,0)as$y=>$o)echo strrev(sprintf("\n%0{$w}b",$p[$y][$o]));
— टाइटस
स्रोत
1
बड़ा उदाहरण मेरे छोटे होम सर्वर (500 - आंतरिक सर्वर त्रुटि) को मारता है। संयोजन 15 सेकंड के बाद तैयार हैं, लेकिन कार्टेशियन उत्पाद में 1.823E + 61 सदस्य हैं। (7 वीं और 22 वीं पंक्ति में केवल एक समाधान btw है।) एल्गोरिथ्म में सुधार किया जाना चाहिए।
— टाइटस
मुझे लगता है कि यदि आप पुनरावर्ती बैकट्रैकिंग का उपयोग करते हैं, तो इस पर ध्यान दिया जा सकता है। फिर भी, महान काम!
— गौहर
@gowrath: backtracking थोड़ा देता है और यहां तक ​​कि बाइट्स भी बचाता है ... बिट अंकगणित के साथ पूर्णांक लगभग 50% गति देता है, लेकिन आकार बढ़ाता है (यह पता लगाना है कि यह वास्तव में कितना खर्च करता है) ... मैं अभी भी इस पर हूं।
— टाइटस
@ गोवरथ: मैंने अपनी बग को नीचे गिराया; यह वेतन वृद्धि में (और कहाँ था?): $dके लिए सही क्रम में होना चाहिएforeach
— टाइटस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.