Au lieu d'être un guerrier habile capable de tuer des hydres (voir ici et ici ), cette fois, vous êtes un guerrier qui n'a aucune connaissance préalable de la façon de tuer une ou des armes à utiliser contre la créature.

Dans ce problème, chaque fois que vous coupez une seule tête, deux poussent au même endroit. Puisque vous n'avez pas le mécanisme pour couper plusieurs têtes simultanément, le nombre de têtes ne fera qu'augmenter. Dans ce cas, notre Hydra peut commencer avec N(N ⩾ 1) têtes. Appelons la première rencontre une génération et nous représenterons les têtes de la première génération comme 0 , les têtes créées après le premier coup comme 1 , et ainsi de suite.

Contribution

Vous recevrez un entier Nreprésentant le nombre de têtes que l'Hydra a initialement et une liste de taille Ncontenant dans quel index (dans les exemples j'utiliserai le format indexé 0) vous couperez une tête. Vous pouvez toujours supposer que les index donnés sont valides - rappelez-vous que la liste (c'est-à-dire: les têtes) augmentera à mesure que vous couperez les têtes.

Exemple

Entrée : N = 4et[0,4,2,5]

Génération 0 - Indice d'attaque 0

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

Génération 1 - Indice d'attaque 4

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

Génération 2 - Indice d'attaque 2

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

Génération 3 - Indice d'attaque 5

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

La dernière génération

1 1 3 3 0 4 4 2

Comme vous pouvez le voir, les index donnés sont liés à la liste de la génération précédente.

Production

Vous devez sortir la dernière génération.

Cas de 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]

C'est le code-golf, donc la réponse la plus courte en octets gagne!

Python 2 , 59 octets

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

Essayez-le en ligne!

Très intelligent -1 grâce à xnor .

Python 2 , 60 octets

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

Essayez-le en ligne!

Stax , 12 11 octets

î╓≡╧▄#¥oWä)A

Exécutez-le et déboguez-le sur staxlang.xyz!

Merci à récursif pour un octet d'économies!

Déballé (13 octets) et explication:

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

Le défi dit explicitement «vous devez produire la dernière génération», donc je suppose que ce consensus ne tient pas ici. Si c'est le cas, cependant, dix octets peuvent être gérés en laissant le résultat sur une pile autrement vide:

z),Fi^c\&:f

Haskell , 63 57 octets

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

Essayez-le en ligne!

Oracle SQL, 325 octets

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

Testez dans 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. Fonctionne pour des nombres jusqu'à 255.

Zsh , 41 octets

Nous ignorons N, comme indiqué par les règles .

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

Essayez-le en ligne!

Assez standard: créez un tableau de 0 pour commencer, imprimez-le pour terminer. La a[i]=(a b)méthode de changement et d'insertion est nouvelle pour moi, heureuse d'avoir trouvé une utilisation.

OU, également 41 octets :

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

Celui-ci est moins standard. Nous profitons de quelques astuces intéressantes:

• ${a/#%/0}: C'est un remplacement, mais #et %dites à zsh d'ancrer le match au début et à la fin. Puisqu'il est vide, nous remplaçons tous les éléments vides par 0.
• a[#]=: Cela déclare effectivement un tableau vide de taille $#dans Zsh. C'est comme char *a[argc]en C. Si nous ne faisons pas cela, nous n'obtiendrons pas les zéros de fin dont nous avons besoin.

Essayez-le en ligne!

Scala , 104 octets

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

Essayez-le en ligne!

Semble être la réponse la plus longue jusqu'à présent. :)

List.fill(2)(l.max+1)peut être remplacé par List(l.max+1,l.max+1)mais la longueur reste la même.

JavaScript (ES6),  61 59  51 octets

Merci à @Shaggy d'avoir souligné que nc'est toujours la longueur du tableau, économisant 8 octets dans les deux versions

Attend le tableau au format indexé 0. Ignore n.

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

Essayez-le en ligne!

JavaScript (Node.js) ,  64  56 octets

Utilisation de reduce()et flat():

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

Essayez-le en ligne!

Japt , 14 octets

rÈhY[°TT] c}Uî

Essayez-le

PHP , 101 octets

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

Essayez-le en ligne!

Perl 5 -pal , 48 octets

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

Essayez-le en ligne!

Prend le tableau en tant que liste séparée par des espaces de STDIN. N'entre pas n.

Retina 0.8.2 , 69 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. 1 indexé. Prend l'entrée comme ...list,N. Ne nécessite pas que la liste soit longue N. Explication:

\d+
$*_

Convertissez toutes les entrées en unaire, mais en utilisant _, afin qu'il ne soit pas confondu avec les utilisations ultérieures du chiffre 1. (Retina 1 le ferait automatiquement pour une économie de 2 octets.)

r`_\G
,0

Remplacez Npar un tableau de Nzéros, mais ne modifiez pas la liste.

+`

Traitez tous les éléments de la liste.

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

Recherchez l'élément suivant de la liste et la position équivalente dans le tableau. $1= génération actuelle (en longueur), $2= virgules des générations précédentes, $3= index actuel - 1, $4= premières $3têtes.

$2$4$.1,$.1

Remplacez la tête à l'index actuel par deux copies de la génération actuelle en décimal.

Pyth , 16 octets

u.nXGH,=+Z1ZE*]0

Essayez-le en ligne!

Fait intéressant, il s'avère que je ne peux pas utiliser spour aplatir la liste car c'est en fait un raccourci pour +F, qui fonctionne +sur les deux éléments les plus à gauche de la liste jusqu'à ce que tous les éléments aient été traités. Cela signifie que les premiers éléments peuvent simplement être additionnés, selon l'endroit où le dernier remplacement s'est produit.

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ée , 13 octets

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

Essayez-le en ligne!

Lien monadique qui prend comme argument la liste de têtes indexée 1 et renvoie la génération finale.

C # (Visual C # Interactive Compiler) , 94 89 85 octets

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

Enregistré 2 octets grâce à Andrew Bauhmer

Essayez-le en ligne!

05AB1E , 10 octets

-IvN>D‚yǝ˜

Essayez-le en ligne!

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