합리적인 형식의 음이 아닌 정수 목록이 주어지면 반복하는 모든 정수만큼 많은 요소를 건너 뛰고 반복합니다.

다음은 작동하는 예입니다.

[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

완전히 다른 델타가 아닌 다른 작동 예 :

[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

범위를 벗어난 예 :

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

규칙

• 당신은 이 중 어떤 지루한 치트를 사용할 수 없습니다 , 그들은 지루하고 재미없는 도전을합니다.
• 최종 결과 만 반환 / 인쇄해야합니다. STDERR 출력은 무시됩니다.
• 어떤 기준에서든 입력을 문자열로 얻을 수 없습니다 (예 : 첫 번째 경우 "0102513162").
• 입력하려면 왼쪽에서 오른쪽 순서를 사용해야합니다.
• 작동하는 예제에서와 같이 범위를 벗어나면 다른 방식으로 실행이 종료됩니다.
• 00 개의 요소를 건너 뛰는 데 사용해야 합니다.
• 빈 목록 ( [])을 입력으로 받으면를 반환해야합니다 [].

테스트 사례

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

이것은 code-golf 이므로 가장 짧은 답변이 이깁니다!

파이썬 2 , 36 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 49 44 * 41 바이트

^{44를 넘어서도 여전히 규칙적인 44입니다 :(}

* -3 @ASCII 전용 덕분 입니다.

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

온라인으로 사용해보십시오!

채팅에서 OP가 허용 한대로 결과를 줄 바꿈으로 구분하여 인쇄합니다. 비 재귀 전체 프로그램 으로 더 짧아 질 수 있다고 생각하지 않습니다 .

어떻게 작동합니까?

• l=input() -표준 입력에서 목록을 읽습니다.

• while l: -파이썬에서 빈 목록이 거짓이라는 사실을 남용하고 목록이 비어있을 때까지 반복합니다.

• print l[0]; -목록의 첫 번째 요소를 인쇄합니다.

• l=l[l[0]+1:]- "토끼처럼 건너 뛰기"- l[0]+1목록 에서 첫 번째 트림 .

예를 들어 보자

목록 [5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]을 입력으로 지정하면 코드는 다음을 수행합니다 (위 설명에 따라).-배열의 첫 번째 항목을 인쇄합니다. 5, 첫 번째 6을 자릅니다 [2, 1, 2, 1, 0, 0]. 그런 다음 2첫 번째 3 을 인쇄 하고 자릅니다 [1,0,0]. 마찬가지로을 출력 1하고 처음 2를 자르면을 얻습니다 [0]. 물론 0인쇄되고 프로그램이 종료됩니다.

하스켈, 29 27 26 바이트

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

Zgarb 덕분에 1 바이트를 절약했습니다.

온라인으로 사용해보십시오.

자바 스크립트 (ES6), 42 39 35 바이트

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]

이전 솔루션 39 바이트

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

@ThePirateBay 덕분에 -3 바이트

05AB1E , 10 9 바이트

[¬Dg>#=ƒ¦

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

매스 매 티카, 46 44 바이트

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

대안 :

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

C #, 68 바이트

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

온라인으로 사용해보십시오!

풀 / 포맷 버전 :

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

목록을 반환하는 시간은 107 바이트입니다.

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

껍질 , 8 6 바이트

←TU¡Γ↓

온라인으로 사용해보십시오!

Leo 덕분에 -2 바이트 (그리고 완전히 새로운 솔루션 아이디어)!

설명

list pattern match function을 사용하고 있습니다 Γ. 이 함수 소요 f와 머리 목록 x및 꼬리를 xs, 그리고 적용 f에 x와 xs. 목록이 비어 있으면 Γ유형과 일치하는 기본값 (이 경우 빈 목록)을 반환합니다. 우리는 f에서 요소 ↓를 삭제 x합니다 xs. 그런 다음이 함수가 반복되고 결과 요소가 목록에 수집됩니다.

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

파이썬 2 , 59 55 바이트

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

온라인으로 사용해보십시오!

피 이스, 22 바이트

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

쓸모없는 바이트를 제거

파이썬 2 , 60 42 41 바이트

^{Luis Mendo 덕분에 -18 바이트,
Jonathan Frech 덕분에 -1 바이트}

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

온라인으로 사용해보십시오!

레티 나 , 36 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

입력과 출력은 후행 줄 바꿈으로 줄 바꿈됩니다.

온라인으로 사용해보십시오! 편리한 테스트 스위트를 위해 줄 바꿈 대신 쉼표를 사용합니다.

Brain-Flak , 64 바이트

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

온라인으로 사용해보십시오!

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

Mathematica, 64 50 바이트

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

C # (. NET 코어) , 68 바이트

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

온라인으로 사용해보십시오!

입력을 정수 배열로 가져오고 건너 뛰지 않은 값이 포함 된 문자열을 반환합니다.

R, 58 바이트

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

재귀 기능. 벡터 x를 인수로 사용하고 포인터를 초기화합니다 p. 그러면의 해당 항목이 인쇄되고 범위를 벗어나 x는지 확인 p+x[p]하고 그렇지 않은 경우 새 포인터에 대한 함수를 호출합니다.

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

이것은 숫자를 인쇄하는 대신 적절한 벡터를 반환하는 비슷한 솔루션입니다.

자바 (OpenJDK 8) , 53 바이트

@ PunPun1000 및 @TheLethalCoder 덕분에

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

온라인으로 사용해보십시오!

Alice , 15 바이트

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

온라인으로 사용해보십시오!

줄 바꿈으로 구분 된 십진 정수 목록을 입력하고 출력합니다.

설명

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

반복자 큐에 정수 n 을 저장하면 다음 명령이 n 번 실행 됩니다. 같은 미러 /는 명령이 아니므로 다음 명령은입니다 I. 따라서 값 x 만 읽고 인쇄 하면 다음 반복에서 x + 1 값을 읽습니다 . 마지막 값은 스택 맨 위로 끝납니다. 필요한 숫자 목록 요소를 건너 뜁니다.

Mathematica , 37 (30?)

user202729의 훌륭한 방법에 대한 추가 골프.

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

규칙은 출력 형식을 명시 적으로 지정하지 않는 것 같습니다.

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

두 번째 함수의 출력은 다음과 같습니다. 0.2.4.{}— 특히 {}빈 규칙에 대해서는 최종 규칙에 따라 여전히 반환됩니다.

공통 리스프, 51 바이트

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

온라인으로 사용해보십시오!

Brain-Flak , 64 60 바이트

0 ' 의 아이디어를 기반으로 4 바이트 저장

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

온라인으로 사용해보십시오!

주석이 달린

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

루비, 36 33 31

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

온라인으로 사용해보십시오.

파이썬 2.4, 85 바이트

파이썬으로 승리 할 기회는 없지만, 나는 oneliners를 좋아하며 이것은 다른 사람들에게 흥미로울 수 있습니다.
이해 내부 건물 목록에 액세스하는 멋진 마술이 있지만 2.4에서만 작동하며 <= 2.3
locals()['_[1]']에서는 일부 편집 이 가능합니다. Python은 _[1]리스트의 비밀 이름 을 작성하고이를 작성하여에 저장합니다 locals. 또한 names _[2], _[3]...은 중첩 목록에 사용됩니다.

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

따라서 이미 추가 된 요소 수에 합계를 더합니다. 결과는 원하는 다음 요소의 색인입니다.
나는 열거를 피할 수있는 방법이 있어야한다고 생각합니다. 인덱스로 직접 입력 배열에 액세스하는 것과 같습니다 [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]. 그러나 범위를 벗어난 색인으로부터 보호하는 간단한 방법을 알 수는 없습니다 (하나의 라이너를 유지하는 동안)

스위프트, 63 바이트

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

이것은 내 첫 번째 항목이므로 규칙을 100 % 확신하지 못하지만이 답변이 충분하기를 바랍니다. 입력을 시스템으로 가져 오는 방법에 대한 규칙이 확실하지 않습니다. 입력을 반환 할 수있는 함수를 가정 할 수 있다면 더 짧은 대답이 있습니다.

펄 6 , 31 바이트

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

그것을 테스트

넓히는:

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

코드가 작동하는 방식을 이해하는 데 도움 [*;0]이 되지 않으면 다음과 같은 시퀀스가 ​​생성됩니다.

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

젤리 , 8 바이트

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

파이썬 3 , 35 바이트

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

온라인으로 사용해보십시오!

입력이 있는 f(*l)곳으로 실행하십시오 l. 입력 규칙을 늘릴 수는 있지만 고급 포장 풀기를 좋아합니다.

APL (Dyalog Unicode) , 20 바이트 ^SBCS

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

온라인으로 사용해보십시오!

펄 5 , 36 30 + 1 (-a) = 31 바이트

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

온라인으로 사용해보십시오!

공백으로 구분 된 숫자 목록으로 입력을받습니다.

PowerShell , 25 바이트

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

온라인으로 사용해보십시오!