En lugar de ser un guerrero habilidoso capaz de matar Hydras (ver aquí y aquí ), esta vez eres un guerrero que no tiene conocimiento previo sobre cómo matar una o qué armas usar contra la criatura.

En este problema, cada vez que corte una sola cabeza, dos crecerán en el mismo lugar. Como no tiene el mecanismo para cortar muchas cabezas simultáneamente, la cantidad de cabezas solo crecerá. En este caso, nuestra Hydra puede comenzar con N(N ⩾ 1) cabezas. Llamemos al primer encuentro una generación y representaremos las cabezas de la primera generación como 0 , las cabezas creadas después del primer golpe como 1 , y así sucesivamente.

Entrada

Se le dará un número entero que Nrepresenta cuántas cabezas tiene inicialmente la Hydra y una lista de tamaños que Ncontiene en qué índice (en los ejemplos usaré el formato indexado 0) cortará una cabeza. Siempre puede suponer que los índices dados son válidos; recuerde que la lista (es decir, las cabezas) crecerá a medida que corta las cabezas.

Ejemplo

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

Generación 0 - Índice de ataque 0

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

Generación 1 - Índice de ataque 4

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

Generación 2 - Índice de ataque 2

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

Generación 3 - Índice de ataque 5

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

Última generación

1 1 3 3 0 4 4 2

Como puede ver, los índices dados están relacionados con la lista de la generación anterior.

Salida

Se requiere que envíe la última generación.

Casos de prueba

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]

Este es el código de golf, ¡la respuesta más corta en bytes gana!

Python 2 , 59 bytes

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

Pruébalo en línea!

Muy inteligente -1 gracias a 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

Pruébalo en línea!

Stax , 12 11 bytes

î╓≡╧▄#¥oWä)A

¡Ejecútelo y depúrelo en staxlang.xyz!

¡Gracias a recursivo por un byte de ahorro!

Desempaquetado (13 bytes) y explicación:

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

El desafío dice explícitamente "se requiere que produzca la última generación", así que supongo que este consenso no se mantiene aquí. Sin embargo, si lo hace, se pueden administrar diez bytes dejando el resultado en una pila vacía:

z),Fi^c\&:f

Haskell , 63 57 bytes

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

Pruébalo en línea!

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

Prueba en 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

PD. Funciona para números hasta 255.

Zsh , 41 bytes

Ignoramos N, como lo establecen las reglas .

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

Pruébalo en línea!

Bastante estándar: haga un conjunto de 0 para comenzar, imprímalo para terminar. El a[i]=(a b)método de cambiar e insertar es nuevo para mí, feliz de haber encontrado un uso para él.

O, también 41 bytes :

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

Este es menos estándar. Aprovechamos algunos trucos geniales:

• ${a/#%/0}: Esto es un reemplazo, pero #y %dile a zsh que ancle la partida al principio y al final. Como está vacío, reemplazamos todos los elementos vacíos con 0.
• a[#]=: Esto declara efectivamente una matriz vacía de tamaño $#en Zsh. Es como char *a[argc]en C. Si no hacemos esto, no obtendremos los ceros finales que necesitamos.

Pruébalo en línea!

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

Pruébalo en línea!

Parece ser la respuesta más larga hasta ahora. :)

List.fill(2)(l.max+1)se puede reemplazar con List(l.max+1,l.max+1)pero la longitud sigue siendo la misma.

JavaScript (ES6),  61 59  51 bytes

Gracias a @Shaggy por señalar que n siempre es la longitud de la matriz, ahorrando 8 bytes en ambas versiones

Espera la matriz en formato indexado 0. Ignora n.

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

Pruébalo en línea!

JavaScript (Node.js) ,  64  56 bytes

Usando reduce()y flat():

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

Pruébalo en línea!

Japt , 14 bytes

rÈhY[°TT] c}Uî

Intentalo

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

Pruébalo en línea!

Perl 5 -pal , 48 bytes

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

Pruébalo en línea!

Toma la matriz como lista separada por espacios de STDIN. No entra n.

Retina 0.8.2 , 69 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. 1 indexado. Toma entrada como ...list,N. No requiere que la lista sea larga N. Explicación:

\d+
$*_

Convierta todas las entradas a unario, pero utilizando _, para que no se confunda con usos posteriores del dígito 1. (La Retina 1 haría esto automáticamente para un ahorro de 2 bytes).

r`_\G
,0

Reemplace Ncon una matriz de Nceros, pero no modifique la lista.

+`

Procesar todos los elementos de la lista.

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

Encuentre el siguiente elemento de la lista y la posición equivalente en la matriz. $1= generación actual (como longitud), $2= comas de generaciones anteriores, $3= índice actual - 1, $4= primeras $3cabezas.

$2$4$.1,$.1

Reemplace la cabeza en el índice actual con dos copias de la generación actual en decimal.

Pyth , 16 bytes

u.nXGH,=+Z1ZE*]0

Pruébalo en línea!

Curiosamente, resulta que no puedo usar spara aplanar la lista, ya que en realidad es una abreviatura +F, que se realiza +en los dos elementos más a la izquierda de la lista hasta que se hayan procesado todos los elementos. Esto significa que los primeros elementos podrían simplemente sumarse, dependiendo de dónde ocurrió el último reemplazo.

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

Jalea , 13 bytes

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

Pruébalo en línea!

Enlace monádico que toma la lista indexada de 1 cabezas para cortar como argumento y devuelve la generación final.

C # (compilador interactivo de 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 gracias a Andrew Bauhmer

Pruébalo en línea!

05AB1E , 10 bytes

-IvN>D‚yǝ˜

Pruébalo en línea!

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