Завдання

Враховуючи масив невід’ємних цілих чисел 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.

Редагувати:

Через кілька запитань про значення повернення: Повернення ∞цілком справедливо, якщо немає шансу вирватися. Тому що, якщо є шанс, ми можемо визначити це число.

Це код-гольф , тому найкоротший код у байтах виграє!

Лушпиння , 9 байт

Γö→▼Mo₀↓ŀ

Повертається, Infколи рішення не існує. Спробуйте в Інтернеті!

Пояснення

Тут корисні зворотні значення Husk.

Γö→▼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₀↓ŀпорожнього списку, на який ▼повертає нескінченність.

Haskell , 70 58 байт

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

Спробуйте в Інтернеті!

EDIT: -12 байт завдяки @Esolanging Fruit та OP за те, що вони вирішили дозволити нескінченність!

Повертається, Infinityколи немає рішення, що робить рішення набагато простішим. Оскільки ми можемо рухатись лише вперед, fпросто дивимося на головну частину списку і скидає 1<=k<=xелементи зі списку та повторюється. Тоді ми просто додаємо 1 до кожного рішення знайдених рекурсивних дзвінків і приймаємо мінімум. Якщо голова 0, результат буде нескінченним (оскільки ми не можемо рухатись, рішення немає). Оскільки 1+Infinity==Infinityцей результат буде переданий абонентам. Якщо список порожній, це означає, що ми залишили масив, тож ми повернемо вартість 0.

Пітон 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 байт завдяки містеру Xcoder
-12 байт завдяки містеру Xcoder та Rod

APL (Dyalog Classic) ngn / apl , 18 байт

EDIT: перейшов до власної реалізації APL, оскільки Dyalog не підтримує нескінченності, а автор виклику не дозволяє кінцевим числам діяти як "null"

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

Спробуйте в Інтернеті! спробуйте це на демонстраційній сторінці ngn / apl

повертається без рішення⌊/⍬ ∞

Haskell , 45 байт

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

Спробуйте в Інтернеті!

Виходи, Infinityколи неможливо. Лівий допоміжний аргумент %відстежує, скільки ще просторів ми можемо перемістити в нашому поточному стрибку.

Perl 5 , 56 53 байти

Включає +1дляa

perl -aE '1until-@F~~%v?say$n:$n++>map\@v{$_-$F[-$_]..$_},%v,0'  <<< "4 0 2 0 2 0"; echo

Просто код:

#!/usr/bin/perl -a
1until-@F~~%v?say$n:$n++>map\@v{$_-$F[-$_]..$_},%v,0

Спробуйте в Інтернеті!

Perl 5 , 80 байт

sub f{$_[0]>=@_||1+((sort{$a?$b?$a-$b:-1:1}map f(@_[$_..$#_]),1..$_[0])[0]||-1)}

Спробуйте в Інтернеті!

Желе , 32 байти

ṛ/ṆȧJ’Ṛ
Rḟ"ÇƤZ$$Tị$Œp+\€Ṁ<Li0ȧ@Ḣ

Спробуйте в Інтернеті!

Це занадто довго ...

Желе , 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

JavaScript ES6 , 118 байт

(x,g=[[0,0]])=>{while(g.length){if((s=(t=g.shift())[0])>=x.length)return t[1];for(i=0;i++<x[s];)g.push([s+i,t[1]+1])}}

Спробуйте в Інтернеті!

Здійснює перший широтний пошук масиву, щоб знайти найкоротший шлях.

C (gcc) , 80 байт

f(A,l,M,j,r)int*A;{M=~0;for(j=0;l>0&&j++<*A;)if(M<1|M>(r=f(A+j,l-j)))M=r;A=-~M;}

Спробуйте в Інтернеті!

Джулія 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)

Спробуйте в Інтернеті!

C # (.NET Core) , 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.
    }

Python 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

Спробуйте в Інтернеті! Повертає нескінченність для нульового значення.