Anstatt ein geschickter Krieger zu sein, der Hydras töten kann (siehe hier und hier ), bist du diesmal ein Krieger, der keine Vorkenntnisse darüber hat, wie man eine oder welche Waffen gegen die Kreatur verwendet.

Bei diesem Problem wachsen immer dann, wenn Sie einen einzigen Kopf abschneiden, zwei an derselben Stelle. Da Sie nicht den Mechanismus haben, um viele Köpfe gleichzeitig abzuschneiden, wird die Anzahl der Köpfe nur wachsen. In diesem Fall kann unsere Hydra mit N(N ⩾ 1) Köpfen beginnen. Nennen wir die erste Begegnung eine Generation und wir werden die Köpfe der ersten Generation als 0 darstellen , die Köpfe, die nach dem ersten Schlag erzeugt wurden, als 1 und so weiter.

Eingang

Sie erhalten eine Ganzzahl, Ndie angibt , wie viele Köpfe die Hydra anfangs hat, und eine Liste der Größen, die Nenthält, in welchem ​​Index (in den Beispielen verwende ich das 0-indizierte Format) Sie einen Kopf abschneiden. Sie können immer davon ausgehen, dass die angegebenen Indizes gültig sind - denken Sie daran, dass die Liste (dh die Köpfe) wächst, wenn Sie die Köpfe abschneiden.

Beispiel

Eingabe : N = 4und[0,4,2,5]

Generation 0 - Angriffsindex 0

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

Generation 1 - Angriffsindex 4

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

Generation 2 - Angriffsindex 2

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

Generation 3 - Angriffsindex 5

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

Letzte Generation

1 1 3 3 0 4 4 2

Wie Sie sehen, beziehen sich die angegebenen Indizes auf die Liste der vorherigen Generation.

Ausgabe

Sie müssen die letzte Generation ausgeben.

Testfälle

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]

Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes!

Python 2 , 59 Bytes

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

Probieren Sie es online!

Sehr clever -1 dank 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

Probieren Sie es online!

Stax , 12 11 Bytes

î╓≡╧▄#¥oWä)A

Führen Sie es aus und debuggen Sie es unter staxlang.xyz!

Dank rekursiv für ein Byte Ersparnis!

Entpackt (13 Bytes) und Erklärung:

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

Die Herausforderung besagt ausdrücklich, dass "Sie die letzte Generation ausgeben müssen". Ich vermute also, dass dieser Konsens hier nicht zutrifft. In diesem Fall können zehn Bytes verwaltet werden, indem das Ergebnis auf einem ansonsten leeren Stapel belassen wird:

z),Fi^c\&:f

Haskell , 63.57 Bytes

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

Probieren Sie es 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);

Testen Sie 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. Funktioniert für Nummern bis zu 255.

Zsh , 41 Bytes

Wir ignorieren N, wie in den Regeln angegeben .

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

Probieren Sie es online!

Ziemlich normal: Erstellen Sie ein Array von 0s zum Starten und drucken Sie es zum Beenden. Die a[i]=(a b)Methode des Änderns und Einfügens ist für mich neu, froh, dass ich eine Verwendung dafür gefunden habe.

ODER, auch 41 Bytes :

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

Dieser ist weniger Standard. Wir nutzen ein paar nette Tricks:

• ${a/#%/0}: Dies ist Ersatz, aber #und %tell zsh das Spiel am Anfang und Ende zu Anker. Da es leer ist, ersetzen wir alle leeren Elemente durch 0.
• a[#]=: Dies deklariert effektiv ein leeres Array der Größe $#in Zsh. Es ist wie char *a[argc]in C. Wenn wir das nicht tun, werden wir nicht die nachgestellten Nullen bekommen, die wir brauchen.

Probieren Sie es 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

Probieren Sie es online!

Scheint die längste Antwort zu sein. :)

List.fill(2)(l.max+1)kann durch ersetzt werden, List(l.max+1,l.max+1)aber die Länge bleibt gleich.

JavaScript (ES6),  61 59  51 Byte

Vielen Dank an @Shaggy, der darauf hingewiesen hat, dass dies nimmer die Länge des Arrays ist und in beiden Versionen 8 Byte gespart werden

Erwartet das Array im 0-indizierten Format. Ignoriert n.

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

Probieren Sie es online!

JavaScript (Node.js) ,  64  56 Bytes

Verwenden reduce()und flat():

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

Probieren Sie es online!

Japt , 14 Bytes

rÈhY[°TT] c}Uî

Versuch es

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

Probieren Sie es online!

Perl 5 -pal , 48 Bytes

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

Probieren Sie es online!

Nimmt Array als durch Leerzeichen getrennte Liste von STDIN. Gibt nicht ein n.

Retina 0.8.2 , 69 Bytes

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

Probieren Sie es online! Link enthält Testfälle. 1-indiziert. Übernimmt die Eingabe als ...list,N. Die Liste muss nicht lang sein N. Erläuterung:

\d+
$*_

Konvertieren Sie alle Eingaben in unary, aber using _, damit sie nicht mit späteren Verwendungen der Ziffer verwechselt werden 1. (Retina 1 würde dies automatisch für eine 2-Byte-Speicherung tun.)

r`_\G
,0

Ersetzen Sie Ndurch ein Array mit NNullen, aber ändern Sie die Liste nicht.

+`

Verarbeiten Sie alle Elemente der Liste.

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

Suchen Sie das nächste Element der Liste und die entsprechende Position im Array. $1= aktuelle Generation (als Länge), $2= Kommas aus früheren Generationen, $3= aktueller Index - 1, $4= erste $3Köpfe.

$2$4$.1,$.1

Ersetzen Sie den Kopf am aktuellen Index durch zwei Kopien der aktuellen Generation in Dezimalzahl.

Pyth , 16 Bytes

u.nXGH,=+Z1ZE*]0

Probieren Sie es online!

Interessanterweise kann ich sdie Liste nicht reduzieren, da es sich um eine Abkürzung handelt +F, die +für die beiden Elemente ganz links der Liste ausgeführt wird, bis alle Elemente verarbeitet wurden. Dies bedeutet, dass die ersten paar Elemente möglicherweise einfach summiert werden, je nachdem, wo die letzte Ersetzung stattgefunden hat.

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

Gelee , 13 Bytes

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

Probieren Sie es online!

Monadischer Link, der die 1-indizierte Liste der zu schneidenden Köpfe als Argument verwendet und die letzte Generation zurückgibt.

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

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

2 Bytes gespart dank Andrew Bauhmer

Probieren Sie es online!

05AB1E , 10 Bytes

-IvN>D‚yǝ˜

Probieren Sie es 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