हाइड्रा कातिलों की वापसी

Question

जब से आप उस हाइड्रा को मारते हैं , तब तक आप कुछ वर्षों के लिए गौरवशाली हो जाते हैं, लेकिन अब लोग आपको धो रहे हैं। खैर इसका समय जब आप उन्हें गलत साबित करते हैं, तो आपने अन्नदाता हाइड्रा के ठिकाने के बारे में सुना है। बस इसे मार डालो और आप सभी महिमा से सम्मानित किया जाएगा जिसके आप हकदार हैं।

आप अपनी तलवारें प्राप्त करने के लिए शस्त्रागार में पहुंचते हैं, लेकिन वे सभी नियमित तलवारों से बाहर निकल जाते हैं जो उनके पास शेष हैं वे सेक्टर हैं। एक n- सेक्टर एक हाइड्रा पर सिर की संख्या को n से विभाजित करेगा, लेकिन इसका उपयोग केवल तभी किया जा सकता है जब सिर की संख्या n से विभाज्य हो।

एक बार फिर आप हाइड्रा को मारने में मदद करने के लिए कुछ कोड लिखने जा रहे हैं। आपका कोड हेड हाइड की संख्या को इनपुट के रूप में लेगा, लड़ाई शुरू करता है, हेड्स की संख्या प्रत्येक मोड़ को बढ़ाती है, और आपके द्वारा उपयोग किए जा सकने वाले एन-सेक्टरों की एक सूची। आपका कोड हाइड्रा को जल्दी से जल्दी खिसकाने के लिए चालों के एक इष्टतम पैटर्न का उत्पादन करेगा

लड़ाई के प्रत्येक मोड़ का उपयोग करने के लिए आप एक एकल तलवार का चयन कर सकते हैं, अगर एक स्लाइस के बाद हाइड्रा में केवल एक ही सिर होता है जिसे आप जीतते हैं, अगर यह सिर नहीं बढ़ता है। आप कभी भी कोई चाल नहीं बना सकते हैं, और यदि कोई संभावित कदम उपलब्ध नहीं हैं तो आप हार जाते हैं।

यदि कोई समाधान संभव नहीं है, तो आप समाधान के अलावा कुछ भी आउटपुट कर सकते हैं, जैसे एक खाली सूची, कुछ भी नहीं, संख्या शून्य आदि।

यह कोड-गोल्फ है इसलिए उत्तरों को उनके बाइट काउंट के रूप में स्कोर किया जाएगा, कम बेहतर होने के साथ।

परीक्षण के मामलों

यहां कुछ सुपर बेसिक टेस्ट-केस हैं, अनुरोध पर अधिक टेस्ट-केस जोड़े जाएंगे।

24 heads, 1  heads per turn, [2,3] -> [3,3,2,3]
25 heads, 2  heads per turn, [2,3] -> No solutions
4  heads, 2  heads per turn, [2]   -> No solutions
4  heads, 3  heads per turn, [2,5] -> [2,5]
10 heads, 17 heads per turn, [2, 3, 7, 19] -> No solutions
10 heads, 6  heads per turn, [1,16] -> [1,16]
6  heads, 2  heads per turn, [2, 3, 5] -> [2, 5]
125 heads, 1  head per turn, [1, 2, 3, 127] -> [1, 1, 127]

Comments

क्या हाइड्रा को शुरू करने के लिए केवल 1 सिर हो सकता है?

— ETHproductions

@ETHproductions आपको उस मामले को संभालने की आवश्यकता नहीं है।

— तदर्थ गार्फ हंटर

क्या हम मान सकते हैं कि सूची क्रमबद्ध है?

— ETHproductions

@ETHproductions हाँ आप कर सकते हैं। मैं नहीं देखता कि क्यों नहीं।

— तदर्थ गार्फ हंटर

1-सेक्टर मूल रूप से "स्किप टर्न" तलवार है?

— नील

Answer 1

जावास्क्रिप्ट (ईएस 6), 111 105 बाइट्स

सहेजे गए 4 बाइट्स @ThePirateBay के लिए धन्यवाद

(h,p,a)=>{for(b={[h]:[]};c=b,b=[];)for(d in c)for(e of a){d%e?0:q=b[d/e+p]=[...c[d],e];if(d==e)return q}}

मैंने गहराई-पहली पुनरावृत्ति खाई है जो मैं बहुत अधिक सुरक्षित-प्रथम छोरों के लिए उपयोग करने का प्रयास कर रहा था। यदि यह मौजूद है तो एक सरणी के रूप में समाधान को आउटपुट करता है, अगर यह नहीं चलता है तो हमेशा के लिए चलता है। यदि यह स्वीकार्य नहीं है, तो यहां एक है जो अंततः रुकता है (ज्यादातर मामलों में, वैसे भी):

(h,p,a)=>{for(b={[h]:[]};c=b,b=[],c+c;)for(d in c){for(e of a){a[[,d]]||d%e?0:q=b[d/e+p]=[...c[d],e];if(d==e)return q}a[[,d]]=1}}

Answer 2

जावास्क्रिप्ट, 191 190 बाइट्स

स्टेप हेन को एक बाइट धन्यवाद दिया

(h,t,s)=>eval(`r=[],d=0,q=[],s.map(a=>q.push([],h));while(q.length){p=q.shift(),h=q.shift(),s.map(w=>(a=h/w)==1?d=w:!(a%1)&!r[a+=t]?r[q.push([...p,w],a),a]=1:0);d?(q=[],p).push(d):0}d?p:[]`)

f=(h,t,s)=>eval(`r=[],d=0,q=[],s.map(a=>q.push([],h));while(q.length){p=q.shift(),h=q.shift(),s.map(w=>(a=h/w)==1?d=w:!(a%1)&!r[a+=t]?r[q.push([...p,w],a),a]=1:0);d?(q=[],p).push(d):0}d?p:[]`)

console.log(`[${f(24, 1, [2,3])}]`);
console.log(`[${f(25, 2, [2,3])}]`);
console.log(`[${f(4, 2, [2])}]`);
console.log(`[${f(4, 3, [2,5])}]`);
console.log(`[${f(10, 17, [2, 3, 7, 19])}]`);
console.log(`[${f(10, 6, [1,16])}]`);
console.log(`[${f(125, 1, [1, 16])}]`);
console.log(`[${f(1024, 3, [1, 2, 137])}]`);

---

Answer 3

पायथन 2 , 169 195 222 बाइट्स

बुरा हथियार अचार पर चक्रीय सिर उत्थान को ठीक से संभालने के लिए 5: बाइट्स। (इसे इंगित करने के लिए @ThePirateBay का धन्यवाद)

कुछ त्रुटियों के कारण कुछ मामलों को ठीक करने के लिए 5: बाइट्स।

lambda n,p,w:g(n,n,p,w[::-1])[:-1]
def g(n,b,p,w,a=[]):
 if b<2:return[1]
 for x in w:
	if n%x<1and n/x+p!=n and n not in a:
	 try:
		l=[x]+g(n/x+p,n/x,p,w,[n]+a)
	 	if l and l[-1]!=0:return l
	 except:return[0]
 return[0]

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

Comments

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

— स्टीफन

210 बाइट्स

— मिस्टर एक्सकोडर

संभव 208 बाइट्स ।

— जोनाथन फ्रीच

Answer 4

VB.NET (.NET 4.5), 439 + 35 (आयात) = 474 बाइट्स

आवश्यक है Imports System.Collections.Generic

Const N=Nothing
Function Z(h,r,a,Optional c=N,Optional p=N,Optional ByRef s=N)
If c Is N Then
c=New List(Of Long)
p=New List(Of Long)
End If
If s IsNot N And s?.Count<c.Count Then Return N
If p.Contains(h)Then Return N
p.Add(h)
For i=0To a.Count-1
Dim w=a(i)
If h Mod w=0Then
c.Add(w)
If h\w=1And(s Is N Or s?.Count>c.Count)Then
s=New List(Of Long)
s.AddRange(c)
End If
Z(h\w+r,r,a,c,p,s)
c.RemoveAt(c.Count-1)
End If
Next
Z=s
End Function

फ़ंक्शन Zदो लेता है Int64(सिर और सिर regrow दर की संख्या), और एक List(Of Int64)(क्षेत्र), और List(Of Int64) (the ordered choice of Sectors). Returnsकोई भी समाधान नहीं होने पर रिटर्न देता है ।

माना जाता है कि सेक्टरों को सबसे बड़े से लेकर सबसे छोटे क्रम में प्रस्तुत किया जाता है।

Optionalपुनरावर्ती कॉल राज्य को बचाने के लिए के लिए मानकों हैं। वे उपयोग में सेक्टर्स के वर्तमान ऑर्डर को ट्रैक करते हैं, सैक्टर्स का अब तक का सबसे छोटा ऑर्डर, और कभी भी सामने आए प्रमुखों की संख्या। यदि हम फिर से एक ही संख्या का सामना करते हैं, तो उस तक पहुंचने के लिए एक छोटा रास्ता होना चाहिए।

सेक्टरों का एकमात्र आदेश जो मायने रखता है, 1अगर वह मौजूद है तो मुझे अंतिम होने की आवश्यकता है। अन्यथा, हाइड्रा बिना सीमा के बढ़ सकता है क्योंकि मैं हर मोड़ पर 1सेक्टर का उपयोग कर सकता हूं और कभी भी किसी अन्य की कोशिश नहीं करूंगा ।

जब भी मैं उपयोग करना चाहता था, मैंने प्रत्येक बार 6 बाइट्स को शेविंग Nकरने के लिए एक निरंतरता घोषित की ।NothingNothing

And/ Orशॉर्ट-सर्किटिंग नहीं हैं, इसलिए मैं ?.ऑब्जेक्ट अशक्त त्रुटियों से बचने के लिए अशक्त सशर्त ऑपरेटर ( ) का उपयोग करता हूं । वास्तविक कोड में, मैं शॉर्ट सर्किट का उपयोग करता AndAlso/ OrElseकरती हूं।

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

---

Z पठनीयता के लिए अन-गोल्फ

Public Function Z(currentHeads As Long, regrowRate As Integer, weapons As ISet(Of Long), Optional currentWeapons As List(Of Long) = Nothing, Optional previousHeads As List(Of Long) = Nothing, Optional shortestWeapons As List(Of Long) = Nothing) As List(Of Long)

    ' initial call
    If currentWeapons Is Nothing Then
        currentWeapons = New List(Of Long)
        previousHeads = New List(Of Long)
    End If

    ' we've made more moves than our best so far
    If shortestWeapons IsNot Nothing AndAlso shortestWeapons.Count <= currentWeapons.Count Then
        Return Nothing
    End If

    ' exit, we've been here before
    If previousHeads.Contains(currentHeads) Then
        Return Nothing
    End If

    ' keep track of previous state to prevent duplicate paths
    previousHeads.Add(currentHeads)

    For Each w In weapons

        ' save 1 for last
        If w = 1 Then Continue For

        If currentHeads Mod w = 0 Then
            currentWeapons.Add(w)

            If currentHeads \ w = 1 Then
                If shortestWeapons Is Nothing OrElse shortestWeapons.Count > currentWeapons.Count Then
                    shortestWeapons = New List(Of Long)(currentWeapons)
                End If
            End If

            Dim answer = A(currentHeads \ w + regrowRate, regrowRate, weapons, currentWeapons, previousHeads, shortestWeapons)
            If answer IsNot Nothing Then
                If shortestWeapons Is Nothing OrElse shortestWeapons.Count > answer.Count Then
                    shortestWeapons = New List(Of Long)(answer)
                End If
            End If

            currentWeapons.RemoveAt(currentWeapons.Count - 1)
        End If
    Next

    If weapons.Contains(1) Then
        currentWeapons.Add(1)

        Dim answer = A(currentHeads \ 1 + regrowRate, regrowRate, weapons, currentWeapons, previousHeads, shortestWeapons)
        If answer IsNot Nothing Then
            If shortestWeapons Is Nothing OrElse shortestWeapons.Count > answer.Count Then
                shortestWeapons = New List(Of Long)(answer)
            End If
        End If

        currentWeapons.RemoveAt(currentWeapons.Count - 1)
    End If

    Return shortestWeapons
End Function