Dato un elenco di numeri interi non negativi in ​​qualsiasi formato ragionevole, passa su di esso, saltando tutti gli elementi quanti ne dice ogni numero intero su cui passi.

Ecco un esempio funzionante:

[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 altro esempio funzionante, non così tutti uguali:

[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 esempio fuori limite:

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

Regole

• Non puoi usare trucchi noiosi tra questi , rendono la sfida noiosa e poco interessante.
• Dovresti solo restituire / stampare il risultato finale. L'output STDERR viene ignorato.
• Non è possibile ottenere l'input come una stringa di cifre in nessuna base (ad es. "0102513162" per il primo caso).
• È necessario utilizzare l'ordine da sinistra a destra per l'input.
• Come negli esempi lavorati, se esci dai limiti, l'esecuzione termina come se fosse diversamente.
• Dovresti usare 0per saltare 0 elementi.
• Dato l'elenco vuoto ( []) come input, è necessario tornare [].

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

Questo è code-golf , quindi vince la risposta più breve!

Python 2 , 36 byte

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

Provalo online!

Python 2 , 49 44 * 41 byte

^{Cancellato 44 è ancora regolare 44 :(}

* -3 grazie solo a @ ASCII .

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

Provalo online!

Stampa i risultati separati da una nuova riga, come consentito dall'OP nella chat. Non penso che possa diventare più breve come programma completo non ricorsivo .

Come funziona?

• l=input() - Legge l'elenco dall'input standard.

• while l: - Abusa del fatto che gli elenchi vuoti siano falsi in Python, scorre fino a quando l'elenco è vuoto.

• print l[0]; - Stampa il primo elemento dell'elenco.

• l=l[l[0]+1:]- "Salta come un coniglio" - Taglia il primo l[0]+1dall'elenco.

Facciamo un esempio

Dato l'elenco [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]come input, il codice esegue quanto segue (secondo la spiegazione sopra): stampa il primo elemento dell'array:5 , tagliare il primo 6: [2, 1, 2, 1, 0, 0]. Abbiamo poi stampiamo 2e tagliare i primi 3: [1,0,0]. Allo stesso modo, produciamo 1, ritagliamo i primi 2 e otteniamo [0]. Naturalmente, 0viene stampato e il programma termina.

Haskell, 29 27 26 byte

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

Salvato 1 byte grazie a Zgarb.

Provalo online.

JavaScript (ES6), 42 39 35 byte

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]

Vecchia soluzione 39 byte

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

-3 byte grazie a @ThePirateBay

05AB1E , 10 9 byte

[¬Dg>#=ƒ¦

Utilizza la codifica 05AB1E . Provalo online!

Mathematica, 46 44 byte

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

alternative:

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

C #, 68 byte

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

Provalo online!

Versione completa / formattata:

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

La restituzione di un elenco è più lunga a 107 byte.

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

Buccia , 8 6 byte

←TU¡Γ↓

Provalo online!

-2 byte (e un'idea di soluzione completamente nuova) grazie a Leo!

Spiegazione

Sto usando la funzione match pattern list Γ. Prende una funzione fe un elenco con testa xe coda xse si applica fa xe xs. Se l'elenco è vuoto, Γrestituisce un valore predefinito coerente con il suo tipo, in questo caso un elenco vuoto. Riteniamo fdi essere ↓, da cui gli xelementi cadono xs. Questa funzione viene quindi ripetuta e gli elementi risultanti vengono raccolti in un elenco.

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

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

Provalo online!

Pyth, 22 byte

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

Rimosso un byte inutile

Python 2 , 60 42 41 byte

^{-18 bytes thanks to Luis Mendo
-1 byte thanks to Jonathan Frech}

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

Try it online!

Retina, 36 bytes

Byte count assumes ISO 8859-1 encoding.

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

Input and output are linefeed-separated with a trailing linefeed.

Try it online! (Uses commas instead of linefeeds to allow for convenient test suites.)

Brain-Flak, 64 bytes

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

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

Try it online!

Takes input as an array of integers, returns a string containing the non-skipped values.

R, 58 bytes

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

Recursive function. Takes a vector x as argument and intiates a pointer p. This prints the corresponding entry of x, checks if p+x[p] would go out of bounds, and if not, calls the function for the new pointer.

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

This is a comparable solution that returns a proper vector instead of printing the digits.

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!