Aquí hay un desafío relativamente simple para ti:

Dada una lista de enteros positivos:

• Alinéelos en una cuadrícula y sume cada columna. Por ejemplo, si la entrada fue [123, 7, 49, 681], la cuadrícula se vería así:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  Y la suma de cada columna sería [18, 19, 4]:

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

• Encuentre el máximo de estas sumas, que en este caso sería 19, y luego

• Imprima cada dígito que esté en el mismo índice que esta columna máxima. En este caso, eso sería

  2
  9
  8
  

  No tiene que generar estos números en ningún orden en particular. Tenga en cuenta que solo hay tres salidas, a pesar de que teníamos 4 entradas. En caso de empate, elija el índice más antiguo. Por ejemplo, si la entrada fue [25, 223, 302], su grilla es:

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

  Usted debe salir

  2
  2
  3
  

Puede imprimir estos números en cualquier formato que desee. Formato de lista, nueva línea separada, espacio separado, etc. No puede tomar la entrada como una matriz 2D de dígitos, p. Ej.

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

Pero aparte de eso, puede tomar la entrada como una lista de cadenas, una lista de dígitos o cualquier otro formato razonable.

También puede suponer que todas las entradas serán válidas y contendrán al menos dos números.

Como de costumbre, ¡la respuesta más corta en bytes gana!

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

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

Cómo funciona:

                     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

Jalea , 6 bytes

DZṚSÞṪ

Pruébalo en línea! . Esta es una implementación relativamente sencilla de la pregunta.

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

Esto rellena los dígitos de cada número con las x a la derecha, transpone la matriz, elimina las x falsas, ordena por la suma de los dígitos y toma el mayor.

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

Debería haber alguna forma de usar la forma de superíndice T Transposepara guardar algunos bytes.

Perl 49 48 bytes

Incluye +1 para -p

Ejecute con la entrada en STDIN, imprime en STDOUT los números de columna con el prefijo +

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 un poco detallado y probablemente podría jugar un poco más con un enfoque diferente. Desearía poder deshacerme de esto .filter(n=>n).

Guardado 5 bytes gracias a Neil
Guardado 3 bytes gracias a 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)

Manifestación

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

Toma la entrada como una lista de cadenas, emite como una lista de dígitos sin nada.

Pruébalo en línea!

Explicación:

      .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

Un programa que toma la entrada de una lista de enteros en STDIN e imprime una lista.

Pruébalo en línea

Cómo funciona

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 .