Получив список неотрицательных целых чисел в любом приемлемом формате, переберите его, пропустив столько элементов, сколько говорит каждое целое число, на которое вы наступаете.

Вот рабочий пример:

[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-only .

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

Попробуйте онлайн!

Печатает результаты, разделенные новой строкой, так как OP разрешен в чате. Я не думаю, что это может быть немного короче, как нерекурсивная полная программа .

Как это работает?

• 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 . Попробуйте онлайн!

Mathematica, 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

Попробуйте онлайн!

Pyth, 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$

Вход и выход разделены переводом строки с завершающим переводом строки.

Попробуйте онлайн! (Использует запятые вместо перевода строки, чтобы обеспечить удобные тестовые наборы.)

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 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 на следующей итерации, причем последние из них окажутся на вершине стека. Это пропускает необходимые элементы списка номеров.

Mathematica , 37 (30?)

Дальнейшее игра в гольф по методу user202729.

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

Кажется, что правила явно не указывают формат вывода, поэтому возможно:

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

Вывод для второй функции выглядит следующим образом: 0.2.4.{}- в частности {}, все еще возвращается для пустого набора, соответствующего окончательному правилу.

Common Lisp, 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 байт

У меня нет шансов победить в питоне, но я люблю однопользовательских, и этот может быть интересен другим.
Оказывается, есть хитрая волшебная уловка для доступа к списку зданий внутри понимания, но она работает только в 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 ... ]. Но я не могу придумать компактный способ защитить его от индекса вне диапазона (при этом оставляя его на одном уровне)

Swift, 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]}

Попробуй это

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
}

Чтобы помочь понять, как работает код, без [*;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=$_)}

Попробуйте онлайн!