Biorąc pod uwagę listę liczb całkowitych nieujemnych w dowolnym rozsądnym formacie, iteruj ją, pomijając tyle elementów, ile mówi każda liczba całkowita, na którą wkraczasz.

Oto działający przykład:

[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

Kolejny działający przykład, nie tak jednakowo-deltowy:

[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

Przykład poza zakresem:

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

Zasady

• Nie możesz używać nudnego oszustwa wśród tych , które sprawiają, że wyzwanie jest nudne i nieciekawe.
• Powinieneś tylko zwrócić / wydrukować wynik końcowy. Dane wyjściowe STDERR są ignorowane.
• Nie możesz otrzymać danych wejściowych jako ciąg cyfr w żadnej bazie (np. „0102513162” w pierwszym przypadku).
• Do wprowadzania danych należy stosować kolejność od lewej do prawej.
• Podobnie jak w sprawdzonych przykładach, jeśli wyjdziesz poza granice, wykonanie kończy się tak, jakby było inaczej.
• Powinieneś użyć 0do pominięcia 0 elementów.
• Biorąc pod uwagę pustą listę ( []) jako dane wejściowe, powinieneś powrócić [].

Przypadki testowe

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

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź!

Python 2 , 36 bajtów

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

Wypróbuj online!

Python 2 , 49 44 * 41 bajtów

^{Przekreślone 44 jest nadal regularne 44 :(}

* -3 dzięki tylko @ ASCII .

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

Wypróbuj online!

Drukuje wyniki oddzielone znakiem nowej linii, ponieważ OP jest dozwolony na czacie. Nie sądzę, że może stać się krótszy jako nierekurencyjny pełny program .

Jak to działa?

• l=input() - Czyta listę ze standardowego wejścia.

• while l: - Nadużywa faktu, że puste listy są w Pythonie fałszywe, zapętla się, dopóki lista nie będzie pusta.

• print l[0]; - Drukuje pierwszy element listy.

• l=l[l[0]+1:]- „Pomija jak królik” - przycina pierwszy l[0]+1z listy.

Weźmy przykład

Biorąc pod uwagę listę [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]jako wejściowych, wykonuje kod następujący (zgodnie z wyjaśnieniem powyżej) - Drukuje pierwszy element tablicy: 5, wykończenia pierwszych 6: [2, 1, 2, 1, 0, 0]. Następnie wydrukować 2i wykończenia pierwszy 3: [1,0,0]. Podobnie, produkujemy 1, przycinamy pierwsze 2 i otrzymujemy [0]. Oczywiście 0jest drukowany i program się kończy.

Haskell, 29 27 26 bajtów

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

Zaoszczędzony 1 bajt dzięki Zgarbowi.

Wypróbuj online.

JavaScript (ES6), 42 39 35 bajtów

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]

Stare rozwiązanie 39 bajtów

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

-3 bajty dzięki @ThePirateBay

05AB1E , 10 9 bajtów

[¬Dg>#=ƒ¦

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Mathematica, 46 44 bajtów

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

Alternatywy:

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

C #, 68 bajtów

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

Wypróbuj online!

Wersja pełna / sformatowana:

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

Zwracanie listy jest dłuższe i wynosi 107 bajtów.

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

Łuska , 8 6 bajtów

←TU¡Γ↓

Wypróbuj online!

-2 bajty (i zupełnie nowy pomysł na rozwiązanie) dzięki Leo!

Wyjaśnienie

Używam funkcji dopasowania wzorca listy Γ. Zajmuje funkcji foraz listę z głową xi ogonem xs, i odnosi się fdo xa xs. Jeśli lista jest pusta, Γzwraca wartość domyślną zgodną z jej typem, w tym przypadku pustą listą. Uważamy fsię za ↓, który odrzuca xelementy xs. Ta funkcja jest następnie iterowana, a powstałe elementy są gromadzone na liście.

←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 bajtów

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

Wypróbuj online!

Pyth, 22 bajtów

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

Usunięto bezużyteczny bajt

Python 2 , 60 42 41 bajtów

^{-18 bajtów dzięki Luis Mendo
-1 bajtów dzięki Jonathan Frech}

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

Wypróbuj online!

Siatkówka , 36 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wejścia i wyjścia są oddzielone od linii za pomocą końcowego linii.

Wypróbuj online! (Używa przecinków zamiast linii, aby umożliwić wygodne zestawy testów).

Brain-Flak , 64 bajty

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

Wypróbuj online!

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

Mathematica, 64 50 bajtów

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

C # (.NET Core) , 68 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako tablicę liczb całkowitych, zwraca ciąg zawierający wartości, które nie zostały pominięte.

R, 58 bajtów

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

Funkcja rekurencyjna. Bierze wektor xjako argument i intiuje wskaźnik p. Spowoduje to wydrukowanie odpowiedniego wpisu x, sprawdzenie, czy p+x[p]wyjdzie poza granice, a jeśli nie, wywołuje funkcję nowego wskaźnika.

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

Jest to porównywalne rozwiązanie, które zwraca prawidłowy wektor zamiast drukowania cyfr.

Java (OpenJDK 8) , 53 bajty

Dzięki @ PunPun1000 i @TheLethalCoder

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

Wypróbuj online!

Alice , 15 bajtów

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

Wypróbuj online!

Wprowadź i wyodrębnij rozdzielone wierszem listy liczb całkowitych dziesiętnych.

Wyjaśnienie

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

Zapisanie liczby całkowitej n w kolejce iteratora powoduje, że następne polecenie zostanie wykonane n razy. Lustra takie jak /nie są poleceniami, więc następnym poleceniem będzie I. Dlatego jeśli po prostu odczytamy i wydrukujemy wartość x , odczytamy wartości x + 1 podczas następnej iteracji, a ostatnia z nich znajdzie się na górze stosu. Pomija to wymagane elementy listy numerów.

Mathematica , 37 (30?)

Dalsza gra w golfa według metody użytkownika user202729.

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

Reguły nie wydają się wyraźnie określać formatu wyjściowego, więc może:

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

Dane wyjściowe dla drugiej funkcji wyglądają następująco: 0.2.4.{}- zwłaszcza {}jest zwracane dla pustego zestawu, zgodnie z ostateczną regułą.

Common Lisp, 51 bajtów

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

Wypróbuj online!

Brain-Flak , 64 60 bajtów

4 bajty oszczędzasz na podstawie pomysłu od 0 '

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

Wypróbuj online!

Adnotacja

([]){{}            #{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)]}

Wypróbuj online.

Python 2.4, 85 bajtów

Nie ma szans na wygraną w pythonie, ale uwielbiam onelinerów, a ten może być interesujący dla innych.
Okazuje się, że istnieje fantastyczna magiczna sztuczka, aby uzyskać dostęp do listy budynków wewnątrz zrozumienia, ale działa tylko w wersji 2.4, a przy niektórych zmianach w <= 2.3
locals()['_[1]']tak jest. Python tworzy tajną nazwę _[1]dla listy podczas jej tworzenia i zapisywania locals. Również nazwy _[2], _[3]... są używane dla list zagnieżdżonych.

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

Liczy więc liczbę już dodanych elementów plus ich sumę. Wynik jest indeksem następnego pożądanego elementu.
Myślę, że powinien istnieć sposób na uniknięcie wyliczenia. Jak dostęp do tablicy wejściowej bezpośrednio przez indeks: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Ale nie mogę wymyślić kompaktowego sposobu, aby zabezpieczyć go przed indeksowaniem poza zasięgiem (zachowując go oneliner)

Szybki, 63 bajty

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

To jest mój pierwszy wpis, więc nie jestem w 100% pewien zasad, ale mam nadzieję, że ta odpowiedź wystarczy. Nie jestem pewien zasad dotyczących wprowadzania danych wejściowych do systemu. Mam krótszą odpowiedź, jeśli pozwolono mi przyjąć funkcję, która może zwrócić dane wejściowe.

Perl 6 , 31 bajtów

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

Sprawdź to

Rozszerzony:

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

Aby pomóc zrozumieć, jak działa kod, bez [*;0]tego wygenerowałby sekwencję podobną do następującej:

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

Galaretka , 8 bajtów

ḢṄ‘ṫ@µL¿

Pełny program drukujący wyniki, po którym następuje nowa linia (pusta lista nie generuje danych wyjściowych).

Wypróbuj online!

W jaki sposób?

ḢṄ‘ṫ@µ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 bajtów

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

Wypróbuj online!

Uruchom z tym, f(*l)gdzie ljest twój wkład. Prawdopodobnie rozciąga reguły wprowadzania, ale uwielbiam zaawansowane rozpakowywanie.

APL (Dyalog Unicode) , 20 bajtów ^SBCS

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

Wypróbuj online!

Perl 5 , 36 30 + 1 (-a) = 31 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako listę liczb oddzieloną spacjami.

PowerShell , 25 bajtów

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

Wypróbuj online!