Вместо того, чтобы быть умелым воином, способным убить Гидр (см. Здесь и здесь ), на этот раз вы - воин, который не имеет предварительных знаний о том, как убить одно или какое оружие использовать против существа.

В этой задаче, когда вы отсекаете одну голову, две будут расти в одном месте. Поскольку у вас нет механизма, позволяющего одновременно отрезать много голов, количество голов будет только расти. В этом случае наша Гидра может начинаться с N(N ⩾ 1) голов. Давайте назовем первое столкновение поколением, и мы будем представлять головы первого поколения как 0 , головы, созданные после первого удара, как 1 , и так далее.

вход

Вам будет дано целое число, Nпредставляющее, сколько голов Hydra изначально имеет, и список размеров, Nв котором указывается, в каком индексе (в примерах я буду использовать 0-индексированный формат) вы отрежете голову. Вы всегда можете предположить, что данные индексы действительны - помните, что список (то есть: головы) будет расти, когда вы отсекаете головы.

пример

Вход : N = 4и[0,4,2,5]

Поколение 0 - Индекс атаки 0

0 0 0 0     =>     1 1 0 0 0
^                  ^ ^

Поколение 1 - Индекс атаки 4

1 1 0 0 0     =>     1 1 0 0 2 2
        ^                    ^ ^

Поколение 2 - Индекс атаки 2

1 1 0 0 2 2     =>     1 1 3 3 0 2 2
    ^                      ^ ^

Поколение 3 - Индекс атаки 5

1 1 3 3 0 2 2     =>     1 1 3 3 0 4 4 2
          ^                        ^ ^

Последнее поколение

1 1 3 3 0 4 4 2

Как видите, приведенные индексы относятся к списку предыдущего поколения.

Выход

Вам необходимо вывести последнее поколение.

Контрольные примеры

N = 1 and [0] => [1,1]
N = 2 and [0,0] => [2,2,1,0]
N = 2 and [0,1] => [1,2,2,0]
N = 2 and [1,0] => [2,2,1,1]
N = 2 and [1,1] => [0,2,2,1]
N = 4 and [0,4,2,5] => [1,1,3,3,0,4,4,2]
N = 6 and [0,0,0,0,0,0] => [6, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0]
N = 6 and [5,6,7,8,9,10] => [0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 6]
N = 10 and [1,7,3,12,9,0,15,2,2,10] => [6, 6, 9, 9, 8, 1, 3, 3, 0, 0, 10, 10, 2, 5, 5, 0, 0, 4, 7, 7]

Это код-гольф, поэтому выигрывает самый короткий ответ в байтах!

Python 2 , 59 байт

H,a=input()
H*=[0]
for i in a:H[i:i+1]=[max(H)+1]*2
print H

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

Очень умно -1 благодаря xnor .

Python 2 , 60 байт

n,a=input()
h=[0]*n
for c in a:h[c:c+1]=[max(h)+1]*2
print h

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

Stax , 12 11 байт

î╓≡╧▄#¥oWä)A

Запустите и отладьте его на staxlang.xyz!

Благодаря рекурсивный за один байт экономии!

Распаковывается (13 байт) и объяснение:

z),{i^c\&:fFm
z)               Push initial array of zeroes to stack
  ,              Push array of attacks to stack
   {       F     For each attack, push it and then:
    i^c\           Push [x,x], where x is the generation number
        &          Set the head at the attack index to this new array
         :f        Flatten
            m    Print the last generation

Задача прямо говорит: «Вы должны вывести последнее поколение», поэтому я предполагаю, что этот консенсус здесь не держится. Если это так, то десятью байтами можно управлять, оставляя результат в пустом стеке:

z),Fi^c\&:f

Haskell , 63 57 байт

foldl(\y(x,n)->take n y++x:x:drop(n+1)y).(0<$)<*>zip[1..]

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

Oracle SQL, 325 байт

select listagg(ascii(substr(l,level,1)),', ')within group(order by level)
from(select * from t
model dimension by(1 i)measures(l,r)
rules iterate(1e5)until(r[1]is null)
(l[1]=regexp_replace(l[1],'.',chr(:n-length(r[1])+1)||chr(:n-length(r[1])+1),1,ascii(substr(r[1],1,1))+1),r[1]=substr(r[1],2)))
connect by level<=length(l);

Тест в SQL * Plus.

SQL> set heading off
SQL>
SQL> create table t(l varchar2(4000), r varchar2(4000));

Table created.

SQL>
SQL> var n number;
SQL> exec :n := 10;

PL/SQL procedure successfully completed.

SQL>
SQL> insert into t
  2  values(rpad(chr(0),:n,chr(0)), chr(1)||chr(7)||chr(3)||chr(12)||chr(9)||chr(0)||chr(15)||chr(2)||chr(2)||chr(10));

1 row created.

SQL>
SQL> select listagg(ascii(substr(l,level,1)),', ')within group(order by level)
  2  from(select * from t
  3  model dimension by(1 i)measures(l,r)
  4  rules iterate(1e5)until(r[1]is null)
  5  (l[1]=regexp_replace(l[1],'.',chr(:n-length(r[1])+1)||chr(:n-length(r[1])+1),1,ascii(substr(r[1],1,1))+1),r[1]=substr(r[1],2)))
  6  connect by level<=length(l);

6, 6, 9, 9, 8, 1, 3, 3, 0, 0, 10, 10, 2, 5, 5, 0, 0, 4, 7, 7

PS. Работает на номера до 255.

Zsh , 41 байт

Мы игнорируем N, как указано в правилах .

for i;a+=(0)
for i;a[i]=($[++j] $j)
<<<$a

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

Довольно стандартно: создайте массив из 0 для начала, напечатайте его до конца. a[i]=(a b)Метод как изменения и вставки нового для меня, счастлив , что нашел применение для него.

ИЛИ также 41 байт :

a[#]=
for i;a[i]=($[++j] $j)
<<<${a/#%/0}

Этот менее стандартный. Мы используем несколько изящных приемов:

• ${a/#%/0}: Это замена, но #и %скажите zsh, чтобы закрепить совпадение в начале и в конце. Поскольку он пуст, мы заменяем все пустые элементы на 0.
• a[#]=: Это фактически объявляет пустой массив размера $#в Zsh. Это как char *a[argc]в C. Если мы не сделаем этого, мы не получим конечные нули, которые нам нужны.

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

Scala , 104 байта

def^(l:Seq[Int],r:Seq[Int]):Seq[Int]=if(r.size>0)^(l.patch(r(0),Seq.fill(2)(l.max+1),1),r.drop(1))else l

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

Кажется, самый длинный ответ до сих пор. :)

List.fill(2)(l.max+1)можно заменить, List(l.max+1,l.max+1)но длина остается неизменной.

JavaScript (ES6),  61 59  51 байт

Спасибо @Shaggy за указание на то, что n это всегда длина массива, экономя 8 байтов в обеих версиях

Ожидается массив в 0-индексированном формате. Игнорирует n.

a=>a.map(i=>b.splice(i,1,++g,g),b=a.map(_=>g=0))&&b

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

JavaScript (Node.js) ,  64  56 байт

Использование reduce()и flat():

a=>a.reduce((b,i,g)=>b.flat(1,b[i]=[++g,g]),a.map(_=>0))

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

Japt , 14 байт

rÈhY[°TT] c}Uî

Попытайся

PHP , 101 байт

function h($n,$a){$h=array_fill(0,$n,0);foreach($a as$b)array_splice($h,$b,0,$h[$b]=++$x);return $h;}

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

Perl 5 -pal , 48 байт

@h=($i=0)x@F;splice@h,$_,1,(++$i)x2for@F;$_="@h"

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

Принимает массив как разделенный пробелами список из STDIN. Не вводит n.

Сетчатка 0.8.2 , 69 байт

\d+
$*_
r`_\G
,0
+`^((,*)_)(_)*(.*,,(?<-3>\d+,)*)\d+
$2$4$.1,$.1
^,+

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. 1-индексироваться. Принимает вход как ...list,N. Не требует, чтобы список был длинным N. Объяснение:

\d+
$*_

Преобразуйте все входные данные в унарные, но с использованием _, чтобы не путать их с последующим использованием цифры 1. (Retina 1 сделает это автоматически для 2-байтового сохранения.)

r`_\G
,0

Замените Nмассивом Nнулей, но не изменяйте список.

+`

Обработать все элементы списка.

^((,*)_)(_)*(.*,,(?<-3>\d+,)*)\d+

Найдите следующий элемент списка и эквивалентную позицию в массиве. $1= текущее поколение (как длина), $2= запятые от предыдущих поколений, $3= текущий индекс - 1, $4= первые $3заголовки.

$2$4$.1,$.1

Замените заголовок в текущем индексе двумя копиями текущего поколения в десятичном формате.

Pyth , 16 байт

u.nXGH,=+Z1ZE*]0

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

Интересно, что оказывается, что я не могу использовать, sчтобы сгладить список, так как он на самом деле является сокращением +F, которое выполняет +два крайних левых элемента списка, пока все элементы не будут обработаны. Это означает, что первые несколько элементов могут быть просто суммированы, в зависимости от того, где произошла последняя замена.

u.nXGH,=+Z1ZE*]0Q   Implicit: Q=input 1 (N), E=input 2 (array), Z=0
                    Trailing Q inferred
              ]0    [0]
             *  Q   Repeat Q times
u           E       Reduce E, with current value G and next value H, starting with the above:
       =+Z1           Increment Z in-place
      ,  Z Z          Pair the updated Z with itself
   XGH                In G, replace the element with index H with the above
 .n                   Flatten
                    Implicit print

Желе , 13 байт

;`ɼṁœP@j‘ɼɗƒ@

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

Монадическая ссылка, которая берет 1-индексированный список головок, чтобы сократить в качестве аргумента, и возвращает окончательное поколение.

C # (интерактивный компилятор Visual C #) , 94 89 85 байт

a=>b=>b.Aggregate(new int[a-(a-=a)].ToList(),(c,d)=>{c.Insert(d,c[d]=++a);return c;})

Сохранено 2 байта благодаря Эндрю Баумеру

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

05AB1E , 10 байтов

-IvN>D‚yǝ˜

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

   -             # subtract the input from itself (yields a list of 0s)
    Iv           # for each number y in the input
      N          # push the 0-based loop count
       >         # add 1 to get the generation number
        D        # duplicate
         ‚       # wrap the two copies in a list
          yǝ     # replace the element at index y with that list
            ˜    # flatten