İşte sizin için nispeten basit bir zorluk:

Pozitif tamsayıların bir listesi verildi:

• Onları bir ızgaraya hizalayın ve her sütunu toplayın. Örneğin, giriş [123, 7, 49, 681]olsaydı, ızgara şöyle görünecektir:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  Ve her sütunun toplamı [18, 19, 4]:

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

• Bu durumda 19 olan bu toplamların maksimumunu bulun ve ardından

• Bu maksimum sütunla aynı dizinde bulunan her basamağın çıktısını alın. Bu durumda,

  2
  9
  8
  

  Bu numaraları belirli bir sırada vermeniz gerekmez. 4 girişimiz olmasına rağmen sadece üç çıkış olduğunu unutmayın. Beraberlik durumunda, en erken endeksi seçin. Örneğin, giriş şuysa [25, 223, 302], kılavuzunuz:

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

  Çıktı almalısınız

  2
  2
  3
  

Bu numaraları istediğiniz herhangi bir biçimde yazdırabilirsiniz. Liste formatı, satırsonu ayrılmış, boşluk ayrılmış, vb. Girişi 2D bir basamak dizisi olarak alamazsınız, ör.

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

Ancak bunun dışında, girdiyi dizeler listesi, rakamlar listesi veya başka bir makul biçim olarak alabilirsiniz.

Ayrıca tüm girişlerin geçerli olacağını ve en az iki sayı içerdiğini varsayabilirsiniz.

Her zamanki gibi, bayttaki en kısa cevap kazanır!

Test G / Ç:

#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 bayt

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

Kullanım örneği: argmax sum.transpose.map(map(read.pure).show) $ [12,304,506]-> [4,6].

Nasıl çalışır:

                     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

Jöle , 6 bayt

DZṚSÞṪ

Çevrimiçi deneyin! . Bu, sorunun nispeten basit bir uygulamasıdır.

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]

Yakut, 100 97 bayt

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

Mathematica 82 bayt

Bu, her sayının rakamlarını x'leri sağa doğru doldurur, matrisi aktarır, kukla x'leri kaldırır, basamakların toplamını sıralar ve en iyisini alır.

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

TransposeBirkaç bayt kaydetmek için üst simge-T biçimini kullanmanın bir yolu olmalı .

Perl, 49 48 bayt

İçin +1 içerir -p

STDIN üzerindeki girişle çalıştır, önündeki sütun numaralarını STDOUT'a yazdırır +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

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

JavaScript (ES6), 108 103 , 100 bayt

Biraz ayrıntılı ve muhtemelen farklı bir yaklaşımla biraz daha golf olabilir. Keşke bundan kurtulabilseydim .filter(n=>n).

Neil sayesinde 5 bayt
kaydedildi edc65 sayesinde 3 bayt kaydedildi

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)

gösteri

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 bayt

esDsMM.T

Dizeleri bir liste olarak alır, hiçbir şeyle ayrılmış bir sayı listesi olarak çıkar.

Çevrimiçi deneyin!

Açıklama:

      .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 bayt

h.MsZ.TmjdT

STDIN üzerinde tamsayıların bir listesini alan ve bir liste basan bir program.

Çevrimiçi deneyin

Nasıl çalışır

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 bayt

esD_.TjRT

Test Takımı .