Hidraları öldürme yeteneğine sahip yetenekli bir savaşçı olmak yerine ( buraya ve buraya bakın ), bu kez yaratığa karşı kullanılacak silahları veya hangi silahları nasıl kullanacağınız hakkında önceden bilgisi olmayan bir savaşçısınız.

Bu problemde, tek bir başı kestiğinizde, ikisi aynı yerde büyüyecektir. Aynı anda birçok kafayı kesecek bir mekanizmaya sahip olmadığınız için, kafa sayısı sadece artacaktır. Bu durumda, Hydra N(N ⩾ 1) kafalarıyla başlayabilir . Let ilk karşılaşması bir nesil diyoruz ve biz ilk kuşaktan başlarını temsil edecektir 0 olarak ilk darbe sonrası oluşturulan başkanları, 1 , vb.

Giriş

NBaşlangıçta Hydra'nın kaç kafaya sahip olduğunu gösteren bir tam sayı ve Nhangi dizinde ( boyutlarda 0 dizinli format kullanacağım) içeren bir boyut listesi verilir . Verilen dizinlerin her zaman geçerli olduğunu varsayabilirsiniz - kafaları kestiğinizde listenin (örn. Kafalar) büyüyeceğini unutmayın.

Misal

Girdi : N = 4ve[0,4,2,5]

Nesil 0 - Saldırı endeksi 0

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

Nesil 1 - Saldırı endeksi 4

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

Nesil 2 - Saldırı endeksi 2

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

Nesil 3 - Saldırı endeksi 5

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

Son nesil

1 1 3 3 0 4 4 2

Gördüğünüz gibi, verilen indeksler önceki neslin listesiyle ilgilidir.

Çıktı

Son nesli çıkarmanız gerekiyor.

Test senaryoları

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]

Bu kod golf bayt kazanır çok kısa cevap kazanır!

Python 2 , 59 bayt

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

Çevrimiçi deneyin!

Xnor sayesinde çok zeki -1 .

Python 2 , 60 bayt

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

Çevrimiçi deneyin!

Stax , 12 11 bayt

î╓≡╧▄#¥oWä)A

Çalıştırın ve hata ayıklayın staxlang.xyz!

Bir bayt tasarruf için özyinelemeli teşekkürler !

Ambalajsız (13 bayt) ve açıklama:

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

Zorluk açıkça "son nesli çıkarmanız gerekiyor" diyor, bu yüzden tahminimce bu fikir birliği burada kalmıyor. Bununla birlikte, sonuç başka türlü boş bir yığın üzerinde bırakılarak on bayt yönetilebilir:

z),Fi^c\&:f

Haskell , 63 57 bayt

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

Çevrimiçi deneyin!

Oracle SQL, 325 bayt

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

SQL * Plus'ta test edin.

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. 255'e kadar olan sayılar için çalışır.

Zsh , 41 bayt

Kurallarda belirtildiği gibi N'yi görmezden geliriz .

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

Çevrimiçi deneyin!

Oldukça standart: Başlamak için 0 saniyelik bir dizi yapın, bitirmek için yazdırın. Değiştirme a[i]=(a b)ve yerleştirme yöntemi benim için yeni, mutlu bunun için bir kullanım buldum.

VEYA, ayrıca 41 bayt :

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

Bu daha az standarttır. Birkaç düzgün hileden yararlanıyoruz:

• ${a/#%/0}Bu yerine geçer, ancak #ve %demire söyle zsh başında ve sonunda maçı. Boş olduğundan, tüm boş öğeleri 0 ile değiştiririz.
• a[#]=: Bu $#, Zsh'da boş bir boyut dizisini etkili bir şekilde bildirir . char *a[argc]C'deki gibi . Eğer bunu yapmazsak, ihtiyacımız olan sondaki sıfırları alamayacağız.

Çevrimiçi deneyin!

Scala , 104 bayt

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

Çevrimiçi deneyin!

Şimdiye kadarki en uzun cevap gibi görünüyor. :)

List.fill(2)(l.max+1)ile değiştirilebilir List(l.max+1,l.max+1)ancak uzunluk aynı kalır.

JavaScript (ES6),  61 59  51 bayt

@Shaggy sayesinde nher zaman dizinin uzunluğuna işaret eder , her iki sürümde de 8 bayt tasarruf sağlar

Diziyi 0 dizinli biçimde bekler. Yok sayar n.

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

Çevrimiçi deneyin!

JavaScript (Node.js) ,  64  56 bayt

Kullanılması reduce()ve flat():

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

Çevrimiçi deneyin!

Japt , 14 bayt

rÈhY[°TT] c}Uî

Dene

PHP , 101 bayt

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

Çevrimiçi deneyin!

Perl 5 -pal , 48 bayt

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

Çevrimiçi deneyin!

Diziyi STDIN'den boşlukla ayrılmış liste olarak alır. Girilmez n.

Retina 0.8.2 , 69 bayt

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. 1 endeksli. Girişi alır ...list,N. Listenin uzun olmasını gerektirmez N. Açıklama:

\d+
$*_

Rakamın _sonraki kullanımlarıyla karıştırılmaması için tüm girişleri tekli, ancak kullanarak dönüştürün 1. (Retina 1 bunu 2 baytlık tasarruf için otomatik olarak yapar.)

r`_\G
,0

Değiştir Nbir dizi Nsıfır, ancak liste değiştirmez.

+`

Listenin tüm öğelerini işleyin.

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

Listenin bir sonraki öğesini ve dizideki eşdeğer konumu bulun. $1= akım üretimi (uzunluk olarak), $2= önceki nesillerden virgül, $3= akım endeksi - 1, $4= ilk $3başlıklar.

$2$4$.1,$.1

Geçerli dizindeki başlığı, geçerli neslin ondalık olarak iki kopyasıyla değiştirin.

Pyth , 16 bayt

u.nXGH,=+Z1ZE*]0

Çevrimiçi deneyin!

İlginç bir şekilde, slisteyi aslında kısayol olarak düzleştirmek için kullanamadığım ortaya çıkıyor, bu da tüm öğeler işlenene kadar listenin en soldaki iki öğesini +Fgerçekleştiriyor +. Bu, son değiştirmenin gerçekleştiği yere bağlı olarak ilk birkaç öğenin toplanabileceği anlamına gelir.

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

Jöle , 13 bayt

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

Çevrimiçi deneyin!

Bağımsız değişken olarak kesmek için 1 dizinli başlık listesini alan ve son nesli döndüren monadik bağlantı.

C # (Görsel C # Etkileşimli Derleyici) , 94 89 85 bayt

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

Andrew Bauhmer sayesinde 2 bayt tasarruf edildi

Çevrimiçi deneyin!

05AB1E , 10 bayt

-IvN>D‚yǝ˜

Çevrimiçi deneyin!

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