हम टॉवर होपिंग करते हैं

17

कार्य

गैर-नकारात्मक पूर्णांक की एक सरणी को देखते हुए, सरणी को a"बाहर" कूदने के लिए आवश्यक न्यूनतम कूदता की न्यूनतम संख्या निर्धारित करें, स्थिति 0 पर शुरू, या शून्य / शून्य पर लौटें यदि ऐसा करना संभव नहीं है।

एक कूद इंडेक्स से iज्यादा से ज्यादा से सरणी सूचकांक में वृद्धि होने के लिए परिभाषित किया गया हैa[i] ।

एक कूद के बाहर एक कूद जहां सूचकांक कूद से उत्पन्न है iतो 1 आधारित अनुक्रमण के लिए, बाहर के सीमा सरणी के लिए है i>length(a), और 0 के आधार पर अनुक्रमण के लिए, i>=length(a)।

उदाहरण 1

विचार करें Array = [4,0,2,0,2,0]:

Array[0] = 4 -> You can jump 4 field
Array[1] = 0 -> You can jump 0 field
Array[2] = 2 -> You can jump 2 field
Array[3] = 0 -> You can jump 0 field
Array[4] = 2 -> You can jump 2 field
Array[5] = 0 -> You can jump 0 field

"कूदने" के लिए सबसे छोटे रास्ते से बाहर जाने की सीमा है 2 :

हम कूद सकते हैं 0->2->4->outsideजिसमें लंबाई है 3लेकिन 0->4->outsideलंबाई है 2इसलिए हम वापस लौट आए2 ।

उदाहरण 2

मान लीजिए Array=[0,1,2,3,2,1]:

Array[0] = 0 -> You can jump 0 fields
Array[1] = 1 -> You can jump 1 field
Array[2] = 2 -> You can jump 2 field
Array[3] = 3 -> You can jump 3 field
Array[4] = 2 -> You can jump 2 field
Array[5] = 1 -> You can jump 1 field

इस स्थिति में, सरणी के बाहर कूदना असंभव है, इसलिए हमें एक शून्य / शून्य या किसी भी गैर नियतात्मक मान को वापस करना चाहिए ∞ ।

उदाहरण 3

मान लीजिए Array=[4]:

Array[0] = 4 -> You can jump 4 field

हम सीधे केवल एक छलांग के साथ, सरणी के बाहर सूचकांक 0 से कूद सकते हैं, इसलिए हम वापस लौटते हैं 1 ।

संपादित करें:

रिटर्न वैल्यू के बारे में कई सवालों के कारण: रिटर्निंग ∞पूरी तरह से वैध है, अगर बचने का कोई मौका नहीं है। क्योंकि, यदि कोई मौका है, तो हम उस संख्या को परिभाषित कर सकते हैं।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf  array-manipulation  decision-problem  optimization 
— 0x45
स्रोत
9
इसके अलावा, कृपया अपनी चुनौतियों के लिए सैंडबॉक्स का उपयोग करने पर विचार करें! यदि आपने वहां पोस्ट किया था तो इनमें से कई चिंताओं को पहले ही संबोधित किया जा सकता है।
— ग्यूसेप
3
— श्री एक्सकोडर
3
@ 0x45 क्या धारणा है? यह तथ्य कि मैंने आपको कुछ संबंधित चुनौतियों से जोड़ा है? मैंने कभी डुप्लीकेट नहीं कहा । मुझे स्पष्ट नहीं है आपका क्या मतलब है।
— मिस्टर एक्सकोडर
10
@ 0x45 कृपया अच्छे इरादे मान लें । हम ये सवाल इसलिए नहीं पूछ रहे हैं क्योंकि हम आपकी चुनौती का मजाक बनाने की कोशिश कर रहे हैं। वास्तव में, यह काफी विपरीत है: हम आपकी चुनौती में रुचि रखते हैं। इसके बारे में जरा सोचें, अगर हम आपकी चुनौती को नापसंद करते हैं तो हम स्पष्ट सवाल क्यों पूछेंगे? हमारे पास उस उद्देश्य के लिए डाउनवोट्स / करीबी वोट हैं। (और जैसा कि मैं देख रहा हूं, किसी ने भी आपके पोस्ट को
— डाउनवोट
13
यह अच्छा होगा कि एक ऐसा परीक्षण मामला हो जहां हर कदम पर लालची अधिकतम दूरी पर कूदता हो, यह इष्टतम नहीं है। उदाहरण के लिए [2, 3, 1, 1]।
— मार्टिन एंडर

जवाबों:

4

भूसी , 9 बाइट्स

Γö→▼Mo₀↓ŀ

रिटर्न Infजब कोई समाधान मौजूद है। इसे ऑनलाइन आज़माएं!

व्याख्या

हस्क के डिफ़ॉल्ट रिटर्न मान यहां काम आते हैं।

Γö→▼Mo₀↓ŀ  Implicit input: a list, say [2,3,1,1]
Γ          Deconstruct into head H = 2 and tail T = [3,1,1]
 ö         and feed them into this function:
        ŀ   Range from 0 to H-1: [0,1]
    Mo      For each element in range,
       ↓    drop that many element from T: [[3,1,1],[1,1]]
      ₀     and call this function recursively on the result: [1,2]
   ▼        Take minimum of the results: 2
  →         and increment: 3

यदि इनपुट सूची रिक्त है, तो Γइसे फिर से संगठित नहीं किया जा सकता है, इसलिए यह डिफ़ॉल्ट पूर्णांक मान लौटाता है, 0. यदि पहला तत्व 0 है, तो इसका परिणाम Mo₀↓ŀएक खाली सूची है, जिस पर ▼अनंत लौटता है।

— Zgarb
स्रोत
6

हास्केल , 70 58 बाइट्स

f[]=0
f(0:_)=1/0
f(x:s)=minimum[1+f(drop k$x:s)|k<-[1..x]]

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

संपादित करें: - अनंत को अनुमति देने के लिए निर्णय लेने के लिए @Esolanging Fruit और OP को -12 बाइट्स धन्यवाद!

रिटर्न Infinityजब वहाँ कोई समाधान जो समाधान बहुत आसान बना देता है। चूँकि हम केवल आगे की ओर बढ़ सकते हैं fबस सूची के प्रमुख को देखता है और सूची 1<=k<=xसे आइटम को हटाता है और पुनरावर्ती करता है। फिर हम केवल प्रत्येक समाधान में 1 जोड़ते हैं जो पाया गया पुनरावर्ती कॉल और न्यूनतम लेता है। यदि सिर 0 है तो परिणाम अनंत होगा (क्योंकि हम स्थानांतरित नहीं कर सकते कोई समाधान नहीं है)। चूंकि 1+Infinity==Infinityयह परिणाम कॉल करने वालों को वापस ले जाया जाएगा। यदि सूची खाली है, तो इसका मतलब है कि हमने सरणी छोड़ दी है इसलिए हम 0 की लागत लौटाते हैं।

— user1472751
स्रोत
1
58 बाइट्स , लेकिन केवल अगर आप Infinityशून्य मान के रूप में अनुमति देते हैं (जो ओपी ने अभी तक स्पष्ट नहीं किया है)।
— फलन
दरअसल, ओपी ने अब इसकी अनुमति दे दी है, ताकि यह वैध हो।
— फलों का स्वाद
3

पायथन 2 , 124 बाइट्स

def f(a):
 i={0};l=len(a)
 for j in range(l):
	for q in{0}|i:
	 if q<l:i|=set(range(q-a[q],q-~a[q]))
	 if max(i)/l:return-~j

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

-11 बाइट्स मिस्टर एक्सकोडर
-12 बाइट्स की बदौलत मिस्टर एक्सकोडर और रॉड को धन्यवाद

— HyperNeutrino
स्रोत
आप विफल रहे print(f([4,1,0,4,1,1,1]))आप लौट आए 3, लेकिन 2जैसा होना चाहिए[0] -> [3] -> outside
— 0x45
@ 0x45 ऐसा कैसे ... प्रतीक्षा करें, जब आप कूदते हैं, तो क्या आपको यथासंभव या बीच में कहीं कूदना है?
— हाइपरएनुट्रिनो
@ Mr.Xcoder ओह यस, डुह। इसके लिए भी धन्यवाद-~चाल के , उस एक के बारे में भूल गया।
— हाइपरएनुट्रिनो
@HyperNeutrino "इंडेक्स से एक छलांग को सबसे अधिक []] द्वारा सरणी इंडेक्स में वृद्धि के रूप में परिभाषित किया गया है ।"
— मार्टिन एंडर
1
@ 0x45 ठीक है, स्पष्ट करने के लिए धन्यवाद। मुझे लगता है कि मैंने इसे ठीक कर लिया
— हाइपरन्यूट्रिनो
3

APL (Dyalog Classic) ngn / apl , 18 बाइट्स

संपादित करें: एपीएल के मेरे स्वयं के कार्यान्वयन के लिए स्विच किया गया क्योंकि Dyalog शिशुओं का समर्थन नहीं करता है और चुनौती लेखक परिमित संख्याओं को "अशक्त" के रूप में कार्य करने की अनुमति नहीं देता है।

⊃⊃{⍵,⍨1+⌊/⍺↑⍵}/⎕,0

इसे ऑनलाइन आज़माएं! इसे ngn / apl के डेमो पेज पर आज़माएँ

बिना किसी समाधान के लौटता है⌊/⍬ ∞

— NGN
स्रोत
"सही तर्क" क्या है ??
— आउटगोल्फर
यह चुनौती बेहतर परीक्षण-मामलों की सख्त जरूरत है। लेकिन उदाहरण के लिए आपका समाधान अमान्य 2 3 1 1है2
— H.PWiz
@EriktheOutgolfer 0Nजो k का पूर्णांक अशक्त है; अगर आपका रुचि रखते हैं, मैं आगे एपीएल कमरे में व्याख्या कर सकते हैं
— NGN
@ H.PWiz अब इससे निपट सकती है
— ngn
3

हास्केल , 45 बाइट्स

(1%)
0%_=1/0
a%(h:t)=min(1+h%t)$(a-1)%t
_%_=0

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

Infinityअसंभव होने पर आउटपुट । सहायक बाएं तर्क को %ट्रैक करता है कि हम अपने वर्तमान हॉप में कितने अधिक स्थान ले सकते हैं।

— XNOR
स्रोत
1

जेली , 19 18 बाइट्स

<LḢ
ḊßÐƤṁḢḟ0‘Ṃµ1Ç?

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

व्याख्या

<LḢ  Helper link. Input: array
<    Less than
 L   Length
  Ḣ  Head - Returns 0 if its possible to jump out, else 1

ḊßÐƤṁḢḟ0‘Ṃµ1Ç?  Main link. Input: array
            Ç   Call helper link
             ?  If 0
           1      Return 1
                Else
          µ       Monadic chain
Ḋ                   Dequeue
 ßÐƤ                Recurse on each suffix
     Ḣ              Head of input
    ṁ               Mold, take only that many values
      ḟ0            Filter 0
        ‘           Increment
         Ṃ          Minimum
— मील की दूरी पर
स्रोत
0

जूलिया 0.6 , 79 बाइट्स

कूदता है या Infयदि आप बच नहीं सकते हैं। पुनरावर्ती रूप से पहले तत्व को देखें और या तो वापस लौटें Infया 1इस पर निर्भर करें कि क्या आप बच सकते हैं, अन्यथा 1प्रत्येक वैध कूद का प्रतिनिधित्व करने वाले कम से कम सरणियों के लिए सबसे छोटा समाधान जोड़ें । नियंत्रण प्रवाह दो टर्नरी बयानों की तरह किया जाता है test1 ? ontrue1 : test2 ? ontrue2 : onfalse2। 

f(a,n=endof(a))=a[1]<1?Inf:a[1]>=n?1:1+minimum(f(a[z:min(z+a[1],n)]) for z=2:n)

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

— gggg
स्रोत
0

सी # (.NET कोर) , 97 बाइट्स

f=l=>{for(int c=l.Count,s=0,j=l[0];j>0;s=f(l.GetRange(j,c-j--)))if(s>0|j>=c)return s+1;return 0;}

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

0 अगर कोई रास्ता नहीं मिला तो वापस लौटता है।

व्याख्या

f = 
    l =>                                      //The list of integers
    {
        for (
            int c = l.Count,                  //The length of the list
                s = 0,                        //Helper to keep track of the steps of the recursion
                j = l[0];                     //The length of the jump, initialize with the first element of the list
                j > 0;                        //Loop while the jump length is not 0
                s = f(l.GetRange(j, c - j--)) //Recursive call of the function with a sub-list stating at the current jump length. 
                                              //Then decrement the jumplength. 
                                              //Returns the number of steps needed to jump out of the sup-list or 0 if no path was found. 
                                              //This is only executed after the first run of the loop body.
            )
        {
            if (j >= c |                      //Check if the current jump lengt gets you out of the list. 
                                              //If true return 1 (s is currently 0). OR
                s > 0 )                       //If the recursive call found a solution (s not 0) 
                                              //return the number of steps from the recursive call + 1
                return s + 1;
        }
        return 0;                             //If the jump length was 0 return 0 
                                              //to indicate that no path was found from the current sub-list.
    }
— raznagul
स्रोत
0

पायथन 2 , 83 73 72 बाइट्स

-10 धन्यवाद @ user202729
-1 के लिए @JonathanFrech को धन्यवाद

lambda a:a and(a[0]and-~min(f(a[k+1:])for k in range(a[0]))or 1e999)or 0

इसे ऑनलाइन आज़माएं! शून्य मान के लिए अनंत लौटाता है।

— फल तोड़ना
स्रोत
and min(...)+1forहो सकता है and-~min(...)for।
— जोनाथन फ्रीच
@JonathanFrech संपादित
— फलों का भंडार
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.