Враховуючи список невід’ємних цілих чисел у будь-якому розумному форматі, повторіть його, пропустивши стільки елементів, скільки сказане кожне ціле число.

Ось відпрацьований приклад:

[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" для першого випадку).
• Ви повинні використовувати замовлення зліва направо для введення.
• Як і в відпрацьованих прикладах, якщо ви виходите за межі, виконання завершується так, ніби інакше.
• Ви повинні використовувати 0для пропуску 0 елементів.
• Враховуючи порожній список ( []), ви повинні повернутися [].

Тестові справи

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

Це код-гольф , тому найкоротша відповідь виграє!

Python 2 , 36 байт

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

Спробуйте в Інтернеті!

Python 2 , 49 44 * 41 байт

^{Закреслений 44 все ще є регулярним 44 :(}

* -3 завдяки @ ASCII .

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

Спробуйте в Інтернеті!

Друкує результати, розділені новим рядком, оскільки в чаті дозволено ОП. Я не думаю, що вона може бути коротшою як нерекурсивна повна програма .

Як це працює?

• l=input() - читає список зі стандартного вводу.

• while l: - Зловживає тим, що порожні списки є хибними в Python, циклічно, поки список не буде порожнім.

• 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друкується і програма припиняється.

Haskell, 29 27 26 байт

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

Збережено 1 байт завдяки Zgarb.

Спробуйте в Інтернеті.

JavaScript (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

-3 байти завдяки @ThePirateBay

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¡Γ↓

Спробуйте в Інтернеті!

-2 байти (і абсолютно нова ідея рішення) завдяки Леву!

Пояснення

Я використовую функцію відповідності списку шаблонів Γ. Вона приймає функцію 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]

Python 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

Видалено марний байт

Python 2 , 60 42 41 байт

^{-18 байт завдяки Луїсу Мендо
-1 байт завдяки Джонатану Фреху}

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

Спробуйте в Інтернеті!

Сітківка , 36 байт

Кількість байтів передбачає кодування ISO 8859-1.

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

Вхід і вихід відокремлюються від лінії передачі за допомогою зворотного каналу.

Спробуйте в Інтернеті! (Використовує коми замість каналів ліній для забезпечення зручних тестових наборів.)

Мозок-Флак , 64 байти

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

Спробуйте в Інтернеті!

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

Математика, 64 50 байт

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

C # (.NET Core) , 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])))

Це порівнянне рішення, яке повертає належний вектор замість друку цифр.

Java (OpenJDK 8) , 53 байти

Завдяки @ PunPun1000 та @TheLethalCoder

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

Спробуйте в Інтернеті!

Аліса , 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 на наступній ітерації, останнє з яких закінчується вгорі стека. Це пропускає необхідні елементи списку номерів.

Математика , 37 (30?)

Подальше гольфу за прекрасним методом користувача202729.

±{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)))

Спробуйте в Інтернеті!

Мозок-Флак , 64 60 байт

4 байти зберегти на основі ідеї від 0 '

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

Спробуйте в Інтернеті!

Повідомлення

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

Спробуйте в Інтернеті.

Python 2,4, 85 байт

Немає шансів перемогти в пітоні, але я люблю oneliners, і цей може бути цікавим іншим.
Виявляється, є фантастичний фокус, щоб отримати доступ до списку будівель всередині розуміння, але він працює лише в 2.4 і з деякими правками в <= 2.3
locals()['_[1]']. Python створює таємне ім'я _[1]для списку, в той час як він створюється і зберігає його locals. Також імена _[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% впевнений у правилах, але, сподіваюся, цієї відповіді достатньо. Я трохи не впевнений у правилах, як отримати вхід у систему. У мене є коротша відповідь, якщо мені дозволили взяти функцію десь, яка може повернути дані.

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

Python 3 , 35 байт

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

Спробуйте в Інтернеті!

Запустіть його f(*l)там, де lваш вклад. Можливо, розтягуючи правила введення, але я просто люблю розширене розпакування.

APL (Dyalog Unicode) , 20 байт ^SBCS

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

Спробуйте в Інтернеті!

Perl 5 , 36 30 + 1 (-a) = 31 байт

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

Спробуйте в Інтернеті!

Приймає свій вхід як розділений пробілом список номерів.

PowerShell , 25 байт

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

Спробуйте в Інтернеті!