अधिकतम मैक्सिमा!

11

इस सवाल से प्रेरित और लुइस मेंडो द्वारा परिष्कृत ।

चुनौती

पूर्णांक के 2 डी मैट्रिक्स को देखते हुए, प्रत्येक पंक्ति का अधिकतम मूल्य होता है। प्रत्येक पंक्ति के एक या अधिक तत्व उनकी संबंधित पंक्ति के अधिकतम मूल्य के बराबर होंगे। आपका लक्ष्य यह निर्धारित करना है कि किस कॉलम में सबसे अधिक प्रविष्टियाँ हैं, जो उनकी संबंधित पंक्ति के अधिकतम मूल्य के बराबर हैं और साथ ही इन कॉलमों में मिली पंक्ति-वार मैक्सिमा की संख्या भी है।

इनपुट

  • इनपुट गैर-रिक्त Mx Nमैट्रिक्स ( M> 0 और N> 0) होगा जो भी रूप में आपकी पसंद की भाषा के लिए अच्छी तरह से अनुकूल है।

उत्पादन

  • आपके प्रोग्राम को पंक्ति-वार मैक्सिमा की अधिकतम संख्या वाले प्रत्येक कॉलम के इंडेक्स को वापस करना चाहिए (या तो अलग-अलग मान या सूची के रूप में)। या तो 0- या 1-आधारित इंडेक्सिंग का उपयोग किया जा सकता है (आपके विवरण में निर्दिष्ट करें)।
  • आपके प्रोग्राम को इन कॉलमों में मौजूद अधिकतम संख्या (एकल संख्या) को भी वापस करना चाहिए।
  • आउटपुट का क्रम / प्रारूप लचीला है लेकिन आपके उत्तर के साथ पाठ में समझाया जाना चाहिए।

अतिरिक्त जानकारी

  • इनपुट मैट्रिक्स में सभी प्रविष्टियां सकारात्मक पूर्णांक होंगी।
  • यदि किसी पंक्ति का अधिकतम मूल्य उस पंक्ति में कई तत्वों द्वारा साझा किया जाता है, तो उस मूल्य की सभी घटनाएँ उनके कॉलम के कुल की ओर गिना जाती हैं।
  • यदि एकाधिक स्तंभों में अधिकतम संख्या में अधिकतम संख्या होती है, तो आपको उन सभी स्तंभों की एक सूची वापस देनी चाहिए, जिनमें अधिकतम संख्या थी।

एक उदाहरण

इनपुट पर विचार करें

 7  93
69  35
77  30

पंक्ति 1 में अधिकतम 93 है, जो स्तंभ पर केवल एक बार होता है, 2. पंक्ति 2: स्तंभ 1 पर होता है। पंक्ति 3: स्तंभ 1 पर भी। इसलिए विजेता कॉलम 1 है, जिसमें 2 मैक्सिमा हैं। इस प्रकार उत्पादन होगा [1] [2]। यदि हम इनपुट को बदलते हैं

 7  93
69  35
77  77

आउटपुट होगा [1 2] [2], क्योंकि दोनों कॉलम में 2 मैक्सिमा हैं।

परीक्षण के मामलों

input                 =>    output ( [1-based index array], [nMaxima] )
----------------------------------------------
 7  93
69  35                =>    [1], [2]
77  30

 7  93
69  35                =>    [1 2], [2]
77  77     

1   2   3   4         =>    [4], [2]
5   6   7   8

16   2   3  13
 5  11  10   8        =>    [1  2  4], [1]
 9   7   6  12    

 1   1   1   1        =>    [1  2  3  4], [1]

25   6  13  25        =>    [1  4], [1]

1
2
3                     =>    [1], [4] 
4

100                   =>    [1], [1]

स्कोरिंग

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड। टाईब्रेकर पहले वाले उत्तर पर जाता है।

लीडरबोर्ड

नीचे सभी प्रविष्टियों का विश्लेषण करने के लिए एक स्टैक स्निपेट है।

कोड स्निपेट दिखाएं

code-golf  number  array-manipulation 
— Suever
स्रोत
7
मजेदार तथ्य; डच रानी को मैक्सिमा कहा जाता है, इसलिए तकनीकी रूप से हमारे पास केवल 1 मैक्सिमा हो सकता है।
— बैसब्रांड कंबरवुबवबूब
1
मजेदार तथ्य; मैक्सिमा नामक एक ओपनसोर्स कैस भी है ।
— flawr

जवाबों:

3

जेली , 9 बाइट्स

="Ṁ€SµM,Ṁ

इनपुट एक 2 डी सूची है, आउटपुट एक जोड़ी है: 1-आधारित सूचकांकों की सूची और मैक्सिमा की अधिकतम संख्या।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

="Ṁ€SµM,Ṁ  Main link. Argument: M (matrix)

  Ṁ€       Apply maximum to each row.
="         Zipwith equal; compare the entries of the nth row with its maxmium.
    S      Sum; reduce across columns to count the maxima in each row.
     µ     Begin a new, monadic link. Argument: A (list of maxima)
      M    Yield all indices with maximal value.
        Ṁ  Yield the maximum of A.
       ,   Pair the results to both sides.
— डेनिस
स्रोत
3

जे, 27 बाइट्स

((I.@:=;])>./)@(+/@:=>./"1)

यह एक मोनडिक क्रिया है, जिसका उपयोग दूसरे उदाहरण के मामले में निम्नानुसार है:

   f =: ((I.@:=;])>./)@(+/@:=>./"1)
   m =: 3 2 $ 7 93 69 35 77 77
   f m
+---+-+
|0 1|1|
+---+-+

आउटपुट में दो बॉक्स होते हैं, और 0-आधारित अनुक्रमण का उपयोग करता है। यहाँ यह कोशिश करो!

व्याख्या

((I.@:=;])>./)@(+/@:=>./"1)  Input is m.
(            )@(          )  Composition: apply right hand side, then left hand side.
                     >./"1   Take maximum of each row of m.
                    =        Replace row maxima by 1 and other values by 0,
                +/@:         then take sum (number of maxima) on each column.
                             The result is the array of number of row maxima in each column.
          >./                Compute the maximum of this array
 (     ;])                   and put it in a box with
  I.@:=                      the indices of those entries that are equal to it.
— Zgarb
स्रोत
3

MATL, 17 बाइट्स

vH3$X>G=XstX>tb=f

पहला आउटपुट मैक्सिमा की अधिकतम संख्या है और दूसरा आउटपुट वह कॉलम है जिसमें यह (1-आधारित इंडेक्सिंग) किया गया है।

इसे ऑनलाइन आज़माएं!

व्याख्या

v       % Vertically concatenate everything on the stack (nothing), yields []
        % Implicitly grab the input
H       % Push the number 2 to the stack
3$X>    % Compute the maximum value of each row (along the second dimension)
G       % Explicitly grab input again
=       % Compare each row of the input to the row-wise max (automatically broadcasts). 
Xs      % Sum the number of matches in each column
t       % Duplicate the array
X>      % Determine the max number of maxima in all columns
t       % Duplicate this value
b=f     % Find the index of the columns which had the maximum number of maxima
        % Implicitly display stack contents
— Suever
स्रोत
3

MATL , 17 बाइट्स

!tvX>!G=5#fFTT#XM

इनपुट एक 2 डी सरणी है, जिसमें अर्धविराम द्वारा अलग की गई पंक्तियाँ हैं। तो परीक्षण मामलों के लिए इनपुट हैं

[7 93; 69 35; 77  30]
[7 93; 69 35; 77  77]
[1 2 3 4; 5 6 7 8]
[16 2 3 13; 5 11 10 8; 9 7 6 12]
[1 1 1 1]
[25 6 13 25]
[1; 2; 3; 4]
[100]

आउटपुट है: पहले मैक्सिमा की अधिकतम मात्रा, फिर एक या एक से अधिक स्तंभ सूचक।

इसे ऑनलाइन आज़माएं!

व्याख्या

यह सूवर के उत्तर से अलग दृष्टिकोण का उपयोग करता है ।

पहले तार्किक मूल्यों का एक मैट्रिक्स ( trueऔर false) गणना की जाती है, जहां trueएक पंक्ति-अधिकतम की उपस्थिति को इंगित करता है। तब trueमानों के स्तंभ सूचक एक वेक्टर में निकाले जाते हैं। अंत में, उस वेक्टर का मोड गणना किया गया है (अधिकतम संख्या अधिकतम), साथ ही उन सभी मूल्यों के साथ जो सबसे अधिक बार (वांछित कॉलम इंडिक) हैं।

!        % Implicit input. Transpose
tv       % Duplicate. Concatenate vertically. This forces next function (max)
         % to work along columns even if input is a row vector
X>       % Maximum of each column (gives row vector)
!        % Transpose into column vector
G        % Push input again
=        % Test for equality, with broadcast. Gives matrix of true and false
5#f      % Column indices of true values, as a column vector
FTT#XM   % Mode of that vector, and all values that occur maximum number of times
         % Implicit display
— लुइस मेंडो
स्रोत
3

पायथ, 20 19 17 बाइट्स

1 बाइट @ शुक्रिया के लिए धन्यवाद ।

1 बाइट @ जेक्यूब को धन्यवाद ।

{MC.MhZrSsxLeSdQ8

परीक्षण सूट।

आउटपुट 0-अनुक्रमित है।

आदेश उलटा है।

सभी इनपुट

[[7,93],[69,35],[77,30]]
[[7,93],[69,35],[77,77]]
[[1,2,3,4],[5,6,7,8]]
[[16,2,3,13],[5,11,10,8],[9,7,6,12]]
[[1,1,1,1]]
[[25,6,13,25]]
[[1],[2],[3],[4]]
[[100]]

सभी आउटपुट

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

[[1], [0, 1, 3]]

[[1], [0, 1, 2, 3]]

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

यह काम किस प्रकार करता है

{MC.MhZrSsxLeSdQ8

               Q   Yield input.
           L       For each array in input (as d):
            eSd      Yield maximum of d.
          x          Yield the 0-indexed indices of the maximum in d.
         s          Flatten.
        S           Sort.
       r         8  Run-length encoding.
                    Now the array is:
                      [number of maxima in column, index of column]
                      for all the columns
   .MhZ             Yield the sub-arrays whose first element is maximum.
                     The first element of each sub-array
                     is "number of maxima in column".
                     Now the array is:
                       [number of maxima in column, index of column]
                       for all the required columns
  C                 Transpose.
                    Now the array is:
                      [[number of maxima in each column],
                       [index of each required column]]
                    Note that every element in the
                    first sub-array is the same.
{M                  Deduplicate each.
— लीक नन
स्रोत
3

CJam , 38 35 31 बाइट्स

2 बाइट्स @FryAmTheEggMan के लिए कम धन्यवाद, मदद से @quartata से भी। 4 और बाइट्स निकालने के लिए @ डेनिस को भी धन्यवाद।

q~_::e>.f=:.+_:e>_@f{=U):Ua*~}p

इनपुट फॉर्म का है

[[7 93] [69 35] [77 77]]

आउटपुट 1-आधारित कॉलम सूचक और संख्या का एक सरणी है।

इसे ऑनलाइन आज़माएं!

— लुइस मेंडो
स्रोत
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}pकुछ बाइट्स बचाता है। इसे कोड ब्लॉक में बदलने से 1 और बचत होगी।
— डेनिस
@ डेनिस धन्यवाद! अब मुझे यह समझने की ज़रूरत है कि क्या {=U):Ua*~}होता है ...
— लुइस मेंडो
2

पायथन 2, 106 बाइट्स

x=map(sum,zip(*[map(max(r).__eq__,r)for r in input()]))
m=max(x);print[i for i,n in enumerate(x)if n==m],m

इनपुट फ्लोट्स की 2 डी सूची है, आउटपुट एक जोड़ी है: 0-आधारित सूचकांकों और पूर्णांक की एक सूची।

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
2

जूलिया, 54 बाइट्स

f(x,m=maximum,t=sum(x.==m(x,2),1))=find(t.==m(t)),m(t)

इनपुट एक मैट्रिक्स है, आउटपुट एक जोड़ी है: 1-आधारित सूचकांकों की सूची और मैक्सिमा की अधिकतम संख्या।

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
1

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

a=>[m=Math.max(...a=a[0].map((_,i)=>a.map(a=>c+=a[i]==Math.min(...a),c=0)|c)),[...a.keys()].filter(i=>a[i]==m)]

दो तत्वों की एक सरणी देता है; पहला मैक्सिमा की अधिकतम गिनती है, दूसरा उस गिनती के साथ शून्य-अनुक्रमित स्तंभों का सरणी है।

— नील
स्रोत
1

ऑक्टेव, 47 46 बाइट्स

@(r){m=max(s=sum(r==max(r,0,2),1)),find(s==m)}

यह एक अनाम फ़ंक्शन बनाता है जो स्वचालित रूप से स्वयं को असाइन करता है ansऔर इसका उपयोग करके चलाया जा सकता है ans([1 2 3; 4 5 6])। यह एक दो-तत्व सेल सरणी देता है जहां पहला तत्व मैक्सिमा की अधिकतम संख्या है और दूसरा इन मैक्सिमा वाले स्तंभों का 1-आधारित सूचकांक है।

सभी परीक्षण मामले

— Suever
स्रोत
1

पायथन 3, 142 बाइट्स

यहां एल्गोरिथ्म मूल रूप से, प्रत्येक पंक्ति से गुजरता है और उस पंक्ति के अधिकतम स्तंभों के स्कोर को बढ़ाता है। फिर अधिकतम स्कोर खोजें और उन कॉलमों को खोजें जिनमें अधिकतम स्कोर है और उन्हें वापस लौटाएं। कॉलम 1-अनुक्रमित हैं। मैंने इसे लैम्बडा में वन-लाइनिंग की कोशिश की, लेकिन कॉलम के द्वारा स्कोर कॉलम बनाने के साथ यह 153 बाइट्स था।

def f(r):
    s=[0]*len(r[0]);e=enumerate
    for x in r:
        for i,j in e(x):
            s[i]+=(0,1)[j==max(x)]
    m=max(s);return[i+1for i,j in e(s)if j==m],m

परीक्षण के मामलों

x=[[7, 93],
[69, 35],              
[77, 30]]

print(f(x)) #=>    [[1], 2]

x=[[ 7, 93],
[69, 35],             
[77, 77]]    

print(f(x)) #=>    [[1 2], 2]

x=[[1,  2,   3,  4],        
[5,  6,  7,  8]]

print(f(x)) #=>    [[4], 2]

x=[[16,  2,  3, 13],
 [5, 11, 10,  8],      
 [9,  7, 6, 12]]

print(f(x)) #=>    [[1  2  4], 1]

x=[[1,  1,  1,  1]]      

print(f(x)) #=>    [[1  2  3  4], 1]

x=[[25,   6,  13,  25]]        

print(f(x)) #=>    [[1  4], 1]

x=[[1],
[2],
[3],                   
[4]]

print(f(x)) #=>    [[1], 4] 

x=[[100]]                   

print(f(x)) #=>    [[1], 1]
— NonlinearFruit
स्रोत
1

क्लोजर, 150 बाइट्स

(fn[M](let[F(dissoc(frequencies(mapcat(fn[r](map-indexed #(if(=(apply max r)%2)%)r))M))nil)m(apply max(vals F))][(map first(filter #(#{m}(% 1))F))m]))

आदमी जो लंबा है, मुझे लग रहा है कि यह बहुत सरल हो सकता है। कम से कम यह सही आउटपुट पैदा करता है।

[(f [[ 7  93][69  35][77  30]])
 (f [[ 7  93][69  35][77  77]])
 (f [[16   2   3  13][5  11  10   8][9   7   6  12]])]

[[(0) 2] [(1 0) 2] [(0 1 3) 1]]
— NikoNyrh
स्रोत
1

05AB1E , 14 (या 12) बाइट्स

εZQ}øOZ©Qƶ0K®‚

प्रारूप में आउटपुट [[1-indexed columns-list], maxima]।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

यदि इसे 0कॉलम-सूची में आइटम रखने की अनुमति है , जिसे हम अनदेखा करते हैं, तो इसे हटाकर 2 बाइट्स कम हो सकते हैं 0K:

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ε               # Map each row in the (implicit) input-matrix:
 Z              #  Get the maximum of the row (without popping)
  Q             #  Check for each value in this row if its equal to the row-maximum
   }ø           # After the map: zip/transpose the matrix; swapping rows/columns
     O          # Take the sum of each inner list (the truthy/falsey values of the columns)
      Z         # Get the maximum column-sum (without popping)
       ©        # Store it in the register (without popping)
        Q       # Check for each column-sum if its equal to this maximum
         ƶ      # Multiply each truthy/falsey value in the list by its 1-based index
          0K    # Remove all 0s
            ®‚  # Pair the resulting list with the maximum we stored in the register
                # (and output the result implicitly)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.