एक हत्यारा सुडोकू सॉल्वर बनाएँ

Question

आपने सोचा था कि सुडोकू कठिन था, अब किलर सुडोकू आज़माएं !

किलर सुडोकू के खेल में, आपको कोई भी नंबर नहीं दिया जाता है। इसके बजाय, आपको ऐसे क्षेत्र दिए गए हैं जो एक निश्चित संख्या तक जोड़ते हैं। विकिपीडिया से निम्नलिखित उदाहरण पर विचार करें:

और इसका समाधान:

आपके द्वारा लिखा गया प्रोग्राम 81 अक्षरों के अनुक्रम से मिलकर एक प्रारूप लेगा, जो संख्याओं के अनुक्रम के बाद क्षेत्रों का प्रतिनिधित्व करेगा। फिर अनुक्रम में प्रत्येक संख्या "ए", "बी", आदि से शुरू होने वाले प्रत्येक अक्षर क्षेत्रों में संख्याओं का योग दर्शाती है।

यह तब समाधान का प्रतिनिधित्व करने वाले 81 अंकों के अनुक्रम का उत्पादन करेगा।

उदाहरण के लिए, ऊपर दी गई पहेली पहेली में निम्नलिखित इनपुट होंगे:

AABBBCDEFGGHHCCDEFGGIICJKKFLMMINJKOFLPPQNJOORSPTQNUVVRSTTQWUUXXSYZWWaaXXSYZWbbbcc
3 15 22 4 16 15 25 17 9 8 20 6 14 17 17 13 20 12 27 6 20 6 10 14 8 16 15 13 17

और परिणामी आउटपुट होगा:

215647398368952174794381652586274931142593867973816425821739546659428713437165289

आप मान सकते हैं कि इनपुट वैध है, और यह कि क्षेत्र हमेशा ए, बी, ..., वाई, जेड, ए, बी, ..., जेड द्वारा क्रम में दिखाई देंगे।

(सबसे छोटा कोड जो जीतता है।)

Comments

आप प्रतियोगिता कैसे जीतते हैं? सबसे छोटा कोड? सबसे तेज कोड?

— भालू ५०५

सबसे छोटा कोड। [ 1 चरित्र द्वारा चार्ली सीमा को याद किया ।]

— जो जेड

और अगर 52 से अधिक क्षेत्र हैं, तो क्या?

— श्री लिस्टर

आप मान सकते हैं कि 45 से अधिक क्षेत्र नहीं होंगे।

— जो जेड।

क्या कोई संख्या एक पिंजरे के भीतर दोहरा सकती है?

— पीटर टेलर

Answer 1

आर - 378 वर्ण

यह मानते हुए

x="AABBBCDEFGGHHCCDEFGGIICJKKFLMMINJKOFLPPQNJOORSPTQNUVVRSTTQWUUXXSYZWWaaXXSYZWbbbcc"
y="3 15 22 4 16 15 25 17 9 8 20 6 14 17 17 13 20 12 27 6 20 6 10 14 8 16 15 13 17"

378 वर्ण:

z=strsplit
v=sapply
R=rep(1:9,9)
C=rep(1:9,e=9)
N=1+(R-1)%/%3+3*(C-1)%/%3
G=z(x,"")[[1]]
M=as.integer(z(y," ")[[1]])[order(unique(G))]
s=c(1,rep(NA,80))
i=1
repeat if({n=function(g)!any(v(split(s,g),function(x)any(duplicated(x,i=NA))))
S=v(split(s,G),sum)
n(R)&&n(C)&&n(N)&&n(G)&&all(is.na(S)|S==M)}){if(i==81)break;i=i+1;s[i]=1}else{while(s[i]==9){s[i]=NA
i=i-1};s[i]=s[i]+1}
s

2,964,690 पुनरावृत्तियों के बाद, अपेक्षित समाधान तक पहुंचने में मेरे मामूली पीसी पर लगभग एक घंटे का समय लगता है।

---

डी-golfed:

ROWS   <- rep(1:9, 9)
COLS   <- rep(1:9, each = 9)
NONETS <- 1 + (ROWS - 1) %/% 3 + 3 * (COLS - 1) %/% 3
CAGES  <- strsplit(x, "")[[1]]
SUMS   <- as.integer(strsplit(y, " ")[[1]])[order(unique(CAGES))]

is.valid <- function(sol) {

   has.no.repeats <- function(sol, grouping) {
      !any(vapply(split(sol, grouping),
                  function(x) any(duplicated(x, incomparables = NA)),
                  logical(1)))
   }
   has.exp.sum <- function(sol, grouping, exp.sums) {
      sums <- vapply(split(sol, grouping), sum, integer(1))
      all(is.na(sums) | sums == exp.sums)
   }

   has.no.repeats(sol, ROWS  ) &&
   has.no.repeats(sol, COLS  ) &&
   has.no.repeats(sol, NONETS) &&
   has.no.repeats(sol, CAGES ) &&
   has.exp.sum(sol, CAGES, SUMS)        
}

sol <- c(1L, rep(NA, 80)) # start by putting a 1
i <- 1L                   # in the first cell
it <- 0L

repeat {
   it <- it + 1L
   if (it %% 100L == 0L) print(sol)
   if(is.valid(sol)) {         # if everything looks good
      if (i == 81L) break         # we are either done
      i <- i + 1L                 # or we move to the next cell
      sol[i] <- 1L                # and make it a 1
   } else {                    # otherwise
      while (sol[i] == 9L) {      # while 9s are found
         sol[i] <- NA             # replace them with NA
         i <- i - 1L              # and move back to the previous cell
      }
      sol[i] <- sol[i] + 1L       # when a non-9 is found, increase it
   }                           # repeat
}
sol

Answer 2

GolfScript, 138 अक्षर

n%~[~]:N;1/:P.&:L;9..*?{(.[{.9%)\9/}81*;]:§;L{.`{\~@@=*}+[P§]zip%{+}*\L?N==}%§9/..zip+\3/{{3/}%zip{{+}*}%}%{+}*+{.&,9=}%+1-,!{§puts}*.}do;

यह GolfScript में एक किलर सुडोकू सॉल्वर है। यह दो पंक्तियों में STDIN पर इनपुट की अपेक्षा करता है जैसा कि ऊपर दिए गए उदाहरण में दिया गया है।

कृपया ध्यान दें: चूंकि पहेली विवरण निष्पादन समय पर कोई प्रतिबंध नहीं लगाता है इसलिए मैंने गति पर छोटे कोड आकार को प्राथमिकता दी। कोड एक समाधान के लिए सभी 9 ^ 81 ग्रिड कॉन्फ़िगरेशन का परीक्षण करता है जो धीमे कंप्यूटर पर कुछ समय ले सकता है; ;-)

Comments

क्या आप इसे सत्यापित कर सकते हैं? : पी

— जो जे।

@ जोज़ेंग, यह 4x4 के लिए इसे ट्वीक करने के लिए काफी आसान है। यहाँ एक परीक्षण मामला है:AABBCADEFFDDGGGG 6 7 4 8 2 3 10

— पीटर टेलर

@PeterTaylor आपके परीक्षण मामले में चार अलग-अलग वैध समाधान हैं।

— जो जे।

Answer 3

रूबी, 970 अक्षर

A,B=gets,gets.split
L=[]
R=[]
U=[]
D=[]
N=[]
C=[]
S=[]
O=[0]*81
z='A'
(0..324).map{|j|U<<j;D<<j;R<<(j+1)%325;L<<(j+324)%325;N<<j;C<<j;S<<0}
X=->s,j,c,cf,n{j<81?(z==A[j]?(0..8).map{|i|X[s-1-i,j+1,c+[i],cf+[1+j,1+81+27*i+j/9,1+81+27*i+9+j%9,1+81+27*i+18+j/3%3+j/27*3],n+[i+1]]}:X[s,j+1,c,cf,n+[0]]if s>=0):(h=U.size;cf.uniq.sort.map{|l|N<<n;L<<(L[h]||h);R<<h;U<<U[l];D<<l;C<<l;S[l]+=1;L[R[-1]]=R[L[-1]]=U[D[-1]]=D[U[-1]]=L.size-1}if s==0)}
Y=->c{L[R[c]]=L[c];R[L[c]]=R[c];i=D[c];(j=R[i];(U[D[j]]=U[j];D[U[j]]=D[j];S[C[j]]-=1;j=R[j])while j!=i;i=D[i])while i!=c}
Z=->c{i=U[c];(j=L[i];(S[C[j]]+=1;U[D[j]]=j;D[U[j]]=j;j=L[j])while j!=i;i=U[i])while i!=c;L[R[c]]=c;R[L[c]]=c}
B.map{|k|X[k.to_i,0,[],[],[]];z=z=='Z'?'a':z.next}
s=->k{c=R[0];c<1?($><<(O[0,k].map{|s|N[s]}.transpose.map &:max)*""):(g=S[b=c];g=S[b=c]if S[c]<g while 0<c=R[c];Y[b];r=D[b];(O[k]=r;j=R[r];(Y[C[j]];j=R[j])while j!=r;s[k+1];r=O[k];c=C[r];j=L[r];(Z[C[j]];j=L[j])while j!=r;r=D[r])while r!=b;Z[b])}
s[0]

उपरोक्त रूबी कोड मेरे गोल्फस्क्रिप्ट सदस्यता के विपरीत है। यह काफी लंबा है (और अभी तक पूरी तरह से गोल्फ नहीं है), लेकिन गति के लिए अनुकूलित। ऊपर दिए गए हत्यारे सुडोकू को एक सेकंड के भीतर अच्छी तरह से हल किया गया है (मेरे मूल जावा संस्करण के साथ यह केवल कुछ मिली सेकंड था)। सॉल्वर स्वयं नूथ के डीएलएक्स एल्गोरिथ्म का एक बुनियादी कार्यान्वयन है।

इनपुट STDIN पर दो लाइनों के रूप में दिया जाना चाहिए। उदाहरण ( ऑनलाइन ):

> AABBBCDEFGGHHCCDEFGGIICJKKFLMMINJKOFLPPQNJOORSPTQNUVVRSTTQWUUXXSYZWWaaXXSYZWbbbcc
3 15 22 4 16 15 25 17 9 8 20 6 14 17 17 13 20 12 27 6 20 6 10 14 8 16 15 13 17

215647398368952174794381652586274931142593867973816425821739546659428713437165289