Đây là một thử thách tương đối đơn giản dành cho bạn:

Đưa ra một danh sách các số nguyên dương:

• Sắp xếp chúng trong một lưới và tính tổng mỗi cột. Ví dụ: nếu đầu vào là [123, 7, 49, 681], lưới sẽ trông như thế này:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  Và tổng của mỗi cột sẽ là [18, 19, 4]:

   1  2  3
   7 
   4  9 
   6  8  1 
   --------
   18 19 4
  

• Tìm số tiền tối đa, trong trường hợp này là 19, và sau đó

• Xuất ra mỗi chữ số có cùng chỉ số với cột tối đa này. Trong trường hợp này, đó sẽ là

  2
  9
  8
  

  Bạn không phải xuất các số này theo bất kỳ thứ tự cụ thể nào. Lưu ý rằng chỉ có ba đầu ra, mặc dù chúng tôi có 4 đầu vào. Trong trường hợp hòa, chọn chỉ số sớm nhất. Ví dụ: nếu đầu vào là [25, 223, 302], lưới của bạn là:

  2  5
  2  2  3
  3  0  2
  -------
  7  7  5
  

  Bạn nên xuất

  2
  2
  3
  

Bạn có thể in những con số này ở bất kỳ định dạng nào bạn thích. Định dạng danh sách, dòng mới được phân tách, khoảng cách được phân tách, v.v. Bạn không thể lấy đầu vào dưới dạng một mảng 2D của các chữ số, vd

[[1, 2, 3],
[7],
[4, 9],
[6, 8, 1]

Nhưng ngoài ra, bạn có thể lấy đầu vào làm danh sách các chuỗi, danh sách các chữ số hoặc bất kỳ định dạng hợp lý nào khác.

Bạn cũng có thể cho rằng tất cả các đầu vào sẽ hợp lệ và chứa ít nhất hai số.

Như thường lệ, câu trả lời ngắn nhất tính bằng byte sẽ thắng!

Kiểm tra IO:

#Input                      #Output
[1, 11, 111, 1111]      --> [1, 1, 1, 1]
[1, 12, 123]            --> [2, 2]
[987654321, 111]        --> [9, 1]
[111, 123456789]        --> [9]
[4, 8, 15, 16, 23, 42]  --> [4, 8, 1, 1, 2, 4]
[4, 8, 12, 26, 27, 38]  --> [2, 6, 7, 8]
[24, 53]                --> [2, 5]
[12, 304, 506]          --> [4, 6]
[30, 285, 121]          --> [0, 8, 2]

Haskell, 63 byte

import Data.Lists
argmax sum.transpose.map(map(read.pure).show)

Ví dụ sử dụng: argmax sum.transpose.map(map(read.pure).show) $ [12,304,506]->[4,6] .

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

                     map                       -- for each number
                         map(read.pure).show   -- turn into list of digits
           transpose                           -- transpose the list of list
argmax sum                                     -- find the element with the
                                               -- largest sum

Thạch , 6 byte

DZṚSÞṪ

Hãy thử trực tuyến! . Đây là một thực hiện tương đối đơn giản của câu hỏi.

D              Convert each number in the input to a list of digits, e.g.
               [353, 2247] -> [[3, 5, 3], [2, 2, 4, 7]]
 Z             Zip the lists together, e.g. [[3, 2], [5, 2], [3, 4], [7]]
  Ṛ            Reverse the list of lists so that first occurrences are now
               at the end, e.g. [[7], [3, 4], [5, 2], [3, 2]]
   SÞ          Sort by sum - this uses Python's sorted function, which is stable
               so equal elements end up in order of appearance, e.g.
               [[3, 2], [7], [3, 4], [5, 2]]
     Ṫ         Tail - get the last element, e.g. [5, 2]

Ruby, 100 97 byte

a=$<.map &:chomp
puts a.map(&:size).max.times.map{|i|a.map{|e|e[i]}.compact}.max_by{|e|eval e*?+}

Toán học 82 byte

Điều này đệm các chữ số của mỗi số với x là bên phải, hoán vị ma trận, loại bỏ các hình nộm x, sắp xếp theo tổng các chữ số và lấy giá trị lớn nhất.

SortBy[#~Select~NumberQ&/@Transpose[PadRight[#,30,x]&/@IntegerDigits@#],Tr][[-1]]&

Phải có một số cách để sử dụng dạng siêu ký tự-T Transposeđể lưu một vài byte.

Perl, 49 48 byte

Bao gồm +1 cho -p

Chạy với đầu vào trên STDIN, in ra STDOUT các số cột có tiền tố bởi +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

#!/usr/bin/perl -p
s/./@;[@-].="+$&"/eg}{($_)=sort{eval"$b<=>$a"}@

Javascript (ES6), 108 103 100 byte

Đó là một chút dài dòng và có thể có thể được đánh gôn nhiều hơn với một cách tiếp cận khác. Tôi ước tôi có thể thoát khỏi điều này.filter(n=>n) .

Đã lưu 5 byte nhờ Neil
Lưu 3 byte nhờ edc65

l=>l.map(n=>[...n].map((d,x)=>(m=(s[x]=(s[x]|0)-d)<m?s[c=x]:m,d)),s=[m=0]).map(n=>n[c]).filter(n=>n)

Bản giới thiệu

let f =
l=>l.map(n=>[...n].map((d,x)=>(m=(s[x]=(s[x]|0)-d)<m?s[c=x]:m,d)),s=[m=0]).map(n=>n[c]).filter(n=>n)

console.log(f(["1", "11", "111", "1111"]).join`,`);          // --> [1, 1, 1, 1]
console.log(f(["1", "12", "123"]).join`,`);                  // --> [2, 2]
console.log(f(["987654321", "111"]).join`,`);                // --> [9, 1]
console.log(f(["111", "123456789"]).join`,`);                // --> [9]
console.log(f(["4", "8", "15", "16", "23", "42"]).join`,`);  // --> [4, 8, 1, 1, 2, 4]
console.log(f(["4", "8", "12", "26", "27", "38"]).join`,`);  // --> [2, 6, 7, 8]
console.log(f(["24", "53"]).join`,`);                        // --> [2, 5]
console.log(f(["12", "304", "506"]).join`,`);                // --> [4, 6]
console.log(f(["30", "285", "121"]).join`,`);                // --> [0, 8, 2]

Bình thường, 5 8 byte

esDsMM.T

Lấy đầu vào là một danh sách các chuỗi, đầu ra là một danh sách các chữ số không có gì tách rời.

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

Giải trình:

      .T  Transpose input to zip together corresponding columns
   sMM    Cast to digit lists
 sD       sort(D) by (s)um
e         take last element, implicitly print

Bình thường, 11 byte

h.MsZ.TmjdT

Một chương trình lấy đầu vào của danh sách các số nguyên trên STDIN và in danh sách.

Dùng thử trực tuyến

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

h.MsZ.TmjdT  Program. Input: Q
        j T   Yield the base-10 representation, giving a list of digits
       m d   Map that over Q (implicit input fill)
     .T      Justified transpose, giving each column as a list
 .MsZ        Filter the above by maximum sum
h            First element of above
             Implicitly print

JavaScript (ES6), 90

(l,x)=>[...l+0].map((t,i)=>l.map(n=>(n=n[i])&&(v-=n,t.push(n)),v=t=[])|v>=x||(x=v,r=t))&&r

f=(l,x)=>[...l+0].map((t,i)=>l.map(n=>(n=n[i])&&(v-=n,t.push(n)),v=t=[])|v>=x||(x=v,r=t))&&r

;[
 [[123, 7, 49, 681]       , [2,9,8]]
,[[25, 223, 302]          , [2, 2, 3]]
,[[1, 11, 111, 1111]      , [1, 1, 1, 1]]
,[[1, 12, 123]            , [2, 2]]
,[[987654321, 111]        , [9, 1]]
,[[111, 123456789]        , [9]]
,[[4, 8, 15, 16, 23, 42]  , [4, 8, 1, 1, 2, 4]]
,[[4, 8, 12, 26, 27, 38]  , [2, 6, 7, 8]]
,[[24, 53]                , [2, 5]]
,[[12, 304, 506]          , [4, 6]]
,[[30, 285, 121]          , [0, 8, 2]]]
.forEach(t=>{
  var i=t[0], o=t[1], r, ok
  i=i.map(x=>x+'') // convert i to a string list
  r=f(i) 
  ok = (r+'')==(o+'') // compare r and o as comma separated strings
  console.log(ok?'OK':'KO', i+' -> '+ r)
  
})

Pyth - 9 byte

esD_.TjRT

Phòng thử nghiệm .