Olumsuz olmayan tamsayıların herhangi bir makul biçimde listesi göz önüne alındığında, üzerine bastığınız her tamsayıdaki kadar çok öğe atlayarak üzerinde tekrarlayın.

İşte çalışılmış bir örnek:

[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

Başka bir işe yarayan örnek, hepsi eşit olmayan deltalar değil:

[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

Sınır dışı bir örnek:

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

kurallar

• Bunlar arasında herhangi bir sıkıcı hile kullanamazsınız , zorlu ve ilgi çekici olmayan bir meydan okuma yaparlar.
• Sadece nihai sonucu iade etmeli / yazdırmalısınız. STDERR çıkışı yoksayılır.
• Girdiyi herhangi bir temelde bir rakam dizisi olarak alamayabilirsiniz (örneğin, ilk durum için "0102513162").
• Giriş için soldan sağa sıra kullanmanız gerekir.
• Çalışılan örneklerde olduğu gibi, sınırların dışına çıkarsanız, yürütme aksi durumda olduğu gibi sona erer.
• 00 öğeyi atlamak için kullanmalısınız .
• Boş listeyi ( []) giriş olarak verilene göre geri dönmelisiniz [].

Test durumları

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

Bu kod golf , bu yüzden en kısa cevap kazanır!

Python 2,36 bayt

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

Çevrimiçi deneyin!

Python 2 , 49 44 * 41 bayt

^{44 çarpı hala normal 44 :(}

* -3 sadece @ ASCII sayesinde .

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

Çevrimiçi deneyin!

OP'nin sohbete izin verdiği şekilde, bir yeni satırla ayrılmış sonuçları yazdırır. Özyinelemeli olmayan bir tam program olarak daha kısa sürede elde edebileceğini sanmıyorum .

Bu nasıl çalışıyor?

• l=input() - Listeyi standart girişten okur.

• while l: - Python'da boş listelerin yanlış olması gerçeğini kötüye kullanır, liste boşalana kadar döngüler.

• print l[0]; - Listenin ilk öğesini yazdırır.

• l=l[l[0]+1:]- "Bir tavşan gibi atlar" - l[0]+1Listedeki ilki keser .

Bir örnek alalım

Listesi verilen [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]girdi olarak, kod gerçekleştirir (Yukarıda tarif edilen uygun) Aşağıdaki - dizinin ilk madde yazdırır: 5ilk 6 Döşeme: [2, 1, 2, 1, 0, 0]. Sonra baskı 2ve ilk 3 Döşeme: [1,0,0]. Aynı şekilde, 1ilk 2'yi çıkarıp kesiyoruz ve alıyoruz [0]. Tabii ki, 0yazdırılır ve program sona erer.

Haskell, 29 27 26 bayt

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

Zgarb sayesinde 1 bayt kaydedildi.

Çevrimiçi deneyin.

JavaScript (ES6), 42 39 35 bayt

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]

Eski Çözüm 39 Bayt

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

@ThePirateBay sayesinde -3 bayt

05AB1E , 10 9 bayt

[¬Dg>#=ƒ¦

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Mathematica, 46 44 bayt

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

Alternatifler:

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

C #, 68 bayt

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

Çevrimiçi deneyin!

Tam / Biçimli sürüm:

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

Bir listenin döndürülmesi 107 bayttan daha uzundur.

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

Kabuğu , 8 6 bayt

←TU¡Γ↓

Çevrimiçi deneyin!

Leo sayesinde -2 bayt (ve tamamen yeni bir çözüm fikri)!

açıklama

Liste deseni eşleştirme işlevini kullanıyorum Γ. Bu bir işlev alır fve kafa ile bir liste xve kuyruk xsve uygular fetmek xve xs. Liste boşsa, Γtürüyle tutarlı bir varsayılan değer döndürür, bu durumda boş bir liste. Biz almak folmayı ↓düşer, hangi xelemanları xs. Bu işlev daha sonra yinelenir ve ortaya çıkan öğeler bir listede toplanır.

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

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

Çevrimiçi deneyin!

Pyth, 22 Bayt

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

Bir işe yaramaz bayt kaldırıldı

Python 2 , 60 42 41 bayt

^{-18 bayt, Luis Mendo
-1 bayt sayesinde Jonathan Frech sayesinde}

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

Çevrimiçi deneyin!

Retina , 36 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

Giriş ve çıkış, takip eden satır besleme ile satır besleme ayrılır.

Çevrimiçi deneyin! (Uygun test takımlarına izin vermek için satır beslemeleri yerine virgül kullanır.)

Brain-Flak , 64 bayt

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

Çevrimiçi deneyin!

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

Mathematica, 64 50 bayt

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

C # (.NET Core) , 68 bayt

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

Çevrimiçi deneyin!

Bir tam sayı dizisi olarak girdi alır, atlanmayan değerleri içeren bir dize döndürür.

R, 58 bayt

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

Özyinelemeli işlevi. Bir vektörü xargüman olarak alır ve işaretçiyi başlatır p. Bu, karşılık gelen girişini yazdırır, sınırların dışına çıkıp çıkmayacağını xkontrol eder p+x[p]ve değilse, yeni işaretçinin işlevini çağırır.

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

Bu, rakamları yazdırmak yerine uygun bir vektör döndüren karşılaştırılabilir bir çözümdür.

Java (OpenJDK 8) , 53 bayt

@ PunPun1000 ve @TheLethalCoder için teşekkürler

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

Çevrimiçi deneyin!

Alice , 15 bayt

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

Çevrimiçi deneyin!

Ondalık tam sayıların satır besleme ile ayrılmış listelerini girin ve çıkarın.

açıklama

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

Bir tamsayı saklanması n yineleyici kuyruğunda sonraki komut çalıştırılmasına sebep olur n kere. Aynalar gibi /komutlar değildir, bu yüzden bir sonraki komut olacaktır I. Bu nedenle, yalnızca x değerini okuyup yazdırırsak, bir sonraki yinelemede x + 1 değerlerini okuyacağız , sonuncusu yığının üstüne gelecek. Bu, gerekli sayı listesi öğelerini atlar.

Mathematica , 37 (30?)

Kullanıcının202729 en iyi yönteminin daha da golfü.

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

Kurallar çıktı biçimini açıkça belirtmiyor gibi görünüyor, bu yüzden belki:

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

İkinci işlevin çıktısı şöyle görünür: 0.2.4.{}- özellikle {}boş bir küme için son kurala uygun olarak hala döndürülür.

Ortak Lisp, 51 bayt

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

Çevrimiçi deneyin!

Brain-Flak , 64 60 bayt

0 by ' fikrine dayanan 4 bayt tasarruf

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

Çevrimiçi deneyin!

Açıklamalı

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

Çevrimiçi deneyin.

Python 2.4, 85 bayt

Onunla python kazanma şansım yok, ama ben oneliner'ı seviyorum ve bu başkaları için ilginç olabilir.
Anlaşılıyor ki, bina listesine kavrayış içinde erişmek için süslü bir sihir numarası var, ancak yalnızca 2.4'te ve bazı düzenlemelerde <= 2.3'te
locals()['_[1]']çalışıyor. Python, _[1]liste için gizli isim oluşturur, oluşturulmuş ve depolanmış locals. Ayrıca isimler _[2], _[3]... iç içe geçmiş listeler için kullanılır.

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

Bu yüzden zaten eklenmiş elementlerin sayısını artı toplamlarını sayar. Sonuç, bir sonraki istenen öğenin indeksidir.
Numaralandırmayı önlemenin bir yolu olması gerektiğini düşünüyorum. Endeksine göre doğrudan giriş dizisi erişen gibi: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Ancak, endeks dışı değerlerden korumanın kompakt bir yolunu bulamıyorum (aynı zamanda çevrimiçi tutarken)

Swift, 63 bayt

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

Bu benim ilk girişim, bu yüzden kurallardan% 100 emin değilim, ama umarım bu cevap yeterlidir. Girdiyi bir sisteme nasıl sokacağım konusunda biraz kuraldan emin değilim. Girdiyi döndürebilecek bir yerde bir işlevi üstlenmeme izin verilirse daha kısa bir cevabım var.

Perl 6 , 31 bayt

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

Dene

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
}

Kodun nasıl çalıştığını anlamanıza yardımcı olmak için, [*;0]bu olmadan aşağıdaki gibi bir dizi oluşturulur:

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

Jöle , 8 bayt

ḢṄ‘ṫ@µL¿

Sonuçların her birinin ardından yeni satır yazdırılan tam bir program (boş liste çıktı üretmez).

Çevrimiçi deneyin!

Nasıl?

ḢṄ‘ṫ@µ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 bayt

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

Çevrimiçi deneyin!

Girdinin f(*l)nerede lolduğu ile çalıştır . Muhtemelen girdi kurallarını esnetiyordum, ama ben sadece gelişmiş paket açmayı seviyorum.

APL (Dyalog Unicode) , 20 bayt ^SBCS

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Girişini boşluklarla ayrılmış bir sayı listesi olarak alır.

PowerShell , 25 bayt

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

Çevrimiçi deneyin!