रूबी - लगभग 700 गोल्फ। मैंने एक गोल्फ संस्करण शुरू किया, जिसमें चर और विधियों के एकल-चरित्र नाम हैं, लेकिन थोड़ी देर बाद मुझे गोल्फ की तुलना में एल्गोरिथम में अधिक रुचि मिली, इसलिए कोड लंबाई को अनुकूलित करने की कोशिश करना बंद कर दिया। न ही मुझे इनपुट स्ट्रिंग मिलने की चिंता थी। मेरा प्रयास नीचे है।
आपको यह समझने में मदद करने के लिए कि यह कैसे काम करता है मैंने टिप्पणियों को शामिल किया है जो दिखाते हैं कि एक विशेष स्ट्रिंग (u = "2 1 4 3 0 3 4 4 3 3 5 0 3") में हेरफेर किया गया है। मैं "स्ट्रीम में चट्टानों" के संयोजन की गणना करता हूं जो कि हॉप करने के लिए उपलब्ध हैं। इन्हें बाइनरी स्ट्रिंग के साथ दर्शाया गया है। मैं उदाहरण 0b0101101010 टिप्पणियों में देता हूं और दिखाता हूं कि इसका उपयोग कैसे किया जाएगा। प्रारंभिक यात्रा के लिए उपलब्ध चट्टानों की स्थिति के लिए 1 का पत्राचार; वापसी यात्रा के लिए 0 है। इस तरह के प्रत्येक आवंटन के लिए, मैं प्रत्येक दिशा में आवश्यक हॉप्स की न्यूनतम संख्या निर्धारित करने के लिए गतिशील प्रोग्रामिंग का उपयोग करता हूं। कुछ संयोजनों को जल्दी खत्म करने के लिए मैं कुछ सरल अनुकूलन भी करता हूं।
मैंने इसे अन्य उत्तरों में दिए गए तार के साथ चलाया है और समान परिणाम प्राप्त करता हूं। यहाँ कुछ अन्य परिणाम प्राप्त हुए हैं:
"2 1 4 3 0 3 4 4 3 5 0 3" # => 8
"3 4 3 5 6 4 7 4 3 1 5 6 4 3 1 4" # => 7
"2 3 2 4 5 3 6 3 2 0 4 5 3 2 0 3" # => 10
"3 4 3 0 4 3 4 4 5 3 5 3 0 4 3 3 0 3" # => 11
"2 3 2 4 5 3 6 3 2 0 4 5 3 2 0 3 4 1 6 3 8 2 0 5 2 3" # => 14
मुझे यह सुनने में दिलचस्पी होगी कि क्या दूसरों को इन स्ट्रिंग्स के लिए समान परिणाम मिलते हैं। प्रदर्शन उचित है। उदाहरण के लिए, इस स्ट्रिंग का समाधान पाने में एक मिनट से भी कम समय लगा:
"3 4 3 0 4 3 4 4 5 5 3 3 4 4 3 3 0 3 4 5 3 2 2 3 4 1 6 4 2 2 4 4 3 2 2 3 4 1 6 3 0 4 3 4 4 5 5 1"
कोड इस प्रकार है।
I=99 # infinity - unlikely we'll attempt to solve problems with more than 48 rocks to step on
def leap!(u)
p = u.split.map(&:to_i) # p = [2,1,4,3,0,3,4,4,3,5,0,3]
s = p.shift # s=2, p = [1,4,3,0,3,4,4,3,5,0,3] # start
f = p.pop # f=3, p = [1,4,3,0,3,4,4,3,5,0] # finish
q = p.reverse # q = [0,5,3,4,4,3,0,3,4,1] # reverse order
# No path if cannot get to a non-zero rock from s or f
return -1 if t(p,s) || t(q,f)
@n=p.size # 10 rocks in the stream
r = 2**@n # 10000000000 - 11 binary digits
j = s > @n ? 0 : 2**(@n-s) # 100000000 for s = 2 (cannot leave start if combo number is smaller than j)
k=r-1 # 1111111111 - 10 binary digits
b=I # best number of hops so far (s->f + f->s), initialized to infinity
(j..k).each do |c|
# Representative combo: 0b0101101010, convert to array
c += r # 0b10 1 0 1 1 0 1 0 1 0
c = c.to_s(2).split('').map(&:to_i)
# [1,0,1,0,1,1,0,1,0,1,0]
c.shift # [0,1,0,1,1,0,1,0,1,0] s->f: rock offsets available: 1,3,4,6,8
d = c.map {|e|1-e}.reverse # [1,0,1,0,1,0,0,1,0,1] f->s: rock offsets available: 0,2,5,7,9
c = z(c,p) # [0,4,0,0,3,0,4,0,5,0] s->f: max hops by offset for combo c
d = z(d,q) # [0,0,3,0,4,0,0,3,0,1] f->s: max hops by offset for combo c
# Skip combo if cannot get from to a rock from f, or can't
# get to the end (can always get to a rock from s if s > 0).
next if [s,f,l(c),l(d)].max < @n && t(d,f)
# Compute sum of smallest number of hops from s to f and back to s,
# for combo c, and save it if it is the best solution so far.
b = [b, m([s]+c) + m([f]+d)].min
end
b < I ? b : -1 # return result
end
# t(w,n) returns true if can conclude cannot get from sourch n to destination
def t(w,n) n==0 || (w[0,n].max==0 && n < @n) end
def l(w) w.map.with_index {|e,i|i+e}.max end
def z(c,p) c.zip(p).map {|x,y| x*y} end
def m(p)
# for s->f: p = [2,0,4,0,0,3,0,4,0,5,0] - can be on rock offsets 2,5,7,9
# for f->s: p = [3,0,0,3,0,4,0,0,3,0,1] - can be on rock offsets 3,5,8,10
a=[{d: 0,i: @n+1}]
(0..@n).each do |j|
i=@n-j
v=p[i]
if v > 0
b=[I]
a.each{|h| i+v < h[:i] ? break : b << (1 + h[:d])}
m = b.min
a.unshift({d: m,i: i}) if m < I
end
end
h = a.shift
return h[:i]>0 ? I : h[:d]
end
Thus, it should be clear that one can always jump from the last position.- क्या कोई1 0प्रतिघात नहीं है?