Skip like a rabbit!

Question

Given a list of non-negative integers in any reasonable format, iterate over it, skipping as many elements as every integer you step on says.

---

Here is a worked example:

[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

Another worked example, not so all-equal-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

An out-of-bounds example:

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

---

Rules

• You may not use any boring cheat among these ones, they make the challenge boring and uninteresting.
• You should only return/print the final result. STDERR output is ignored.
• You may not get the input as a string of digits in any base (e.g. "0102513162" for the first case).
• You must use left-to-right order for input.
• As in the worked examples, if you go out of bounds, execution terminates as if otherwise.
• You should use 0 for skipping 0 elements.
• Given the empty list ([]) as input, you should return [].

---

Test cases

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

This is code-golf, so shortest answer wins!

Answer 1

Python 2, 36 bytes

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

Try it online!

Answer 2

Python 2, 49 44* 41 bytes

^{Crossed out 44 is still regular 44 :(}

* -3 thanks to @ASCII-only.

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

Try it online!

Prints the results separated by a newline, as the OP allowed in chat. I don't think it can get any shorter as a non-recursive full program.

---

How does this work?

• l=input() - Reads the list from the standard input.

• while l: - Abuses the fact that empty lists are falsy in Python, loops until the list is empty.

• print l[0]; - Prints the first element of the list.

• l=l[l[0]+1:] - "Skips like a rabbit" - Trims the first l[0]+1 from the list.

Let's take an example

Given the list [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0] as input, the code performs the following (according to the explanation above) - Prints the first item of the array: 5, trim the first 6: [2, 1, 2, 1, 0, 0]. We then print 2 and trim the first 3: [1,0,0]. Likewise, we output 1, crop the first 2, and we get [0]. Of course, 0 is printed and the program terminates.

Answer 3

Haskell, 29 27 26 bytes

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

Saved 1 byte thanks to Zgarb.

Try it online.

Answer 4

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]

Old Solution 39 Bytes

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

-3 bytes thanks to @ThePirateBay

Answer 5

05AB1E, 10 9 bytes

[¬Dg>#=ƒ¦

Uses the 05AB1E encoding. Try it online!

Answer 6

Mathematica, 46 44 bytes

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

Answer 7

C#, 68 bytes

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

Try it online!

Full/Formatted version:

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

---

Returning a list is longer at 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;}

Answer 8

Husk, 8 6 bytes

←TU¡Γ↓

Try it online!

-2 bytes (and a completely new solution idea) thanks to Leo!

Explanation

I'm using the list pattern match function Γ. It takes a function f and a list with head x and tail xs, and applies f to x and xs. If the list is empty, Γ returns a default value consistent with its type, in this case an empty list. We take f to be ↓, which drops x elements from xs. This function is then iterated and the resulting elements are collected in a list.

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

Answer 9

Python 2, 59 55 bytes

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

Try it online!

Answer 10

Pyth, 22 Bytes

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

Removed a useless byte

Answer 11

Python 2, 60 42 41 bytes

^{-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!

Answer 12

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

Answer 13

Brain-Flak, 64 bytes

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

Try it online!

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

Answer 14

Mathematica, 64 50 bytes

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

Answer 15

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!

Answer 16

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.

Answer 17

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.

Answer 18

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.

Answer 19

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.

Answer 20

Common Lisp, 51 bytes

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

Try it online!

Answer 21

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}

Answer 22

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)

Answer 23

Ruby, 36 33 31

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

Try it online.

Answer 24

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.

Answer 25

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.

Answer 26

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)

Answer 27

C++ (gcc), 172 bytes

(for 144 bytes see @ceilingcat comment)

#include<iostream>
int main(){std::istream& i=std::cin;char c;int a,b;while(i>>c&&i>>a){std::cout<<c<<(c/91?"":" ")<<a;while(a--&&i>>c&&i>>b);}std::cout<<c<<(c/93?"":"]");}

Try it online

The awful (c/91?"":" ") is for correct spacing in output. Without it (-15 bytes) output is in form: [0,2,4], when I change it to simple " " (-9 bytes) output is like [ 0, 2, 4] (additional space at the beginning).

<<(c/93?"":"]") on the end is only to handle [] empty input corner case

Prints no trailing endline.

Answer 28

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

Answer 29

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.

Answer 30

APL (Dyalog Unicode), 20 bytes^SBCS

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

Try it online!

Answer 31

PowerShell, 25 bytes

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

Try it online!

Answer 32

Mathematica, 65 bytes

(s=#;t=1;w={};While[t<=Length@s,AppendTo[w,k=s[[t]]];t=t+k+1];w)&

Try it online!

Answer 33

Clojure, 67 bytes

#(nth(reduce(fn[[z k]b](if(= z 0)[b(conj k b)][(- z 1)k]))[0[]]%)1)

Starts with the initial parameters [0 []], where 0 is the counter and [] is the result. If the first element in this list is 0 appends item n from the argument to the result and passes further this list [n [... n]] otherwise decrements the first element. (this explanation feels horrible to me)

See it online

Answer 34

Batch, 69 bytes

:l
@if not "%1"=="" echo %1&(for /l %%i in (0,1,%1)do @shift)&goto l

(I need the ()s around the for otherwise the goto happens inside the loop.)

Answer 35

C (gcc), 100 96 93 90 65 61 58 bytes

s;main(d){while(scanf("%d",&d)>0)s--||printf("%d\n",s=d);}

Try it online!

• recursive main() saves a few bytes, yay!
• indexing into string saves another 3 bytes

• relaxing the output format saves a whole lot of bytes (25 to be exact), see here the shortest version with nice list-style output (90 bytes):

  s;d;main(p){scanf("%*c %d",&d)>0?s--||printf(p?"[%d":", %d",s=d),main(0):printf("[]"+!p);}
  

• a different input format (1 number per line) saves another 4 bytes

• Now it's shorter without recursion

Answer 36

Perl 6, 33 bytes

my&f={$_&&(.[0],|f .[.[0]+1..*])}

Try it online!

Answer 37

Cubix, 24 bytes

U.;@I)!/(O?vL!(.;I<.oWSL

Try it online!

Takes input as a comma- (or whitespace-) separated list with a -1 at the end to signify end of input.

I expect there's some golfing to do here.

Expands to the following cube:

    U .
    ; @
I ) ! / ( O ? v
L ! ( . ; I < .
    o W
    S L

Algorithm is in two parts:

• I) : read in an input, increment it.
• !/ : If zero (i.e., input is -1), turn left to @ and end program, otherwise proceed
• (O : decrement and output as a number
• ? : if zero, go straight, if positive, turn right.

Positive case:

• <I : go right and read in input
• ;( : pop TOS and decrement TOS
• !L : skip L (turn left) if TOS is nonzero
• wrap around to <I again
• otherwise we hit SLWo(!;U which is the same as the zero case.

Zero case:

• vS : go down, push 32 (space character)
• o( : output as a character, decrement
• !; : (no ops)
• U : re-enter main loop, I)!/ etc.

Answer 38

Jelly, 7 bytes

ḊḢṄ$¡¹¿

Try it online!

Since nobody has discovered this yet (I challenged Jonathan Allan a long time ago), I am posting it.

Jelly, 12 bytes

Ḋ1ị$‘$¡ÐĿṖḢ€

Try it online!

I had 18 bytes back then (can't remember the exact code), but now I managed to make a list-returning version in 12 bytes.

Answer 39

PHP, 74 bytes

function s($l){$k=0;while(isset($l[$k]))$k+=($r[]=$l[$k])+1;return$r?:[];}

Try it online!

Answer 40

PowerShell, 57 50 bytes

^{-7 bytes thanks to mazzy}

param($l)for(;$i-lt$l.count){($z=$l[$i++]);$i+=$z}

Try it online!

Simple for-loop approach that does alright.

Answer 41

Japt, 5 bytes

Modifies the input array in place.

£jYÄX

Try it - Footer outputs the original array

Answer 42

Javascript 2019, 43 42 chars

a=>a.flatMap(x=>i^q++?[]:(i+=x+1,x),i=q=0)

Test:

f=a=>a.flatMap(x=>i^q++?[]:(i+=x+1,x),i=q=0)

console.log(
`[]                                                    => []
[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]`
.split`
`.map(s=>s.split`=>`)
.map(([s,key])=>f(eval(s))==""+eval(key))
)

Answer 43

Runic Enchantments, 25 bytes

>Ri:$' $\
~/i~1-!;R:0)2*?

Try it online!

But input and output are space-separated integer lists. There is a trailing space because the logic to check to see if any input was actually read is a pain (and about 7 bytes) and not strictly needed for processing of this sort.

Answer 44

Stax, 5 bytes

√⌡╜9{

Run and debug it

Answer 45

PHP, 66 bytes

function($a){for(;$x<count($a);$x+=$o[]=$a[$x++|0]);return$o?:[];}

Try it online!

Output:

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