Introducción

Algunos de ustedes habrán oído hablar del Hilbert's Grand Hotel . El gerente allí ha perdido su lista de dónde se hospedan los invitados, pero aún tiene el orden en el que se registraron. Cada huésped no puede permanecer en una habitación con un número de habitación inferior a su valor y si un invitado se agrega a una tarifa inferior habitación, todos los huéspedes en habitaciones superiores sin espacio vacío entre ellos y el nuevo huésped se desplazan una habitación. ¿Puedes ayudarlo a encontrar dónde se hospedan cada uno de los invitados?

Requisitos

Escriba un programa que reciba una lista ordenada de números naturales como entrada y los coloque en su índice. Si ya hay un valor en ese índice, se desplaza a la siguiente entrada de la lista. Este proceso se repite hasta que se encuentra el primer espacio vacío (0 o indefinido). Cualquier espacio indefinido entre el índice más alto actual y cualquier entrada nueva se llenará agregando 0s. Como se trata del Grand Hotel de Hilbert, no existen habitaciones más altas que el índice ocupado más alto actual.

Entrada y salida

La entrada será una lista ordenada de números naturales (se permite leer a través de cualquier forma de entrada aceptada)
Cada número en la entrada se considera un huésped que llega al hotel y está en orden de llegada

La salida será la disposición final de los invitados (números)

Ejemplos

Entrada: 1 3 1
Salida: 1 1 3
Paso a paso:
1
Cree una habitación en el índice 1 y coloque 1 en ella
1 0 3
Cree habitaciones hasta el índice 3 y coloque 3 en la habitación 3
1 1 3
Cambie el contenido de la habitación 1 hacia arriba una habitación y lugar 1 en la habitación 1

Entrada: 1 4 3 1 2 1
Salida : 1 1 2 1 3 4
Paso a paso:
1
Crear habitación en el índice 1 y colocar 1 en ella
1 0 0 4
Crear habitaciones hasta el índice 4 y colocar 4 en la habitación 4
1 0 3 4
Coloque 3 en la habitación 3
1 1 3 4
Cambie el contenido de la habitación 1 hacia arriba una habitación y coloque 1 en la habitación 1
1 2 1 3 4
Cambie el contenido de las habitaciones 2 a 4 hasta una habitación y coloque 2 en la habitación 2
1 1 2 1 3 4
Cambie el contenido de las habitaciones 1 a 5 hacia arriba una habitación y coloque 1 en la habitación 1

Entrada: 10
Salida: 0 0 0 0 0 0 0 0 0 0 10
Paso a paso:
0 0 0 0 0 0 0 0 0 10
Crea habitaciones hasta la habitación 10 y coloca 10 en la habitación 10

Notas:
Trabajar con 0 indexado está bien y puede insertar un 0 al frente de la salida en ese caso

Las lagunas estándar están prohibidas, el código más corto en bytes gana

Jalea , 28 bytes

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

Pruébalo en línea!

PHP 93 bytes

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

0 indexado. Utiliza un bucle 2 en 1 que busca al siguiente invitado después de que obtiene un 0 (o una forma nula que va más allá de la sala final actual). Usar como:

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

Sin golf:

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 bytes

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)[]

Pruébalo en línea!

JavaScript (ES6), 144 120 bytes

Ahorró 20B gracias a Arnauld y 11B gracias 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

Puede asignar la función a la variable fy la lista debe darse como una matriz. Ejemplo:

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

Salida

La salida también está en una matriz. Dado que Javascript funciona indexado a cero, hay un 0 adicional por adelantado.

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

JavaScript (ES6), 86 bytes

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)

El cero inicial en el resultado porque JavaScript está indexado en 0.

Mathematica, 98 bytes

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

Función sin nombre que toma una lista de enteros positivos y devuelve una lista de enteros indexados en 0. Toda la Iffunción toma una lista parcialmente completada y el siguiente entero para insertar como argumentos. Si el siguiente entero excede la longitud de la lista parcial, PadRight@##~Append~#2aumenta la lista parcial en consecuencia; de lo contrario, Join[Take@##,{#2},Drop@##/.{a___,0,b__}->{a,b}]]inserta el siguiente entero en su posición, luego tira el primero que se 0encuentra después de él. Fold[...,{0},#]aplica esta función repetidamente a la lista original, comenzando con el hotel vacío {0}, y genera la lista final de hoteles.

JavaScript (ES6), 81

Usando 0 indexación

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)

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

Prueba

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 bytes

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

Para evitar problemas con una mala indexación, relleno con algunos ceros y luego los elimino al final. Quizás esta no sea la mejor solución, pero funciona.

Pitón, 134 125 116 bytes

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

Válido para Python 2.7.13 y 3.6.0. Este código funciona mediante el intercambio del valor retenido con el valor contenido en cada índice hasta que el valor retenido sea 0. Si alcanza un índice que aún no está en la matriz, agrega ceros al final de la matriz hasta que la matriz contenga índice. Gracias a Wheat Wizard y xnor por jugar 9 bytes cada uno