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 Code-Golf , also gewinnt die kürzeste Antwort!

Python 2 , 36 Bytes

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

Probieren Sie es online!

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.

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.

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

05AB1E , 10 9 Bytes

[¬Dg>#=ƒ¦

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

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

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

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]

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!

Pyth, 22 Bytes

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

Ein nutzloses Byte wurde entfernt

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!

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

Brain-Flak , 64 Bytes

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

Probieren Sie es 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 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.

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.

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!

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.

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.

Common Lisp, 51 Bytes

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

Probieren Sie es online!

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}

Ruby, 36 33 31

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

Probieren Sie es online aus.

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)

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.

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)

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

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.

APL (Dyalog Unicode) , 20 Byte ^SBCS

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

Probieren Sie es online!

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.

PowerShell , 25 Byte

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

Probieren Sie es online!