introduzione

Alcuni di voi potrebbero aver sentito parlare del Grand Hotel di Hilbert . Il manager ha perso la sua lista di dove alloggiano gli ospiti, ma ha ancora l'ordine in cui hanno effettuato il check-in. Ogni ospite non può stare in una stanza con un numero di stanza inferiore al loro valore e se un ospite viene aggiunto a un livello inferiore stanza, tutti gli ospiti nelle stanze superiori senza spazio vuoto tra loro e il nuovo ospite vengono spostati in una stanza. Puoi aiutarlo a trovare dove alloggiano gli ospiti?

Requisiti

Scrivi un programma che riceve un elenco ordinato di numeri naturali come input e li posiziona nel loro indice. Se esiste già un valore in quell'indice, viene spostato alla voce successiva nell'elenco. Questo processo si ripete fino a quando non viene trovato il primo spazio vuoto (0 o non definito). Tutti gli spazi non definiti tra l'indice più alto corrente e qualsiasi nuovo input verranno riempiti aggiungendo 0. Dato che si tratta del Grand Hotel di Hilbert, non esistono camere più alte dell'attuale indice più alto occupato.

Ingresso e uscita

L'ingresso sarà un elenco ordinato di numeri naturali (è possibile leggere attraverso qualsiasi forma accettata di input)
Ogni numero nell'input è considerato un ospite che arriva in hotel ed è in ordine di arrivo

L'output sarà la disposizione finale degli ospiti (numeri)

Esempi

Input: 1 3 1
Output: 1 1 3
Step by step:
1
Crea spazio all'indice 1 e posiziona 1 in esso
1 0 3
Crea room fino all'indice 3 e posiziona 3 in room 3
1 1 3
Sposta il contenuto della room 1 in alto una stanza e posizionare 1 nella stanza 1

Input: 1 4 3 1 2 1
Output : 1 1 2 1 3 4
Step by step:
1
Crea room all'indice 1 e posiziona 1 in esso
1 0 0 4
Crea room fino all'indice 4 e posiziona 4 in room 4
1 0 3 4
Posiziona 3 nella stanza 3
1 1 3 4
Sposta il contenuto della stanza 1 su una stanza e posiziona 1 nella stanza 1
1 2 1 3 4
Sposta il contenuto delle stanze da 2 a 4 in alto di una stanza e metti 2 in stanza 2
1 1 2 1 3 4
Spostare il contenuto delle stanze da 1 a 5 in alto di una stanza e posizionare 1 nella stanza 1

Ingresso: 10
Uscita: 0 0 0 0 0 0 0 0 0 0 10
Passo dopo passo:
0 0 0 0 0 0 0 0 0 10
Crea room fino alla room 10 e posiziona 10 nella room 10

Gli appunti:
lavorare con 0 indicizzato va bene e in questo caso è possibile inserire uno 0 nella parte anteriore dell'output

Sono vietate le scappatoie standard , vince il codice più corto in byte

Gelatina , 28 byte

ṫœṡ0F
’⁹ḣ;⁸;ç@ð0ẋ;@
0;ç@/œr0

Provalo online!

PHP 93 byte

for(;$r=$g?$r+1:$g=$argv[++$i];[$g,$h[$r]]=[$h[$r],$g])$h=array_pad($h?:[],$g,0);print_r($h);

0 indicizzato. Utilizza un ciclo 2 in 1 che cerca il guest successivo dopo che ottiene uno 0 (o un modulo null che va oltre l'attuale room finale). Usa come:

php -r "for(;$r=$g?$r+1:$g=$argv[++$i];[$g,$h[$r]]=[$h[$r],$g])$h=array_pad($h?:[],$g,0);print_r($h);" 1 4 3 1 2 1

Ungolfed:

for( $hotel = []; $room = $guest = $argv[ ++$i ]; )
{
    for( $hotel = array_pad( $hotel, $guest, 0 ); $guest; $room++ )
    {
        $last = $hotel[ $room ];
        $hotel[ $room ] = $guest;
        $guest = $last;
    }
}
print_r( $hotel );

Haskell , 107 byte

h=foldl(\h n->let{(b,a)=splitAt n h;(c,d)=span(>0)a;e=0:e;f=take n$b++e;g(0:m)=m;g m=m}in f++[n]++c++g d)[]

Provalo online!

JavaScript (ES6), 144 120 byte

Risparmio 20B grazie ad Arnauld e 11B grazie a Neil

a=>a.map((d,c)=>b[d]?(b.splice(d,0,d),b.splice([...b,0].find‌​Index((e,g)=>g&&!e),‌​1)):b[d]=d,b=[])&&[...b].map(c=>c|0)

uso

È possibile assegnare la funzione alla variabile fe l'elenco deve essere fornito come un array. Esempio:

f=a=>a.map((d,c)=>b[d]?(b.splice(d,0,d),b.splice([...b,0].find‌​Index((e,g)=>g&&!e),‌​1)):b[d]=d,b=[])&&[...b].map(c=>c|0)
f([1,4,3,1,2,1])

Produzione

Anche l'output è in un array. Poiché Javascript funziona a zero, c'è un ulteriore 0 in primo piano.

[0, 1, 1, 2, 1, 3, 4]

JavaScript (ES6), 86 byte

f=([n,...a],r=[],p=n,m=r[p],_=r[p]=n)=>n?m?f([m,...a],r,p+1):f(a,r):[...r].map(n=>n|0)

Zero iniziale nel risultato perché JavaScript è indicizzato 0.

Mathematica, 98 byte

Fold[If[Length@#<#2,PadRight@##~Append~#2,Join[Take@##,{#2},Drop@##/.{a___,0,b__}->{a,b}]]&,{0},#]&

Funzione senza nome che prende un elenco di numeri interi positivi e restituisce un elenco di numeri interi con indice 0. L'intera Iffunzione accetta un elenco parzialmente completato e il numero intero successivo da inserire come argomenti. Se il numero intero successivo supera la lunghezza dell'elenco parziale, PadRight@##~Append~#2aumenta di conseguenza l'elenco parziale; in caso contrario, Join[Take@##,{#2},Drop@##/.{a___,0,b__}->{a,b}]]inserisce il numero intero successivo nella sua posizione, quindi elimina il primo 0trovato successivo. Fold[...,{0},#]applica ripetutamente questa funzione all'elenco originale, iniziando con l'hotel vuoto {0}, e restituisce l'elenco finale degli hotel.

JavaScript (ES6), 81

Utilizzando 0 indicizzazione

l=>l.map(v=>(s=(p,v,w=r[p])=>(w&&s(p+1,w),r[p]=v))(v,v),r=[])&&[...r].map(x=>~~x)

Meno golf

l => {
  s = ( // recursively insert a value, shifting present values up until it finds an empty spot
       p, // insert position
       v, // value to insert
       w = r[p] // value a current position
      ) => ( 
         w && s(p+1,w), // if there is a value, put it in the next position
         r[p] = v // now the current place is empty
      );
  r = []; // initialize the result array   
  l.map( // execute the following for each value in input
     v => s(v,v) // insert value
  );
  return [...r].map(x=>~~x) // fill the missing places with 0
}

Test

F=
l=>l.map(v=>(s=(p,v,w=r[p])=>(w&&s(p+1,w),r[p]=v))(v,v),r=[])&&[...r].map(x=>~~x)

out=x=>O.textContent+=x+'\n'

out([1,3,1]+' -> '+F([1,3,1]))
out([10]+' -> '+F([10]))

function go() {
   var v = I.value.match(/\d+/g).map(x=>+x)
   out(v +' -> ' + F(v))
}
go()

<input id=I value='1 4 3 1 2 1'><button onclick='go()'>go</button>
<pre id=O></pre>

R, 133 byte

a=scan()
z=rep(0,max(a))
for(i in a){b=match(0,z[-1:-i])+i
if(z[i])z[i:b]=c(i,z[i:(b-1)])else(z[i]=i)
z=c(z,0)}
z[1:max(which(z!=0))]

Per evitare problemi con una cattiva indicizzazione, inserisco alcuni zeri e quindi li spoglio alla fine. Questa non è forse la soluzione migliore, ma funziona.

Python, 134 125 116 byte

def a(b):
 r=[]
 i=0
 for n in b:
    d=n
    while n:
     if i<d:r.extend([0]*(d-i));i=d
     n,r[d-1]=r[d-1],n;d+=1
 return r

Valido per Python 2.7.13 e 3.6.0. Questo codice funziona mediante lo scambio del valore trattenuto con il valore contenuto in ciascun indice fino a quando il valore trattenuto è 0. Se raggiunge un indice non ancora presente nella matrice, aggiunge zeri alla fine della matrice fino a quando la matrice non contiene indice. Grazie a Wheat Wizard e xnor per giocare a golf con 9 byte ciascuno