Em vez de ser um guerreiro habilidoso capaz de matar Hydras (veja aqui e aqui ), desta vez você é um guerreiro que não tem conhecimento prévio sobre como matar uma ou quais armas usar contra a criatura.

Nesse problema, sempre que você cortar uma única cabeça, duas crescerão no mesmo lugar. Como você não tem o mecanismo para cortar muitas cabeças simultaneamente, o número de cabeças só aumentará. Nesse caso, nossa Hydra pode começar com N(N ⩾ 1) cabeças. Vamos chamar o primeiro encontro de uma geração e representaremos as cabeças da primeira geração como 0 , as cabeças criadas após o primeiro golpe como 1 e assim por diante.

Entrada

Você receberá um número inteiro Nrepresentando quantas cabeças a Hydra possui inicialmente e uma lista de tamanhos Ncontendo em qual índice (nos exemplos eu usarei o formato indexado em 0) você cortará uma cabeça. Você sempre pode assumir que os índices fornecidos são válidos - lembre-se de que a lista (ou seja: as cabeças) crescerá à medida que você as cortar.

Exemplo

Entrada : N = 4e[0,4,2,5]

Geração 0 - Índice de ataque 0

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

Geração 1 - Índice de ataque 4

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

Geração 2 - Índice de ataque 2

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

Geração 3 - Índice de ataque 5

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

Última geração

1 1 3 3 0 4 4 2

Como você pode ver, os índices fornecidos estão relacionados à lista da geração anterior.

Resultado

Você é obrigado a produzir a última geração.

Casos de teste

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]

Isso é código-golfe, então a resposta mais curta em bytes vence!

Python 2 , 59 bytes

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

Experimente online!

-1 muito inteligente graças ao xnor .

Python 2 , 60 bytes

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

Experimente online!

Stax , 12 11 bytes

î╓≡╧▄#¥oWä)A

Execute e depure-o em staxlang.xyz!

Graças à recursiva por um byte de economia!

Descompactado (13 bytes) e explicação:

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

O desafio diz explicitamente "é necessário que você produza a última geração", então acho que esse consenso não se mantém aqui. Se isso acontecer, no entanto, dez bytes podem ser gerenciados deixando o resultado em uma pilha vazia:

z),Fi^c\&:f

Haskell , 63 57 bytes

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

Experimente online!

Oracle SQL, 325 bytes

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);

Teste no 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. Funciona para números de até 255.

Zsh , 41 bytes

Ignoramos N, conforme declarado pelas regras .

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

Experimente online!

Padrão: faça uma matriz de 0s para começar, imprima-a para terminar. O a[i]=(a b)método de alterar e inserir é novo para mim, feliz por ter encontrado um uso para ele.

OU, também 41 bytes :

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

Este é menos padrão. Aproveitamos alguns truques legais:

• ${a/#%/0}: Isso é substituição, mas #e% diga ao zsh para ancorar a partida no início e no final. Como está vazio, substituímos todos os elementos vazios por 0.
• a[#]=: Isso efetivamente declara uma matriz vazia de tamanho $#no Zsh. É como char *a[argc]em C. Se não fizermos isso, não obteremos os zeros à direita de que precisamos.

Experimente online!

Scala , 104 bytes

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

Experimente online!

Parece ser a resposta mais longa até agora. :)

List.fill(2)(l.max+1)pode ser substituído por, List(l.max+1,l.max+1)mas o comprimento permanece o mesmo.

JavaScript (ES6),  61 59  51 bytes

Agradecemos a @Shaggy por apontar que nsempre é o comprimento da matriz, economizando 8 bytes nas duas versões

Espera a matriz no formato indexado em 0. Ignora n.

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

Experimente online!

JavaScript (Node.js) ,  64  56 bytes

Usando reduce()e flat():

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

Experimente online!

Japonês , 14 bytes

rÈhY[°TT] c}Uî

Tente

PHP , 101 bytes

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

Experimente online!

Perl 5 -pal , 48 bytes

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

Experimente online!

Leva a matriz como lista separada por espaço de STDIN. Não entra n.

Retina 0.8.2 , 69 bytes

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

Experimente online! O link inclui casos de teste. 1 indexado. Toma entrada como ...list,N. Não requer que a lista seja longa N. Explicação:

\d+
$*_

Converta todas as entradas em unárias, mas usando _, para que não se confunda com os usos posteriores do dígito 1. (A Retina 1 faria isso automaticamente para uma economia de 2 bytes.)

r`_\G
,0

Substitua Npor uma matriz de Nzeros, mas não altere a lista.

+`

Processe todos os elementos da lista.

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

Encontre o próximo elemento da lista e a posição equivalente na matriz. $1= geração atual (em comprimento), $2= vírgulas de gerações anteriores, $3= índice atual - 1,$4 = primeiras $3cabeças.

$2$4$.1,$.1

Substitua a cabeça no índice atual por duas cópias da geração atual em decimal.

Pitão , 16 bytes

u.nXGH,=+Z1ZE*]0

Experimente online!

Curiosamente, acontece que eu não posso usar s para achatar a lista, pois é realmente uma abreviação de +F, que atua +nos dois elementos mais à esquerda da lista até que todos os elementos tenham sido processados. Isso significa que os primeiros elementos podem simplesmente ser somados, dependendo de onde ocorreu a última substituição.

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

Geléia , 13 bytes

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

Experimente online!

Link monádico que usa a lista indexada em 1 de cabeçotes como argumento e retorna a geração final.

C # (compilador interativo do Visual C #) , 94 89 85 bytes

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

Guardado 2 bytes graças a Andrew Bauhmer

Experimente online!

05AB1E , 10 bytes

-IvN>D‚yǝ˜

Experimente online!

   -             # 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