introduction

Certains d'entre vous ont peut-être entendu parler du Hilbert's Grand Hotel . Le responsable a perdu sa liste des lieux de séjour des invités mais il a toujours l'ordre dans lequel ils se sont enregistrés. chambre, tous les invités dans les chambres supérieures sans espace vide entre eux et le nouvel invité sont déplacés d'une chambre. Pouvez-vous l'aider à trouver où logent chacun des invités?

Exigences

Écrivez un programme qui reçoit une liste ordonnée de nombres naturels en entrée et les place à leur index. S'il existe déjà une valeur dans cet index, elle est déplacée vers le haut jusqu'à l'entrée suivante dans la liste. Ce processus se répète jusqu'à ce que le premier espace vide (0 ou non défini) soit trouvé. Tout espace non défini entre l'index le plus élevé actuel et toute nouvelle entrée sera rempli en ajoutant des 0. Comme il s'agit du Hilbert's Grand Hotel, les chambres supérieures à l'indice d'occupation actuel le plus élevé n'existent pas.

Entrée et sortie

L'entrée sera une liste ordonnée de nombres naturels (autorisés à être lus à travers toute forme acceptée d'entrée)
Chaque numéro dans l'entrée est considéré comme un invité arrivant à l'hôtel et est dans l'ordre d'arrivée

La sortie sera l'arrangement final des invités (nombres)

Exemples

Entrée: 1 3 1
Sortie: 1 1 3
Étape par étape:
1
Créez une pièce à l'index 1 et placez-y 1
1 3
Créez des pièces jusqu'à l'index 3 et placez 3 dans la pièce 3
1 1 3
Déplacez le contenu de la pièce 1 vers le haut une pièce et place 1 dans la pièce 1

Entrée: 1 4 3 1 2 1
Sortie : 1 1 2 1 3 4
Étape par étape:
1
Créez une pièce à l'index 1 et placez-y 1
1 0 0 4
Créez des pièces jusqu'à l'index 4 et placez 4 dans la pièce 4
1 0 3 4
Placez 3 dans la pièce 3
1 1 3 4
Déplacez le contenu de la pièce 1 vers le haut d'une pièce et placez 1 dans la pièce 1
1 2 1 3 4
Déplacez le contenu des pièces 2 à 4 vers le haut d'une pièce et placez 2 dans la pièce 2
1 1 2 1 3 4
Décaler le contenu des pièces 1 à 5 d'une pièce et placer 1 dans la pièce 1

Entrée: 10
Sortie: 0 0 0 0 0 0 0 0 0 0 10 10
Pas à pas:
0 0 0 0 0 0 0 0 0 10
Créez des pièces jusqu'à la pièce 10 et placez 10 dans la pièce 10

Remarques:
travailler avec 0 indexé est très bien et vous pouvez insérer un 0 à l'avant de la sortie dans ce cas

Les failles standard sont interdites, le code le plus court en octets gagne

Gelée , 28 octets

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

Essayez-le en ligne!

PHP 93 octets

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

0 indexé. Utilise une boucle 2 en 1 qui recherche l'invité suivant après avoir obtenu un 0 (ou une forme nulle dépassant la salle finale actuelle). Utilisez comme:

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

Non 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 octets

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

Essayez-le en ligne!

JavaScript (ES6), 144 120 octets

Sauvé de 20 milliards grâce à Arnauld et de 11 milliards grâce à 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)

Usage

Vous pouvez affecter la fonction à la variable fet la liste doit être donnée sous forme de tableau. Exemple:

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

Sortie

La sortie est également dans un tableau. Étant donné que Javascript fonctionne avec un index zéro, il y a un 0 supplémentaire à l'avant.

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

JavaScript (ES6), 86 octets

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)

Zéro en tête du résultat car JavaScript est indexé sur 0.

Mathematica, 98 octets

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

Fonction sans nom prenant une liste d'entiers positifs et renvoyant une liste d'entiers indexés sur 0. La Iffonction entière prend une liste partiellement complétée et le prochain entier à insérer comme arguments. Si l'entier suivant dépasse la longueur de la liste partielle, PadRight@##~Append~#2augmente la liste partielle en conséquence; sinon, Join[Take@##,{#2},Drop@##/.{a___,0,b__}->{a,b}]]insère le prochain entier dans sa position, puis jette le premier 0trouvé après lui. Fold[...,{0},#]applique cette fonction à plusieurs reprises à la liste d'origine, en commençant par l'hôtel vide {0}, et affiche la liste finale des hôtels.

JavaScript (ES6), 81

Utilisation de l'indexation 0

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)

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

Tester

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 octets

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

Pour éviter les problèmes d'indexation incorrecte, je remplis de zéros, puis je les supprime à la fin. Ce n'est peut-être pas la meilleure solution, mais cela fonctionne.

Python, 134 125 116 octets

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

Valable pour Python 2.7.13 et 3.6.0. Ce code fonctionne au moyen d'un échange de la valeur maintenue avec la valeur contenue à chaque index jusqu'à ce que la valeur retenue soit 0. S'il atteint un index pas encore dans le tableau, il ajoute des zéros à la fin du tableau jusqu'à ce que le tableau contienne cela indice. Merci à Wheat Wizard et xnor pour avoir joué 9 octets chacun