एक सुडोकू बोर्ड का उत्पादन

25

आज की चुनौती सरल है: किसी भी इनपुट के बिना, किसी भी वैध सुडोकू बोर्ड का उत्पादन करना।

यदि आप सुडोकू से अपरिचित हैं, तो विकिपीडिया बताता है कि एक वैध बोर्ड को क्या देखना चाहिए :

उद्देश्य अंकों के साथ एक 9 × 9 ग्रिड को भरना है ताकि प्रत्येक कॉलम, प्रत्येक पंक्ति, और नौ 3 × 3 सबग्रिड में से जो ग्रिड की रचना करते हैं (जिसे "बक्से", "ब्लॉक", या "क्षेत्र" भी कहा जाता है) शामिल हैं 1 से 9 तक के सभी अंक।

अब यहाँ बात है ... 6,670,903,752,021,072,936,960 विभिन्न वैध सुडोकू बोर्ड हैं । उनमें से कुछ को कम बाइट्स में संपीड़ित और आउटपुट करना बहुत मुश्किल हो सकता है। उनमें से अन्य आसान हो सकते हैं। इस चुनौती का एक हिस्सा यह पता लगाना है कि कौन से बोर्ड सबसे अधिक संकुचित होंगे और सबसे कम बाइट्स में आउटपुट किए जा सकते हैं।

आपके प्रस्तुत करने के लिए आवश्यक नहीं है कि हर बार एक ही बोर्ड का उत्पादन हो। लेकिन अगर कई आउटपुट संभव हैं, तो आपको यह साबित करना होगा कि हर संभव आउटपुट एक वैध बोर्ड है।

आप इस स्क्रिप्ट का उपयोग कर सकते हैं (मैजिक ऑक्टोपस Urn के लिए धन्यवाद) या इनमें से किसी भी उत्तर को सत्यापित करने के लिए कि क्या कोई विशेष ग्रिड एक वैध समाधान है। यह [1]वैध बोर्ड के लिए आउटपुट करेगा , और अमान्य बोर्ड के लिए कुछ भी।

जब तक आप स्पष्ट रूप से 2-आयामी है, तब तक आप अपने उत्तर को किस स्वरूप में आउटपुट करते हैं, इसके बारे में मैं बहुत अधिक उत्सुक नहीं हूं। उदाहरण के लिए, आप 9x9 मैट्रिक्स, नौ 3x3 मैट्रिक्स, एक स्ट्रिंग, स्ट्रिंग्स की एक सरणी, 9-अंकीय पूर्णांकों की एक सरणी या एक विभाजक के साथ नौ 9-अंकीय संख्याओं का उत्पादन कर सकते हैं। 81 आयामों को 1 आयाम में आउटपुट करने की अनुमति नहीं होगी। यदि आप किसी विशेष आउटपुट प्रारूप के बारे में जानना चाहते हैं, तो बेझिझक मुझे टिप्पणियों में पूछ सकते हैं।

हमेशा की तरह, यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर लिखें जिसे आप अपने चयन की भाषा (भाषाओं) में ले सकते हैं!

code-golf  kolmogorov-complexity  grid  sudoku 
— DJMcMayhem
स्रोत
हम उत्पादन कर सकते हैं तीन 3x9 matrices? प्रत्येक उप-मैट्रिक्स की प्रत्येक पंक्ति सुडोकू बोर्ड में एक पंक्ति का प्रतिनिधित्व करती है। इस
— dylnan
2
संबंधित लेकिन एक डुबकी नहीं । इसके अलावा, यदि आप लचीले आउटपुट की अनुमति दे रहे हैं, तो मुझे यकीन नहीं है कि कोल्मोगोरोव-जटिलता लागू होती है, क्योंकि यह सामान्य रूप से निश्चित आउटपुट के लिए होता है, जैसे कि एससीआई कला।
— ब्रैडसी

जवाबों:

13

पायथ, 22 14 12 10 बाइट्स

.<LS9%D3 9

श्री एक्सकोडर के लिए 2 बाइट्स का धन्यवाद।

इसे यहाँ आज़माएँ

.<LS9%D3 9
     %D3 9     Order the range [0, ..., 8] mod 3.
  >            For each, ...
.< S9          ... Rotate the list [1, ..., 9] that many times.
11: m.<S9d%D3 9।
— मिस्टर एक्सकोडर
उस पार, 10 .<LS9%D3 9:।
— मिस्टर एक्सकोडर
लिंक ( tio ) को अपडेट करना चाहते हैं
— bryc
8

टी-एसक्यूएल, 96 89 बाइट्स

तुच्छ आउटपुट से एक छोटा पाया गया!

SELECT SUBSTRING('12345678912345678',0+value,9)FROM STRING_SPLIT('1,4,7,2,5,8,3,6,9',',')

9-वर्ण स्ट्रिंग्स को विभिन्न बिंदुओं पर शुरू करता है, जैसा कि इन-मेमोरी टेबल द्वारा बनाई गई STRING_SPLIT(जिसे SQL 2016 और बाद में समर्थित है) द्वारा परिभाषित किया गया है । सबसे 0+valueछोटा तरीका था जो मैं पूर्णांक कलाकारों को एक पूर्णांक बना सकता था।

मूल तुच्छ उत्पादन (96 बाइट्स):

PRINT'726493815
315728946
489651237
852147693
673985124
941362758
194836572
567214389
238579461'
— BradC
स्रोत
6

पायथन 2 , 53 बाइट्स

r=range(9)
for i in r:print[1+(j*10/3+i)%9for j in r]

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

विकल्प:

पायथन 2 , 53 बाइट्स

i=0;exec"print[1+(i/3+j)%9for j in range(9)];i-=8;"*9

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

पायथन 2 , 54 बाइट्स

for i in range(81):print(i/9*10/3+i)%9+1,'\n'*(i%9>7),
i=0;exec"print[1+(i/3+j)%9for j in range(9)];i+=10;"*9
r=range(9);print[[1+(i*10/3+j)%9for j in r]for i in r]
— TFeld
स्रोत
5

पायथन 3 , 58 55 बाइट्स

l=*range(10),
for i in b"	":print(l[i:]+l[1:i])

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

  • -3 बाइट्स जो किंग के लिए धन्यवाद,

बाइट स्ट्रिंग के तत्व उन संख्याओं को समाप्त करते हैं [1, 4, 7, 2, 5, 8, 3, 6, 9], जिनका उपयोग रोटेशन को अनुमति देने के लिए किया जाता है [0..9]। 0में निकाल दिया जाता है l[1:i]और एक अशक्त बाइट जो दो characaters लेता है की कोई आवश्यकता नहीं (नहीं है \0) एक बाइट वस्तु में प्रतिनिधित्व करने के लिए।

55 बाइट्स

_,*l=range(10)
for i in b"	":print(l[i:]+l[:i])
— dylnan
स्रोत
— जो किंग
@ जोकिंग क्लेवर, धन्यवाद
— dylnan
4

जेली , ९ by बाइट्स

9Rṙ`s3ZẎ

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

9Rṙ`s3ZẎ
9R         Range(9) -> [1,2,3,4,5,6,7,8,9]
   `       Use the same argument twice for the dyad:
  ṙ        Rotate [1..9] each of [1..9] times.
           This gives all cyclic rotations of the list [1..9]
    s3     Split into three lists.
      Z    Zip. This puts the first row of each list of three in it's own list, 
           as well as the the second and third.
       Ẏ   Dump into a single list of nine arrays.
— dylnan
स्रोत
4

बैच, 84 बाइट्स

@set s=123456789
@for %%a in (0 3 6 1 4 7 2 5 8)do @call echo %%s:~%%a%%%%s:~,%%a%%

@ Mnemonic के आउटपुट का उपयोग करता है। callस्लाइसिंग ऑपरेशन में वेरिएबल को प्रक्षेपित करने के लिए उपयोग किया जाता है (आमतौर पर यह केवल संख्यात्मक स्थिरांक को स्वीकार करता है)।

— नील
स्रोत
4

पर्ल 6 , 40 32 27 बाइट्स

-5 बाइट्स nwellnhof के लिए धन्यवाद

{[^9+1].rotate($+=3.3)xx 9}

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

अनाम कोड ब्लॉक जो 9x9 मैट्रिक्स लौटाता है। प्रत्येक पंक्ति को श्रेणी 1 से 9 के एक अलग रोटेशन के लिए मैप करें।

— मजाक कर रहा है
स्रोत
4

जे , 18 बाइट्स

>:(,&|:|."{,)i.3 3

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

उत्पादन

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8

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

>:(,&|:|."{,)i.3 3
             i.3 3  The 2D array X = [0 1 2;3 4 5;6 7 8]
   ,&|:|."{,        3-verb train:
   ,&|:               Transpose and flatten X to get Y = [0 3 6 1 4 7 2 5 8]
           ,          Flatten X to get Z = [0 1 2 3 4 5 6 7 8]
       |."{           Get 2D array whose rows are Z rotated Y times
>:                  Increment

फैंसी संस्करण, 23 बाइट्स

|.&(>:i.3 3)&.>|:{;~i.3

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

आउटपुट:

┌─────┬─────┬─────┐
│1 2 3│4 5 6│7 8 9│
│4 5 6│7 8 9│1 2 3│
│7 8 9│1 2 3│4 5 6│
├─────┼─────┼─────┤
│2 3 1│5 6 4│8 9 7│
│5 6 4│8 9 7│2 3 1│
│8 9 7│2 3 1│5 6 4│
├─────┼─────┼─────┤
│3 1 2│6 4 5│9 7 8│
│6 4 5│9 7 8│3 1 2│
│9 7 8│3 1 2│6 4 5│
└─────┴─────┴─────┘

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

|.&(>:i.3 3)&.>|:{;~i.3
                    i.3  Array [0 1 2]
                 {;~     Get 2D array of boxed pairs (0 0) to (2 2)
               |:        Transpose
|.&(>:i.3 3)&.>          Change each pair to a Sudoku box:
            &.>            Unbox
    >:i.3 3                2D array X = [1 2 3;4 5 6;7 8 9]
|.&                        Rotate this 2D array over both axes
                             e.g. 1 2|.X gives [6 4 5;9 7 8;3 1 2]
            &.>            Box again so the result looks like the above
— bubbler
स्रोत
4

05AB1E , 14 12 बाइट्स

8ÝΣ3%}ε9Ls._

-2 के एक बंदरगाह बनाने के द्वारा बाइट्स @Mnemonic के Pyth जवाब ।

इसे ऑनलाइन आज़माएं। (इसे सुंदर प्रिंट करने के लिए पाद जोड़ा जाता है। वास्तविक परिणाम 9x9 मैट्रिक्स है, देखने के लिए पाद हटाने के लिए स्वतंत्र महसूस करें।)

स्पष्टीकरण:

8Ý              # List in the range [0, 8]
  Σ  }          # Sort the integers `i` by
   3%           #  `i` modulo-3
      ε         # Map each value to:
       9L       #  List in the range [1, 9]
         s._    #  Rotated towards the left the value amount of times

मूल 14 बाइट्स समाधान:

9Lε9LN3*N3÷+._

इसे ऑनलाइन आज़माएं। (इसे सुंदर प्रिंट करने के लिए पाद जोड़ा जाता है। वास्तविक परिणाम 9x9 मैट्रिक्स है, देखने के लिए पाद हटाने के लिए स्वतंत्र महसूस करें।)

स्पष्टीकरण:

9L                # Create a list of size 9
  ε               # Change each value to:
   9L             #  Create a list in the range [1, 9]
     N3*N3÷+      #  Calculate N*3 + N//3 (where N is the 0-indexed index,
                  #                        and // is integer-division)
            ._    #  Rotate that many times towards the left

दोनों जवाब सुडोकू में परिणाम:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678
— केविन क्रूज़सेन
स्रोत
4

ऑक्टेव और मतलाब, 50 48 29 बाइट्स

mod((1:9)+['furRaghAt']',9)+1

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

-2 जॉनथन फ्रीच को धन्यवाद

-14 Sanchises ब्रॉडकास्ट सुझाव के लिए धन्यवाद, जिन्होंने गैर-संगतता को भी इंगित किया।

-5 यह देखते हुए कि वेक्टर को चार्ल स्ट्रिंग और ट्रांसपोज़ेशन के साथ मतलाब में लिखा जा सकता है।

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

सुडोकू बोर्ड का उत्पादन:

 5 6 7 8 9 1 2 3 4
 2 3 4 5 6 7 8 9 1
 8 9 1 2 3 4 5 6 7
 3 4 5 6 7 8 9 1 2
 9 1 2 3 4 5 6 7 8
 6 7 8 9 1 2 3 4 5
 7 8 9 1 2 3 4 5 6
 4 5 6 7 8 9 1 2 3
 1 2 3 4 5 6 7 8 9
— Poptimist
स्रोत
नमस्कार और पीपीसीजी में आपका स्वागत है; अच्छी पहली पोस्ट।
— जोनाथन फ्रीच
— जोनाथन फ्रीच
बेशक, मैट्रिक्स में ही परिभाषित किया जा सकता है। मैंने बाइट्स को भी मिस किया होगा।
— पोप्टीमिस्ट
यह अब ऑक्टेव है, MATLAB के साथ संगत नहीं है। यदि आप चाहें, तो आप डिफ़ॉल्ट PPCG फॉर्मेटिंग को कॉपी करने के लिए जोनाथन के लिंक के शीर्ष पर छोटी चेन आइकन का उपयोग कर सकते हैं।
— सेंचुरी
यदि आप चाहें, तो आप इसे प्रसारण के अतिरिक्त 34 बाइट्स तक प्राप्त कर सकते हैं: इसे ऑनलाइन आज़माएं!
— सैनचाइज
3

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

[[x..9]++[1..x-1]|x<-[1,4,7,2,5,8,3,6,9]]

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

— कर्टिस Bechtel
स्रोत
यह मान्य नहीं है। प्रत्येक वर्ग में एक ही संख्या के कई होते हैं। आप इसके बजाय कुछ ऐसा कर सकते हैं (43 बाइट्स)
— जो किंग
धन्यवाद! मैंने आपका सुझाव लिया
— कर्टिस बेकटेल
@RushabhMehta मैंने किया। यह 43 बाइट्स था, लेकिन मैंने s=इसे हटा दिया क्योंकि यह आवश्यक नहीं है
— कर्टिस बेचटेल ने
3

जावा 10, 82 75 बाइट्स

v->{for(int i=81;i-->0;)System.out.print((i/9*10/3+i)%9+1+(i%9<1?" ":""));}

-7 बाइट्स @TFeld के पायथन 2 उत्तरों में से एक का पोर्ट बनाकर ।

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

स्पष्टीकरण:

v->{                    // Method with empty unused parameter and no return-type
  for(int i=81;i-->0;)  //  Loop `i` in the range (81, 0]
    System.out.print(   //   Print:
     (i/9               //    (`i` integer-divided by 9,
         *10            //     then multiplied by 10,
         /3             //     then integer-divided by 3,
           +i)          //     and then we add `i`)
             %9         //    Then take modulo-9 on the sum of that above
               +1       //    And finally add 1
    +(i%9<1?            //    Then if `i` modulo-9 is 0:
            " "         //     Append a space delimiter
           :            //    Else:
            ""));}      //     Append nothing more

निम्नलिखित सुडोकू आउटपुट (नीचे की तरह newlines के बजाय स्थान सीमांकित)

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321
— केविन क्रूज़सेन
स्रोत
2

पायथन - 81 बाइट्स

l=list(range(1,10))
for i in range(1,10):print(l);l=l[3+(i%3==0):]+l[:3+(i%3==0)]

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

मुझे 81 बाइट्स पसंद हैं, लेकिन कुछ अनुकूलन के बाद :(

पायथन 2 - 75 68 59 58 बाइट्स

-7 बाइट्स @DLosc को धन्यवाद

-9 बाइट्स @ थैंनिक को धन्यवाद

-1 बाइट @JoKing की बदौलत

l=range(1,10)
for i in l:print l;j=i%3<1;l=l[3+j:]+l[:3+j]

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

— डॉन हजार
स्रोत
2
81 बाइट्स परफेक्ट स्कोर! : डी
— DJMcMayhem
@DJMcMayhem मैं ऐसा करने से इसे छोटा बनाने पर विचार कर रहा था, r=range(1,10)लेकिन मैं सुंदरता को बर्बाद नहीं कर सकता था
— डॉन थाउजेंड
— डीएलओसी
@ डलोस ऊह का चतुर पुन: उपयोगl
— डॉन थाउजेंड
यदि आप पायथन 2 को बुरा नहीं मानते हैं, तो आप प्रिंट से पार्न्स को निकाल सकते हैं और सूची पैकिंग को हटा सकते हैं।
2

@Shaggy को बहुत-बहुत धन्यवाद!

जावास्क्रिप्ट (Node.js) , 61 बाइट्स

t=>[...s='123456789'].map(e=>s.slice(t=e*3.3%9)+s.slice(0,t))

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

1
गोल्फ के एक त्वरित बिट यह 63 बाइट्स के लिए नीचे हो जाता है ।
— झबरा
2
क्षमा करें, 61 बाइट्स ; एक बेवकूफ स्पष्ट गोल्फ याद किया!
— शैगी
1

सी (क्लैंग) , 65 बाइट्स

f(i){for(i=0;i<81;)printf("%d%c",(i/9*10/3+i)%9+1,i++%9>7?10:9);}

फ़ंक्शन अब पुन: उपयोग किया जा सकता है

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

— Logern
स्रोत
अपने अंकों को अलग करने के लिए एनयूएल बाइट को प्रिंट करने के बजाय, आप उसी बाइट की गिनती में एक टैब चरित्र का उपयोग कर सकते हैं।
— जोनाथन फ्रीच
"आपके प्रस्तुत करने के लिए जरूरी नहीं है कि हर बार एक ही बोर्ड का उत्पादन किया जाए। लेकिन यदि कई आउटपुट संभव हैं, तो आपको यह साबित करना होगा कि हर संभव आउटपुट एक वैध बोर्ड है।" यह नहीं कहता है कि कई आउटपुट की आवश्यकता है। @ceilingcat
— लॉगर्न
1
@Logern प्रश्न में नियम यह है कि फ़ंक्शन सबमिशन को पुन: उपयोग करना होगा । यह ठीक है अगर यह f(); f()एक ही बोर्ड को दो बार आउटपुट करता है, लेकिन नहीं अगर दूसरा कॉल बिल्कुल काम नहीं करता है।
— एंडर्स कासोर्ग
— जो किंग
61 बाइट्स, @ जोकिंग से सुझावों को शामिल करते हुएf(i){for(i=81;i--;)printf("%d%c",(i/9*10/3+i)%9+1,i%9?9:10);}
— छत
1

के (ngn / k) , 16 बाइट्स

1+9!(<9#!3)+\:!9

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

Ngn / k में पहला उत्तर, खुद आदमी से एक बड़ी मदद के साथ किया, @ngn।

किस तरह:

1+9!(<9#!3)+\:!9 // Anonymous fn
              !9 // Range [0..8]
    (     )+\:   // Sum (+) that range with each left (\:) argument
        !3       // Range [0..2]
      9#         // Reshaped (#) to 9 elements: (0 1 2 0 1 2 0 1 2)
     <           // Grade up
  9!             // Modulo 9
1+               // plus 1
— जे। सल्ल
स्रोत
0

चारकोल , 14 बाइट्स

Ｅ⁹⭆⁹⊕﹪⁺÷×χι³λ⁹

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। @ Mnemonic के आउटपुट का उपयोग करता है। स्पष्टीकरण:

Ｅ⁹              Map over 9 rows
  ⭆⁹            Map over 9 columns and join
          ι     Current row
         χ      Predefined variable 10
        ×       Multiply
       ÷   ³    Integer divide by 3
            λ   Current column
      ⁺         Add
     ﹪       ⁹  Modulo 9
    ⊕           Increment
                Implicitly print each row on its own line
— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.