37
\$\begingroup\$

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 , so shortest answer wins!

\$\endgroup\$
  • 1
    \$\begingroup\$ Is it okay to have trailing zeros in my array? would save me ~18 bytes \$\endgroup\$ – Roman Gräf Jul 28 '17 at 11:15
  • \$\begingroup\$ @EriktheOutgolfer Could we output a string array and have trailing empty strings? \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 11:17
  • \$\begingroup\$ @TheLethalCoder Sorry I'd say no since that's not reasonable imo...can't you just remove trailing ""s? \$\endgroup\$ – Erik the Outgolfer Jul 28 '17 at 11:25
  • 1
    \$\begingroup\$ @RomanGräf Sorry but no, that would be too ambiguous since there are cases you should have trailing 0s in the output. \$\endgroup\$ – Erik the Outgolfer Jul 28 '17 at 11:25

38 Answers 38

14
\$\begingroup\$

Python 2, 36 bytes

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ I was expecting to get outgolfed, but not that badly :) \$\endgroup\$ – Mr. Xcoder Jul 28 '17 at 11:31
  • \$\begingroup\$ Can't you do x[0] instead of x[:1]? \$\endgroup\$ – Erik the Outgolfer Jul 28 '17 at 11:32
  • \$\begingroup\$ @EriktheOutgolfer yes, but it need to be a list, so it would be [x[0]] \$\endgroup\$ – Rod Jul 28 '17 at 11:32
  • \$\begingroup\$ @Rod You're not saving any bytes with x[:1] anyways...f=lambda x:x and[x[0]]+f(x[x[0]+1:]) \$\endgroup\$ – Erik the Outgolfer Jul 28 '17 at 11:33
13
\$\begingroup\$

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.

\$\endgroup\$
11
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ f x=x on the second line saves a byte. \$\endgroup\$ – Zgarb Jul 28 '17 at 12:27
8
\$\begingroup\$

05AB1E, 10 9 bytes

[¬Dg>#=ƒ¦

Uses the 05AB1E encoding. Try it online!

\$\endgroup\$
  • \$\begingroup\$ Yeah, that is way better than what I was thinking. \$\endgroup\$ – Magic Octopus Urn Jul 28 '17 at 13:57
8
\$\begingroup\$

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]&
\$\endgroup\$
8
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ 39 bytes a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r \$\endgroup\$ – user72349 Jul 28 '17 at 11:47
7
\$\begingroup\$

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;}
\$\endgroup\$
  • 2
    \$\begingroup\$ Why has someone downvoted this? \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 15:15
  • \$\begingroup\$ To round your score and make a perfect 5k? \$\endgroup\$ – Thomas Ayoub Jul 31 '17 at 10:13
  • \$\begingroup\$ @ThomasAyoub We can only assume it was someone with OCD yes. \$\endgroup\$ – TheLethalCoder Jul 31 '17 at 10:20
6
\$\begingroup\$

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]
\$\endgroup\$
  • \$\begingroup\$ You can drop the default value of ø, and everything will still magically work :) \$\endgroup\$ – Leo Jul 28 '17 at 13:36
  • \$\begingroup\$ Or, for even less bytes, tio.run/##yygtzv7//1HbhJDQQwvPTX7UNvn////RBjpGOiBsomOoYxQLAA \$\endgroup\$ – Leo Jul 28 '17 at 15:34
  • \$\begingroup\$ @Leo Oh wow, that's clever! \$\endgroup\$ – Zgarb Jul 28 '17 at 17:32
  • \$\begingroup\$ Why did you CW this? \$\endgroup\$ – Erik the Outgolfer Jul 28 '17 at 17:36
  • \$\begingroup\$ @ErikTheOutgolfer That was a mistake (I'm on my phone and apparently pushed something by accident). I'm trying to undo it... \$\endgroup\$ – Zgarb Jul 28 '17 at 17:42
5
\$\begingroup\$

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!

\$\endgroup\$
  • 1
    \$\begingroup\$ You can use l[i:i+l[i-1]]=[] instead del l[i:i+l[i-1]] to save a byte \$\endgroup\$ – Rod Jul 28 '17 at 11:11
  • 1
    \$\begingroup\$ 56 bytes \$\endgroup\$ – ASCII-only Jul 28 '17 at 11:18
5
\$\begingroup\$

Pyth, 22 Bytes

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

Removed a useless byte

\$\endgroup\$
  • \$\begingroup\$ I see 23 bytes there. \$\endgroup\$ – Erik the Outgolfer Jul 28 '17 at 13:16
  • \$\begingroup\$ Typo :) sorry... \$\endgroup\$ – Dave Jul 28 '17 at 13:17
  • 3
    \$\begingroup\$ I'm not sure why you have a down vote. There is a possibility that when you edited fixing your answer this triggered an "automatic down vote". The reasons for this automatic downvote are confusing and terrible but it happens if the system considers your answer to be "low quality" based on it heuristics. Its also possible that someone didn't like your answer, but I don't see anything wrong with it at the moment so I'm not sure why that would be the case. \$\endgroup\$ – Sriotchilism O'Zaic Jul 28 '17 at 13:23
  • \$\begingroup\$ I'm glad you're using Pyth! \$\endgroup\$ – isaacg Jul 31 '17 at 3:01
4
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ i-=~x[i] is one byte shorter than i+=1+x[i]. \$\endgroup\$ – Jonathan Frech Oct 4 '17 at 17:15
3
\$\begingroup\$

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

\$\endgroup\$
3
\$\begingroup\$

Brain-Flak, 64 bytes

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

Try it online!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack
\$\endgroup\$
  • 7
    \$\begingroup\$ Holy crap! I wrote up a solution, and then scrolled down to post it, but it turns out we wrote the exact same solution byte-for-byte! Even minor details like ({}[()]<{}>) vs ({}<{}>[()]) were the same! What a coincidence! \$\endgroup\$ – DJMcMayhem Jul 28 '17 at 16:54
  • \$\begingroup\$ @DJMcMayhem stealing all the fame XD \$\endgroup\$ – Christopher Jul 28 '17 at 17:08
  • \$\begingroup\$ I also made a byte for byte identical solution, but I golfed it down 4 bytes. Just some delayed competition :) \$\endgroup\$ – Sriotchilism O'Zaic Oct 5 '17 at 4:21
2
\$\begingroup\$

Mathematica, 64 50 bytes

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={}
\$\endgroup\$
  • \$\begingroup\$ I couldn't resist further golfing this neat code; my answer is below. \$\endgroup\$ – Mr.Wizard Jul 28 '17 at 18:29
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Nice way to do it and comes in at the same count as printing. \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 11:49
  • \$\begingroup\$ I love the simple solutions. Still gotta learn LINQ though, as I have seen that shorten so many c# lambdas.. \$\endgroup\$ – jkelm Jul 28 '17 at 11:52
  • \$\begingroup\$ Shortens it because you can implicit return most of the time. Though it is a toss up between implicit return with using System.Linq; and a normal loop. \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 11:54
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ what about an input of numeric(0)? aka empty array. \$\endgroup\$ – Giuseppe Jul 28 '17 at 17:23
  • \$\begingroup\$ @Giuseppe I'll take a look at it when I'm behind my pc \$\endgroup\$ – JAD Jul 28 '17 at 17:35
  • \$\begingroup\$ 55 bytes \$\endgroup\$ – Giuseppe Oct 4 '17 at 17:24
2
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ Would printing the results, like in my C# answer, save you anything? \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 11:42
  • \$\begingroup\$ @TheLethalCoder Ill try \$\endgroup\$ – Roman Gräf Jul 28 '17 at 11:43
  • \$\begingroup\$ Can you save a byte by moving n into the loop? \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 12:45
  • \$\begingroup\$ Plus this doesn't seem to work at the moment. \$\endgroup\$ – TheLethalCoder Jul 28 '17 at 12:46
  • \$\begingroup\$ You're missing a paren after the (a[n+=1+a[n]]. Function also throws an error after outputting the correct value, I don't know the concensus on whether this is allowed or not (the question does say anything to standard error is ignore). If that was the intention, then you can remove the n<a.length in the for loop. Finally the TIO code doesn't run as is, even with the paren. The function should be a Consumer<int[]> and use func.accept(test) \$\endgroup\$ – PunPun1000 Jul 28 '17 at 12:46
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ ±Drop[{x},a] can be ±{x}~Drop~a because ± has a lower precedence than Infix. \$\endgroup\$ – JungHwan Min Jul 28 '17 at 19:08
  • \$\begingroup\$ @JungHwanMin I missed that; thanks! \$\endgroup\$ – Mr.Wizard Jul 28 '17 at 19:13
2
\$\begingroup\$

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}
\$\endgroup\$
1
\$\begingroup\$

Ruby, 36 33 31

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

Try it online.

\$\endgroup\$
  • \$\begingroup\$ You're allowed to subtract the f= as a header element. \$\endgroup\$ – sethrin Jul 30 '17 at 2:39
  • \$\begingroup\$ @sethrin Even if I need to call it recursively? \$\endgroup\$ – Cristian Lupascu Jul 30 '17 at 5:42
  • \$\begingroup\$ Hmm, good question. I suppose not. I did very much like that about your solution, by the way. \$\endgroup\$ – sethrin Jul 30 '17 at 12:01
1
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! The default rules are that you can either have code that works as a full program, so input (usually) in STDIN and output (usually) to STDOUT, or a function, so input (usually) from function parameters and output (usually) from function return. \$\endgroup\$ – Stephen Jul 28 '17 at 12:53
  • \$\begingroup\$ @StepHen - thanks! I guess that makes my other version invalid then. Looking forward to contributing more! \$\endgroup\$ – AnonymousReality Jul 28 '17 at 14:28
1
\$\begingroup\$

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)
\$\endgroup\$
1
\$\begingroup\$

Common Lisp, 51 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

C++ (gcc), 172 bytes

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

\$\endgroup\$
  • \$\begingroup\$ You can also print the numbers separated by a no-digit separator, no need for [] and you can have empty output for that edge-case, and no need for (c/91?"":" "). You don't have to match the format of the examples in the challenge. \$\endgroup\$ – Erik the Outgolfer Jul 30 '17 at 7:52
1
\$\begingroup\$

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
                                                                         '''
\$\endgroup\$
  • \$\begingroup\$ Finally a Jelly answer! BTW I can do it in 7 bytes. \$\endgroup\$ – Erik the Outgolfer Jul 30 '17 at 7:30
  • \$\begingroup\$ And I also have a list-returning function in 18 bytes. \$\endgroup\$ – Erik the Outgolfer Jul 30 '17 at 7:49
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

APL (Dyalog Unicode), 20 bytesSBCS

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ The way you use that tacit function inside the dfn is creative. \$\endgroup\$ – Erik the Outgolfer Feb 3 '18 at 20:29
0
\$\begingroup\$

Mathematica, 65 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

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

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.