रूबी - 541 ..., 394
मूल एल्गोरिथम पुनरावर्ती रूप से चयन करने के लिए डुप्लिकेट की एक पुनरावर्ती गहराई-पहली खोज है, पंक्ति 1, फिर कॉलम 1, फिर पंक्ति 2, आदि के माध्यम से देख रहा है, और जाँच कर रहा है कि दो पड़ोसी मारे नहीं गए हैं और ग्रिड जुड़ा हुआ है (जो कि break ifखंड में है) वहाँ, और बिट जो इससे पहले आता है)।
K=(0...(N=gets.to_i)*N).to_a
J=gets(p).split*''
H=->m{K&[m+1,m-1,m+N,m-N]}
Q=->k{s=[k[j=0]]
(j=s.size
s.map{|x|(s+=H[x]&k).uniq!})while s[j]
break if(K-k).any?{|m|(H[m]-k)[0]}||k!=k&s
$><<K.map{|m|[k.index(m)?J[m]:?#,m%N>N-2?"
":p]}*''|exit if !g=((0...N*2).map{|x|(k.select{|m|m.divmod(N)[x/N]==x%N}.group_by{|m|J[m]}.find{|l,c|c[1]}||[])[1]}-[p]).min
g.map{|d|Q[k-g<<d]}}
Q[K]
puts"no answer"
कुछ साफ टोटके:
if w[1]की तुलना में बहुत कम है if !w.one?और यदि आप जानते हैं कि कम से कम एक सदस्य है, तो यह एक ही परिणाम है।
इसी तरह, [0]की तुलना में कम है any?अगर कोई ब्लॉक है, और s[j]के लिए एक प्यारा शॉर्टकट है j<s.size(तकनीकी रूप से, यह अधिक की तरह हैj.abs<s.size ) के
और y%N+(y/N).iसे बहुत कम हैComplex(y%N,y/N)
इसके अलावा, जब तारों को उत्पन्न करने के लिए दो जटिल स्थितियां होती हैं, तो यह [cond1?str1a:str1b,cond2?str2a:str2b]*''करने के लिए सभी पार्न्स या #{}एस को जोड़ने की तुलना में छोटा हो सकता है।
असहमति और स्पष्टीकरण:
(यह 531 बाइट संस्करण से है। मैंने बदलाव किए हैं। सबसे विशेष रूप से, मैंने तब से उत्पाद को कॉल को समाप्त कर दिया है - एक समय में प्रति पंक्ति / कॉलम एक अंक हल करता हूं, और जे अब केवल एक सरणी है, जिसे अनुक्रमित किया गया है। पूर्णांक। सभी निर्देशांक पूर्णांक हैं।)
H पड़ोसियों की गणना करता है
def H m
# m, like all indices, is a complex number
# where the real part is x and the imaginary is y
# so neighbors are just +/-i and +/-1
i='i'.to_c
neighborhood = [m+1, m-1, m+i, m-i]
# and let's just make sure to eliminate out-of-bounds cells
K & neighborhood
end
N ग्रिड का आकार है
N = gets.to_i
K नक्शे की कुंजी हैं (जटिल संख्या)
# pretty self-explanatory
# a range of, e.g., if N=3, (0..8)
# mapped to (0+0i),(1+0i),(2+0i),(0+1i),(1+1i),(2+1i),...
K = (0..N**2-1).map{|y| (y%N) +(y/N).i }
J इनपुट मैप (जेल) है
# so J is [[0+0,"2"],[0+1i,"3"],....].to_h
J=K.zip($<.flat_map {|s|
# take each input line, and...
# remove the "\n" and then turn it into an array of chars
s.chomp.chars
}).to_h
k गैर-मारे गए कुंजी हैं
# starts as K
Q मुख्य पुनरावर्ती विधि है
def Q k
j=0 # j is the size of mass
# the connected mass starts arbitrarily wherever k starts
mass=[k[0]]
while j < s.size # while s hasn't grown
j = mass.size
mass.each{|cell|
# add all neighbors that are in k
(mass+=H[cell] & k).uniq!
}
end
# if mass != k, it's not all orthogonally connected
is_all_connected = k!=k&mass
# (K-k) are the killed cells
two_neighbors_killed = (K-k).any?{|m|
# if any neighbors of killed cells aren't in k,
# it means it was killed, too
(H[m]-k)[0]
}
# fail fast
return if two_neighbors_killed || is_all_connected
def u x
x.group_by{|m|J[m]}.select{|l,c|c[1]}
end
rows_with_dupes = Array.new(N){|r|u[k.select{|m|m.imag==r}]}
cols_with_dupes = Array.new(N){|r|u[k.select{|m|m.real==r}]}
# dupes is an array of hashes
# each hash represents one row or column. E.g.,
# {
# "3"=>[(0+0i),(1+0i),(3+0i)],
# "2"=>[(2+0i),(4+0i)]
# }
# means that the 0th, 1st and 3rd cells in row 0
# all are "3", and 2nd and 4th are "2".
# Any digits without a duplicate are rejected.
# Any row/col without any dupes is removed here.
dupes = (rows_with_dupes+cols_with_dupes-[{}])
# we solve one row at a time
first_row = dupes[0]
if !first_row
# no dupes => success!
J.map{|m,v|k.member?(m)?v:?#}.each_slice(N){|s|puts s*''}
exit
else
# the digit doesn't really matter
t=first_row.values
# cross-multiply all arrays in the row to get a
# small search space. We choose one cell from each
# digit grouping and drop the rest.
t.inject(:product).map{ |*e|
# Technically, we drop all cells, and add back the
# chosen cells, but it's all the same.
new_k = k-t.flatten+e.flatten
# and then search that space, recursively
Q[new_k]
}
end
end
कोड के साथ निष्पादित किया जाता है:
# run with whole board
Q[K]
# if we get here, we didn't hit an exit, so we fail
puts"no answer"
बदलाव का
394 ने @ ब्लोटोरेंज के सुझाव को नीचे जोड़ा, और बहुत अधिक हेरफेर किया
408 संशोधित उत्पादन एक बार फिर। इसके .minबजाय का उपयोग करें.inject(:+) के बाद से मैं सिर्फ वैसे भी एक पंक्ति ले रहा हूँ।
417 छोटी आउटपुट गणना
421 जटिल संख्या गिरा दिया। बस पूर्णांक का उपयोग करें। एक बंडल बचाओ
450 अधिक इनपुट सुधार
456 इनपुट सुधार
462 वृद्धिशील सुधार - esp। find, नहींselect
475 गिरा uऔर पंक्ति / कॉल डुप्ले बिल्डर को कुचल दिया
503 एक समय में केवल एक डुप्लिकेट अंक प्रति पंक्ति / स्तंभ को हल करते हैं।
केmap &:pop बजाय 530 का उपयोग करेंvalues
531 लैम्ब्डा को खींचता है जो डुप्स सरणी बनाता है
552 उफ़! एक आवश्यकता याद आती है
536 की औसत से बेहतर जनसंख्या जनसंख्या में वृद्धि हुई है (जो पहले थी d)
541 प्रारंभिक