Avec une liste d'entiers non négatifs dans n'importe quel format raisonnable, parcourez-la en ignorant autant d'éléments que chaque nombre entier indiqué.

Voici un exemple travaillé:

[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

Un autre exemple travaillé, pas si égal à tous les deltas:

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

Règles

• Vous ne pouvez utiliser aucune astuce ennuyeuse parmi celles-ci , elles rendent le défi ennuyeux et sans intérêt.
• Vous devez uniquement renvoyer / imprimer le résultat final. La sortie STDERR est ignorée.
• Vous ne pouvez pas obtenir l'entrée sous forme de chaîne de chiffres dans aucune base (par exemple, "0102513162" pour le premier cas).
• Vous devez utiliser un ordre de gauche à droite pour la saisie.
• Comme dans les exemples travaillés, si vous sortez des limites, l'exécution se termine comme si c'était le cas.
• Vous devriez utiliser 0pour sauter 0 éléments.
• Étant donné la liste vide ( []) en entrée, vous devriez retourner [].

Cas de test

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

C'est du code-golf , alors la réponse la plus courte gagne!

Python 2 , 36 octets

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

Essayez-le en ligne!

Python 2 , 49 44 * 41 octets

^{44 barré est encore régulier 44 :(}

* -3 grâce à @ ASCII uniquement .

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

Essayez-le en ligne!

Imprime les résultats séparés par une nouvelle ligne, comme l'OP autorisé dans le chat. Je ne pense pas qu'il puisse être plus court en tant que programme complet non récursif .

Comment cela marche-t-il?

• l=input() - Lit la liste à partir de l'entrée standard.

• while l: - Abuse du fait que les listes vides sont faussées en Python, boucle jusqu'à ce que la liste soit vide.

• print l[0]; - Imprime le premier élément de la liste.

• l=l[l[0]+1:]- "Saute comme un lapin" - Coupe le premier l[0]+1de la liste.

Prenons un exemple

Compte tenu de la liste [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]comme entrée, le code effectue les opérations suivantes (selon la définition ci - dessus) - imprime le premier élément de la matrice: 5, couper la première 6: [2, 1, 2, 1, 0, 0]. Nous avons ensuite imprimer 2et couper les 3 premiers: [1,0,0]. De même, nous produisons 1, coupons les 2 premiers et nous obtenons [0]. Bien sûr, 0est imprimé et le programme se termine.

Haskell, 29 27 26 octets

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

Enregistré 1 octet grâce à Zgarb.

Essayez-le en ligne.

JavaScript (ES6), 42 39 35 octets

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]

Ancienne solution 39 octets

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

-3 octets grâce à @ThePirateBay

05AB1E , 10 9 octets

[¬Dg>#=ƒ¦

Utilise le codage 05AB1E . Essayez-le en ligne!

Mathematica, 46 44 octets

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

Alternatives:

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

C #, 68 octets

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

Essayez-le en ligne!

Version complète / formatée:

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

Le renvoi d'une liste est plus long à 107 octets.

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

Husk , 8 à 6 octets

←TU¡Γ↓

Essayez-le en ligne!

-2 octets (et une idée de solution totalement nouvelle) grâce à Leo!

Explication

J'utilise la fonction de correspondance de modèle de liste Γ. Il prend une fonction fet une liste avec tête xet queue xs, et s'applique fà xet xs. Si la liste est vide, Γrenvoie une valeur par défaut cohérente avec son type, dans ce cas une liste vide. Nous prenons fpour être ↓, ce qui laisse tomber des xéléments de xs. Cette fonction est ensuite itérée et les éléments résultants sont rassemblés dans une liste.

←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 octets

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

Essayez-le en ligne!

Pyth, 22 octets

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

Suppression d'un octet inutile

Python 2 , 60 42 41 octets

^{-18 octets grâce à Luis Mendo
-1 octets grâce à Jonathan Frech}

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

Essayez-le en ligne!

Retina , 36 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Les entrées et les sorties sont séparées par des sauts de ligne.

Essayez-le en ligne! (Utilise des virgules au lieu de sauts de ligne pour permettre des suites de tests pratiques.)

Brain-Flak , 64 octets

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

Essayez-le en ligne!

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

Mathematica, 64 50 octets

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

C # (.NET Core) , 68 octets

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

Essayez-le en ligne!

Prend l'entrée en tant que tableau d'entiers, retourne une chaîne contenant les valeurs non ignorées.

R, 58 octets

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

Fonction récursive. Prend un vecteur xcomme argument et introduit un pointeur p. Ceci affiche l’entrée correspondante de x, vérifie si p+x[p]les limites sont dépassées et, dans le cas contraire, appelle la fonction pour le nouveau pointeur.

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

C'est une solution comparable qui renvoie un vecteur correct au lieu d'imprimer les chiffres.

Java (OpenJDK 8), 53 bytes

Thanks to @PunPun1000 and @TheLethalCoder

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

Try it online!

Alice, 15 bytes

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

Try it online!

Input and output a linefeed-separated lists of decimal integers.

Explanation

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

Storing an integer n in the iterator queue causes the next command to be executed n times. Mirrors like / are not commands, so the next command will be I. Therefore if we just read and printed a value x, we will read x+1 values on the next iteration, with the last of them ending up on top of the stack. This skips the required number list elements.

Mathematica, 37 (30?)

Further golfing of user202729's fine method.

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

The rules don't seem to explicitly specify the output format, so maybe:

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

Output for the second function looks like: 0.2.4.{} — notably {} is still returned for an empty set, conforming to the final rule.

Common Lisp, 51 bytes

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

Try it online!

Brain-Flak, 64 60 bytes

4 bytes save based on an idea from 0 '

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

Try it online!

Annotated

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

Try it online.

Python 2.4, 85 bytes

No chance to win in python with it, but I love oneliners and this one might be interesting to others.
Turns out, there is a fancy magic trick to access building list inside comprehension, but it works only in 2.4 and with some edits in <= 2.3
locals()['_[1]'] it is. Python creates secret name _[1] for list, while it is created and store it in locals. Also names _[2], _[3]... are used for nested lists.

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

So it counts number of already added elements plus their sum. Result is the index of next desired element.
I think, that there should be a way to avoid enumerate. Like accessing input array directly by index: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. But I can't figure out a compact way to protect it from index-out-of-range (while keeping it oneliner)

Swift, 63 bytes

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

This is my first entry, ever, so I'm not 100% sure on the rules, but hopefully this answer suffices. I'm a little unsure of rules on how to get the input into a system. I have a shorter answer if I was allowed to assume a function somewhere that can return the input.

Perl 6, 31 bytes

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

Test it

Expanded:

{  # 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
}

To help understand how the code works, without [*;0] this would generate a sequence like the following:

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

Jelly, 8 bytes

ḢṄ‘ṫ@µL¿

A full program printing the results each followed by a newline (empty list produces no output).

Try it online!

How?

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

Try it online!

Run it with f(*l) where l is your input. Arguably stretching the rules for input, but I just love advanced unpacking.

APL (Dyalog Unicode), 20 bytes^SBCS

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

Try it online!

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

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

Try it online!

Takes its input as a space separated list of numbers.

PowerShell, 25 bytes

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

Try it online!