任务

给定一个非负整数数组a，请确定从数组0处“跳出”数组所需的向右跳转的最小次数，从位置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

通过“跳跃”越界的最短路径为length 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]]

在线尝试！

编辑：-12字节感谢@Esolanging Fruit和OP决定允许无限！

Infinity当没有解决方案时返回，这使解决方案更加简单。由于我们只能向前移动，因此f只需查看列表的开头，然后1<=k<=x从列表中删除项目并重复。然后，我们只需将找到的递归调用加到每个解决方案中，然后取最小值即可。如果head为0，结果将是无穷大（因为我们不能移动，所以没有解）。由于1+Infinity==Infinity此结果将被带回给呼叫者。如果列表为空，则意味着我们离开了数组，因此返回的成本为0。

Python 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

在线尝试！

Xcoder先生提供-11个
字节Xcoder和Rod 先生提供了-12个字节

APL（Dyalog Classic）ngn / apl，18字节

编辑：切换到我自己的APL实现，因为Dyalog不支持无限，并且挑战作者不允许有限数字充当“空”

⊃⊃{⍵,⍨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字节

返回跳转数或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

在线尝试！返回无穷大的空值。