นี่คือความท้าทายที่ค่อนข้างง่ายสำหรับคุณ:

รับรายการจำนวนเต็มบวก:

• จัดเรียงพวกมันในตารางและรวมแต่ละคอลัมน์ ตัวอย่างเช่นถ้าอินพุตเป็น[123, 7, 49, 681]กริดจะมีลักษณะเช่นนี้:

   1  2  3
   7 
   4  9 
   6  8  1 
  

  และผลรวมของแต่ละคอลัมน์จะเป็น[18, 19, 4]:

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

• หาจำนวนเงินสูงสุดเหล่านี้ซึ่งในกรณีนี้จะเท่ากับ 19 แล้ว

• เอาต์พุตทุกหลักที่อยู่ในดัชนีเดียวกันกับคอลัมน์สูงสุดนี้ ในกรณีนี้ก็จะเป็น

  2
  9
  8
  

  คุณไม่จำเป็นต้องแสดงหมายเลขเหล่านี้ในลำดับใด ๆ โปรดทราบว่ามีเพียงสามเอาต์พุตแม้ว่าเราจะมี 4 อินพุต ในกรณีที่เสมอกันให้เลือกดัชนีที่เร็วที่สุด ตัวอย่างเช่นถ้าอินพุตเป็น[25, 223, 302]กริดของคุณคือ:

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

  คุณควรส่งออก

  2
  2
  3
  

คุณสามารถพิมพ์ตัวเลขเหล่านี้ในรูปแบบที่คุณต้องการ รูปแบบรายการ, การขึ้นบรรทัดใหม่, การเว้นวรรค, ฯลฯ คุณไม่สามารถรับอินพุตเป็นตัวเลขสองหลักเช่น

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

แต่นอกเหนือจากนั้นคุณสามารถรับอินพุตเป็นรายการสตริงรายการตัวเลขหรือรูปแบบอื่นที่สมเหตุสมผล

คุณอาจสมมติว่าอินพุตทั้งหมดจะถูกต้องและมีตัวเลขอย่างน้อยสองตัว

ตามปกติคำตอบที่สั้นที่สุดเป็นไบต์ชนะ!

ทดสอบ 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 ไบต์

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

ตัวอย่างการใช้งาน: ->argmax sum.transpose.map(map(read.pure).show) $ [12,304,506][4,6]

มันทำงานอย่างไร:

                     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

เยลลี่ขนาด 6 ไบต์

DZṚSÞṪ

ลองออนไลน์! . นี่เป็นการใช้คำถามที่ค่อนข้างตรงไปตรงมา

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 ไบต์

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

Mathematica 82 ไบต์

นี่คือตัวเลขของแต่ละตัวเลขโดยมี x ทางขวาสลับเมทริกซ์ลบ dummy x's ออกคำสั่งด้วยผลรวมของตัวเลขและใช้เวลามากที่สุด

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

ควรมีวิธีการใช้รูปแบบตัวยก -T ของTransposeการบันทึกไม่กี่ไบต์

Perl, 49 48 ไบต์

รวม +1 สำหรับ -p

รันด้วยอินพุตบน STDIN พิมพ์ไปที่ STDOUT หมายเลขคอลัมน์ที่ขึ้นต้นด้วย +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

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

Javascript (ES6), 108 103 100 ไบต์

มันค่อนข้าง verbose และอาจจะ golfed เพิ่มเติมด้วยวิธีการที่แตกต่างกัน ฉันหวังว่าฉันจะกำจัดสิ่งนี้.filter(n=>n)ได้

บันทึก 5 ไบต์ขอบคุณ Neil
บันทึก 3 ไบต์ขอบคุณ 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)

การสาธิต

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 ไบต์

esDsMM.T

รับอินพุตเป็นรายการของสตริงเอาต์พุตเป็นรายการของตัวเลขที่ไม่มีการคั่น

ลองออนไลน์!

คำอธิบาย:

      .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 ไบต์

h.MsZ.TmjdT

โปรแกรมที่รับอินพุตของรายการจำนวนเต็มบน STDIN และพิมพ์รายการ

ลองออนไลน์

มันทำงานอย่างไร

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 ไบต์

esD_.TjRT

Test Suite