Hier ist eine relativ einfache Herausforderung für Sie:

Eine Liste von positiven ganzen Zahlen gegeben:

• Richten Sie sie in einem Raster aus und addieren Sie jede Spalte. Wenn die Eingabe beispielsweise so wäre, würde das [123, 7, 49, 681]Raster folgendermaßen aussehen:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  Und die Summe jeder Spalte wäre [18, 19, 4]:

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

• Bestimmen Sie das Maximum dieser Summen, in diesem Fall 19, und dann

• Geben Sie jede Ziffer aus, die sich am selben Index wie diese maximale Spalte befindet. In diesem Fall wäre das

  2
  9
  8
  

  Sie müssen diese Nummern nicht in einer bestimmten Reihenfolge ausgeben. Beachten Sie, dass es nur drei Ausgänge gibt, obwohl wir 4 Eingänge hatten. Wählen Sie im Falle eines Unentschieden den frühesten Index. Wenn die Eingabe beispielsweise war [25, 223, 302], lautet Ihr Raster:

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

  Sie sollten ausgeben

  2
  2
  3
  

Sie können diese Zahlen in einem beliebigen Format ausdrucken. Listenformat, Zeilenvorschub getrennt, Leerzeichen getrennt usw. Sie können die Eingabe möglicherweise nicht als 2D-Array von Ziffern verwenden, z

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

Ansonsten können Sie Eingaben als eine Liste von Zeichenfolgen, eine Liste von Ziffern oder ein anderes vernünftiges Format annehmen.

Sie können auch davon ausgehen, dass alle Eingaben gültig sind und mindestens zwei Zahlen enthalten.

Wie immer gewinnt die kürzeste Antwort in Bytes!

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 Bytes

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

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

Wie es funktioniert:

                     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

Gelee , 6 Bytes

DZṚSÞṪ

Probieren Sie es online! . Dies ist eine relativ einfache Umsetzung der Frage.

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 Bytes

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

Mathematica 82 Bytes

Dies füllt die Ziffern jeder Zahl mit x rechts auf, transponiert die Matrix, entfernt die Dummy-x, ordnet nach der Summe der Ziffern und nimmt die größten.

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

Es sollte eine Möglichkeit geben, die hochgestellte T-Form von zu verwenden Transpose zu verwenden, um ein paar Bytes zu sparen.

Perl, 49 48 Bytes

Beinhaltet +1 für -p

Run mit der Eingabe auf STDIN, druckt die Spaltennummern, denen das Präfix vorangestellt ist, auf STDOUT +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

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

Javascript (ES6), 108 103 100 Bytes

Es ist ein bisschen wortreich und könnte mit einer anderen Herangehensweise wahrscheinlich noch etwas mehr golfen werden. Ich wünschte, ich könnte das loswerden .filter(n=>n).

5 Bytes dank Neil
gespeichert 3 Bytes dank edc65 gespeichert

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 Bytes

esDsMM.T

Nimmt Eingaben als Liste von Zeichenfolgen auf, gibt sie als durch nichts getrennte Ziffernliste aus.

Probieren Sie es online!

Erläuterung:

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

h.MsZ.TmjdT

Ein Programm, das eine Liste von Ganzzahlen in STDIN eingibt und eine Liste druckt.

Probieren Sie es online aus

Wie es funktioniert

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 Bytes

esD_.TjRT

Test Suite .