एक सुडोकू समाधान बनाएं चेकर

21

एक सुडोकू समाधान बनाएँ

यहां सुडोकू सॉल्वर्स के oodles हैं, लेकिन मैं चाहता हूं कि आप मानवीय रूप से संभव (कोड-गोल्फ) के रूप में एक समाधान CHECKER बनाएं।

  • एक वैध प्रविष्टि या तो एक तर्क के रूप में 9x9 सरणी लेने में सक्षम होगी (संदर्भ द्वारा पारित, कमांड लाइन पर क्रमबद्ध, या फिर भी आप इसे लेना चाहते हैं) या एक इनपुट फ़ाइल को स्वीकार करें जो अंतिम ग्रिड के लिए नौ संख्याओं की नौ लाइनें है। । नीचे इनपुट के उदाहरण देखें।

  • मान्य इनपुट बेस -10 नंबर (1-9) होना चाहिए

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

  • आपके कार्यक्रम को यह जांचने की आवश्यकता है कि क्या प्रत्येक संख्या प्रति कॉलम एक बार, प्रति पंक्ति एक बार और 3x3 उप-ग्रिड के अनुसार दिखाई देती है। यदि यह गुजरता है, तो "0" लौटाएं और यदि नहीं, तो एक गैर-शून्य परिणाम लौटाएं।

  • बाहरी संसाधनों (वेबसाइटों आदि) के उपयोग से बचना है।

  • यदि आपका समाधान एक स्टैंड-अलोन प्रोग्राम है, जो क्रमशः "पास" या "फेल" के लिए, "0" या गैर-शून्य की निकास स्थिति के साथ बाहर निकलता है, तो ठीक है।

सबसे छोटी उत्तर जीत दें!

इनपुट उदाहरण:

सी सरणी:

int input[9][9]={{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}
                };

फ़ाइल:

123456789
456789123
789123456
231564897
564897231
897231564
312645978
645978312
978312645

9 उप-ग्रिड:

+---+---+---+
|123|456|789|
|456|789|123|
|789|123|456|
+---+---+---+
|231|564|897|
|564|897|231|
|897|231|564|
+---+---+---+
|312|645|978|
|645|978|312|
|978|312|645|
+---+---+---+
code-golf  decision-problem  sudoku 
— डेविड विल्किंस
स्रोत

जवाबों:

5

GolfScript, 39 अक्षर

.zip.{3/}%zip{~}%3/{[]*}%++{$10,1>=!},,

यह इनपुट के रूप में सरणियों की एक सरणी लेता है ( ऑनलाइन उदाहरण देखें ) और आउटपुट 0अगर यह एक वैध ग्रिड है।

कोड की संक्षिप्त व्याख्या

.zip         # Copy the input array and transpose it
.{3/}%       # Split each line into 3 blocks
zip{~}%      # Transpose these blocks
3/{[]*}%     # Do the same for the lines themselves and join again
++           # Make one large list of 27 9-element arrays 
             # (9 for rows, 9 for columns, 9 for blocks)
{$10,1>=!},  # From those 27 select the ones which are not a permutation of [1 2 3 ... 9]
             #   $      -> sort
             #   10,1>  -> [1 2 3 ... 9]
             #   =!     -> not equal
,            # Count after filtering
— हावर्ड
स्रोत
मुझे पसंद है कि आपके कोड के गैर शून्य उत्पादन की तुलना में अधिक सार्थक है बस 1या-1
— डेविड विल्किंस
मुझे वास्तव में आपका जवाब पसंद आया लेकिन अंत में मैंने एक गोल्फस्क्रिप्ट समाधान के साथ नहीं जाने के लिए चुना। मैं वास्तव में आशा करता हूं कि आप समझ गए होंगे
— डेविड विल्किंस
2
@DavidWilkins वास्तव में मुझे समझ में नहीं आता - आपने नियम (!) बनाए और कहीं भी यह नहीं बताया कि गोल्फस्क्रिप्ट की अनुमति नहीं थी।
— होवार्ड
आपकी बात पूरी तरह से मान्य है ... वास्तव में मेरे पास आपके उत्तर को चुनने का औचित्य नहीं है। अच्छी तरह से खेला
— डेविड विल्किंस
10

अजगर, 103

मुझे सुडोकू से नफरत है।

b = [[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]]

e=enumerate;print 243-len(set((a,t)for(i,r)in e(b)for(j,t)in e(r)for a in e([i,j,i/3*3+j/3]*(0<t<10))))

यह कैसे काम करता है: प्रत्येक पंक्ति, स्तंभ और ब्लॉक में प्रत्येक नंबर 1 से 9 तक होना चाहिए। इसलिए प्रत्येक के लिए 0 <= i, j < 9, सेल i,jब्लॉक में है 3*floor(i/3) + floor(j/3)। इस प्रकार, संतुष्ट करने के लिए 243 आवश्यकताएं हैं। मैं प्रत्येक आवश्यकता को एक ट्यूपल बनाता हूं ((item index,item type number),symbol)जहां item index0 और 8 (समावेशी) के बीच की संख्या item type numberहै, क्रमशः पंक्ति, स्तंभ या ब्लॉक को निरूपित करने के लिए 0,1 या 2 है, और symbolप्रविष्टि है b[i][j]।

संपादित करें: मैंने गलती से वैध प्रविष्टियों की जांच नहीं की। अब मैं करता हूँ।

— boothby
स्रोत
0यदि समाधान पास हो जाता है तो आपका कार्यक्रम आउटपुट होना चाहिए , नहींTrue
— डेविड विल्किंस
@DavidWilkins क्या एक अजीब आवश्यकता है। फिक्स्ड।
— बूथ
आप अपना मत प्राप्त करने के लिए मेरे सर को अपना जवाब दें: D
— Teun Pronk
9

एपीएल (46)

{∧/,↑∊∘Z¨(/∘(,⍵)¨↓Z∘.=,3/3⌿3 3⍴Z←⍳9),(↓⍵),↓⍉⍵}

यह एक 9-बाय -9 मैट्रिक्स लेता है। उदाहरण को TryAPL पर दर्ज किया जा सकता है जैसे:

     sudoku ← ↑(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)
     {∧/,↑∊∘Z¨(/∘(,⍵)¨↓Z∘.=,3/3⌿3 3⍴Z←⍳9),(↓⍵),↓⍉⍵} sudoku
1

स्पष्टीकरण:

  • ↓⍉⍵: के स्तंभों मिल ⍵,
  • ↓⍵: की पंक्तियों मिल ⍵,
  • 3/3⌿3 3⍴Z←⍳9: बनाने के लिए एक 3-दर-3 मैट्रिक्स संख्या से युक्त 1करने के लिए 9है, तो दोनों दिशाओं में प्रत्येक संख्या तीन प्रतियों, संख्या के साथ एक 9-दर-9 मैट्रिक्स देने 1के लिए 9प्रत्येक समूह का संकेत,
  • Z∘.=: प्रत्येक संख्या के 1लिए 9, दिए गए समूह के लिए एक बिटमास्क बनाएं,
  • /∘(,⍵)¨: और ⍵प्रत्येक के साथ मुखौटा , के समूह दे रही है ⍵।
  • ∊∘Z¨: प्रत्येक उप-सरणी के लिए, यह देखें कि इसमें संख्याएँ 1हैं 9,
  • ∧/,↑: andइन सभी नंबरों का तार्किक साथ लें।
— मारीनस
स्रोत
+1 नाइस! लेकिन 3 × 3 समूह कुछ और गोल्फ हो सकते हैं। उदाहरण के लिए इस ↓9 9⍴1 3 2⍉3 3 9⍴⍵के बराबर है /∘(,⍵)¨↓Z∘.=,3/3⌿3 3⍴Z←⍳9, लेकिन काफी कम। मुझे यकीन है कि और भी छोटे फॉर्मूले हैं।
— टोबिया
इसके अलावा, आप 1 आयाम से मेट्रिसेस को समेट सकते हैं ⍪और अंत में एक ही विभाजन कर सकते हैं:↓(9 9⍴1 3 2⍉3 3 9⍴⍵)⍪⍵⍪⍉⍵
— टोबिया
एक बग है: यह कोड ∊∘Z¨परीक्षण कर रहा है कि क्या प्रत्येक उप-सरणी (पंक्ति, स्तंभ या ब्लॉक) केवल संख्या 1 से 9 तक बना है। यह परीक्षण नहीं कर रहा है कि सभी संख्याओं का प्रतिनिधित्व किया गया है या नहीं। आपको कुछ ऐसा करने की आवश्यकता है Z∘.∊जो यह जांचता है कि Z में प्रत्येक संख्या हर उप-सरणी में निहित है।
— टोबिया
और इसे ∧/,↑छोटा किया जा सकता है ∧/∊। मैं कर रहा हूँ, मैं कर रहा हूँ! ;-)
— टोबिया
बहुत कॉम्पैक्ट, लेकिन आपने एक महत्वपूर्ण बिंदु को याद किया, जिसे मैं सही तरीके से देख सकता हूं:If it passes, return "0" and if not, return a non-zero result.
— डेविड विल्किंस
5

जावा / सी # - 183/180 181/178 173/170 बाइट्स

boolean s(int[][]a){int x=0,y,j;int[]u=new int[27];for(;x<(y=9);x++)while(y>0){j=1<<a[x][--y];u[x]|=j;u[y+9]|=j;u[x/3+y/3*3+18]|=j;}for(x=0;x<27;)y+=u[x++];return y==27603;}

(बदलें booleanकरने के लिए boolसी # के लिए)

प्रारूपित:

boolean s(int[][] a){
    int x=0, y, j;
    int[] u=new int[27];
    for(;x<(y=9);x++)
        while(y>0){
            j=1<<a[x][--y];
            u[x]|=j;
            u[y+9]|=j;
            u[x/3+y/3*3+18]|=j;
        }

    for(x=0;x<27;)
        y+=u[x++];

    return y==27603;
}

विधि u27 बिटमास्क के साथ एक सरणी बनाता है , नौ पंक्तियों, स्तंभों और वर्गों में पाए गए अंकों का प्रतिनिधित्व करता है।

इसके बाद यह सभी कोशिकाओं पर आधारित होता है, यह 1 << a[x][y]एक बिटमास्क बनाने के लिए ऑपरेशन का प्रदर्शन करता है जो अंक का प्रतिनिधित्व करता है और इसके साथ कॉलम, रो और स्क्वायर बिटमास्क का निर्माण करता है।

तब यह सभी 27 बिटकॉम्स पर आधारित होता है, यह सुनिश्चित करते हुए कि वे सभी 27594 (1022 * 9, 1022) सभी अंकों 1-9 के लिए बिटमास्क होने के साथ जोड़ते हैं)। (ध्यान दें कि yयह 27603 के रूप में समाप्त होता है क्योंकि इसमें पहले से ही दोहरे लूप के बाद 9 होते हैं।)

संपादित करें: दुर्घटनावश छोड़ दिया गया %3यह अब आवश्यक नहीं है।

संपादित 2: ब्रायस वैगनर की टिप्पणी से प्रेरित होकर, कोड को थोड़ा और संकुचित किया गया है।

— Smallhacker
स्रोत
C # 149 वर्णों में लगभग समान एल्गोरिथ्म (लेकिन केवल अगर Linq की अनुमति है): bool s (int [] a) {int x = 0, y, j; var u = new int [27]; जबकि (x ++ <(y) = 9)), जबकि (y> 0) {j = 1 << एक [x + 9 * - y]; यू [x] | = j; यू [y + 9] | = j; यू [x / 3 + y / 3 * 3 + 18] | = j;} वापसी u.Sum () == 27594;}
— ब्रायस वैगनर
@BryceWagner Linq वास्तव में उपयोगी होगा। हालांकि, मेरा समाधान जावा के लिए है C # के साथ एक बाद (मूल पोस्ट में भी उल्लेख नहीं किया गया है) और इस तरह कम प्राथमिकता। मैंने इसके खिलाफ निर्णय लेने से पहले शुरुआत में कॉम्पैक्टनेस के लिए एक-आयामी सरणियों का उपयोग किया (जैसा कि उदाहरण दो-आयामी लोगों का उपयोग करते हैं)। फिर भी, आपके कोड ने मुझे कुछ विचार दिए कि कैसे कुछ और बाइट्स का मुंडन किया जा सकता है। :)
— स्मालकैप
3

अजगर = 196

सबसे गोल्फ नहीं है, लेकिन विचार है। सेट बहुत उपयोगी हैं।

मंडल: 

b = [[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]]

कार्यक्रम:

n={1,2,3,4,5,6,7,8,9};z=0
for r in b:
 if set(r)!=n:z=1
for i in zip(*b):
 if set(i)!=n:z=1
for i in (0,3,6):
 for j in (0,3,6):
  k=j+3
  if set(b[i][j:k]+b[i+1][j:k]+b[i+2][j:k])!=n:z=1
print(z)
— qwr
स्रोत
s / {1,2,3,4,5,6,7,8,9} / सेट (श्रेणी (1,10)) / 3 वर्ण बचाता है।
— मैट्रिक्सफ्रॉग
पायथन 3.5 में आप उपयोग कर सकते हैं n={*range(1,10)}, लेकिन यह चुनौती से नया है। इसके बजाय set(range(1,10))मैट्रिक्सट्रॉग ने कहा कि उपयोग करें ।
— mbomb007
3

जावा - 385 306 328 260 वर्ण

संपादित करें: मैंने मूर्खतापूर्वक निर्देशों का गलत अर्थ निकाला कि उत्तर को पूरा कार्यक्रम होना था । चूंकि यह सिर्फ एक वैध फ़ंक्शन हो सकता है, इसलिए मैंने एक फ़ंक्शन होने के लिए फिर से लिखा और कम से कम किया है, और मेरे समाधान परिचय को ध्यान में रखते हुए फिर से लिखा है।

तो, अपने आप को एक चुनौती के रूप में मैंने सोचा कि मैं सबसे छोटा जावा सॉल्यूशन चेकर बनाने की कोशिश करूंगा।

इसे प्राप्त करने के लिए, मुझे लगता है कि सुडोकू पहेली को एक जावा बहुआयामी सरणी के रूप में पारित किया जाएगा, जैसे:

s(new int[][] {
    {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}});

फिर, हमारे पास वास्तविक सॉल्वर है, जो "0" लौटाता है यदि वैध समाधान, "1" यदि नहीं।

पूरी तरह से गोल्फ:

int s(int[][] s){int i=0,j,k=1;long[] f=new long[9];long r=0L,c=r,g=r,z=45L,q=r;for(f[0]=1L;k<9;){f[k]=f[k-1]*49;z+=f[k++]*45;}for(;i<9;i++){for(j=0;j<9;){k=s[i][j];r+=k*f[i];c+=k*f[j];g+=k*f[j++/3+3*(i/3)];q+=5*f[k-1];}}return (r==z&&c==z&&g==z&&q==z)?0:1;}

पठनीय:

    int s(int[][] s) {
        int i=0,j,k=1;
        long[] f=new long[9]; 
        long r=0L,c=r,g=r,z=45L,q=r;
        for(f[0]=1L;k<9;){f[k]=f[k-1]*49;z+=f[k++]*45;}
        for(;i<9;i++) {
            for (j=0;j<9;) {
                k=s[i][j];
                r+=k*f[i];
                c+=k*f[j];
                g+=k*f[j++/3+3*(i/3)];
                q+=5*f[k-1];
            }
        }
        return (r==z&&c==z&&g==z&&q==z)?0:1;
    }

यह कैसे काम करता है? मैं मूल रूप से प्रत्येक अंक में पर्याप्त रिज़ॉल्यूशन के साथ मूल रूप से अपना खुद का नंबर बेस बनाता हूं कि मुझे केवल एक बार पहेली के माध्यम से गुजरने के बाद तीन संख्यात्मक तुलनाएं करनी हैं ताकि यह पता चल सके कि क्या यह वैध है। मैंने इस समस्या के लिए आधार 49 को चुना, लेकिन 45 से बड़ा कोई भी आधार पर्याप्त होगा।

ए (उम्मीद है) स्पष्ट उदाहरण: कल्पना करें कि सुडोकू पहेली में प्रत्येक "पंक्ति" आधार -49 संख्या में एक एकल अंक है। हम सरलता के लिए वेक्टर में आधार -10 संख्या के रूप में आधार -49 संख्या में प्रत्येक अंक का प्रतिनिधित्व करेंगे। इसलिए, यदि सभी पंक्तियाँ "सही" हैं, तो हम निम्नलिखित बेस -49 संख्या (बेस -10 वेक्टर के रूप में) की अपेक्षा करते हैं:

(45,45,45,45,45,45,45,45,45)

या एकल आधार -10 संख्या में परिवर्तित: 1526637748041045

सभी स्तंभों के लिए समान तर्क का पालन करें, और "उप-ग्रिड" के लिए भी। अंतिम विश्लेषण में सामना किया गया कोई भी मूल्य जो इस "आदर्श नंबर" के बराबर नहीं है, इसका मतलब है कि पहेली समाधान अमान्य है।

सभी -5-एस भेद्यता और अन्य संबंधित मुद्दों को हल करने के लिए संपादित करें: मैं एक चौथा आधार -49 संख्या जोड़ता हूं, इस विचार के आधार पर कि प्रत्येक पहेली में प्रत्येक संख्या के 9 होना चाहिए। इसलिए, मैं बेस -10 नंबर की प्रत्येक घटना के लिए आधार -49 संख्या में प्रत्येक अंक में 5 जोड़ देता हूं जो अंक के सूचकांक का प्रतिनिधित्व करता है। एक उदाहरण, यदि 10 9 और 9 8 के, 9 7 के, 8 6 के, और 9 अन्य सभी हैं, तो आपको आधार -49 संख्या (ओवरफ्लो से निपटने के लिए आकार 10 के बेस -10 वेक्टर के रूप में) मिलेगी:

(1, 1, 45, 45, 40, 45, 45, 45, 45, 45)

जो हमारे "आदर्श" आधार -49 नंबर के खिलाफ तुलना करने पर विफल हो जाएगा।

मेरा समाधान इस गणितीय समाधान का लाभ उठाता है, जितना संभव हो उतना लूपिंग और तुलना से बचने के लिए। मैं बस longबेस -10 नंबर के रूप में प्रत्येक बेस -49 नंबर को स्टोर करने के लिए एक वैल्यू का उपयोग करता हूं और कॉलम / रो / सबग्रिड चेक वैल्यू कम्प्यूटेशन के दौरान प्रत्येक बेस -49 49 अंक के लिए "कारक" प्राप्त करने के लिए लुकअप सरणी का उपयोग करता हूं ।

जैसा कि जावा को संक्षिप्त करने के लिए डिज़ाइन नहीं किया गया है, गणितीय निर्माण में सावधानी बरतने का एकमात्र तरीका है जो मुझे लगा कि मैं एक संक्षिप्त परीक्षक का निर्माण कर सकता हूं।

आप क्या सोचते हैं मुझे बताओ।

— ProgrammerDan
स्रोत
1
वास्तव में, यह @ स्टीववे-क्रिल द्वारा उल्लिखित उसी भेद्यता से ग्रस्त है - सभी 5 के, या संख्याओं का कोई भी सेट जो 45 तक गाया जाता है, सॉल्वर को "छल" करेगा। मैं संशोधित करने जा रहा हूं। मुझे इस बात का अंदाजा है कि इसे कैसे हराया जाता है।
— प्रोग्रामरडैन
मैंने अपने नवीनतम अपडेट में इस भेद्यता को संबोधित किया है। अब उस मामले को संबोधित किया गया है, और इसके अन्य सभी प्रकार। मूल रूप से, यह आधार -10 अंकों के प्रत्येक प्रकार के "मायने रखता" से निपटने के लिए गंभीर निरीक्षण नहीं था। मैं अब उस जाँच को सीधे करता हूं, लेकिन उसी गणितीय दृष्टिकोण (आधार -49 संख्या) का उपयोग करके।
— प्रोग्रामरडैन
दान, स्वीकारोक्ति के लिए धन्यवाद। मैंने इसे देखा और आश्चर्य किया कि मुझे क्यों सूचित नहीं किया गया, लेकिन मुझे लगता है कि आपने मेरे नाम पर एक डाका डाला। इससे सिस्टम गड़बड़ हो गया है। बस अंतरिक्ष छोड़ दें। मैं अपना नाम प्रदर्शित करने के तरीके को बदलने पर विचार करूंगा।
— लेवल रिवर सेंट
आह, कि यह बताते हैं। धन्यवाद @steveverrill - मैं अभी भी चीजों को करने के स्टैकएक्सचेंज तरीके का आदी हो रहा हूं। उस ने कहा, योग -45 सिद्धांत के आपके संक्षिप्त शोषण को शानदार ढंग से कहा गया था। इसे दूर करने के लिए मेरे समाधान को लंबा बना दिया, लेकिन यह जीवन है!
— प्रोग्रामरडैन
3

आर 145

function(x)colSums(do.call(rbind,lapply(list(R<-row(b<-matrix(1,9,9)),C<-col(b),(R-1)%/%3+1+3*(C-1)%/%3),sapply,`==`,1:9))%*%c(2^(x-1))==511)==27

डी-गोल्फ कोड (अधिक या कम) यहां /programming//a/21691541/1201032 पाया जा सकता है ।

— flodel
स्रोत
क्या आप r-fiddle जैसी साइट पर काम करने का उदाहरण दे सकते हैं? r-fiddle.org/#
— डेविड विल्किंस
3

हास्केल (लैंबडॉट), 65 बाइट्स

k x=and$(all$([1..9]==).sort)<$>[x,transpose x,join$chunksOf 3 x]
— BlackCap
स्रोत
2

पर्ल, 193 बाइट्स

for(@x=1..9){$i=$_-1;@y=();push@y,$a[$i][$_-1]for@x;@y=sort@y;$r+=@y~~@x;@y=();push@y,$a[3*int($i/3)+$_/3][3*($i%3)+$_%3]for 0..8;@y=sort@y;$r+=@y~~@x}for(@a){@y=sort@$_;$r+=@y~~@x}exit($r!=27)

सरणी रूप में इनपुट अपेक्षित है:

@a=(
    [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]
);

बाहर निकलें कोड 0 है, अगर @aकोई समाधान है, अन्यथा 1वापस लौटा दिया जाता है।

Ungolfed संस्करण:

@x = (1..9);
for (@x) {
    $i = $_ - 1;
    # columns
    @y = ();
    for (@x) {
        push @y, $a[$i][$_-1];
    }
    @y = sort @y;
    $r += @y ~~ @x;
    # sub arrays
    @y = ();
    for (0..8) {
        push @y, $a[ 3 * int($i / 3) + $_ / 3 ][ 3 * ($i % 3) + $_ % 3 ];
    }
    @y = sort @y;
    $r += @y ~~ @x
}
# rows
for (@a) {
    @y = sort @$_;
    $r += @y ~~ @x
}
exit ($r != 27);

9 पंक्तियों, 9 कॉलम और 9 उप सरणियों में से प्रत्येक को एक क्रमबद्ध सरणी में डाल दिया जाता है और जाँच की जाती है कि क्या यह सरणी से मेल खाता है (1..9)। $rप्रत्येक सफल मैच के लिए संख्या बढ़ाई जाती है जो कि वैध समाधान के लिए 27 तक होनी चाहिए।

— हेइको ओबर्डिएक
स्रोत
2

जे ५२ ५४

-.*/,(9=#)@~.@,"2(0 3 16 A.i.4)&|:(4#3)($,)".;._2]0 :0

कमांड लाइन पर इसे तर्क दिया जाता है, समाप्त होता है)

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
)

अगर 1 पास हो जाता है, तो 0 नहीं।

आंतरिक रूप से, यह 9x9 ग्रिड को 3x3x3x3 ग्रिड में परिवर्तित करता है, और अंतिम 2 आयामों में वांछित इकाई (पंक्तियों, लाइनों और बक्से) को प्राप्त करने के लिए कुल्हाड़ियों पर कुछ क्रमपरिवर्तन करता है।

ऐसा करने के बाद, यह जांचा जाता है कि प्रत्येक इकाई में 9 अद्वितीय मूल्य हैं।

शायद एकदम सही है, लेकिन पहले से ही बहुमत धड़कता है ;-)

— jpjacobs
स्रोत
पहली नज़र में, आप कुछ अन्य लोगों की तरह ही आवश्यकता से पकड़े गए हैं .... आपके रिटर्न को उलट जाना चाहिए ... 0 पास के लिए, गैर-शून्य असफल होने के लिए
— डेविड विल्किंस
पास के लिए 0 मुहावरेदार है। एक कारण है बोउल ने 1 को सच और 0 को गलत के लिए चुना। लेकिन आप सही हैं। 2 वर्ण जोड़ता है।
— jpjacobs
इसे एग्जिट स्टेटस मानिए, बूलियन वैल्यू नहीं
— डेविड विल्किंस
मैं आपका जवाब चुन रहा हूं क्योंकि यह काम करता है। आपने नियमों का पालन किया और आपका कार्यक्रम बहुत छोटा है। धन्यवाद!
— डेविड विल्किंस
वैसे मैं फ़बर्डेड हूँ ... सच में, मैं गोल्फस्क्रिप्ट के उस जवाब को चुनने का औचित्य नहीं रख सकता जो आपके से छोटा है ... लेकिन कुडोस 2 वें स्थान के लिए
— डेविड विल्किंस
2

गणितज्ञ, 84 79 वर्ण

f=Tr[Norm[Sort@#-Range@9]&/@Join[#,Thread@#,Flatten/@Join@@#~Partition~{3,3}]]&

उदाहरण:

f[{{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}}]

0

f[{{2,1,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}}]

2

f[{{0,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}}]

3

— alephalpha
स्रोत
आपका तीसरा आउटपुट उदाहरण: 3हमेशा अमान्य इनपुट का संकेत होता है, या क्या यह कभी-कभी एक असफल समाधान की प्रतिक्रिया है?
— डेविड विल्किंस
2

जावास्क्रिप्ट ईएस 6, 150 वर्ण

किसी भी परिधि के बिना 81-चार तार के रूप में इनपुट लेता है।

s=>s.match("^(?=(#.{0,8}#.{9})+$)(?=(#(.{9}){0,8}#.){9})((#.?.?(.{9}){0,2}#...){3}.{18})+$".replace(/#(.*?)#/g,"123456789".replace(/./g,"(?=$$1$&)")))

nullनकारात्मक उत्तर के रूप में फ़ंक्शन देता है और एक सकारात्मक के रूप में पहले तत्व में मूल स्ट्रिंग के साथ एक सरणी। !!फ़ंक्शन से जुड़ने से बूल में बदल सकते हैं ।

परीक्षण ( अधिक detais के लिए संबंधित चुनौती देखें ):

f=s=>s.match("^(?=(#.{0,8}#.{9})+$)(?=(#(.{9}){0,8}#.){9})((#.?.?(.{9}){0,2}#...){3}.{18})+$".replace(/#(.*?)#/g,"123456789".replace(/./g,"(?=$$1$&)")))
;`123456789456789123789123456231564897564897231897231564312645978645978312978312645
725893461841657392396142758473516829168429537952378146234761985687935214519284673
395412678824376591671589243156928437249735186738641925983164752412857369567293814
679543182158926473432817659567381294914265738283479561345792816896154327721638945
867539142324167859159482736275398614936241587481756923592873461743615298618924375
954217683861453729372968145516832497249675318783149256437581962695324871128796534
271459386435168927986273541518734269769821435342596178194387652657942813823615794
237541896186927345495386721743269158569178432812435679378652914924813567651794283
168279435459863271273415986821354769734692518596781342615947823387526194942138657
863459712415273869279168354526387941947615238138942576781596423354821697692734185
768593142423176859951428736184765923572389614639214587816942375295837461347651298`
.split`
`.every(f)
&&
`519284673725893461841657392396142758473516829168429537952378146234761985687935214
839541267182437659367158924715692843624973518573864192298316475941285736456729381
679543182158926473432817659567381294914256738283479561345792816896154327721638945
867539142324167859159482736275398684936241517481756923592873461743615298618924375
754219683861453729372968145516832497249675318983147256437581962695324871128796534
271459386435168927986273541518734269769828435342596178194387652657942813823615794
237541896186927345378652914743269158569178432812435679495386721924813567651794283
168759432459613278273165984821594763734982516596821347615437829387246195942378651
869887283619214453457338664548525781275424668379969727517385163319223917621449519
894158578962859187461322315913849812241742157275462973384219294849882291119423759
123456789456789123564897231231564897789123456897231564312645978645978312978312645
145278369256389147364197258478512693589623471697431582712845936823956714931764825`
.split`
`.every(s => !f(s))
— Qwertiy
स्रोत
यह एक हास्यास्पद regex है ... अद्भुत काम।
— ETHproductions
2

आर, 63 50 बाइट्स

मान लें कि इनपुट mसंख्याओं का 9x9 मैट्रिक्स है।

all(apply(m,1,match,x=1:9),apply(m,2,match,x=1:9))

मैं सही था कि आगे गोल्फ संभव था।

स्पष्टीकरण:

    apply(m,1,match,x=1:9),

लो m, और प्रत्येक पंक्ति के लिए, matchफ़ंक्शन लागू करें । हम एक और तर्क यह निर्दिष्ट x=1:9करने के लिए प्रदान किया जाने वाला match। xडिफ़ॉल्ट पहली स्थिति तर्क है, और इसलिए प्रत्येक पंक्ति को दूसरे तर्क स्थिति में रखा गया है, जो है table। matchके उदाहरणों के लिए फ़ंक्शन दिखता xहै table। इस स्थिति में, यह 1:9प्रत्येक पंक्ति में (9 के माध्यम से संख्या 1) की तलाश कर रहा है। प्रत्येक के लिए 1:9, यह वापस आ जाएगा TRUE(या FALSE) यदि वह संख्या पाई जाती है (या नहीं)।

तो, यह 81 बूलियन मूल्यों की एक श्रृंखला पैदा करता है।

                           apply(m,2,match,x=1:9)

इनपुट के प्रत्येक कॉलम के लिए ऊपर दोहराएं।

all(                                             )

अंत में, allजाँचता है कि बुलियन की सूची का हर तत्व क्या है TRUE। यह मामला होगा यदि और केवल यदि समाधान सही है (यानी प्रत्येक संख्या 1:9प्रत्येक कॉलम और प्रत्येक पंक्ति में केवल एक बार मौजूद है)।

पुराना तरीका:

for(i in 1:2)F=F+apply(m,i,function(x)sort(x)==1:9);sum(F)==162

यह प्रत्येक पंक्ति लेता है, इसे सॉर्ट करता है, और फिर इसकी तुलना करता है [1, 2, ... 9]। एक सही पंक्ति बिल्कुल मेल खाना चाहिए। फिर यह प्रत्येक कॉलम के लिए समान है। कुल मिलाकर, हमारे पास 162 सटीक मैच होने चाहिए, जो कि अंतिम भाग की जांच है। यहाँ आगे गोल्फिंग के लिए कुछ गुंजाइश होने की संभावना है ...

— rturnbull
स्रोत
ऐसा लगता है कि आप कॉलम और पंक्तियों के लिए जाँच कर रहे हैं, लेकिन बक्से के लिए नहीं ...
— JayCe
1

हास्केल - 175

import Data.List
c=concat
m=map
q=[1..9]
w=length.c.m (\x->(x\\q)++(q\\x))
b x=c.m(take 3.drop(3*mod x 3)).take 3.drop(3*div x 3)
v i=sum$m(w)[i,transpose i,[b x i|x<-[0..8]]]

फ़ंक्शन vकॉल करने वाला है। यह सूची के खिलाफ प्रत्येक पंक्तियों, कॉलम और ब्लॉक का अंतर प्राप्त करके काम करता है [1..9]और उन अंतर सूचियों की लंबाई को समेटता है।

डेमो सुडोकू उदाहरण का उपयोग कर:

*Main> :l so-22443.hs 
[1 of 1] Compiling Main             ( so-22443.hs, interpreted )
Ok, modules loaded: Main.
*Main> v [[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]]
0
— TimWolla
स्रोत
1

जावास्क्रिप्ट - 149 वर्ण

r=[];c=[];g=[];for(i=9;i;)r[o=--i]=c[i]=g[i]=36;for(x in a)for(y in z=a[x]){r[v=z[y]-1]-=y;c[v]-=x;g[v]-=3*(x/3|0)+y/3|0}for(i in r)o|=r[i]|c[i]|g[i]

एक सरणी aकी मौजूदगी की उम्मीद करता है और oआउटपुट के लिए एक चर बनाता है जो 0सफलता और गैर-शून्य पर है अन्यथा।

यह जाँचने पर काम करता है कि प्रत्येक पंक्ति, स्तंभ और 3 * 3 ग्रिड के लिए प्रत्येक पद के मान का योग 36 (0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8) के बराबर है।

परिक्षण

a=[
    [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]
  ];

'ओ = 0' देता है

a=[
    [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,5,4]
  ];

(अंतिम 2 अंक स्वैप किए गए)

देता है o=-1

a=[
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],

    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],

    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5],
    [5,5,5, 5,5,5, 5,5,5]
  ];

देता है o=-284

— MT0
स्रोत
1

हास्केल, 121 130 127 बाइट्स (87 लैंबडॉट)

import Data.List
import Data.List.Split
c=concat
t=transpose
k=chunksOf
p x=all(==[1..9])$(sort<$>)=<<[x,t x,k 9.c.c.t$k 3<$>x]

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

-- k 9.c.c.t$k 3<$> x = chunksOf 9 $ concat $ concat $ transpose $ map chunksOf 3 x

let ts = k 9$[10*a+b|a<-[1..9],b<-[1..9]] --yep, this is ugly
in k 9.c.c.t$k 3<$>ts
-- prints:
--[[11,12,13,21,22,23,31,32,33],[41,42,43,51,52,53,61,62,63],[71,72,73,81,82,83,91,92,93],[14,15,16,24,25,26,34,35,36],[44,45,46,54,55,56,64,65,66],[74,75,76,84,85,86,94,95,96],[17,18,19,27,28,29,37,38,39],[47,48,49,57,58,59,67,68,69],[77,78,79,87,88,89,97,98,99]]

लैंबडबॉट डेटा को लोड करता है। डेटा और डेटा। लिस्ट डिफ़ॉल्ट रूप से (मुझे नहीं लगता कि ब्लैककैप का समाधान बक्से की जांच करता है)।

सुधार के स्वागत के लिए विचार

// संपादित करें: मैंने गड़बड़ कर दी :)
// संपादित करें: 3 बाइट्स ब्लैककैप द्वारा बचाए गए

— michi7x7
स्रोत
आप सही हैं, मैं यह नोटिस करने में विफल रहा कि पंक्तियों और स्तंभों की जाँच करना पर्याप्त नहीं है ..
— BlackCap
ठीक है, मैं साथ ही गड़बड़ कर दिया :)
— michi7x7
1
आप बदल सकते हैं (map sort)के साथ(sort<$>)
— BlackCap
1
और .c$(sort<$>)<$>साथ में$(sort<$>)=<<
— BlackCap
ओह
— माय
0

क्लोजर, 151 बाइट्स

काफी लंबा है, लेकिन दूसरों को भी लगता है। इसके अलावा कि सेट के संघ को नाराज करने के लिए एक की आवश्यकता है require, इसलिए मैंने इसके बजाय वैक्टर के एक कॉनकट का उपयोग किया।

प्रत्येक पंक्ति और स्तंभ पर Iterates और यदि मान 1 और 9 के बीच है तो यह तीन वैक्टर, एक पंक्ति, कर्नल और 3x3 सेल के लिए उत्सर्जित करता है। सफलता पर 0 रिटर्न देता है और nilअन्यथा, दो अतिरिक्त अक्षर असफल होने पर 1 वापस कर सकता है। 1 - 9 के बाहर की संख्या को वापस करके, nilलेकिन गैर-पूर्णांक मान जैसे अन्य विसंगतियों पर क्रैश करेगा। मरीज 0 - 2 हैं, इसलिए मूल्यों का उपयोग करना 8और 9पंक्तियों और स्तंभों से सेल मूल्यों को अलग करना सुरक्षित है ।

(fn[s](if(= 243(count(set(apply concat(for[i(range 9)j(range 9)](let[v(nth(nth s i)j)q #(quot % 3)](if(<= 1 v 9)[[8 v i][9 v j][(q i)(q j)v]])))))))0))

इनपुट वैक्टर का नेस्टेड वेक्टर है (ताकि nthकाम करता है):

(def sudoku [[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]])

Ungolfed:

(defn f [s]
  (->> (for [i (range 9) j (range 9)]
         (let [v (-> s (nth i) (nth j)) q #(quot % 3)]
           (if (<= 1 v 9)
             [[:row v i] [:col v j] [:cell [(q i) (q j)] v]])))
    (apply concat)
    set
    count
    (#(if (= 243 %) :pass :fail))))
— NikoNyrh
स्रोत
0

PHP, 196 190 बाइट्स

while($i<9){for($b=$c=$k=$y="";$y++<9;)$b.=($a=$argv)[$y][$i];for(;$k<3;)$c.=substr($a[++$k+$i-$i%3],$i%3*3,3);if(($u=count_chars)($a[++$i],3)<($d=123456789)|$u($b,3)<$d|$u($c,3)<$d)die(1);}

कार्यक्रम 9 अलग-अलग कमांड लाइन तर्क (ग्रिड की प्रत्येक पंक्ति के लिए अंकों का एक स्ट्रिंग) लेता है; अमान्य के लिए (त्रुटि), (ठीक) के लिए
बाहर निकलता है।10

के साथ भागो php -nr '<code>' <row1> <row2> ...।

टूट - फूट

while($i<9)
{
    for($b=$c=$k=$y="";$y++<9;)$b.=($a=$argv)[$y][$i];  // column to string
    for(;$k++<3;)$c.=substr($a[$i-$i%3+$k],$i%3*3,3);   // sub-grid to string
    if(($u=count_chars)($a[++$i],3)<($d=123456789)      // check row
        |$u($b,3)<$d                                    // check column
        |$u($c,3)<$d                                    // check sub-grid
    )die(1);                                            // test failed: exit with 1
}

व्याख्या

count_charsएक स्ट्रिंग में वर्णों को गिनता है और आमतौर पर एसेसी कोड के साथ एक सरणी बनाता है जैसा कि कुंजी और मान के रूप में वर्ण गणना; लेकिन 3मोड पैरामीटर के रूप में, यह पात्रों से एक क्रमबद्ध स्ट्रिंग बनाता है; और आसानी से वांछित अंकों के साथ संख्या की तुलना की जा सकती है।

तुलना न केवल डुप्लिकेट के लिए जांचती है, बल्कि अमान्य वर्णों के लिए चेक भी शामिल है। और इसे केवल आवश्यकता है <, नहीं !=, क्योंकि यह संख्यात्मक तुलना है: पीएचपी स्ट्रिंग को एक संख्या के रूप में जहाँ तक यह कर सकता है की व्याख्या करेगा। 123e56789, 0x3456789या समान दिखाई नहीं दे सकते, क्योंकि वर्ण क्रमबद्ध हैं; और गायब होने वाले अंकों के साथ कोई भी शुद्ध पूर्णांक 123456789... और .23456789, निश्चित रूप से छोटा है ।

$a=$argvएक बाइट $d=123456789बचाता है , नौ $u=count_charsबचाता है और 13 बचाता है।

— टाइटस
स्रोत
-1

सी # - 306 298 288 वर्ण

निम्न कंसोल प्रोग्राम का उपयोग चेकिंग फ़ंक्शन को कॉल करने के लिए किया गया था;

static void Main(string[] args)
    {
        int[,] i={{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}
            };

            Console.Write(P(i).ToString());
    }

यह सब सरणी को इनिशियलाइज़ करता है और इसे चेकिंग फ़ंक्शन P में पास करता है।

चेकिंग फ़ंक्शन नीचे (गोल्फ के रूप में) है;

private static int P(int[,]i){int[]r=new int[9],c=new int[9],g=new int[9];for(int p=0;p<9;p++){r[p]=45;c[p]=45;g[p]=45;}for(int y=0;y<9;y++){for(int x=0;x<9;x++){r[y]-=i[x,y];c[x]-=i[x,y];int k=(x/3)+((y/3)*3);g[k]-=i[x,y];}}for(int p=0;p<9;p++)if(r[p]>0|c[p]>0|g[p]>0)return 1;return 0;}

या पूरी तरह से निर्धारित रूप में;

    private static int P(int[,] i)
    {
        int[] r = new int[9],c = new int[9],g = new int[9];
        for (int p = 0; p < 9; p++)
        {
            r[p] = 45;
            c[p] = 45;
            g[p] = 45;
        }

        for (int y = 0; y < 9; y++)
        {
            for (int x = 0; x < 9; x++)
            {
                r[y] -= i[x, y];

                c[x] -= i[x, y];

                int k = (x / 3) + ((y / 3) * 3);
                g[k] -= i[x, y];
            }
        }

        for (int p = 0; p < 9; p++)
            if (r[p] > 0 | c[p] > 0 | g[p] > 0) return 1;

        return 0;
    }

यह इस विचार का उपयोग करता है कि सभी स्तंभों, पंक्तियों और उप-ग्रिडों को 45 तक जोड़ना चाहिए। यह इनपुट सरणी के माध्यम से काम करता है और पंक्ति, स्तंभ और उप-ग्रिड से प्रत्येक स्थिति के मूल्य को घटाता है। एक बार इसे पूरा करने के बाद यह जांचता है कि पंक्तियों, स्तंभों या उप-ग्रिडों में से किसी का अभी भी कोई मूल्य नहीं है।

अनुरोध के रूप में एक 0 रिटर्न अगर सरणी एक वैध सुडोकू समाधान और गैर-शून्य (1) है जहां यह नहीं है।

— मर्जी
स्रोत
मुझे लगता है कि आप private static int P(int[,]i){int[]r=new int[9],c=new int[9],g=new int[9];इसके बजाय उपयोग करके कुछ चार्ट बचा सकते हैं । (करीबी वर्ग कोष्ठक के बाद स्थान को हटाने पर ध्यान दें ]।) इसके अलावा, मुझे यकीन नहीं है लेकिन मुझे लगता है कि आप छुटकारा पा सकते हैं private static।
— user12205
इसके अलावा, अंतिम भाग के लिए, C में हम कुछ ब्रेसिज़ निकाल सकते हैं for(int p=0;p<9;p++)if(r[p]>0|c[p]>0|g[p]>0)return 1;return 0;}, यह सुनिश्चित नहीं है कि यह C # में काम करता है। (मुझे वास्तव में C # नहीं पता है)
— user12205
@ace - मैंने आपके सुझावों के आधार पर कई संवर्द्धन किए हैं। अब नीचे 298 चार्ट है।
— विल
@Ace की टिप्पणियों के आधार पर एक और 10 वर्णों की छंटनी की।
— विल
1
संख्या 5 से भरे सरणी के साथ क्या होता है? सभी पंक्तियों, स्तंभों और चौकों को 45 तक जोड़ते हैं।
— लेवल रिवर सेंट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.