Étant donné une liste ordonnée de nombres (éventuellement avec des zéros en tête), organisez les nombres verticalement, puis laissez tous les zéros tomber jusqu'en bas et tous les surplombs tombent dans la fente la plus ouverte en bas. Sortez les entiers résultants, en supprimant les zéros de tête.

Exemple travaillé

Disons que nous avons reçu les éléments suivants en entrée:

['0000312941295', '239124000124581598', '32852353800451258', '10235923505185190', '1491359102149']

Nous l'organisons d'abord verticalement:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Ensuite, colonne par colonne, déposez les zéros "à travers" les autres nombres afin qu'ils reposent sur le bas et "poussez" les autres nombres vers le haut. Cela entraînerait les deux premières étapes comme suit:

2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^

2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^

2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^

...

2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^

Ensuite, déposez tous les surplombs comme si la gravité les tirait comme du sable.

2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^

2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^

...

2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^

Enfin, affichez ces chiffres en supprimant les zéros non significatifs. Pour notre exemple travaillé, sortie:

[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]

Pour un autre exemple, supposons l'entrée de [1234000,12345678,1234,12340608,12341234].

1234000
12345678
1234
12340608
12341234

Déposez les zéros:

1234  
12345678
1234163
12340208
12340004

Déposez les chiffres en surplomb restants:

1234  
1234567
12341638
12340208
12340004

La sortie est [1234, 1234567, 12341638, 12340208, 12340004].

Règles

• L'entrée peut contenir des zéros non significatifs. La sortie ne doit pas contenir de zéros non significatifs.
• Le cas échéant, vous pouvez supposer que l'entrée / sortie s'adaptera au type Integer natif de votre langue.
• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) gagne.

Gelée , 8 octets

Z¬Þ€UZṚḌ

Essayez-le en ligne!

Comment ça marche

Z¬Þ€UZṚḌ  Main link. Argument: M (2D array / matrix)

Z         Zip; transpose M by reading columns as rows.
 ¬Þ€      Sort each row of the transpose by logical NOT, pushing 0's to the end.
    U     Upend; reverse all sorted rows of the transpose.
     Z    Zip again, restoring rows from columns. Overhangs rise to the top.
      Ṛ   Reverse the order of the rows.
       Ḍ  Decimal; convert the rows from base 10 to integer.

05AB1E , 11 octets

ζεð†R0†R}øï

Essayez-le en ligne!

Husk , 12 octets

md↔TmoÖ±miT↔

Essayez-le en ligne!

Explication

md↔Tm(Ö±mi)T↔  -- input as list of strings, example: ["103","32","258"]
            ↔  -- reverse: ["258","32","103"]
           T   -- transpose: ["231","520","83"]
    m(    )    -- with each line do (example with "520")
        mi     -- | convert each char to digit: [5,2,0]
      Ö±       -- | sort by signum (stable): [0,5,2]
               -- : [[2,3,1],[0,5,2],[8,3]]
   T           -- transpose: [[2,0,8],[3,5,3],[1,2]]
  ↔            -- reverse: [[1,2],[3,5,3],[2,0,8]]%
md             -- convert each to integer: [12,353,208]

Python 2 , 118 octets

lambda l:[int(''.join(z))for z in zip(*map(lambda*a:['']*a.count(None)+[e for e in a if'0'<e]+['0']*a.count('0'),*l))]

Essayez-le en ligne!

Version non golfée

def f(list_):
 max_len = max(len(x) for x in list_)
 transposed_list = zip(*[list(row)+(max_len-len(row))*[None] for row in list_])
 weighted_list = [['']*column.count(None)+[cell for cell in column if cell != '0' and cell != None]+['0']*column.count('0') for column in transposed_list]
 return [int(''.join(row)) for row in zip(*weighted_list)]

Les deux premières lignes sont équivalentes à map(lambda*a...), le comportement par défaut si pour mapremplir avec Nones si une liste est plus courte que l'autre.
e>'0'est équivalent à cell != '0' and cell != None, car s'il s'agit d'un chiffre (1 ~ 9), il aura un point de code plus élevé et (toute) chaîne est supérieure à None.

Pyth , 11 octets

iRT_C_M!DMC

Essayez-le en ligne!

Rétine 0,8,2 , 95 92 octets

m(+`^((.)*)(.+)(¶(?<-2>.)*)(?(2)_)$
$1$4$3
+`^((.)*)0(.*¶(?>(?<-2>.)*))([^0])
$1$4${3}0
^0+

Essayez-le en ligne! Explication: La première étape supprime les chiffres en surplomb car cela facilite (modification: encore plus facile pour une sauvegarde sur 3 octets) la seconde étape pour supprimer les zéros. La troisième étape supprime ensuite les zéros non significatifs.

Rubis , 104 octets

->a{a.map{|x|x.ljust(99).chars}.transpose.map{|x|x.sort_by{|x|x<?1?x:?!}}.transpose.map{|x|x.join.to_i}}

Essayez-le en ligne!

Explication

->a{
  a.map{|x|x.ljust(99).chars}  # Fill spaces to make this rectangular
    .transpose.map{|x|
       x.sort_by{|x|x<?1?x:?!} # Treat all chars but " 1" as ! (see ascii table)
    }.transpose.map{|x|x.join.to_i} # Convert back to numbers
                       # note: if no leading 0s, eval x*'' , doesn't work here
}

APL (Dyalog Unicode) , 26 octets ^SBCS

Fonction de préfixe tacite anonyme prenant une matrice de caractères comme argument et renvoyant une liste de nombres.

⍎⍤1∘⍉' 0'(∩∘⊃,~,∩∘⊃∘⌽)⍤1⍨⍉

Essayez-le en ligne!

⍉ transposer l'entrée (car nous devons travailler sur les colonnes)

' 0'(… )⍤1⍨ Appliquer la fonction tacite suivante à chaque ligne (sous-tableau de rang de tenseur 1) avec ' 0'comme argument de droite ( ⍨permute les arguments):

 ∩ intersection de la rangée et
 ∘ et
 ⊃ le premier ' 0'
 (ie row∩' ', tous les espaces de chaque rangée)

 , suivi par…

 ~ la différence définie
 (c'est-à-dire row~' 0'la ligne mais sans espaces ni zéros)

 , suivi par…

 ∩ intersection de la ligne et
 ∘ et
 ⊃ le premier
 ∘ de
 ⌽ l'inverse ' 0'
 (c.-à-d.row∩'0' -à- ; tous les zéros de chaque rangée)

⍎⍤1 évaluer chaque ligne (sous-tableau de rang de tenseur 1)
∘ de
⍉ la transposition (c'est-à-dire chaque colonne; les lignes d'entrée maintenant modifiées)

Perl 5 , -p0 77 octets

Comptage à l'ancienne: 79 octets ( +2pour p0)

Donnez une entrée sous forme de lignes sur STDIN sans retour à la ligne final (sinon tout est considéré comme un surplomb et le retour à la ligne final monte vers le haut lorsque la chaîne d'entrée se bloque). Par exemple:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

C'était un peu difficile d'obtenir la chute du surplomb et la 0chute dans une expression régulière

#!/usr/bin/perl -p0
s/^.{@{+}}\K((0)|.+$)(.*
.{@{+}})((?(2)[1-9]|$))/$4$3$1/m while/|/g;s/^0+//mg

Essayez-le en ligne!

Rubis , 203 octets

->a{t=->b{b[0].zip(*b[1..-1])}
m=a.map{|s|s.size}.max
a.map!{|s|(s+" "*m)[0...m].chars}
a=t[a].map{|c|c.size.times{|i|" 0"[c[i]]&&(c.slice!(i)==?0?c.push(?0):c.unshift(" "))}
c}
t[a].map{|r|r.join.to_i}}

Essayez-le en ligne!

Un lambda acceptant un tableau de chaînes et renvoyant un tableau d'entiers. J'ai l'impression de manquer quelque chose; cela semble énorme: /

->a{
  t = -> b { b[0].zip(*b[1..-1]) }     # t is a lambda that transposes 2D arrays
  m = a.map{ |s| s.size }.max          # m is the maximum input string length
  a.map!{ |s| (s+" "*m)[0...m].chars } # Right-pad every string to the same length
  a = t[a].map{ |c|                    # Transpose a, and for every row (column)
    c.size.times{ |i|                  # For every character in the column
      " 0"[c[i]] && (                  # If the character is 0 or space
        c.slice!(i) == ?0 ?            # Remove it from the column, and if it was 0,
          c.push(?0) :                 # Push a 0 to the end (bottom) of the column, else
          c.unshift(" ")               # Add a space to the top of the column
      )
    }
    c
  }
  t[a].map{ |r| r.join.to_i }          # Transpose a back, and parse each row to int
}

APL (Dyalog Classic) , 24 23 22 octets

⍎⍤1⍉{⍵[⍒⌈9÷⍨⎕d⍳⍵]}⍤1⍉⎕

Essayez-le en ligne!

basé sur la solution d'Adam