这次您不是一个能够杀死九头蛇的熟练战士（请参阅此处和此处），而是您是一个不了解如何杀死一种生物或使用哪种武器对付该生物的战士。

在这个问题上，每当切断一个头时，两个头就会在同一位置长出。由于您没有同时切断许多头的机制，因此头的数量只会增加。在这种情况下，我们的Hydra可以从N（N⩾1）个头开始。让我们将第一个遇到的世代称为世代，我们将来自第一世代的头像表示为0，将第一次打击后创建的头像表示为1，依此类推。

输入值

您将得到一个整数，该整数N表示Hydra最初具有多少个头，以及一个N包含要在其中使用哪个索引的大小列表（在示例中，我将使用0索引格式）。您始终可以假设给定的索引是有效的-请记住，列表（即：heads）会随着您削减heads而增长。

例

输入：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
    ^                      ^ ^

第三代-攻击指数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

在线尝试！

感谢xnor非常聪明-1 。

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中声明了一个空的size数组。就像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，48 -pal个字节

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

在线尝试！

将数组作为STDIN中以空格分隔的列表。不输入n。

视网膜0.8.2字节

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

在线尝试！链接包括测试用例。1个索引。将输入作为...list,N。不需要列表的长度N。说明：

\d+
$*_

将所有输入都转换为一元运算符，但是使用_，这样就不会与digit的后续用法混淆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‘ɼɗƒ@

在线尝试！

Monadic链接，将要切割的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;})

感谢Andrew Bauhmer，节省了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