Voici un défi relativement simple pour vous:

Étant donné une liste d'entiers positifs:

• Alignez-les dans une grille et additionnez chaque colonne. Par exemple, si l'entrée était [123, 7, 49, 681], la grille ressemblerait à ceci:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  Et la somme de chaque colonne serait [18, 19, 4]:

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

• Trouvez le maximum de ces sommes, qui dans ce cas serait 19, puis

• Sortez chaque chiffre qui est au même index que cette colonne maximale. Dans ce cas, ce serait

  2
  9
  8
  

  Vous n'avez pas besoin de sortir ces numéros dans un ordre particulier. Notez qu'il n'y a que trois sorties, même si nous avions 4 entrées. En cas d'égalité, choisissez le premier indice. Par exemple, si l'entrée était [25, 223, 302], votre grille est:

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

  Vous devez sortir

  2
  2
  3
  

Vous pouvez imprimer ces numéros dans le format de votre choix. Format de liste, saut de ligne séparé, espace séparé, etc. Vous ne pouvez pas prendre l'entrée comme un tableau 2D de chiffres, par exemple

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

Mais à part cela, vous pouvez prendre l'entrée comme une liste de chaînes, une liste de chiffres ou tout autre format raisonnable.

Vous pouvez également supposer que toutes les entrées seront valides et contiendront au moins deux nombres.

Comme d'habitude, la réponse la plus courte en octets gagne!

Test 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 octets

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

Exemple d'utilisation: argmax sum.transpose.map(map(read.pure).show) $ [12,304,506]-> [4,6].

Comment ça fonctionne:

                     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

Gelée , 6 octets

DZṚSÞṪ

Essayez-le en ligne! . Il s'agit d'une mise en œuvre relativement simple de la question.

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]

Rubis, 100 97 octets

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

Mathematica 82 octets

Cela remplit les chiffres de chaque nombre avec des x à droite, transpose la matrice, supprime les x fictifs, ordonne par la somme des chiffres et prend le plus grand.

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

Il devrait y avoir un moyen d'utiliser la forme en exposant-T Transposepour économiser quelques octets.

Perl, 49 48 octets

Comprend +1 pour -p

Exécuter avec l'entrée sur STDIN, imprime dans STDOUT les numéros de colonne préfixés par +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

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

Javascript (ES6), 108 103 100 octets

C'est un peu bavard et pourrait probablement être joué au golf avec une approche différente. J'aimerais pouvoir m'en débarrasser .filter(n=>n).

5 octets enregistrés grâce à Neil
3 octets enregistrés grâce à 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)

Démo

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 octets

esDsMM.T

Prend l'entrée comme une liste de chaînes, les sorties comme une liste de chiffres séparés par rien.

Essayez-le en ligne!

Explication:

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

h.MsZ.TmjdT

Un programme qui prend l'entrée d'une liste d'entiers sur STDIN et imprime une liste.

Essayez-le en ligne

Comment ça fonctionne

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 octets

esD_.TjRT

Suite de tests .