Invece di essere un abile guerriero in grado di uccidere Idra (vedi qui e qui ), questa volta sei un guerriero che non ha alcuna conoscenza preliminare su come uccidere una o quali armi usare contro la creatura.

In questo problema, ogni volta che tagli una sola testa, due cresceranno nello stesso posto. Dato che non hai il meccanismo per tagliare molte teste contemporaneamente, il numero di teste aumenterà solo. In questo caso, la nostra Hydra può iniziare con N(N ⩾ 1) teste. Chiamiamo il primo incontro una generazione e rappresenteremo le teste della prima generazione come 0 , le teste create dopo il primo colpo come 1 e così via.

Ingresso

Ti verrà dato un numero intero che Nrappresenta quante teste inizialmente ha l'Hydra e un elenco di dimensioni Ncontenente in quale indice (negli esempi userò il formato 0-indicizzato) ti taglierà una testa. Puoi sempre presumere che gli indici indicati siano validi - ricorda che l'elenco (cioè: le teste) crescerà man mano che tagli le teste.

Esempio

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

Generazione 0 - Indice di attacco 0

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

Generazione 1 - Indice di attacco 4

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

Generazione 2 - Indice di attacco 2

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

Generazione 3 - Indice di attacco 5

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

Ultima generazione

1 1 3 3 0 4 4 2

Come puoi vedere, gli indici forniti sono correlati all'elenco della generazione precedente.

Produzione

È necessario produrre l'ultima generazione.

Casi test

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]

Questo è code-golf, quindi vince la risposta più breve in byte!

Python 2 , 59 byte

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

Provalo online!

Molto intelligente -1 grazie a xnor .

Python 2 , 60 byte

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

Provalo online!

Stax , 12 11 byte

î╓≡╧▄#¥oWä)A

Eseguilo e esegui il debug su staxlang.xyz!

Grazie a ricorsivo per un byte di risparmio!

Spacchettato (13 byte) e spiegazione:

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

La sfida dice esplicitamente "ti viene richiesto di produrre l'ultima generazione", quindi suppongo che questo consenso non sia valido qui. In tal caso, tuttavia, è possibile gestire dieci byte lasciando il risultato su uno stack altrimenti vuoto:

z),Fi^c\&:f

Haskell , 63 57 byte

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

Provalo online!

Oracle SQL, 325 byte

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

Test in 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. Funziona con numeri fino a 255.

Zsh , 41 byte

Ignoriamo N, come affermato dalle regole .

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

Provalo online!

Piuttosto standard: crea una matrice di 0 per iniziare, stampala per finire. Ila[i]=(a b) metodo di modifica e inserimento è nuovo per me, felice di averlo trovato utile.

OPPURE, anche 41 byte :

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

Questo è meno standard. Approfittiamo di alcuni trucchi accurati:

• ${a/#%/0}: Questa è la sostituzione, ma #e% zsh dico di ancoraggio il match all'inizio e alla fine. Poiché è vuoto, sostituiamo tutti gli elementi vuoti con 0.
• a[#]=: Questo dichiara efficacemente un array di dimensioni vuoto $#in Zsh. È come char *a[argc]in C. Se non lo facciamo, non otterremo gli zero finali di cui abbiamo bisogno.

Provalo online!

Scala , 104 byte

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

Provalo online!

Sembra essere la risposta più lunga finora. :)

List.fill(2)(l.max+1)può essere sostituito con List(l.max+1,l.max+1)ma la lunghezza rimane la stessa.

JavaScript (ES6),  61 59  51 byte

Grazie a @Shaggy per aver sottolineato che nè sempre la lunghezza dell'array, risparmiando 8 byte in entrambe le versioni

Si aspetta l'array in formato indicizzato 0. Ignora n.

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

Provalo online!

JavaScript (Node.js) ,  64  56 byte

Utilizzando reduce()e flat():

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

Provalo online!

Japt , 14 byte

rÈhY[°TT] c}Uî

Provalo

PHP , 101 byte

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

Provalo online!

Perl 5 -pal , 48 byte

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

Provalo online!

Prende l'array come elenco separato da spazi da STDIN. Non input n.

Retina 0.8.2 , 69 byte

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

Provalo online! Il link include casi di test. 1-indicizzati. Accetta input come ...list,N. Non richiede che l'elenco sia di lunghezza N. Spiegazione:

\d+
$*_

Converti tutti gli input in unari, ma usando _, in modo che non vengano confusi con gli usi successivi della cifra 1. (Retina 1 lo farebbe automaticamente per un salvataggio di 2 byte.)

r`_\G
,0

Sostituisci Ncon una matrice di Nzeri, ma non alterare l'elenco.

+`

Elabora tutti gli elementi dell'elenco.

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

Trova l'elemento successivo dell'elenco e la posizione equivalente nella matrice. $1= generazione corrente (come lunghezza), $2= virgole delle generazioni precedenti, $3= indice corrente - 1, $4= prime $3teste.

$2$4$.1,$.1

Sostituisci la testa nell'indice corrente con due copie della generazione corrente in decimale.

Pyth , 16 byte

u.nXGH,=+Z1ZE*]0

Provalo online!

È interessante notare che non posso usare sper appiattire l'elenco in quanto è in realtà una scorciatoia +F, che esegue +sugli ultimi due elementi dell'elenco fino a quando non sono stati elaborati tutti gli elementi. Ciò significa che i primi pochi elementi potrebbero semplicemente essere sommati, a seconda di dove è avvenuta l'ultima sostituzione.

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

Gelatina , 13 byte

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

Provalo online!

Link monadico che prende la lista 1-indicizzata delle teste da tagliare come argomento e restituisce la generazione finale.

C # (compilatore interattivo Visual C #) , 94 89 85 byte

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

Salvato 2 byte grazie ad Andrew Bauhmer

Provalo online!

05AB1E , 10 byte

-IvN>D‚yǝ˜

Provalo 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