Tarea

Dado un conjunto de enteros no negativos a , determine el número mínimo de saltos hacia la derecha necesarios para saltar "fuera" de la matriz, comenzando en la posición 0, o devolver cero / nulo si no es posible hacerlo.

Un salto desde el índice ise define como un aumento en el índice de matriz como máximoa[i] .

A fuera de salto es un salto donde el índice resultante de la salto iestá fuera de los límites para la matriz, por lo que para la indexación 1 basada en i>length(a), y para la indexación 0 a base de, i>=length(a).

Ejemplo 1

Considera 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

El camino más corto al "saltar" para salir de los límites tiene longitud 2:

Podríamos saltar de lo 0->2->4->outsideque tiene longitud 3pero 0->4->outsidetiene longitud, 2así que volvemos 2.

Ejemplo 2

Supongamos 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

En este caso, es imposible saltar fuera de la matriz, por lo que deberíamos devolver un valor cero / nulo o cualquier valor no determinista como ∞.

Ejemplo 3

Supongamos Array=[4]:

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

Podemos saltar directamente desde el índice 0 fuera de la matriz, con solo un salto, por lo que volvemos 1 .

Editar:

Debido a múltiples preguntas sobre el valor de retorno: la devolución ∞es totalmente válida, si no hay posibilidad de escapar. Porque, si hay una posibilidad, podemos definir ese número.

Este es el código de golf , por lo que gana el código más corto en bytes.

Casco , 9 bytes

Γö→▼Mo₀↓ŀ

Devuelve Infcuando no existe una solución. Pruébalo en línea!

Explicación

Los valores de retorno predeterminados de Husk son útiles aquí.

Γö→▼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

Si la lista de entrada está vacía, Γno puede deconstruirla, por lo que devuelve el valor entero predeterminado, 0. Si el primer elemento es 0, entonces el resultado de Mo₀↓ŀes una lista vacía, en la que ▼devuelve infinito.

Haskell , 70 58 bytes

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

Pruébalo en línea!

EDITAR: -12 bytes gracias a @Esolanging Fruit y al OP por decidir permitir el infinito.

Regresa Infinitycuando no hay solución, lo que hace que la solución sea mucho más simple. Como solo podemos avanzar, fsolo mira el encabezado de la lista y cae1<=k<=x elementos de la lista y vuelve a aparecer. Luego simplemente agregamos 1 a cada solución que se encuentran las llamadas recursivas y tomamos el mínimo. Si la cabeza es 0, el resultado será infinito (ya que no podemos movernos, no hay solución). Dado que 1+Infinity==Infinityeste resultado será llevado de vuelta a las personas que llaman. Si la lista está vacía, eso significa que hemos abandonado la matriz, por lo que devolvemos un costo de 0.

Python 2 , 124 bytes

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

Pruébalo en línea!

-11 bytes gracias al Sr. Xcoder
-12 bytes gracias al Sr. Xcoder y Rod

APL (Dyalog Classic) ngn / apl , 18 bytes

EDITAR: cambié a mi propia implementación de APL porque Dyalog no admite infinitos y el autor del desafío no permite que los números finitos actúen como "nulos"

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

Pruébalo en línea! pruébalo en la página de demostración de ngn / apl

devuelve sin solución⌊/⍬ ∞

Haskell , 45 bytes

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

Pruébalo en línea!

Salidas Infinitycuando es imposible. El argumento auxiliar izquierdo para %rastrear cuántos espacios más podemos mover en nuestro salto actual.

Perl 5 , 56 53 bytes

Incluye +1paraa

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

Solo el código:

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

Pruébalo en línea!

Perl 5 , 80 bytes

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

Pruébalo en línea!

Jalea , 32 bytes

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

Pruébalo en línea!

Esto es demasiado largo ...

Jalea , 19 18 bytes

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

Pruébalo en línea!

Explicación

<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 bytes

(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])}}

Pruébalo en línea!

Realiza una primera búsqueda amplia de la matriz para encontrar la ruta más corta.

C (gcc) , 80 bytes

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;}

Pruébalo en línea!

Julia 0.6 , 79 bytes

Devuelve el número de saltos o Infsi no puedes escapar. Mire recursivamente el primer elemento y regrese Info 1dependiendo de si puede escapar, de lo contrario, agregue 1a la solución más corta para matrices truncadas que representan cada salto válido. El flujo de control se realiza con dos declaraciones ternarias como 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)

Pruébalo en línea!

C # (.NET Core) , 97 bytes

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;}

Pruébalo en línea!

Devuelve 0 si no se encontró ninguna ruta.

Explicación

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.
    }

Pitón 2 , 83 73 72 bytes

^{-10 gracias a @ user202729
-1 gracias a @JonathanFrech}

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

Pruébalo en línea! Devuelve infinito para un valor nulo.