Zamiast być zręcznym wojownikiem zdolnym do zabijania Hydr (patrz tutaj i tutaj ), tym razem jesteś wojownikiem, który nie ma wcześniejszej wiedzy o tym, jak zabić jedną lub jaką broń użyć przeciwko stworzeniu.

W tym problemie, ilekroć odetniesz pojedynczą głowę, dwie będą rosły w tym samym miejscu. Ponieważ nie masz mechanizmu odcinania wielu głowic jednocześnie, liczba głowic będzie tylko rosła. W takim przypadku nasza Hydra może zacząć od N(N ⩾ 1) głów. Nazwijmy pierwsze spotkanie pokoleniem, a my reprezentujemy głowy pierwszej generacji jako 0 , głowy utworzone po pierwszym uderzeniu jako 1 i tak dalej.

Wejście

Otrzymasz liczbę całkowitą N reprezentującą, ile głów Hydra początkowo ma, oraz listę rozmiarów Nzawierającą, w którym indeksie (w przykładach użyję formatu 0-indeksowanego) odetniesz głowę. Zawsze możesz założyć, że podane indeksy są prawidłowe - pamiętaj, że lista (tj. Główki) będzie rosła w miarę odcinania głów.

Przykład

Wejście :N = 4 i[0,4,2,5]

Generacja 0 - Indeks ataku 0

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

Generacja 1 - Indeks ataku 4

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

Generacja 2 - Indeks ataku 2

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

Generacja 3 - Indeks ataku 5

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

Ostatnie pokolenie

1 1 3 3 0 4 4 2

Jak widać, podane indeksy są powiązane z listą poprzedniej generacji.

Wynik

Jesteś zobowiązany do wyjścia ostatniej generacji.

Przypadki testowe

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]

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach!

Python 2 , 59 bajtów

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

Wypróbuj online!

Bardzo sprytne -1 dzięki xnor .

Python 2 , 60 bajtów

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

Wypróbuj online!

Stax , 12 11 bajtów

î╓≡╧▄#¥oWä)A

Uruchom i debuguj na staxlang.xyz!

Dzięki rekursywnemu za jeden bajt oszczędności!

Rozpakowane (13 bajtów) i objaśnienie:

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

Wyzwanie jednoznacznie mówi „jesteś zobowiązany do wydania ostatniego pokolenia”, więc zgaduję, że ten konsensus nie ma tu miejsca. Jeśli tak się stanie, można zarządzać dziesięcioma bajtami, pozostawiając wynik na innym pustym stosie:

z),Fi^c\&:f

Haskell , 63 57 bajtów

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

Wypróbuj online!

Oracle SQL, 325 bajtów

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

Testuj w 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. Działa dla liczb do 255.

Zsh , 41 bajtów

Ignorujemy N, zgodnie z zasadami .

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

Wypróbuj online!

Całkiem standardowy: utwórz tablicę zer, aby rozpocząć, wydrukuj ją, aby zakończyć. a[i]=(a b)Metoda zarówno zmieniających się i wkładając jest dla mnie nowe, szczęśliwe Znalazłem ją wykorzystać.

LUB również 41 bajtów :

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

Ten jest mniej standardowy. Korzystamy z kilku schludnych sztuczek:

• ${a/#%/0}: To jest zamiana, ale #i% tell zsh do kotwicy mecz na początku i na końcu. Ponieważ jest pusty, wszystkie puste elementy zamieniamy na 0.
• a[#]=: To skutecznie deklaruje pustą tablicę rozmiarów $#w Zsh. To jest jak char *a[argc]w C. Jeśli tego nie zrobimy, nie otrzymamy końcowych zer, których potrzebujemy.

Wypróbuj online!

Scala , 104 bajty

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

Wypróbuj online!

Wydaje się, że jest to najdłuższa jak dotąd odpowiedź. :)

List.fill(2)(l.max+1)można zastąpić, List(l.max+1,l.max+1)ale długość pozostaje taka sama.

JavaScript (ES6),  61 59  51 bajtów

Dzięki @Shaggy za zwrócenie na to uwagi n zawsze ma długość tablicy, oszczędzając 8 bajtów w obu wersjach

Oczekuje tablicy w formacie 0-indeksowanym. Ignoruje n.

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

Wypróbuj online!

JavaScript (Node.js) ,  64  56 bajtów

Korzystanie reduce()i flat():

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

Wypróbuj online!

Japt , 14 bajtów

rÈhY[°TT] c}Uî

Spróbuj

PHP , 101 bajtów

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

Wypróbuj online!

Perl 5 -pal , 48 bajtów

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

Wypróbuj online!

Pobiera tablicę jako listę oddzieloną spacjami od STDIN. Nie wejście n.

Retina 0.8.2 , 69 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. 1-indeksowany. Pobiera dane wejściowe jako ...list,N. Nie wymaga, aby lista była długa N. Wyjaśnienie:

\d+
$*_

Konwertuj wszystkie dane wejściowe na jednoargumentowe, ale za pomocą _, aby nie pomylić ich z późniejszym użyciem cyfry 1. (Retina 1 zrobiłaby to automatycznie w celu zaoszczędzenia 2 bajtów).

r`_\G
,0

Zamień Ntablicę Nzer, ale nie zmieniaj listy.

+`

Przetwórz wszystkie elementy listy.

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

Znajdź następny element listy i równoważną pozycję w tablicy. $1= bieżąca generacja (jako długość), $2= przecinki z poprzednich generacji, $3= aktualny indeks - 1, $4= pierwsze $3głowice.

$2$4$.1,$.1

Zamień głowicę przy bieżącym indeksie na dwie kopie bieżącej generacji w systemie dziesiętnym.

Pyth , 16 bajtów

u.nXGH,=+Z1ZE*]0

Wypróbuj online!

Co ciekawe, okazuje się, że nie mogę użyć sdo spłaszczenia listy, ponieważ tak naprawdę jest ona skrótem +F, która wykonuje +dwa skrajnie lewe elementy listy, dopóki wszystkie elementy nie zostaną przetworzone. Oznacza to, że kilka pierwszych elementów można po prostu zsumować, w zależności od tego, gdzie nastąpiła ostatnia zamiana.

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

Galaretka , 13 bajtów

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

Wypróbuj online!

Monadyczny link, który przyjmuje jako argument argument 1-indeksowaną listę głów i zwraca ostatnią generację.

C # (interaktywny kompilator Visual C #) , 94 89 85 bajtów

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

Zaoszczędzono 2 bajty dzięki Andrew Bauhmerowi

Wypróbuj online!

05AB1E , 10 bajtów

-IvN>D‚yǝ˜

Wypróbuj 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