Inilah tantangan yang relatif sederhana untuk Anda:

Diberikan daftar bilangan bulat positif:

• Sejajarkan mereka dalam kotak, dan jumlah setiap kolom. Misalnya, jika inputnya adalah [123, 7, 49, 681], grid akan terlihat seperti ini:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  Dan jumlah dari setiap kolom adalah [18, 19, 4]:

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

• Temukan maksimum jumlah ini, yang dalam hal ini akan menjadi 19, dan kemudian

• Keluarkan setiap digit dengan indeks yang sama dengan kolom maksimum ini. Dalam hal ini, itu akan terjadi

  2
  9
  8
  

  Anda tidak harus menampilkan angka-angka ini dalam urutan tertentu. Perhatikan bahwa hanya ada tiga output, meskipun kami memiliki 4 input. Untuk dasi, pilih indeks yang paling awal. Misalnya, jika inputnya adalah [25, 223, 302], kisi Anda adalah:

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

  Anda harus mengeluarkan

  2
  2
  3
  

Anda dapat mencetak angka-angka ini dalam format apa pun yang Anda suka. Format daftar, baris baru, ruang terpisah, dll. Anda tidak boleh mengambil input sebagai array angka 2D, mis

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

Tetapi selain itu, Anda dapat mengambil input sebagai daftar string, daftar digit, atau format lain yang masuk akal.

Anda juga dapat mengasumsikan bahwa semua input akan valid dan mengandung setidaknya dua angka.

Seperti biasa, jawaban terpendek dalam byte menang!

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

Contoh penggunaan: argmax sum.transpose.map(map(read.pure).show) $ [12,304,506]-> [4,6].

Bagaimana itu bekerja:

                     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

Jelly , 6 byte

DZṚSÞṪ

Cobalah online! . Ini adalah implementasi pertanyaan yang relatif mudah.

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*?+}

Mathematica 82 byte

Ini mengisi digit masing-masing angka dengan x di sebelah kanan, transpos matriks, menghapus dummy x, memesan dengan jumlah digit dan mengambil yang terbesar.

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

Seharusnya ada beberapa cara untuk menggunakan bentuk superscript-T Transposeuntuk menyimpan beberapa byte.

Perl, 49 48 byte

Termasuk +1 untuk -p

Jalankan dengan input pada STDIN, cetak untuk STDOUT nomor kolom yang diawali oleh +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

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

Javascript (ES6), 108 103 100 byte

Ini agak bertele-tele dan mungkin bisa bermain golf lagi dengan pendekatan yang berbeda. Saya berharap saya bisa menyingkirkan ini .filter(n=>n).

Disimpan 5 byte berkat Neil
Disimpan 3 byte berkat 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)

Demo

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]

Pyth, 5 8 byte

esDsMM.T

Dimasukkan dalam input sebagai daftar string, output sebagai daftar digit yang tidak terpisahkan.

Cobalah online!

Penjelasan:

      .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

Pyth, 11 byte

h.MsZ.TmjdT

Suatu program yang mengambil input dari daftar bilangan bulat pada STDIN dan mencetak daftar.

Cobalah online

Bagaimana itu bekerja

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

Test Suite .