Dada uma lista de números inteiros não negativos em qualquer formato razoável, itere sobre ele, ignorando tantos elementos quanto todo número em que você pisar diz.

Aqui está um exemplo trabalhado:

[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

Outro exemplo funcionado, não tão deltas todos iguais:

[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

Um exemplo fora dos limites:

[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)

Regras

• Você não pode usar nenhum truque chato entre eles , eles tornam o desafio chato e desinteressante.
• Você só deve devolver / imprimir o resultado final. A saída STDERR é ignorada.
• Você não pode obter a entrada como uma sequência de dígitos em nenhuma base (por exemplo, "0102513162" para o primeiro caso).
• Você deve usar a ordem da esquerda para a direita para entrada.
• Como nos exemplos trabalhados, se você sair dos limites, a execução será encerrada como se não fosse o caso.
• Você deve usar 0para pular 0 elementos.
• Dada a lista vazia ( []) como entrada, você deve retornar [].

Casos de teste

[]                                                     => []
[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]

Isso é código-golfe , então a resposta mais curta vence!

Python 2 , 36 bytes

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

Experimente online!

Python 2 , 49 44 * 41 bytes

^{Riscado 44 ainda é regular 44 :(}

* -3 graças a @ ASCII-only .

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

Experimente online!

Imprime os resultados separados por uma nova linha, conforme o OP permitido no bate-papo. Eu não acho que possa ficar mais curto como um programa completo não recursivo .

Como é que isso funciona?

• l=input() - Lê a lista da entrada padrão.

• while l: - Abusa do fato de que listas vazias são falsas no Python, faz um loop até que a lista esteja vazia.

• print l[0]; - Imprime o primeiro elemento da lista.

• l=l[l[0]+1:]- "Salta como um coelho" - corta o primeiro l[0]+1da lista.

Vamos dar um exemplo

Dada a lista [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]como entrada, executa o código seguinte (de acordo com a explicação acima) - Imprime o primeiro item da matriz: 5, cortar o primeiro 6: [2, 1, 2, 1, 0, 0]. Em seguida, imprimir 2e cortar o primeiro 3: [1,0,0]. Da mesma forma, produzimos 1, cortamos os 2 primeiros e obtemos [0]. Obviamente, 0é impresso e o programa termina.

Haskell, 29 27 26 bytes

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

Guardado 1 byte graças ao Zgarb.

Experimente online.

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]

Solução antiga 39 bytes

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

-3 bytes graças a @ThePirateBay

05AB1E , 10 9 bytes

[¬Dg>#=ƒ¦

Usa a codificação 05AB1E . Experimente online!

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]+" ");}

Experimente online!

Versão completa / formatada:

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

O retorno de uma lista é maior em 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;}

Casca , 8 6 bytes

←TU¡Γ↓

Experimente online!

-2 bytes (e uma idéia de solução completamente nova) graças ao Leo!

Explicação

Estou usando a função de correspondência de padrão de lista Γ. É preciso uma função fe uma lista com cabeça xe cauda xse se aplica fa xe xs. Se a lista estiver vazia, Γretornará um valor padrão consistente com seu tipo, nesse caso, uma lista vazia. Tomamos fpara ser ↓, que elimina xelementos xs. Essa função é iterada e os elementos resultantes são coletados em uma 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

Experimente online!

Pyth, 22 bytes

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

Removido um byte inútil

Python 2 , 60 42 41 bytes

^{-18 bytes graças a Luis Mendo
-1 byte graças a Jonathan Frech}

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

Experimente online!

Retina , 36 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Entrada e saída são separadas por avanço de linha com um avanço de linha à direita.

Experimente online! (Usa vírgulas em vez de feeds de linha para permitir suítes de teste convenientes.)

Brain-Flak , 64 bytes

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

Experimente online!

([]){{}                          ([])}{}                         # 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;}

Experimente online!

Recebe a entrada como uma matriz de números inteiros, retorna uma sequência que contém os valores não ignorados.

R, 58 bytes

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

Função recursiva. Pega um vetor xcomo argumento e direciona um ponteiro p. Isso imprime a entrada correspondente de x, verifica se p+x[p]sairia dos limites e, se não, chama a função para o novo ponteiro.

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

Essa é uma solução comparável que retorna um vetor adequado em vez de imprimir os dígitos.

Java (OpenJDK 8) , 53 bytes

Obrigado a @ PunPun1000 e @TheLethalCoder

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

Experimente online!

Alice , 15 bytes

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

Experimente online!

Entrada e saída de listas separadas por avanço de linha de números inteiros decimais.

Explicação

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

Armazenar um número inteiro n na fila do iterador faz com que o próximo comando seja executado n vezes. Espelhos como /não são comandos, então o próximo comando será I. Portanto, se apenas lermos e imprimirmos um valor x , leremos valores x + 1 na próxima iteração, com o último deles terminando no topo da pilha. Isso pula os elementos da lista de números necessários.

Mathematica , 37 (30 anos)

Golfe adicional do método fino de user202729.

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

As regras não parecem especificar explicitamente o formato de saída, então talvez:

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

A saída para a segunda função se parece com: 0.2.4.{}- notavelmente {}ainda é retornada para um conjunto vazio, em conformidade com a regra final.

Lisp comum, 51 bytes

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

Experimente online!

Flacidez cerebral , 64 60 bytes

Economize 4 bytes com base em uma ideia de 0 '

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

Experimente online!

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}

Ruby, 36 33 31

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

Experimente online.

Python 2.4, 85 bytes

Não há chance de ganhar em python com ele, mas eu amo oneliners e este pode ser interessante para os outros.
Acontece que existe um truque de mágica para acessar a lista de construção dentro da compreensão, mas funciona apenas em 2.4 e com algumas edições em <= 2.3
locals()['_[1]']. O Python cria um nome secreto _[1]para a lista, enquanto é criado e o armazena locals. Também nomes _[2], _[3]... são usados ​​para listas aninhadas.

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

Portanto, conta o número de elementos já adicionados mais sua soma. Resultado é o índice do próximo elemento desejado.
Eu acho que deveria haver uma maneira de evitar enumerar. Como matriz de entrada aceder directamente por índice: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Mas não consigo descobrir uma maneira compacta de protegê-lo de um índice fora do intervalo (mantendo-o sempre alinhado)

Rápido, 63 bytes

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

Esta é a minha primeira entrada, portanto, não tenho 100% de certeza sobre as regras, mas espero que esta resposta seja suficiente. Estou um pouco inseguro de regras sobre como inserir a entrada em um sistema. Eu tenho uma resposta mais curta se me for permitido assumir uma função em algum lugar que possa retornar a entrada.

Perl 6 , 31 bytes

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

Teste-o

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 ajudar a entender como o código funciona, sem [*;0]isso, seria gerada uma sequência como a seguinte:

[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)

Geléia , 8 bytes

ḢṄ‘ṫ@µL¿

Um programa completo que imprime os resultados, cada um seguido por uma nova linha (a lista vazia não produz saída).

Experimente online!

Quão?

ḢṄ‘ṫ@µ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:])]

Experimente online!

Execute-o com f(*l)onde lestá sua entrada. Indiscutivelmente esticando as regras para entrada, mas eu adoro descompactar avançado.

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

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

Experimente online!

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

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

Experimente online!

Recebe sua entrada como uma lista de números separados por espaço.

PowerShell , 25 bytes

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

Experimente online!