[Question]
  [
Given an ordered list of numbers (possibly with leading zeros), arrange the numbers vertically, then let all zeros drop all the way to the bottom and all overhangs drop to the bottom-most open slot. Output the resulting integers, removing leading zeros.
### Worked Example
Say we were given the following as input:
```
['0000312941295', '239124000124581598', '32852353800451258', '10235923505185190', '1491359102149']
```
First we arrange it vertically:
```
0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149
```
Then, column by column, drop the zeros "through" the other numbers so they rest on the bottom and "push" the other numbers up. This would result in the first couple steps being as follows:
```
2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^
2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^
2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^
...
2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^
```
Next, drop all overhangs as if gravity is pulling them down like sand.
```
2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^
2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^
...
2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^
```
Finally, output these numbers, removing leading zeros. For our worked example, output:
```
[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]
```
For another example, suppose input of `[1234000,12345678,1234,12340608,12341234]`.
```
1234000
12345678
1234
12340608
12341234
```
Drop the zeros:
```
1234  
12345678
1234163
12340208
12340004
```
Drop the remaining overhanging digits:
```
1234  
1234567
12341638
12340208
12340004
```
Output is `[1234, 1234567, 12341638, 12340208, 12340004]`.
### Rules
* The input *may* contain leading zeros. The output *must not* contain leading zeros.
* If applicable, you can assume that the input/output will fit in your language's native Integer type.
* The input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
Z¬Þ€UZṚḌ
```
[Try it online!](https://tio.run/##y0rNyan8/z/q0JrD8x41rQmNerhz1sMdPf///4@ONtCBQGMdQx0jHUsdEyhtGqujEG0EFLYEC5hAlUHYpjoWQJYpUM4CpMwYKGgB5IKUmwKxBVgpSBlIuSlEkSFQCKLAEkobgBVYgElLHQOIIhOwhRBlEC1gsdhYAA "Jelly – Try It Online")
### How it works
```
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.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
ζεð†R0†R}øï
```
[Try it online!](https://tio.run/##HcmxDUJBDAPQVeiuoYiTs5SsQYsoQGIMJEZhA2hA9Nf/IVjk8P@RbFkvxvMF1zmXz/Ier9/9cbC1buM7nnMem@kCXl1h2@@aR8G7VM0EK1cNT3ow0qwTzg1holKMSKJsw16Q6qfVTn8 "05AB1E – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 12 bytes
```
md↔TmoÖ±miT↔
```
[Try it online!](https://tio.run/##Fcm9DcJQDATgXV5N4Z93kr1HOpSOAoSeKFBWyAQoe2QFsgmLmIuls86f78v7WTVuv/UzjdexfffxmHhU1bUJx9WyM2iXZp5qnciNUGQQ3QLm8BDpUMNpKpRkBBrQlNN6KpEvtjb/AQ "Husk – Try It Online")
### Explanation
```
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]
```
[Answer]
# [Python 2](https://docs.python.org/2/), 118 bytes
```
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))]
```
[Try it online!](https://tio.run/##RZFNcoMwDIX3OYV3xsTNyH@pnSk9Qi/gekEbmNIhwCRk0VyeSiZpYYweH5KeRkw/89c46KWt3pe@Pn0ca9YfYjfMBee777EbipsQ7XhmN9YN7NZNRXmqp2JNLetD5DyV9e5zvGLJ2zg0YhsbRgUNFdSsaznwlyZtI8b/VHwRsuyFSMvcXOZLFTcRM/AySgeLx3HJuDZBaYsUn84rFzxRo73TxhkPYJ3SLkMFiAIecMo7FSBDGxRS/IaKJxmp4Z@DZLmTxU7UXzJltaHbabfaIYKAETuAUp68sMjRnGADufiUJI2utKE5uczK7Z/9Xd4D7OFBMsVZKKLBmr4KtTd@VaDhodAqpU3a0FZpWfLcXK79TPvNuztMZ/xhbKVV1RZEhcyp/OmVyztZfgE "Python 2 – Try It Online")
### Ungolfed version
```
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)]
```
The first two lines are equivalent to `map(lambda*a...)`, the default behaviour if for `map` to fill with `None`s if one list is shorter than the other.  
`e>'0'` is equivalent to `cell != '0' and cell != None`, because if it is any digit (1~9) it will have a higher codepoint, and (any) string is higher than `None`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 104 bytes
```
->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}}
```
[Try it online!](https://tio.run/##bY/dasMgFIDv8xSOXmSDVDzqAR3r8iAhFDtamtIlQQ2ktHn27Ghhu5ni3@fxfEc/HW7rabduP93d8W833h/zY@bXyxTiq7Vv/OvsfFh49K4P4xCOfzFh8HF/uOXDRw31/F6/LP9GXoau53HYd8uydv04RbZjTSmoKZBW08CyYqVUFqQmSjMaQGsSVdKgVKiMEBpBYoYgCFkaAsEgWJGhtkCU7mhXtoU/humaXKcmW9tiZE9WbJok@7VXLFs0WZK7YqClSp3yP0shJCytOTuYVAc9wvQHoW2qwLTrDw "Ruby – Try It Online")
## Explanation
```
->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
}
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 11 bytes
```
iRT_C_M!DMC
```
[Try it online!](https://tio.run/##Lc0xDoAgDAXQq@j@B1SalFlXF@PWEFbdHFw8PZaWEGj5fYTne69a7@Msa9nHbV9rFQnwtWDCjITYK2UMMmucLIideU9g7UhnnCGLZqy3pkk3m2yqaWpmkEkjB6nXYIDtTAiOov3nzJ9YlvMP "Pyth – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~95~~ 92 bytes
```
m(+`^((.)*)(.+)(¶(?<-2>.)*)(?(2)_)$
$1$4$3
+`^((.)*)0(.*¶(?>(?<-2>.)*))([^0])
$1$4${3}0
^0+
```
[Try it online!](https://tio.run/##RYo9CgJBDEb7nGOKZBeX/ExgBmT3IOKqhYWFFmK3eC0P4MXGqKCBL3x5edfj7XQ5tHbGfj8jDtQRDj3h84HTeqXjB0yotKMESVJOBj@Tceje4vh3CTczb@mrLnZnmLmH1jjGRGuOOKhV0RwothfxWsC0uJpbYc4u6gWE464RdikulUFylUDxiPYC "Retina 0.8.2 – Try It Online") Explanation: The first stage drops the overhanging digits as this makes it easier (edit: even easier for a 3-byte saving) for the second stage to drop the zeros. The third stage then removes leading zeros.
[Answer]
# [Perl 5](https://www.perl.org/), -p0 77 bytes
Old style counting: 79 bytes (`+2` for `p0`)
Give input as lines on STDIN without final newline (otherwise everything is seen as overhang and the final newline rises to the top as the input string crashes down). E.g.:
```
0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149
```
It was a bit tricky to get the overhang dropping and the `0` dropping into one regex
```
#!/usr/bin/perl -p0
s/^.{@{+}}\K((0)|.+$)(.*
.{@{+}})((?(2)[1-9]|$))/$4$3$1/m while/|/g;s/^0+//mg
```
[Try it online!](https://tio.run/##LYy7CsMwDEV3f0UGD3ZDbMm2wCZDu/cT@thCGsiLpqVDkl@vq6EXjpCO4M7Ns6f8XpqCDIKBOi/2btbTWu779awU6M2UUitzEH@rlToqpy9YpdsmtbYySC/RDsXn0fWN3WxbcweU1g5tzsDx6FJgSDif0AVWPCkipSi8i@Q8@QgQCB1FgcB3YoAwEiYQGBKy4gdv32l@ddO45GqGHw "Perl 5 – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 26 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function taking a character matrix as argument and returning a list of numbers.
```
⍎⍤1∘⍉' 0'(∩∘⊃,~,∩∘⊃∘⌽)⍤1⍨⍉
```
[Try it online!](https://tio.run/##PY3BSgMxEIbvPsXcYqFCJsnU5C32FZZtdxmou2V3Ebx4EUoVU9pDwYs3D/oQvkxeZJ3UamBm/nz/z0y5Wd8sH8p110xpfyqKtD1YBym@Q9FzO8KmX1U8cNeC4IGblmuuSjGW3PA4wNjlyP1KyFCxjOxD3fV35TjVsi3FfYofmHZvKT4r0Oo67b7y7@Vp/jj/17m/fs/O0fgp0WmqIW2PSsuzaIKTIgXK2IDGCZROHil4gdZ4Mpas19oRGsoMtZAgpQk9YdCZuYACxRKlrn4voLF5X7ZF0eLWX@Rl6IX@I2f6Aw "APL (Dyalog Unicode) – Try It Online")
`⍉` transpose the input (as we need to work on the columns)
`' 0'(`…`)⍤1⍨` apply the following tacit function to each row (sub-array of tensor rank 1) with `' 0'` as *right* argument (`⍨` swaps the arguments) :
 `∩` intersection of the row and  
 `∘` and  
 `⊃` the first of `' 0'`  
 (i.e. `row∩' '`; all the spaces from each row)
 `,` followed by…
 `~` the set difference  
 (i.e. `row~' 0'`; the row but without spaces and zeros)
 `,` followed by…
 `∩` intersection of the row and  
 `∘` and  
 `⊃` the first  
 `∘` of  
 `⌽` the reversed `' 0'`  
 (i.e. `row∩'0'`; all the zeros from each row)
`⍎⍤1` evaluate each row (sub-array of tensor rank 1)  
`∘` of  
`⍉` the transpose of that (i.e. each column; the now modified input rows)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 203 bytes
```
->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}}
```
[Try it online!](https://tio.run/##RY//aoMwEID/9ylSB1W7NiQxgWRg@yAhDA1KM2orRmGr@uzuYmFLyK/vuPsu/Vj9rE2xns7lNBSnczVVmhj8dF16qDTF@ERNtkRtUeK27KbZzx5796wXeH5HG9wFmvr3GMWHNtMEY9wabK9l75eoLAZdmleune2WiwfX1n6a3RwjEmurnTH7fQrBm7P1LnVZUVzIxeJu9Nf0QrIPi8e7v7pmSEGSQT92if7r9nOPvx7ujofHp1uW1d27cUAF0gmBkVOmOCyRHFHCckUZBwq7kFQoGWjOpGC5yCUhXFAmNkgJIAWLCCoFVWSDXFGgEINbYqK@9uMtuBq9WU3UoReL3nSQ/dmPaLNwsAT3EVHO8jCh/qsVQETBuVWnMvQBSSL8gXAVOpBm/QU "Ruby – Try It Online")
A lambda accepting an array of strings and returning an array of ints. I feel like I'm missing something; this feels enormous :/
```
->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
}
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), ~~24~~ ~~23~~ 22 bytes
```
⍎⍤1⍉{⍵[⍒⌈9÷⍨⎕d⍳⍵]}⍤1⍉⎕
```
[Try it online!](https://tio.run/##NY3PisIwEIfvfQpvPRVmkowmz7J4KJaKULDoSZa9Lf5BU1TwDTx4F/EB9k3mRbq/ag1M8s03vyR5XWXFKq/m02xS5cvlbNJqc5nNdX0k3f@CywWYjR@927pGa12i203Zamw0Xlnj7lvj40vjWQ/b8PfUeEO00HiHHv/0GagW19oy0fUpJSzLJjiUpIPU2MDGQWIXzxI8pDVejBXriZywkc4xwQQUCXvhQJ1zgSExAqVJlrz/YGO7F7sASIYj32N/0JA@5mX/AQ "APL (Dyalog Classic) – Try It Online")
based on Adam's solution
]