Entiers de tas de sable

Défi

Vous recevrez un entier positif nen entrée. La sortie doit être un tas de sable de type pyramide construit sur les règles spécifiées ci-dessous:

• Chaque entier "tombe" vers le bas à partir du même point de départ initial, comme du sable tombant en forme conique.
• Si possible, les nombres supérieurs au nombre directement en dessous de celui-ci quand il frappe le tas de sable tomberont vers la droite.
• Si possible, les nombres inférieurs au nombre directement en dessous de celui-ci quand il frappe le tas de sable tomberont vers la gauche.
• Les nombres égaux au nombre juste en dessous quand il frappe le tas de sable resteront en place.
• Les nombres peuvent tomber vers la gauche / droite s'ils peuvent se déplacer vers le bas et vers la gauche / droite respectivement. Autrement dit, s'il y a déjà un nombre en dessous et à gauche / droite, selon la direction, le nombre actuellement en baisse ne bouge pas.
• Un certain nombre continuera de dégringoler le tas de sable jusqu'à ce qu'il ne puisse pas être déplacé dans sa position suivante ou qu'il touche le sol.

Remarques

La vérification de comparaison initiale s'applique uniquement au premier entier rencontré, pas pour chaque rencontre successive lorsqu'elle dégringole le tas de sable.

Les espaces de fin sont corrects mais les nouvelles lignes de fin ne le sont pas.

Pas d'espaces de tête ni de nouvelles lignes sauf là où c'est nécessaire pour préserver la structure du tas de sable.

Vous pouvez écrire un programme ou une fonction complète.

Vous pouvez supposer que l'entrée ne contiendra qu'une certaine combinaison [0-9].

Ceci est le code-golf , le code le plus court en octets sera marqué gagnant par les Ides de mars

Exemples

1

1

12345

35
124

54321

 13
245

555444333222111

    2
    2
    2
  135
 1345
13445

111222333444555

4
4
4
135
1235
12235

7313623030872935273465247457435345345350

    3
    3
    3
    3
    34
    355
    3644
   239475
  201277445
020373685575

JavaScript (ES6), 260 208 octets

s=>[...s].map(c=>a[g(n,(c>(l=a[n].slice(-1)))-(c<l))]+=c,n=s.length,a=Array(n+n).fill(''),g=(i,d)=>a[i].length>a[i+d].length?g(i+d,d):n)&&[...a[n]].map((_,i)=>a.map(c=>c?c[i]||' ':c).join``).reverse().join`\n`

Edit: économisé 25 octets en réalisant que le premier caractère n'est pas un cas spécial. 15 octets enregistrés en utilisant un tableau de chaînes au lieu d'un tableau de tableaux de caractères. Enregistré 12 octets dans divers correctifs, y compris en utilisant un littéral \n(non illustré). Cela rend l'ensemble 20% plus court! Je voulais m'en débarrasser, reversemais cela coûte plus cher que ce que je peux économiser en remplaçant mappar replace.

Non golfé:

function sandpile(str) {
    var arr = new Array(str.length * 2); // max width of sandpile is approx. 2√n but this is close enough
    for (i = 0; i < arr.length; i++) arr[i] = '';
    for (i = 0; i < str.length; i++) {
        var digit = str[i];
        var pos = str.length; // start dropping here
        if (digit < str[pos][str[pos].length - 1]) {
            while (str[pos - 1].length < str[pos].length) pos--;
        } else if (digit > str[pos][str[pos].length - 1]) {
            while (str[pos + 1].length < str[pos].length) pos++;
        }
        str[pos] += digit; // drop the digit
    }
    var len = arr[str.length].length; // final height
    // remove the unused columns, and then pad the columns with spaces for the transpose
    for (i = 0; i < arr.length; ) {
        if (!arr[i]) arr.splice(i, 1);
        else arr[i++] += ' '.repeat(len);
    }
    ans = '';
    for (i = len; i-- > 0; ) {
        for (j = 0; j < arr.length; j++) ans += arr[j][i];
        ans += '\n';
    }
    return ans;
}