Đưa ra một danh sách các số nguyên không âm ở bất kỳ định dạng hợp lý nào, lặp lại nó, bỏ qua nhiều phần tử như mọi số nguyên bạn bước vào.

Đây là một ví dụ hoạt động:

[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

Một ví dụ hoạt động khác, không hoàn toàn bằng nhau - 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

Một ví dụ ngoài giới hạn:

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

Quy tắc

• Bạn không thể sử dụng bất kỳ mánh gian lận nhàm chán nào trong số này , chúng làm cho thử thách trở nên nhàm chán và không thú vị.
• Bạn chỉ nên trả lại / in kết quả cuối cùng. Đầu ra STDERR bị bỏ qua.
• Bạn không thể lấy đầu vào dưới dạng một chuỗi chữ số trong bất kỳ cơ sở nào (ví dụ: "0102513162" cho trường hợp đầu tiên).
• Bạn phải sử dụng thứ tự từ trái sang phải cho đầu vào.
• Như trong các ví dụ đã làm việc, nếu bạn đi ra khỏi giới hạn, việc thực thi chấm dứt như thể khác.
• Bạn nên sử dụng 0để bỏ qua 0 phần tử.
• Đưa ra danh sách trống ( []) làm đầu vào, bạn nên trả về [].

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng!

Python 2 , 36 byte

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

Hãy thử trực tuyến!

Python 2 , 49 44 * 41 byte

^{Vượt qua 44 vẫn là thường xuyên 44 :(}

* -3 chỉ nhờ @ ASCII .

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

Hãy thử trực tuyến!

In các kết quả được phân tách bằng một dòng mới, như OP cho phép trong trò chuyện. Tôi không nghĩ rằng nó có thể ngắn hơn như một chương trình đầy đủ không đệ quy .

Cái này hoạt động ra sao?

• l=input() - Đọc danh sách từ đầu vào tiêu chuẩn.

• while l: - Lạm dụng thực tế là các danh sách trống bị giả mạo trong Python, các vòng lặp cho đến khi danh sách trống.

• print l[0]; - In phần tử đầu tiên của danh sách.

• l=l[l[0]+1:]- "Bỏ qua như một con thỏ" - Cắt đầu tiên l[0]+1từ danh sách.

Hãy lấy một ví dụ

Đưa ra danh sách [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]làm đầu vào, mã thực hiện như sau (theo giải thích ở trên) - In mục đầu tiên của mảng : 5, cắt 6 đầu tiên : [2, 1, 2, 1, 0, 0]. Sau đó chúng tôi in 2và cắt 3 đầu tiên : [1,0,0]. Tương tự như vậy, chúng tôi đầu ra 1, cắt 2 đầu tiên, và chúng tôi nhận được [0]. Tất nhiên, 0được in và chương trình chấm dứt.

Haskell, 29 27 26 byte

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

Đã lưu 1 byte nhờ Zgarb.

Hãy thử trực tuyến.

JavaScript (ES6), 42 39 35 byte

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]

Giải pháp cũ 39 byte

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

-3 byte nhờ @ThePirateBay

05AB1E , 10 9 byte

[¬Dg>#=ƒ¦

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Toán học, 46 44 byte

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

Lựa chọn thay thế:

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

C #, 68 byte

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

Hãy thử trực tuyến!

Phiên bản đầy đủ / được định dạng:

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

Trả về một danh sách dài hơn ở 107 byte.

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

Husk , 8 6 byte

←TU¡Γ↓

Hãy thử trực tuyến!

-2 byte (và một ý tưởng giải pháp hoàn toàn mới) nhờ Leo!

Giải trình

Tôi đang sử dụng chức năng khớp mẫu danh sách Γ. Nó có một chức năng fvà một danh sách với đầu xvà đuôi xs, và áp dụng fcho xvà xs. Nếu danh sách trống, Γtrả về giá trị mặc định phù hợp với loại của nó, trong trường hợp này là danh sách trống. Chúng tôi có fđược ↓, mà giảm xcác yếu tố từ xs. Hàm này sau đó được lặp lại và các phần tử kết quả được thu thập trong một danh sách.

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

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

Hãy thử trực tuyến!

Bình, 22 byte

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

Đã xóa một byte vô dụng

Python 2 , 60 42 41 byte

^{-18 byte nhờ Luis Mendo
-1 byte nhờ Jonathan Frech}

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

Hãy thử trực tuyến!

Võng mạc , 36 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Đầu vào và đầu ra được phân tách bằng nguồn cấp dữ liệu với một dòng cấp dữ liệu.

Hãy thử trực tuyến! (Sử dụng dấu phẩy thay vì nguồn cấp dữ liệu để cho phép các bộ kiểm tra thuận tiện.)

Brain-Flak , 64 byte

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

Hãy thử trực tuyến!

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

Toán học, 64 50 byte

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng một mảng các số nguyên, trả về một chuỗi chứa các giá trị không được bỏ qua.

R, 58 byte

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

Hàm đệ quy. Lấy một vectơ xlàm đối số và giới thiệu một con trỏ p. Điều này in ra mục tương ứng của x, kiểm tra nếu p+x[p]đi ra khỏi giới hạn và nếu không, gọi hàm cho con trỏ mới.

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

Đây là một giải pháp tương đương trả về một vectơ thích hợp thay vì in các chữ số.

Java (OpenJDK 8) , 53 byte

Cảm ơn @ PunPun1000 và @TheLethalCoder

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

Hãy thử trực tuyến!

Alice , 15 byte

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

Hãy thử trực tuyến!

Nhập và xuất một danh sách các số nguyên thập phân được phân tách bằng nguồn cấp.

Giải trình

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

Lưu trữ một số nguyên n trong hàng đợi lặp khiến lệnh tiếp theo được thực thi n lần. Gương như /không phải là lệnh, vì vậy lệnh tiếp theo sẽ là I. Do đó, nếu chúng ta chỉ đọc và in một giá trị x , chúng ta sẽ đọc các giá trị x + 1 ở lần lặp tiếp theo, với lần cuối cùng kết thúc ở trên cùng của ngăn xếp. Điều này bỏ qua các yếu tố danh sách số yêu cầu.

Toán học , 37 (30?)

Tiếp tục chơi golf theo phương pháp tốt của user202729.

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

Các quy tắc dường như không chỉ định rõ ràng định dạng đầu ra, vì vậy có thể:

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

Đầu ra cho hàm thứ hai trông giống như: 0.2.4.{}- đáng chú ý {}vẫn được trả về cho một tập hợp trống, tuân theo quy tắc cuối cùng.

Lisp thông thường, 51 byte

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

Hãy thử trực tuyến!

Brain-Flak , 64 60 byte

Lưu 4 byte dựa trên một ý tưởng từ 0 '

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

Hãy thử trực tuyến!

Chú thích

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

Hãy thử trực tuyến.

Python 2.4, 85 byte

Không có cơ hội để chiến thắng con trăn với nó, nhưng tôi yêu thích oneliners và điều này có thể thú vị với những người khác.
Hóa ra, có một trò ảo thuật lạ mắt để truy cập danh sách xây dựng bên trong sự hiểu biết, nhưng nó chỉ hoạt động trong 2.4 và với một số chỉnh sửa trong <= 2.3
locals()['_[1]']. Python tạo tên bí mật _[1]cho danh sách, trong khi nó được tạo và lưu trữ nó locals. Ngoài ra tên _[2], _[3]... được sử dụng cho danh sách lồng nhau.

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

Vì vậy, nó đếm số phần tử đã được thêm vào cộng với tổng của chúng. Kết quả là chỉ số của yếu tố mong muốn tiếp theo.
Tôi nghĩ rằng, nên có một cách để tránh liệt kê. Giống như truy cập mảng đầu vào trực tiếp theo chỉ mục : [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. Nhưng tôi không thể tìm ra một cách nhỏ gọn để bảo vệ nó khỏi phạm vi chỉ mục (trong khi vẫn giữ nó trên máy chủ)

Swift, 63 byte

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

Đây là mục đầu tiên của tôi, từ trước đến nay, vì vậy tôi không chắc chắn 100% về các quy tắc, nhưng hy vọng câu trả lời này đủ. Tôi không chắc chắn về các quy tắc về cách đưa đầu vào vào hệ thống. Tôi có một câu trả lời ngắn hơn nếu tôi được phép đảm nhận một chức năng ở đâu đó có thể trả về đầu vào.

Perl 6 , 31 byte

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

Kiểm tra nó

Mở rộng:

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

Để giúp hiểu cách thức hoạt động của mã, nếu không có [*;0]điều này sẽ tạo ra một chuỗi như sau:

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

Thạch , 8 byte

ḢṄ‘ṫ@µL¿

Một chương trình đầy đủ in kết quả mỗi dòng theo sau một dòng mới (danh sách trống không tạo ra đầu ra).

Hãy thử trực tuyến!

Làm sao?

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

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

Hãy thử trực tuyến!

Chạy nó với đầu vào của bạn f(*l)ở đâu l. Có thể kéo dài các quy tắc cho đầu vào, nhưng tôi chỉ thích giải nén nâng cao.

APL (Dyalog Unicode) , 20 byte ^SBCS

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

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Lấy đầu vào của nó dưới dạng một danh sách các số được phân tách bằng dấu cách.

PowerShell , 25 byte

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

Hãy thử trực tuyến!