Dada una lista de enteros no negativos en cualquier formato razonable, repítelo, omitiendo tantos elementos como dice cada entero que pisas.

Aquí hay un ejemplo trabajado:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | []
 ^ First element, always include it
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0]
    ^ Skip 0 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1]
          ^ Skip 1 element
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2]
                   ^ Skip 2 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2, 3]
Skip 3 elements; you're done

Otro ejemplo trabajado, no tan deltas iguales:

[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | []
 ^ First element, always include it
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4]
                ^ Skip 4 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3]
                            ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3]
                                        ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3, 4]
Skip 4 elements; you're done

Un ejemplo fuera de límites:

[0, 2, 0, 2, 4, 1, 2] | []
^ First element, always include it
[0, 2, 0, 2, 4, 1, 2] | [0]
    ^ Skip 0 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2]
             ^ Skip 2 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2, 4]
Skip 4 elements; you're done (out of bounds)

Reglas

• No puede usar ningún truco aburrido entre estos , hacen que el desafío sea aburrido y sin interés.
• Solo debe devolver / imprimir el resultado final. La salida STDERR se ignora.
• No puede obtener la entrada como una cadena de dígitos en ninguna base (por ejemplo, "0102513162" para el primer caso).
• Debe usar el orden de izquierda a derecha para la entrada.
• Como en los ejemplos trabajados, si sale de los límites, la ejecución termina como si no fuera así.
• Debe usar 0para omitir 0 elementos.
• Dada la lista vacía ( []) como entrada, debe regresar [].

Casos de prueba

[]                                                     => []
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                     => [0, 1, 3, 7]
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]                   => [5, 2, 1, 0]
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2]                         => [0, 1, 2, 3]
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] => [4, 3, 3, 4]
[0, 2, 0, 2, 4, 1, 2]                                  => [0, 2, 4]

Este es el código de golf , por lo que gana la respuesta más corta.

Python 2 , 36 bytes

f=lambda x:x and x[:1]+f(x[x[0]+1:])

Pruébalo en línea!

Python 2 , 49 44 * 41 bytes

^{Tachado 44 sigue siendo regular 44 :(}

* -3 gracias a @ ASCII-only .

l=input()
while l:print l[0];l=l[l[0]+1:]

Pruébalo en línea!

Imprime los resultados separados por una nueva línea, como lo permitió el OP en el chat. No creo que pueda acortarse como un programa completo no recursivo .

¿Como funciona esto?

• l=input() - Lee la lista de la entrada estándar.

• while l: - Abusa del hecho de que las listas vacías son falsas en Python, se repite hasta que la lista está vacía.

• print l[0]; - Imprime el primer elemento de la lista.

• l=l[l[0]+1:]- "Salta como un conejo" - Recorta el primero l[0]+1de la lista.

Tomemos un ejemplo.

Teniendo en cuenta la lista [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]como entrada, los realiza el código de la siguiente (de acuerdo con la explicación anterior) - imprime el primer elemento de la matriz: 5, recortar la primera 6: [2, 1, 2, 1, 0, 0]. A continuación, imprimir 2y recortar el primer 3: [1,0,0]. Del mismo modo, sacamos 1, recortamos los primeros 2 y obtenemos [0]. Por supuesto, 0se imprime y el programa termina.

Haskell, 29 27 26 bytes

j(x:y)=x:j(drop x y)
j x=x

Guardado 1 byte gracias a Zgarb.

Pruébalo en línea.

JavaScript (ES6), 42 39 35 bytes

a=>a.map((n,i)=>a.splice(i+1,n))&&a

let f = 
a=>a.map((n,i)=>a.splice(i+1,n))&&a

console.log(f([]))                                                     // => []
console.log(f([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))                     // => [0, 1, 3, 7]
console.log(f([5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]))                   // => [5, 2, 1, 0]
console.log(f([0, 1, 0, 2, 5, 1, 3, 1, 6, 2]))                         // => [0, 1, 2, 3]
console.log(f([4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2])) // => [4, 3, 3, 4]
console.log(f([0, 2, 0, 2, 4, 1, 2]))                                  // => [0, 2, 4]

Solución anterior 39 bytes

a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

-3 bytes gracias a @ThePirateBay

05AB1E , 10 9 bytes

[¬Dg>#=ƒ¦

Utiliza la codificación 05AB1E . Pruébalo en línea!

Mathematica, 46 44 bytes

SequenceCases[#,{x_,y___}/;Tr[1^{y}]<=x:>x]&

Alternativas:

SequenceCases[#,{x_,y___}/;x>=Length@!y:>x]&
SequenceCases[#,l:{x_,___}/;x>Tr[1^l]-2:>x]&

C #, 68 bytes

a=>{for(int i=0;i<a.Count;i+=a[i]+1)System.Console.Write(a[i]+" ");}

Pruébalo en línea!

Versión completa / formateada:

namespace System
{
    class P
    {
        static void Main()
        {
            Action<Collections.Generic.List<int>> f = a =>
            {
                for (int i = 0; i < a.Count; i += a[i] + 1)
                    System.Console.Write(a[i] + " ");
            };

            f(new Collections.Generic.List<int>() { });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 0, 2, 5, 1, 3, 1, 6, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 2, 0, 2, 4, 1, 2 });Console.WriteLine();

            Console.ReadLine();
        }
    }
}

Devolver una lista es más largo en 107 bytes.

a=>{var l=new System.Collections.Generic.List<int>();for(int i=0;i<a.Count;i+=a[i]+1)l.Add(a[i]);return l;}

Casco , 8 6 bytes

←TU¡Γ↓

Pruébalo en línea!

-2 bytes (y una idea de solución completamente nueva) gracias a Leo!

Explicación

Estoy usando la función de coincidencia de patrón de lista Γ. Toma una función fy una lista con cabeza xy cola xs, y se aplica fa xy xs. Si la lista está vacía, Γdevuelve un valor predeterminado consistente con su tipo, en este caso una lista vacía. Tomamos fser ↓, que elimina xelementos de xs. Esta función se itera y los elementos resultantes se recopilan en una lista.

←TU¡Γ↓  Implicit input, e.g. [0,2,0,2,4,1,2]
    Γ↓  Pattern match using drop
   ¡    iterated infinitely: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[],[],[],...
  U     Cut at first repeated value: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[]]
 T      Transpose: [[0,2,4],[2,0,1],[0,2,2],[2,4],[4,1],[1,2],[2]]
←       First element: [0,2,4]

Python 2 , 59 55 bytes

l=input()
i=0
while l[i:]:i+=1;l[i:i+l[i-1]]=[]
print l

Pruébalo en línea!

Pyth, 22 bytes

VQ aY.(Q0VeY .x.(Q0 ;Y

Se eliminó un byte inútil.

Python 2 , 60 42 41 bytes

^{-18 bytes gracias a Luis Mendo
-1 byte gracias a Jonathan Frech}

x=input()
i=0
while 1:print x[i];i-=~x[i]

Pruébalo en línea!

Retina , 36 bytes

El recuento de bytes asume la codificación ISO 8859-1.

.+
$*
((1)*¶)(?<-2>1*¶)*
$1
%M`.
0$

La entrada y la salida están separadas por salto de línea con un salto de línea final.

Pruébalo en línea! (Utiliza comas en lugar de avances de línea para permitir convenientes conjuntos de pruebas).

Brain-Flak , 64 bytes

([]){{}(({})<>)<>{({}[()]<{}>)}{}([])}{}<>([]){{}({}<>)<>([])}<>

Pruébalo en línea!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack

Mathematica, 64 50 bytes

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={}

C # (.NET Core) , 68 bytes

n=>{var t="";for(int i=0;i<n.Length;i+=n[i]+1)t+=n[i]+" ";return t;}

Pruébalo en línea!

Toma la entrada como una matriz de enteros, devuelve una cadena que contiene los valores no omitidos.

R, 58 bytes

f=function(x,p=1){cat(z<-x[p]);if(p+z<sum(x|1))f(x,p+z+1)}

Función recursiva. Toma un vector xcomo argumento e inicia un puntero p. Esto imprime la entrada correspondiente de x, comprueba si p+x[p]saldría de los límites y, si no, llama a la función para el nuevo puntero.

f=function(x,p=1,s=x[1])`if`((z<-x[p]+p+1)>sum(x|1),s,f(x,z,c(s,x[z])))

Esta es una solución comparable que devuelve un vector adecuado en lugar de imprimir los dígitos.

Java (OpenJDK 8) , 53 bytes

Gracias a @ PunPun1000 y @TheLethalCoder

a->{for(int n=0;;n+=1+a[n])System.out.println(a[n]);}

Pruébalo en línea!

Alice , 15 bytes

/$.. \h&
\I@nO/

Pruébalo en línea!

Entrada y salida de una lista de enteros decimales separados por salto de línea.

Explicación

/   Switch to Ordinal mode.
I   Read a line.
.   Duplicate it.
n   Logical NOT (gives truthy if we're at EOF).
/   Switch to Cardinal.
    The IP wraps around to the left.
\   Switch to Ordinal.
$@  Terminate the program if we're at EOF.
.   Duplicate the input line again.
O   Print it.
\   Switch to Cardinal.
h   Increment the value.
&   Store the result in the iterator queue.
    The program wraps around to the beginning.

El almacenamiento de un número entero n en la cola del iterador hace que el siguiente comando se ejecute n veces. Los espejos como /no son comandos, por lo que el siguiente comando sí lo será I. Por lo tanto, si solo leemos e imprimimos un valor x , leeremos los valores x + 1 en la próxima iteración, y el último de ellos terminará en la parte superior de la pila. Esto omite los elementos necesarios de la lista de números.

Mathematica , 37 (30?)

Más golfing del método fino de user202729.

±{a_,x___}={a}~Join~±{x}~Drop~a
±_={}

Las reglas no parecen especificar explícitamente el formato de salida, así que tal vez:

±{a_,x___}=a.±{x}~Drop~a
±_={}

La salida para la segunda función se ve así: 0.2.4.{}- notablemente {}aún se devuelve para un conjunto vacío, conforme a la regla final.

Lisp común, 51 bytes

(do((x(read)(nthcdr(1+(print(car x)))x)))((not x)))

Pruébalo en línea!

Brain-Flak , 64 60 bytes

Ahorro de 4 bytes basado en una idea de 0 '

([]){{}(({})<>())<>{({}[()]<{}>)}{}([])}{}<>{({}[()]<>)<>}<>

Pruébalo en línea!

Anotado

([]){{}            #{Until the stack is empty}
  (({})<>())<>     #{Put n+1 to the offstack}
  {({}[()]<{}>)}{} #{Remove n items from the top}
([])}{}            #{End until}
<>                 #{Swap stacks}
{({}[()]<>)<>}<>   #{Move everything back onto the left stack decrementing by 1}

Rubí, 36 33 31

f=->l{a,*l=l;a&&f[l.drop(p a)]}

Pruébalo en línea.

Python 2.4, 85 bytes

No hay posibilidad de ganar en Python con él, pero me encantan los oneliners y este podría ser interesante para los demás.
Resulta que hay un truco mágico elegante para acceder a la lista de construcción dentro de la comprensión, pero funciona solo en 2.4 y con algunas ediciones en <= 2.3
locals()['_[1]']lo es. Python crea un nombre secreto _[1]para la lista, mientras se crea y lo almacena locals. También los nombres _[2], _[3]... se usan para listas anidadas.

lambda n:[j for i,j in enumerate(n)if i==len(locals()['_[1]'])+sum(locals()['_[1]'])]

Por lo tanto, cuenta el número de elementos ya agregados más su suma. El resultado es el índice del siguiente elemento deseado.
Creo que debería haber una manera de evitar la enumeración. Al igual que el acceso a la matriz de entrada directamente por índice: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Pero no puedo encontrar una forma compacta de protegerlo del índice fuera de rango (mientras lo mantengo en línea)

Swift, 63 bytes

func a(d:[Int]){var i=0;while i<d.count{print(d[i]);i+=d[i]+1}}

Esta es mi primera entrada, así que no estoy 100% seguro de las reglas, pero espero que esta respuesta sea suficiente. No estoy seguro de las reglas sobre cómo obtener la entrada en un sistema. Tengo una respuesta más corta si se me permitió asumir una función en algún lugar que pueda devolver la entrada.

Perl 6 , 31 bytes

{(@_,{.[1+.[0]..*]}...^0)[*;0]}

Pruébalo

Expandido:

{  # bare block lambda with implicit parameter ｢@_｣
  (
    # generate a sequence

    @_,

    {
      .[ # index into previous value in the sequence
        1 + .[0]  # start by skipping one plus the first element
                  # of the previous value in the sequence
        ..  *     # use that to create a Range with no end
      ]
    }

    ...^  # keep doing that until: (and throw away last value)
    0     # it generates an empty list

  )[ *; 0 ]  # from every value in the sequence, get the first element
}

Para ayudar a comprender cómo funciona el código, sin [*;0]esto se generaría una secuencia como la siguiente:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2],
   (1, 0, 2, 5, 1, 3, 1, 6, 2),
         (2, 5, 1, 3, 1, 6, 2),
                  (3, 1, 6, 2)

Jalea , 8 bytes

ḢṄ‘ṫ@µL¿

Un programa completo que imprime los resultados, seguido de una nueva línea (la lista vacía no produce resultados).

Pruébalo en línea!

¿Cómo?

ḢṄ‘ṫ@µL¿ - Main link: list of non-negative integers  e.g. [2,5,4,0,1,2,0]
       ¿ - while:           Iteration:  1                  2             3          4        5
      L  -   length (0 is falsey)       7                  4             3          1        0
     µ   - ...do:                                                                            stop
Ḣ        -   head (pop & modify)        2 ([5,4,0,1,2,0])  0 ([1,2,0])   1 ([2,0])  0 ([0])
 Ṅ       -   print it (and yield it)   "2\n"              "0\n"         "1\n"      "0\n"
  ‘      -   increment                  3                  1             2          1
   ṫ@    -   tail from index            [0,1,2,0]          [1,2,0]      [0]         []
         -
         -                       i.e. a resulting in the printing of: '''2
                                                                         0
                                                                         1
                                                                         0
                                                                         '''

Python 3 , 35 bytes

f=lambda h=0,*t:t and[h,*f(*t[h:])]

Pruébalo en línea!

Ejecútelo con f(*l)dónde lestá su entrada. Podría decirse que estira las reglas de entrada, pero me encanta el desempaque avanzado.

APL (Dyalog Unicode) , ^{SBCS de} 20 bytes

{⍵≡⍬:⍬⋄(⊃,∘∇1↓⊃↓⊢)⍵}

Pruébalo en línea!

Perl 5 , 36 30 + 1 (-a) = 31 bytes

$i+=$F[$i]+say$F[$i]while$i<@F

Pruébalo en línea!

Toma su entrada como una lista de números separados por espacios.

PowerShell , 25 bytes

$args|?{!$s--}|%{($s=$_)}

Pruébalo en línea!