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

• Скажімо, масив є [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• По- перше отримати перший елемент масиву, n. Збережіть перші nелементи і відмовтеся від наступних (відмовтесь від них n+1). Новий масив є [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Потім ви захоплюєте елемент, слідуючи за видаленим, і робите точно те саме. Повторно застосувавши процес, ми отримаємо[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Ви повторюєте процес, поки не потрапите за межі масиву / в масиві не залишиться елементів. Ми зупиняємось, тому що 11вище довжини масиву.

• Тепер слід вивести результат.

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

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

Випробування

Вхід -> Вихід

[1, 2, 3, 4, 5] -> [1, 3, 4]

[6, 1, 0, 5, 6] -> [6, 1, 0, 5, 6]

[1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1] -> [1, 2, 11, 5, 2, 0, 13, 10, 1]

[2, 2, 2, 2, 2, 2] -> [2, 2]

[1, 2, 3, 1, 2, 3, 1, 2, 3] -> [1, 2]

[3, 1, 2, 4, 0] -> [] *

* Останній тестовий випадок стосується 0, тому я вирішив опублікувати процес таким чином, щоб він був більш зрозумілим:

[3, 1, 2, 4, 0] --> [3, 1, 2, 0] --> [1, 2, 0] --> [1, 0] --> [0] --> [] )

^{( Натхненний цим викликом з боку Ерік Outgolfer )}

Піт, 18 байт

#IgZlQB .(Q=Z@QZ)Q

Спробуйте тут.

JavaScript (ES6), 45 байт

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

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

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

console.log(JSON.stringify(f([1, 2, 3, 4, 5]))) // --> [1, 3, 4]
console.log(JSON.stringify(f([6, 1, 0, 5, 6]))) // --> [6, 1, 0, 5, 6]
console.log(JSON.stringify(f([1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]))) // --> [1, 2, 11, 5, 2, 0, 13, 10, 1]
console.log(JSON.stringify(f([2, 2, 2, 2, 2, 2]))) // --> [2, 2]
console.log(JSON.stringify(f([1, 2, 3, 1, 2, 3, 1, 2, 3]))) // -> [1, 2]
console.log(JSON.stringify(f([3, 1, 2, 4, 0]))) // --> []

Haskell , 50 байт

g.pure.(0:)це анонімна функція, яка приймає та повертає список Ints, використовує як (g.pure.(0:))[1,2,3,4,5].

g.pure.(0:)
g(a,_:b:c)=g$splitAt b$a++b:c
g(a,_)=a

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

Як це працює

• Функція gбере аргумент кортежу, що представляє розділений список. a- це список початкових елементів, що зберігається на попередньому кроці, _є елементом, який слід відкинути, bнаступним елементом, який буде використовуватися як довжина, і cє решта елементів.
  • Якщо у другій частині кортежу є достатньо елементів для вибору а b, то виконується новий розкол і gповторюється. В іншому випадку це зупиняється з aрезультатом.
• Анонімна функція g.pure.(0:)починає все, зателефонувавши gз кортежем ([],0:l), де lзнаходиться вхід і 0негайно відкидається g.
  • pureтут використовується Applicativeекземпляр для (бінарних) кортежів, а з типом результату ([Int],[Int])зручно розміщувати свій аргумент як другий елемент в кортежі, []як перший елемент.

Python 3 , 59 байт

f=lambda a,i=0:f(a[:a[i]]+a[a[i]+1:],a[i])if i<len(a)else a

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

Haskell , 51 байт

f s=s%s
s%(n:_)|(x,_:z)<-splitAt n s=(x++z)%z
s%_=s

Спробуйте в Інтернеті! Приклад використання: f [1,2,3,4,5].

Java 8, 68 байт

Ця лямбда приймає змінний List<Integer>(підтримує remove(int), наприклад ArrayList). Вихід - мутований вхід. Призначити Consumer<List<Integer>>.

l->{for(int i=0,f=0;i<l.size();f^=1)i=f>0?l.remove(i)*0+i:l.get(i);}

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

Контрольний потік цієї проблеми дуже дратує. Кожну ітерацію ми повинні видалити елемент і отримати елемент у наступній позиції, і обидві ці операції потребують перевірки діапазону (і може викликати завершення програми). Одна стратегія полягає в тому, щоб виконувати обидві операції в одній циклі ітерації, при цьому оновлення індексу захищається за допомогою власної перевірки діапазону. Іншою стратегією, яка виявилася коротшою, є чергування між операціями кожної ітерації циклу, що і робить це рішення.

APL (Dyalog Classic) , 32 байти

1∘{n∇⍣(n≤≢w)⊢w←⍵/⍨(n←1+⍺⊃⍵)≠⍳≢⍵}

Пояснення

1∘{                             } bind 1 as starting left argument (⍺)
                             ⍳≢⍵  generate indexes for right argument (⍵)
                   (n←1+⍺⊃⍵)      n is 1+item at position ⍺ 
              w←⍵/⍨         ≠     w is ⍵ with item at n removed
   n∇⍣(n≤≢w)⊢                     recurse with n as left and w as right arg if n <= length of w

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

Perl 5 , 38 + 1 (-a) = 39 байт

splice@F,$p=$F[$p],1while$p<@F;say"@F"

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

Haskell, 99 байт (88 без відступів)

f x y
 |y>=l=f x$l-1
 |e>=l=x
 |True=f (take e x ++ drop (1+e) x) e
 where e=x!!y
       l=length x

VI, 31 25 байт

O@0kdd<C-v><C-a>Y<C-v><C-x>gg@a<Esc>"add<C-a>Y<C-x>@a

<C-?>відповідає Control + ?, і <Esc>до Escapeочевидно. Кожен з них рахується по 1 байту (див. Мета ).

Вхідні дані

Вхідний файл повинен містити 1 ціле число на рядок + 1 порожній рядок в кінці, наприклад:

1
2
3
4
5
⁣

Ми можемо бачити кожен рядок вхідного файлу як елемент масиву, такий як 1 :: 2 :: 3 :: 4 :: 5 :: [], наприклад, у деяких мовах (наприклад, caml).

Запуск

Ви можете почати vi із наступної команди та ввести обведення рішення обведенням:

vi -u NONE input

Ви також можете скористатися цим одноклассником:

vi -u NONE -c ':exec "norm O@0kdd\<C-v>\<C-a>Y\<C-v>\<C-x>gg@a\<Esc>\"add\<C-a>Y\<C-x>@a"' -c ":w output" -c ':q' input

Це має створити файл outputіз правильним результатом із вхідного файлу input.

Пояснення

Щоб запровадити рішення, я спочатку представляю 19-байтовий розчин, що працює лише для масивів без 0. У цьому рішенні використовується рекурсивний макрос, який використовується з невеликими модифікаціями в кінцевому рішенні:

Yqa@0ddYgg@aquggY@a

Пояснення часткового рішення

Y                       # yank first line (first integer + line break) to "0 register
 qa                     # start recording a macro ("a register)
   @0                   # jump n lines, where n is the content of the "0 register
     dd                 # delete the current line (n+1th line)
       Y                # yank current line (integer after the previously deleted line)
        gg              # go back to the first line
          @a            # recurse on macro "a"
            q           # finish recording the macro
             u          # cancel modifications done by the execution of the macro
              gg        # go back to the first line
                Y@a     # apply the recorded macro with first parameter equal to the first integer

Хитрість тут полягає у використанні "0регістру для зберігання поточного цілого числа (і розрив рядка, дуже важливий). Тому команда @0дозволяє стрибати nрядки (називати nзначення "0). Якщо стрибок перевищує кількість рядків у файлі, макрос вийде з ладу, тому програма зупиниться (поза межами меж масиву, як потрібно).

Але це рішення не працює, якщо вхід містить 0. Дійсно, якщо "0значення регістру дорівнює 0, то @0стрибне один рядок (через розрив рядка), не так, 0як нам сподобалось. Отже, наступна команда ( dd) не видалить 0-е ціле число, але 1-е (не правильне).

Достовірним рішенням для обробки 0є завжди нарощувати ціле число до того, як його з’єднати, і зменшити його відразу після. Таким чином, @0команда буде стрибати n+1рядки ( nце поточне ціле число, яке було збільшено). Після kцього необхідно перейти до рядка n(попередній рядок). Використовуючи цей трюк, порожній рядок потрібен в кінці вхідного файлу, щоб уникнути стрибків за межі масиву (таким чином, закінчуючи програму), оскільки ми завжди стрибаємо n+1рядки, перш ніж переходити до попереднього рядка.

Пояснення остаточного рішення

O                                                       # insert a new line at the beginning of the file, enter insert mode to write the macro content
 @0                                                     # jump n lines                                                       
   k                                                    # go to the previous line
    dd                                                  # delete this line
      <C-v><C-a>                                        # type Control+A (C-v is needed because we are in insert mode) to increment the current integer
                Y                                       # yank the incremented integer
                 <C-v><C-x>                             # decrement the current integer
                           gg                           # go to the first line
                             @a                         # recurse on macro "a"
                               <Esc>                    # exit insert mode : at this step, the first line of the file contains the macro content @0kdd^AY^Xgg@a
                                    "add                # copy @0kdd^AY^Xgg@a line to the register "a and delete the line
                                        <C-a>           # increment the first integer
                                             Y          # yank it (into "0)
                                              <C-x>     # decrement the first integer
                                                   @a   # apply macro in a" (initial @0 will jump n+1 lines, since we incremented the first integer before calling the macro)

Запис вмісту макросу в файл перед реєстрацією дозволяє зберегти кілька байтів:

• уникає писати qa...qта скасовувати всі зміни після реєстрації
• уникає :let @a="...")

Правки

№1

• записати вміст макросу в перший рядок (замість останнього рядка)
• змінити вхід (1 порожній рядок в кінці)
• додати один-лайнер для тестування в командному рядку

Pyth, 32 байти

VlQIgNlQBK@QNI!K=QYBIgKlQB.(QK;Q

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

C # (.NET Core) , 74 байти

n=>{for(int i=n[0];i<n.Count;){n.RemoveAt(i);i=i<n.Count?n[i]:n.Count+1;}}

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

Це включає список вкладень та змінює його. Я бачив деякі відповіді на Java, які спідняться навколо імпорту, використовуючи повністю кваліфіковане ім'я у визначенні аргументу Ламбда. Якщо це заборонено, я можу видалити цю відповідь.

R , 64 53 байти

f=function(a,i=1,d=a[i]+1)"if"(is.na(d),a,f(a[-d],d))

Рекурсивна функція. Має один обов’язковий вхід, aсписок, який можна пропустити. i- це індекс кількості речей, які потрібно перейти (за замовчуванням 1), і dіндекс наступного елемента після видалення необхідного значення, який також є індексом предмета, який потрібно вилучити. Повернення numeric(0), порожній вектор, для порожнього виводу.

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

Безголівки:

f <- function(a, i = 1, d = a[i] + 1) {
  if(is.na(d)) {   # d is NA if and only if a[i] is out of bounds
    a
  } else {
    f( a[-d], d, a[d] + 1 )   # a[-d] is a with the item at index d removed
  }
}