Springe wie ein Hase!

41

Wenn Sie eine Liste nicht negativer Ganzzahlen in einem vernünftigen Format haben, iterieren Sie darüber und überspringen so viele Elemente wie jede Ganzzahl, auf die Sie treten.


Hier ist ein Beispiel:

[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

Ein anderes bearbeitetes Beispiel, nicht so alle gleichen 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

Ein Out-of-Bound-Beispiel:

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

Regeln

  • Sie dürfen keinen langweiligen Cheat unter diesen verwenden , sie machen die Herausforderung langweilig und uninteressant.
  • Sie sollten nur das Endergebnis zurücksenden / ausdrucken. STDERR-Ausgabe wird ignoriert.
  • Möglicherweise erhalten Sie die Eingabe in keiner Basis als Ziffernfolge (z. B. "0102513162" für den ersten Fall).
  • Sie müssen die Reihenfolge von links nach rechts für die Eingabe verwenden.
  • Wie in den Arbeitsbeispielen wird die Ausführung abgebrochen, wenn Sie die Grenzen überschreiten.
  • Sie sollten 0zum Überspringen von 0 Elementen verwenden.
  • Angesichts der leeren Liste ( []) als Eingabe sollten Sie zurückkehren [].

Testfälle

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

Das ist , also gewinnt die kürzeste Antwort!

Erik der Outgolfer
quelle
1
Ist es in Ordnung, nachgestellte Nullen in meinem Array zu haben? würde mich retten ~ 18 Bytes
Roman Gräf
@EriktheOutgolfer Könnten wir ein String-Array ausgeben und leere Strings nachziehen?
TheLethalCoder
1
@TheLethalCoder Sorry, ich würde nein sagen, da das imo nicht zumutbar ist ... kannst du nicht einfach nachfolgende ""s entfernen ?
Erik der Outgolfer
2
@ RomanGräf Sorry, aber nein, das wäre zu zweideutig, da es Fälle gibt, 0in denen die Ausgabe abschließende s enthalten sollte .
Erik der Outgolfer

Antworten:

14

Python 2 , 36 Bytes

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

Probieren Sie es online!

Stange
quelle
Ich hatte erwartet, outgolfed zu werden, aber nicht so schlimm :)
Mr. Xcoder
Kannst du nicht x[0]statt x[:1]?
Erik der Outgolfer
@EriktheOutgolfer ja, aber es muss eine Liste sein, also wäre es[x[0]]
Rod
@ Rod Sie speichern x[:1]sowieso keine Bytes ...f=lambda x:x and[x[0]]+f(x[x[0]+1:])
Erik der Outgolfer
13

Python 2 , 49 44 * 41 Bytes

Durchgestrichen 44 ist immer noch regulär 44 :(

* -3 dank nur @ ASCII .

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

Probieren Sie es online!

Druckt die Ergebnisse durch einen Zeilenumbruch getrennt aus, da das OP im Chat erlaubt ist. Ich denke nicht, dass es als nicht-rekursives Vollprogramm kürzer werden kann .


Wie funktioniert das?

  • l=input() - Liest die Liste aus der Standardeingabe.

  • while l: - Missbraucht die Tatsache, dass leere Listen in Python falsch sind. Schleifen, bis die Liste leer ist.

  • print l[0]; - Druckt das erste Element der Liste.

  • l=l[l[0]+1:]- "Springt wie ein Hase" - Schneidet den ersten l[0]+1aus der Liste.

Nehmen wir ein Beispiel

Angesichts der Liste [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]als Eingabe, die Code führt die folgenden (entsprechend der obigen Erläuterung) - Druckt das erste Element des Arrays: 5, schneiden die ersten 6: [2, 1, 2, 1, 0, 0]. Wir haben dann drucken 2und schneiden Sie die ersten 3: [1,0,0]. Ebenso geben wir aus 1, beschneiden die ersten 2 und wir erhalten [0]. Natürlich 0wird gedruckt und das Programm beendet.

Mr. Xcoder
quelle
46 Bytes
ASCII
11

Haskell, 29 27 26 Bytes

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

1 Byte dank Zgarb gespeichert.

Probieren Sie es online aus.

Cristian Lupascu
quelle
f x=xIn der zweiten Zeile wird ein Byte gespeichert.
Zgarb
9

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]

Alte Lösung 39 Bytes

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

-3 Bytes dank @ThePirateBay

Johan Karlsson
quelle
39 Bytesa=>a.map(n=>i--||r.push(i=n),r=i=[])&&r
8

Mathematica, 46 44 Bytes

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

Alternativen:

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

C #, 68 Bytes

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

Probieren Sie es online!

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

Das Zurückgeben einer Liste ist mit 107 Bytes länger.

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;}
DerLethalCoder
quelle
2
Warum hat jemand dies abgelehnt?
TheLethalCoder
Um deine Punktzahl zu runden und ein perfektes 5-km-Ergebnis zu erzielen?
Thomas Ayoub
@ThomasAyoub Wir können nur annehmen, dass es jemand mit OCD war, ja.
TheLethalCoder
6

Schale , 8 6 Bytes

←TU¡Γ↓

Probieren Sie es online!

-2 Bytes (und eine völlig neue Lösungsidee) dank Leo!

Erläuterung

Ich verwende die Listenmuster-Übereinstimmungsfunktion Γ. Es nimmt eine Funktion fund eine Liste mit Kopf xund Schwanz xsan und gilt ffür xund xs. Wenn die Liste leer ist, wird Γein dem Typ entsprechender Standardwert zurückgegeben, in diesem Fall eine leere Liste. Wir nehmen fan , dass xElemente aus fallen xs. Diese Funktion wird dann iteriert und die resultierenden Elemente werden in einer Liste gesammelt.

←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]
Zgarb
quelle
Sie können den Standardwert von ø löschen, und alles wird immer noch magisch funktionieren :)
Leo
@Leo Oh wow, das ist schlau!
Zgarb
Warum hast du das CW?
Erik der Outgolfer
@ErikTheOutgolfer Das war ein Fehler (ich bin auf meinem Handy und habe anscheinend aus Versehen etwas gedrückt). Ich versuche es rückgängig zu machen ...
Zgarb
5

Python 2 , 59 55 Bytes

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

Probieren Sie es online!

Arfie
quelle
1
Sie können l[i:i+l[i-1]]=[]stattdessen verwenden del l[i:i+l[i-1]], um ein Byte zu speichern
Rod
1
56 Bytes
ASCII
5

Pyth, 22 Bytes

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

Ein nutzloses Byte wurde entfernt

Dave
quelle
Ich sehe dort 23 Bytes.
Erik der Outgolfer
Tippfehler :) Entschuldigung ...
Dave
3
Ich bin mir nicht sicher, warum Sie abstimmen müssen. Es besteht die Möglichkeit, dass Sie bei der Bearbeitung Ihrer Antwort eine "automatische Abwärtsabstimmung" ausgelöst haben. Die Gründe für dieses automatische Downvote sind verwirrend und furchtbar, aber es passiert, wenn das System Ihre Antwort basierend auf der Heuristik als "niedrige Qualität" ansieht. Es ist auch möglich, dass jemand Ihre Antwort nicht mochte, aber ich sehe im Moment nichts Falsches daran, deshalb bin ich mir nicht sicher, warum das der Fall sein sollte.
Weizen-Assistent
Ich bin froh, dass du Pyth benutzt!
isaacg
4

Python 2 , 60 42 41 Bytes

-18 Bytes dank Luis Mendo
-1 Bytes dank Jonathan Frech

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

Probieren Sie es online!

Stange
quelle
i-=~x[i]ist ein Byte kürzer als i+=1+x[i].
Jonathan Frech
3

Netzhaut , 36 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Eingang und Ausgang sind durch einen nachgestellten Zeilenvorschub voneinander getrennt.

Probieren Sie es online! (Verwendet Kommas anstelle von Zeilenvorschüben, um praktische Testsuiten zu ermöglichen.)

Martin Ender
quelle
3

Brain-Flak , 64 Bytes

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

Probieren Sie es online!

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack
Riley
quelle
7
Heiliger Strohsack! Ich habe eine Lösung geschrieben und dann nach unten gescrollt, um sie zu posten, aber es stellte sich heraus, dass wir genau die gleiche Lösung byteweise geschrieben haben! Sogar kleine Details wie ({}[()]<{}>)vs ({}<{}>[()])waren gleich! Was für ein Zufall!
DJMcMayhem
@ DJMcMayhem Diebstahl aller Ruhm XD
Christopher
Ich habe auch eine byte-für-byte-identische Lösung erstellt, aber 4 Bytes weniger . Nur ein verspäteter Wettbewerb :)
Wheat Wizard
2

Mathematica, 64-50 Bytes

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={}
user202729
quelle
Ich konnte nicht widerstehen, diesen netten Code weiter zu spielen. Meine Antwort ist unten.
Mr.Wizard
2

C # (.NET Core) , 68 Byte

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

Probieren Sie es online!

Nimmt Eingaben als Array von Ganzzahlen und gibt eine Zeichenfolge zurück, die die nicht übersprungenen Werte enthält.

jkelm
quelle
Ein guter Weg, dies zu tun, und es kommt genau so weit wie beim Drucken.
TheLethalCoder
Ich mag die einfachen Lösungen. Ich muss allerdings noch LINQ lernen, da ich gesehen habe, dass sich so viele c #
lambdas
Verkürzt es, weil Sie die meiste Zeit implizit zurückkehren können. Es ist jedoch ein Wurf zwischen impliziter Rückkehr mit using System.Linq;und einer normalen Schleife.
TheLethalCoder
2

R, 58 Bytes

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

Rekursive Funktion. Nimmt einen Vektor xals Argument und leitet einen Zeiger ein p. Dies gibt den entsprechenden Eintrag von aus x, prüft, ob p+x[p]die Grenzen überschritten werden, und ruft andernfalls die Funktion für den neuen Zeiger auf.

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

Dies ist eine vergleichbare Lösung, die einen korrekten Vektor zurückgibt, anstatt die Ziffern zu drucken.

JAD
quelle
was ist mit einer Eingabe von numeric(0)? aka leeres Array.
Giuseppe
@ Giuseppe Ich werde es mir ansehen, wenn ich hinter meinem PC bin
JAD
55 Bytes
Giuseppe
2

Java (OpenJDK 8) , 53 Byte

Vielen Dank an @ PunPun1000 und @TheLethalCoder

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

Probieren Sie es online!

Roman Gräf
quelle
Würde das Drucken der Ergebnisse, wie in meiner C # -Antwort, Ihnen etwas ersparen?
TheLethalCoder
@TheLethalCoder Ich versuche es
Roman Gräf
Können Sie ein Byte speichern, indem Sie sich nin die Schleife bewegen ?
TheLethalCoder
Außerdem scheint dies im Moment nicht zu funktionieren.
TheLethalCoder
Sie vermissen ein Elternteil nach dem (a[n+=1+a[n]]. Die Funktion löst auch nach der Ausgabe des korrekten Werts einen Fehler aus. Ich weiß nicht, ob dies zulässig ist oder nicht (die Frage sagt nichts aus, der Standardfehler wird ignoriert). Wenn dies beabsichtigt war, können Sie n<a.lengthdie for-Schleife entfernen . Schließlich läuft der TIO-Code auch mit dem Paren nicht so, wie er ist. Die Funktion sollte a Consumer<int[]>und use seinfunc.accept(test)
PunPun1000
2

Alice , 15 Bytes

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

Probieren Sie es online!

Eingabe und Ausgabe einer durch Zeilenvorschub getrennten Liste von Dezimalzahlen.

Erläuterung

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

Durch Speichern einer Ganzzahl n in der Iteratorwarteschlange wird der nächste Befehl n- mal ausgeführt. Mirrors wie /sind keine Befehle, also wird der nächste Befehl sein I. Wenn wir also nur einen Wert x lesen und ausgeben , lesen wir bei der nächsten Iteration x + 1- Werte, wobei der letzte auf dem Stapel endet. Dadurch werden die erforderlichen Nummernlistenelemente übersprungen.

Martin Ender
quelle
2

Mathematica , 37 (30?)

Weiteres Golfen der feinen Methode von user202729.

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

Die Regeln scheinen das Ausgabeformat nicht explizit anzugeben, also vielleicht:

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

Die Ausgabe für die zweite Funktion sieht folgendermaßen aus: 0.2.4.{}- Insbesondere {}wird für eine leere Menge immer noch eine Ausgabe zurückgegeben, die der endgültigen Regel entspricht.

Mr.Wizard
quelle
1
±Drop[{x},a]kann sein, ±{x}~Drop~aweil ±hat eine niedrigere Priorität als Infix.
JungHwan Min
@JungHwanMin Das habe ich verpasst; Vielen Dank!
Mr.Wizard
2

Common Lisp, 51 Bytes

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

Probieren Sie es online!

Renzo
quelle
2

Brain-Flak , 64 60 Bytes

4 Bytes speichern basierend auf einer Idee von 0 '

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

Probieren Sie es online!

Kommentiert

([]){{}            #{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}
Weizen-Assistent
quelle
1

Ruby, 36 33 31

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

Probieren Sie es online aus.

Cristian Lupascu
quelle
Sie dürfen das f=als Header-Element subtrahieren .
Canhascodez
@sethrin Auch wenn ich es rekursiv aufrufen muss?
Cristian Lupascu
Hmm, gute Frage. Ich vermute nicht. Das hat mir bei Ihrer Lösung übrigens sehr gut gefallen.
Canhascodez
1

Python 2.4, 85 Bytes

Keine Chance, in Python damit zu gewinnen, aber ich liebe Oneliner und dieser könnte für andere interessant sein.
Es stellt sich heraus, dass es einen ausgefallenen Zaubertrick gibt, um auf die Gebäudeliste im Verständnis zuzugreifen, aber er funktioniert nur in 2.4 und mit einigen Änderungen in <= 2.3 ist
locals()['_[1]']er es. Python erstellt einen geheimen Namen _[1]für die Liste, während es erstellt und gespeichert wird locals. Auch Namen _[2], _[3]... werden für verschachtelte Listen verwendet.

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

Es zählt also die Anzahl der bereits hinzugefügten Elemente plus deren Summe. Ergebnis ist der Index des nächsten gewünschten Elements.
Ich denke, dass es eine Möglichkeit geben sollte, die Aufzählung zu vermeiden. Wie Zugriff Eingangsarray direkt Index: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Aber ich kann keinen kompakten Weg finden, um es vor Index-out-of-Range zu schützen (während es oneliner bleibt)

Bildbeschreibung hier eingeben

Totes Opossum
quelle
1

Schnell, 63 Bytes

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

Dies ist mein allererster Eintrag, daher bin ich mir der Regeln nicht 100% sicher, aber hoffentlich reicht diese Antwort aus. Ich bin mir ein wenig unsicher, wie die Eingabe in ein System erfolgen soll. Ich habe eine kürzere Antwort, wenn ich irgendwo eine Funktion übernehmen durfte, die die Eingabe zurückgeben kann.

AnonymousReality
quelle
Willkommen bei PPCG! Die Standardregeln sind, dass Sie entweder Code haben können, der als vollständiges Programm arbeitet, also (normalerweise) in STDIN eingeben und (normalerweise) in STDOUT ausgeben, oder eine Funktion, also (normalerweise) aus Funktionsparametern eingeben und (normalerweise) ausgeben Funktionsrückgabe.
Stephen
@StepHen - danke! Ich denke, das macht meine andere Version dann ungültig. Ich freue mich darauf, mehr beizutragen!
AnonymousReality
1

Perl 6 , 31 Bytes

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

Probier es aus

Erweitert:

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

Um zu verstehen, wie der Code funktioniert, würde ohne [*;0]diesen eine Sequenz wie die folgende generiert:

[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)
Brad Gilbert b2gills
quelle
1

Gelee , 8 Bytes

ḢṄ‘ṫ@µL¿

Ein vollständiges Programm druckt die Ergebnisse, gefolgt von einer neuen Zeile (leere Liste erzeugt keine Ausgabe).

Probieren Sie es online!

Wie?

ḢṄ‘ṫ@µ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
                                                                         '''
Jonathan Allan
quelle
Endlich eine Gelee-Antwort! Übrigens kann ich es in 7 Bytes tun.
Erik der Outgolfer 30.07.17
Und ich habe auch eine Listen-Return-Funktion in 18 Bytes.
Erik der Outgolfer
1

Python 3 , 35 Bytes

f=lambda h=0,*t:t and[h,*f(*t[h:])]

Probieren Sie es online!

Führen Sie es mit f(*l)wo list Ihre Eingabe. Wohl die Regeln für die Eingabe strecken, aber ich liebe es einfach, weiter auszupacken.

Evpok
quelle
1

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

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

Probieren Sie es online!

Nimmt seine Eingabe als eine durch Leerzeichen getrennte Liste von Zahlen.

Xcali
quelle