Đưa ra một danh sách các số được sắp xếp (có thể có các số 0 đứng đầu), sắp xếp các số theo chiều dọc, sau đó để tất cả các số không rơi xuống đáy và tất cả các phần nhô ra rơi vào khe mở dưới cùng. Xuất ra các số nguyên kết quả, loại bỏ các số 0 đứng đầu.

Ví dụ làm việc

Nói rằng chúng tôi đã được đưa ra như sau:

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

Đầu tiên chúng tôi sắp xếp nó theo chiều dọc:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Sau đó, từng cột, thả các số không "qua" các số khác để chúng nằm ở dưới cùng và "đẩy" các số khác lên. Điều này sẽ dẫn đến một vài bước đầu tiên như sau:

2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^

2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^

2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^

...

2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^

Tiếp theo, thả tất cả các phần nhô ra như thể trọng lực đang kéo chúng xuống như cát.

2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^

2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^

...

2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^

Cuối cùng, xuất những con số này, loại bỏ các số không hàng đầu. Ví dụ làm việc của chúng tôi, đầu ra:

[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]

Đối với một ví dụ khác, giả sử đầu vào của [1234000,12345678,1234,12340608,12341234].

1234000
12345678
1234
12340608
12341234

Thả số không:

1234  
12345678
1234163
12340208
12340004

Thả các chữ số nhô ra còn lại:

1234  
1234567
12341638
12340208
12340004

Đầu ra là [1234, 1234567, 12341638, 12340208, 12340004].

Quy tắc

• Đầu vào có thể chứa các số không hàng đầu. Đầu ra không được chứa các số 0 đứng đầu.
• Nếu có thể, bạn có thể giả sử rằng đầu vào / đầu ra sẽ phù hợp với loại Số nguyên gốc của ngôn ngữ của bạn.
• Đầu vào và đầu ra có thể được cung cấp bởi bất kỳ phương pháp thuận tiện .
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn để áp dụng tất cả các quy tắc chơi golf thông thường và mã ngắn nhất (tính bằng byte) sẽ thắng.

Thạch , 8 byte

Z¬Þ€UZṚḌ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

ζεð†R0†R}øï

Hãy thử trực tuyến!

Husk , 12 byte

md↔TmoÖ±miT↔

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Phiên bản ung dung

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

Hai dòng đầu tiên tương đương với map(lambda*a...), hành vi mặc định nếu mapđể điền vào Nones nếu một danh sách ngắn hơn danh sách kia.
e>'0'tương đương với cell != '0' and cell != None, bởi vì nếu nó là bất kỳ chữ số nào (1 ~ 9) thì nó sẽ có một điểm mã cao hơn và chuỗi (bất kỳ) nào cao hơn None.

Bình thường , 11 byte

iRT_C_M!DMC

Hãy thử trực tuyến!

Võng mạc 0.8.2 , 95 92 byte

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

Hãy thử trực tuyến! Giải thích: Giai đoạn đầu tiên bỏ các chữ số nhô ra vì điều này giúp dễ dàng hơn (chỉnh sửa: thậm chí dễ dàng hơn cho việc tiết kiệm 3 byte) cho giai đoạn thứ hai để giảm các số không. Giai đoạn thứ ba sau đó loại bỏ các số không hàng đầu.

Ruby , 104 byte

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

Hãy thử trực tuyến!

Giải trình

->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 byte ^SBCS

Hàm tiền tố ẩn danh ẩn danh ma trận ký tự làm đối số và trả về danh sách các số.

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

Hãy thử trực tuyến!

⍉ hoán chuyển đầu vào (vì chúng ta cần làm việc trên các cột)

' 0'(... )⍤1⍨ áp dụng các chức năng ngầm sau đây để mỗi hàng (sub-mảng của tensor bậc 1) với ' 0'như ngay lập luận ( ⍨giao dịch hoán đổi các đối số):

 ∩ giao điểm của hàng và
 ∘ và
 ⊃ các đầu ' 0'
 (ví dụ row∩' ', tất cả các không gian từ mỗi hàng)

 , theo dõi bởi…

 ~ sự khác biệt được đặt
 (nghĩa là row~' 0'hàng nhưng không có dấu cách và số 0)

 , theo dõi bởi…

 ∩ giao điểm của hàng và
 ∘ và
 ⊃ người đầu tiên
 ∘ của
 ⌽ các đảo ngược ' 0'
 (ví dụ:row∩'0' , tất cả các số không từ mỗi hàng)

⍎⍤1 đánh giá từng hàng (mảng con của thang đo bậc 1)
∘ của
⍉ chuyển vị của nó (tức là mỗi cột; các hàng đầu vào hiện đã được sửa đổi)

Perl 5 , -p0 77 byte

Đếm kiểu cũ: 79 byte ( +2chop0 )

Cung cấp đầu vào dưới dạng các dòng trên STDIN mà không có dòng mới cuối cùng (nếu không mọi thứ được xem là phần nhô ra và dòng mới cuối cùng tăng lên trên cùng khi chuỗi đầu vào gặp sự cố). Ví dụ:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Đó là một chút khó khăn để có được phần nhô ra và 0rơi vào một regex

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

Hãy thử trực tuyến!

Ruby , 203 byte

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

Hãy thử trực tuyến!

Một lambda chấp nhận một chuỗi các chuỗi và trả về một mảng ints. Tôi cảm thấy như mình đang thiếu thứ gì đó; điều này cảm thấy rất lớn: /

->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 byte

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

Hãy thử trực tuyến!

dựa trên giải pháp của Adam