सबसे ज्यादा योगदान पंक्तियों का है

17

गैर-नकारात्मक पूर्णांक के एक गैर-खाली मैट्रिक्स को देखते हुए, उत्तर दें कि मैट्रिक्स में तत्वों की कुल राशि के लिए कौन सी अनूठी पंक्तियाँ सबसे अधिक योगदान करती हैं।

किसी भी उचित संकेत द्वारा उत्तर, उदाहरण के लिए अद्वितीय पंक्तियों का एक मुखौटा क्रम (या क्रम क्रम), या उन लोगों के सूचकांक (शून्य- या एक-आधारित), या पंक्तियों से युक्त सबमेट्रिक्स (किसी भी क्रम में) या कुछ शब्दकोश का निर्माण ... - लेकिन इसे समझाएं!

उदाहरण

[[1,2,3],[2,0,4],[6,3,0],[2,0,4],[6,3,0],[2,0,4]]:

अद्वितीय पंक्तियाँ हैं [1,2,3], [2,0,4]और [6,3,0]प्रत्येक में क्रमशः 6, 6, और 9 का योगदान होता है। हालांकि, वे क्रमशः एक, तीन बार और दो बार होते हैं, इसलिए उनकी सभी संबंधित घटनाएं 6, 18 और कुल (42) में 18 योगदान करती हैं, इसलिए बाद की दो पंक्तियां सबसे अधिक योगदान देती हैं। मान्य उत्तर इसलिए हैं:

[false,true,true] उपस्थिति / सॉर्ट क्रम में नकाब या
[1,2]/ [2,3] शून्य से ऊपर या की / एक आधारित सूचकांक
[[2,0,4],[6,3,0]] वास्तविक पंक्तियों
⋮

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

[false,false,true](उपस्थिति आदेश) / [false,true,false](क्रम में क्रमबद्ध)
[2]/ [3](उपस्थिति आदेश) / [1]/ [2](क्रम में क्रमबद्ध)
[[2,3]]
⋮

code-golf  matrix  subsequence 
— एडम
स्रोत

जवाबों:

4

अजगर , 9 बाइट्स

FryAmTheEggman के लिए धन्यवाद!

{s.MssZ.g

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

— मिस्टर एक्सकोडर
स्रोत
1
अंतिम kआवश्यक नहीं है। इसके अलावा .M*sZ/QZ{एक ही लंबाई समाधान होने लगता है।
— FryAmTheEggman
1
@FryAmTheEggman ओह योग्य मैं ऑटो-पूर्ण के बारे में कैसे भूल गया? आपका बहुत बहुत धन्यवाद!
— श्री एक्सकोडर
4

आर , 64 बाइट्स

function(M)max(x<-tapply(rowSums(M),apply(M,1,toString),sum))==x

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

क्रमबद्ध क्रम (lexicographic) में TRUE / FALSE के साथ एक बूलियन वेक्टर देता है।
अद्वितीय पंक्तियों को वेक्टर नामों के रूप में दिखाया गया है, इसलिए सबसे अधिक योगदान देने वालों की पहचान करना आसान है।

— digEmAll
स्रोत
2

हास्केल, 60 बाइट्स

import Data.Lists
f x=nub$argmaxes(\e->sum e*countElem e x)x

पंक्तियों की सूची लौटाता है।

— nimi
स्रोत
2

चारकोल , 25 बाइट्स

ＩΦθ∧⁼κ⌕θι⁼×№θιΣι⌈Ｅθ×№θλΣλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। डिफ़ॉल्ट आउटपुट स्वरूप प्रत्येक पंक्ति तत्व अपनी लाइन पर है और पंक्तियों को डबल-स्पेस किया गया है। स्पष्टीकरण:

  θ                         Input array
 Φ                          Filtered where
     κ                      Current index
    ⁼                       Equals
      ⌕                     First index of
        ι                   Current row
       θ                    In input array
   ∧                        Logical And
           №                Count of
             ι              Current row
            θ               In input array
          ×                 Multiplied by
              Σ             Sum of
               ι            Current row
         ⁼                  Equals
                ⌈           Maximum of
                  θ         Input array
                 Ｅ          Mapped over rows
                    №       Count of
                      λ     Current row
                     θ      In input array
                   ×        Multiplied by
                       Σ    Sum of
                        λ   Current row
Ｉ                           Cast to string
                            Implicitly printed
— नील
स्रोत
2

मैथेमेटिका, 48 बाइट्स

Last[SortBy[Gather[m], Total[Flatten[#]] &]][[1]]

या

TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]]

कहाँ (उदाहरण के लिए)

m = {{1, 2, 3}, {2, 0, 4}, {7, 9, 5}, {6, 3, 0}, {2, 0, 4}, 
     {6, 3, 0}, {2, 0, 4}, {7, 9, 5}};
— डेविड जी स्टॉर्क
स्रोत
2
आप उपयोग कर सकते हैं आशुलिपि और रिक्त स्थान को बाइट्स को बचाने के लिए निकालें:SortBy[Gather@m,Total@*Flatten][[-1,1]]
— दरवाज़े
1
ऐसा लगता है कि यह पूर्वनिर्धारित चर से इनपुट लेता है, जिसकी अनुमति नहीं है । सबमिशन को डिफ़ॉल्ट रूप से पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए।
— डेनिस
TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]] /@ m
— डेविड जी। स्टॉर्क
यह मान्य नहीं है; यह उन सभी के बजाय सबसे बड़ी मूल्यों वाली पंक्तियों में से एक को लौटाता है।
— lirtosiast
1

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

उपस्थिति क्रम में बूलियन मानों की एक सरणी को आउटपुट करता है।

m=>m.map(h=o=r=>h=(v=o[r]=~~o[r]+eval(r.join`+`))<h?h:v)&&Object.keys(o).map(x=>o[x]==h)

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

— Arnauld
स्रोत
1

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

lambda a:{u for u in a if a.count(u)*sum(u)==max(a.count(t)*sum(t)for t in a)}

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

काले उल्लू काई के लिए 3 बाइट्स ।

Tuples के संग्रह को देखते हुए, आउटपुट उन tuples का एक सेट है जिसमें वांछित अधिकतम संपत्ति होती है।

— चास ब्राउन
स्रोत
— ब्लैक उल्लू काई
@ बैक उल्लू काई: thx! मुझे वह याद आ गया ...
— चास ब्राउन
0

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 126 बाइट्स

n=>{var i=n.OrderBy(a=>a.Sum()*n.Count(a.SequenceEqual));return i.Where((a,b)=>i.Take(b).Count(a.SequenceEqual)<1).Reverse();}

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

इस कोड को अधिकांश सभी डुप्लिकेट मानों को बाहर करने में खर्च किया जाता है, क्योंकि सूचियों के लिए डिफ़ॉल्ट तुलना सूची के अंदर के मूल्यों की तुलना नहीं करता है। इसका मतलब है कि यह है कि मैं का उपयोग नहीं कर सकते हैं Distinct(), GroupBy()या Containsसूची फिल्टर करने के लिए।

— अज्ञान का अवतार
स्रोत
0

के (ngn / k) , 17 बाइट्स

{&a=|/a:+//'x@=x}

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

{ } तर्क के साथ कार्य करें x

=x समूह - एक शब्दकोष है जिसमें कुंजियाँ हैं और मान मैट्रिक्स में उनके सूचकांकों की सूची हैं

x@मूल मैट्रिक्स को उसी के साथ अनुक्रमित करें। परिणाम फिर से कुंजी के रूप में पंक्तियों के साथ एक शब्दकोश है। मान संबंधित कुंजी की कई प्रतियाँ हैं

+//' प्रत्येक अभिसरण तक योग (केवल मूल्यों पर कार्य करता है; कुंजियाँ वैसी ही रहती हैं जैसी वे हैं)

a: को आवंटित a

|/ अधिकतम (मानों का)

a=|/a पंक्ति-टू-बूलियन शब्दकोश जिसमें पंक्तियाँ सबसे अधिक योगदान करती हैं

& "जहां", अर्थात जो कुंजी 1 के मानों के अनुरूप है

— NGN
स्रोत
0

05AB1E , 10 9 बाइट्स

ês{γOOZQÏ

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

स्पष्टीकरण:

ê          # Sort and uniquify the (implicit) input list of lists
           #  i.e. [[2,0,4],[1,2,3],[6,3,0],[2,0,4],[6,3,0],[2,0,4]]
           #   → [[1,2,3],[2,0,4],[6,3,0]]
 s         # Swap so the (implicit) input list of lists is at the top again
  {        # Sort it
           #  i.e. [[2,0,4],[1,2,3],[6,3,0],[2,0,4],[6,3,0],[2,0,4]]
           #   → [[1,2,3],[2,0,4],[2,0,4],[2,0,4],[6,3,0],[6,3,0]]
   γ       # Group the sorted list of lists
           #  i.e. [[1,2,3],[2,0,4],[2,0,4],[2,0,4],[6,3,0],[6,3,0]]
           #   → [[[1,2,3]],[[2,0,4],[2,0,4],[2,0,4]],[[6,3,0],[6,3,0]]]
    O      # Take the sum of each inner-most lists
           #  i.e. [[[1,2,3]],[[2,0,4],[2,0,4],[2,0,4]],[[6,3,0],[6,3,0]]]
           #   → [[6],[6,6,6],[9,9]]
     O     # Take the sum of each inner list
           #  i.e. [[6],[6,6,6],[9,9]] → [6,18,18]
      Z    # Get the max (without popping the list of sums)
           #  i.e. [6,18,18] → 18
       Q   # Check for each if this max is equal to the sum
           #  i.e. [6,18,18] and 18 → [0,1,1]
        Ï  # Filter the uniquified list of lists on truthy values (and output implicitly)
           #  i.e. [[1,2,3],[2,0,4],[6,3,0]] and [0,1,1] → [[2,0,4],[6,3,0]]
— केविन क्रूज़सेन
स्रोत
0

गैया , 10 बाइट्स

ȯẋ_¦Σ¦:⌉=¦

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

चूंकि गैया बहुत आसानी से इनपुट के माध्यम से सूचियों को स्वीकार नहीं करता है, यह एक ऐसा फ़ंक्शन है जो स्टैक के शीर्ष से ऊपर से एक सूची को स्वीकार करता है और परिणाम को शीर्ष पर छोड़ देता है (जैसे क्रमबद्ध क्रम के मास्क)।

ȯ           Sort the list
 ẋ          Split it into runs of the same element (in this case, runs of the same row)
  _¦        Flatten each sublist
    Σ¦      Sum each sublist
      :⌉    Find the maximum sum
        =¦  Compare each sum for equality with the maximum
— बिजनेस कैट
स्रोत
0

जे , 16 बाइट्स

[:(=>./)+/^:2/.~

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

एक मौद्रिक क्रिया जो बूलियन को उपस्थिति क्रम में परिणाम देती है।

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

[:(=>./)+/^:2/.~
             /.~  Self-classify; collect identical rows in appearance order
                  For each collected rows (= a matrix),
        +/^:2       Sum all the elements into one value
[:(=>./)          Compute the boolean vector:
    >./             Is the max of the array
   =                equal to this element?
— bubbler
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.