हर कॉलम को सबसे बड़े कॉलम से खोजें

Question

यहाँ आपके लिए अपेक्षाकृत सरल चुनौती है:

सकारात्मक पूर्णांक की सूची को देखते हुए:

• उन्हें एक ग्रिड में पंक्तिबद्ध करें, और प्रत्येक कॉलम को योग करें। उदाहरण के लिए, यदि इनपुट था [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
  

आप इन नंबरों को अपनी पसंद के किसी भी प्रारूप में प्रिंट कर सकते हैं। सूची प्रारूप, नई रेखा अलग, अंतरिक्ष अलग, आदि। आप इनपुट को अंकों के 2 डी सरणी के रूप में नहीं ले सकते हैं, उदाहरण के लिए

[[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]

Comments

शीर्षक को समझना मुश्किल है। समस्या "सबसे बड़ा स्तंभ" अभिव्यक्ति के साथ झूठ लगती है। शायद कुछ ऐसा है, "कॉलम को सबसे बड़े कुल के साथ खोजें" या "कॉलम जोड़: अधिकतम योग ढूंढें"।

— डेविड सीपी

समस्या कथन कहता है "सकारात्मक पूर्णांक की एक सूची दी", लेकिन उदाहरणों में से एक है 0। शून्य को आमतौर पर अंग्रेजी में सकारात्मक नहीं माना जाता है।

— टन हास्पेल

@tonhospel कौन सा? 302 के साथ एक? स्तंभों को विभाजित करने के बाद ही आपके पास एक शून्य है ।

— जेम्स

सही है, मैंने इनपुट प्रारूप को गलत बताया है। मेरे सबमिशन को फिक्स करना ..

— टन इंस्पिरेशन

Answer 1

हास्केल, 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

Answer 2

जेली , 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]

Comments

अपने समाधान से अलग नहीं होने के लिए, लेकिन यह वास्तव में 11 बाइट्स नहीं है, क्योंकि इसमें कुछ यूटीएफ -8 मल्टी-बाइट वर्ण हैं।

— जोशुआ

@ जोशुआ यह थोड़ा अजीब है, लेकिन जेली अपने स्वयं के कस्टम कोड पृष्ठ का उपयोग करती है जो एक ही बाइट में 256 अक्षरों में से प्रत्येक को समझता है। यह आमतौर पर यूटीएफ -8 में नहीं बनाया जाता है, एपीएल नहीं होगा।

— Sp3000

अच्छा ठीक है। स्पष्टीकरण के लिए धन्यवाद।

— यहोशू

Answer 3

रूबी, 100 97 बाइट्स

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

Comments

eval e*?+महान है! इसके अलावा आप बस कर सकते हैं $<.map; यह एक सरणी में अलग करने की जरूरत नहीं है।

— जॉर्डन

@ जोर्डन आपकी सलाह के लिए धन्यवाद!

— cia_rana

Answer 4

गणितज्ञ 82 बाइट्स

यह x के दाईं ओर प्रत्येक संख्या के अंकों को पैड करता है, मैट्रिक्स को स्थानांतरित करता है, डमी एक्स को हटाता है, अंकों के योग द्वारा आदेश और सबसे बड़ा लेता है।

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

---

Transposeकुछ बाइट्स को बचाने के लिए सुपरस्क्रिप्ट-टी फॉर्म का उपयोग करने का कोई तरीका होना चाहिए ।

Answer 5

पर्ल, 49 48 बाइट्स

के लिए +1 शामिल है -p

एसटीडीआईएन पर इनपुट के साथ चलाएं, उपसर्गित कॉलम संख्याओं के स्टड के लिए प्रिंट +

lcolumn.pl
123
7 
49 
681

lcolumn.pl:

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

Answer 6

जावास्क्रिप्ट (ईएस 6), 108 103 100 बाइट्स

यह थोड़ा वर्बोज़ है और शायद एक अलग दृष्टिकोण के साथ कुछ और गोल्फ हो सकता है। काश मुझे इससे छुटकारा मिल जाता .filter(n=>n)।

बचाया 5 बाइट्स नील
के लिए धन्यवाद 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]

Comments

यदि आप उपयोग करते हैं (d,x)=>(... ,d)तो भीतर की mapएक प्रति लौटाता है k, इस प्रकार आपको असाइन करने के लिए बचत करता है k, जो आपको 4 बाइट्स बचाता है।

— नील

मुझे लगता है कि उपेक्षा करना m, यानी (s[x]=(s[x]|0)-d)<m, आपको एक बाइट बचाता है।

— नील

@Neil - अच्छा आंख, हमेशा की तरह;)

— Arnauld

मैंने एक फ़िल्टर-कम दृष्टिकोण की कोशिश की। यह निकला ... 103 बाइट्स! a=>a.map(n=>[...n+''].map((d,i)=>(t=s[i]=s[i]||[0],t.push(d),(t[0]-=d)<m?r=t:0)),s=[],m=0)&&r.slice(1)

— नील

आप इनपुट को स्ट्रिंग की सूची के रूप में प्राप्त कर सकते हैं, न कि नंबरों पर। इस तरह से आप+''

— edc65

Answer 7

पायथ, 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

Comments

हम्म, यह सभी टेस्टकेस के लिए काम नहीं करता है? मैंने आखिरी कोशिश की है, और यह ओपी के प्रश्न की तुलना में एक अलग आउटपुट देता है ।

— केविन क्रूजेसेन

@ केविनक्रूजसेन हाँ, मैंने गड़बड़ कर दी। पाइथ के ओवरलोडिंग के साथ गड़बड़ी के कारण यह इसके बजाय पूर्णांक मान द्वारा छंटनी कर रहा था।

— स्टीवन एच।

Answer 8

अजगर, 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

Answer 9

जावास्क्रिप्ट (ईएस 6), 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)
  
})

Answer 10

पायथ - 9 बाइट्स

esD_.TjRT

टेस्ट सूट ।