किसी सूची में सबसे आम तत्व खोजें

Question

पायथन सूची में सबसे आम तत्व खोजने के लिए एक कुशल तरीका क्या है?

मेरी सूची आइटम होशेबल नहीं हो सकती है इसलिए शब्दकोश का उपयोग नहीं कर सकते। साथ ही सबसे कम इंडेक्स वाले आइटम को भी लौटाया जाना चाहिए। उदाहरण:

>>> most_common(['duck', 'duck', 'goose'])
'duck'
>>> most_common(['goose', 'duck', 'duck', 'goose'])
'goose'

Comments

यदि सूची में मौजूद वस्तुएं धोने योग्य नहीं हैं, तो आप 'बराबर' होने पर कैसे निर्धारित करेंगे? गैर-धोने योग्य वस्तुओं के लिए समानता का निर्धारण करने में दक्षता हानि शायद किसी भी दक्षता को नकार देगी जो आप एक अच्छे एल्गोरिदम के साथ हासिल करने की उम्मीद करते हैं :)

— एचएस।

मुझे लगता है कि उनका मतलब है कि आइटम एक-दूसरे के योग्य हो सकते हैं और इस तरह एक हैशमैप में चाबियाँ नहीं हो सकती ...

— फोरट्रान

हाँ, यही मेरा मतलब है - कभी-कभी इसमें सूचियाँ शामिल

— होंगी

संबंधित: एक सूची में सबसे आम तत्व ढूँढना, लेकिन एक टाई के मामले में विशेष आवश्यकता के बिना

— अरन-फे

सबसे अच्छा तरीका है stackoverflow.com/a/50227350/7918560

— ब्रेकबेडएसपी

Answer 1

इतने सारे समाधानों के प्रस्ताव के साथ, मैं किसी को भी आश्चर्यचकित नहीं कर रहा हूं कि मैं एक स्पष्ट (गैर-योग्य, लेकिन तुलनीय तत्वों के लिए) क्या विचार करूंगा - [ itertools.groupby] [१]। itertoolsतेज, पुन: प्रयोज्य कार्यक्षमता प्रदान करता है, और आपको कुछ पेचीदा तर्क को अच्छी तरह से परीक्षण किए गए मानक पुस्तकालय घटकों को सौंपने देता है। उदाहरण के लिए विचार करें:

import itertools
import operator

def most_common(L):
  # get an iterable of (item, iterable) pairs
  SL = sorted((x, i) for i, x in enumerate(L))
  # print 'SL:', SL
  groups = itertools.groupby(SL, key=operator.itemgetter(0))
  # auxiliary function to get "quality" for an item
  def _auxfun(g):
    item, iterable = g
    count = 0
    min_index = len(L)
    for _, where in iterable:
      count += 1
      min_index = min(min_index, where)
    # print 'item %r, count %r, minind %r' % (item, count, min_index)
    return count, -min_index
  # pick the highest-count/earliest item
  return max(groups, key=_auxfun)[0]

यह अधिक स्पष्ट रूप से लिखा जा सकता है, निश्चित रूप से, लेकिन मैं अधिकतम स्पष्टता के लिए लक्ष्य बना रहा हूं। printकार्रवाई में मशीनरी को बेहतर ढंग से देखने के लिए दो बयानों को अनियोजित किया जा सकता है; उदाहरण के लिए, प्रिंट के साथ अपूर्ण:

print most_common(['goose', 'duck', 'duck', 'goose'])

का उत्सर्जन करता है:

SL: [('duck', 1), ('duck', 2), ('goose', 0), ('goose', 3)]
item 'duck', count 2, minind 1
item 'goose', count 2, minind 0
goose

जैसा कि आप देखते हैं, SLजोड़ों की एक सूची है, प्रत्येक जोड़ी एक आइटम है जो मूल सूची में आइटम के सूचकांक के बाद है (महत्वपूर्ण स्थिति को लागू करने के लिए, यदि "सबसे आम" समान उच्चतम गिनती वाले आइटम> 1 हैं, तो परिणाम अवश्य होगा जल्द से जल्द होने वाली)।

groupbyकेवल आइटम के माध्यम से समूह (के माध्यम से operator.itemgetter)। maxअभिकलन के दौरान समूहन के अनुसार एक बार कहा जाने वाला सहायक कार्य, एक समूह को प्राप्त करता है और आंतरिक रूप से अनपैक करता है - दो वस्तुओं के साथ एक ट्यूपल (item, iterable)जहां चलने योग्य आइटम भी दो-आइटम ट्यूपल हैं, (item, original index)[[आइटम SL]]।

फिर सहायक फ़ंक्शन समूह के पुनरावृत्ति में प्रविष्टियों की गणना और न्यूनतम मूल सूचकांक दोनों को निर्धारित करने के लिए एक लूप का उपयोग करता है ; यह उन सभी को "गुणवत्ता कुंजी" के रूप में देता है, जो मिनिमम इंडेक्स साइन-बदल गए हैं इसलिए maxऑपरेशन उन वस्तुओं पर "बेहतर" विचार करेगा जो मूल सूची में पहले हुए थे।

यह कोड बहुत आसान हो सकता है अगर यह समय और स्थान में बड़े-ओ मुद्दों के बारे में थोड़ा कम चिंतित हो , जैसे ...:

def most_common(L):
  groups = itertools.groupby(sorted(L))
  def _auxfun((item, iterable)):
    return len(list(iterable)), -L.index(item)
  return max(groups, key=_auxfun)[0]

एक ही मूल विचार, बस और अधिक सरल रूप से व्यक्त ... लेकिन, अफसोस, एक अतिरिक्त O (N) सहायक स्थान (सूचियों के समूहों के पुनरावृत्तियों को मूर्त रूप देने के लिए) और O (N वर्ग) समय ( L.indexप्रत्येक आइटम की अधिकता पाने के लिए ) । जबकि समयपूर्व अनुकूलन प्रोग्रामिंग में सभी बुराई की जड़ है, जब ओ (एन लॉग एन) एक उपलब्ध होने पर जानबूझकर ओ (एन स्क्वार्ड) दृष्टिकोण उठाता है, स्केलेबिलिटी के दाने के मुकाबले बहुत अधिक हो जाता है! -

अंत में, स्पष्टता और प्रदर्शन के लिए "ओनलीनेर्स" पसंद करने वालों के लिए, एक बोनस 1-लाइनर संस्करण जो उपयुक्त रूप से आम के नाम :-) है।

from itertools import groupby as g
def most_common_oneliner(L):
  return max(g(sorted(L)), key=lambda(x, v):(len(list(v)),-L.index(x)))[0]

Comments

यदि आपकी सूची में विभिन्न प्रकार हैं, तो यह Python3 पर टूट जाता है।

— एलेक्सलॉर्ड टोरसन

groupbyपहले (O (NlogN)) को क्रमबद्ध करने की आवश्यकता होती है; के Counter()साथ उपयोग करने से most_common()यह हरा सकता है क्योंकि यह उच्चतम आवृत्ति आइटम (केवल 1 आइटम के लिए, यह O (N) समय) खोजने के लिए एक हीपैक का उपयोग करता है। जैसा कि Counter()अब भारी रूप से अनुकूलित किया गया है (गिनती एक लूप में होती है), यह आसानी से इस समाधान को छोटी सूची के लिए भी हरा सकता है। यह बड़ी सूची के लिए इसे पानी से बाहर निकालता है।

— मार्टिन पीटर्स

संबंधों के लिए केवल 'सबसे कम सूचकांक' की आवश्यकता ही इस समस्या का एक वैध समाधान है। अधिक सामान्य मामले के लिए आपको निश्चित रूप से काउंटर दृष्टिकोण का उपयोग करना चाहिए।

— मार्टिन पीटर्स

@MartijnPieters शायद आपने प्रश्न के उस भाग को याद किया है जहाँ यह कहा गया था कि आइटम उपलब्ध नहीं हो सकते हैं।

— विम

@ सही है, और यदि आइटम उपलब्ध नहीं हैं। जो सेट पर वोट बनाता है और अधिकतम सभी अधिक असंगत दृष्टिकोण।

— मार्टिन पीटर्स

Answer 2

एक सरल एक-लाइनर:

def most_common(lst):
    return max(set(lst), key=lst.count)

Comments

ओपी ने कहा कि [..] सबसे कम इंडेक्स वाले आइटम को वापस करने की स्थिति में। यह कोड, सामान्य रूप से, उस आवश्यकता को पूरा नहीं करता है।

— Stephan202

साथ ही, ओपी ने कहा कि तत्वों को धोने योग्य होना चाहिए: सेट में धोने योग्य वस्तुएं होनी चाहिए।

— एरिक ओ लेबिगॉट

इसके अलावा, यह दृष्टिकोण एल्गोरिदमिक रूप से धीमा है (प्रत्येक तत्वों के लिए set(lst), पूरी सूची को फिर से

— जांचना

आप के set(lst)साथ बदल सकते हैं lstऔर यह गैर-धोने योग्य तत्वों के साथ भी काम करेगा; यद्यपि धीमा।

— newacct

यह आकर्षक लग सकता है लेकिन एक एल्गोरिथम दृष्टिकोण से यह भयानक सलाह है। list.count()सूची को पूरी तरह से पार करना है , और आप सूची में प्रत्येक एकल आइटम के लिए ऐसा करते हैं। यह इसे O (NK) समाधान (O (N ^ 2) सबसे खराब स्थिति में) बनाता है। Counter()केवल O (N) समय का उपयोग करना !

— मार्टिन पीटर्स

Answer 3

यहाँ से उधार , यह पायथन 2.7 के साथ इस्तेमाल किया जा सकता है:

from collections import Counter

def Most_Common(lst):
    data = Counter(lst)
    return data.most_common(1)[0][0]

एलेक्स के समाधानों की तुलना में लगभग 4-6 गुना तेजी से काम करता है, और न्यूएक्ट द्वारा प्रस्तावित वन-लाइनर की तुलना में 50 गुना तेज है।

उन तत्वों को प्राप्त करने के लिए जो संबंधों के मामले में सूची में पहले स्थान पर हैं:

def most_common(lst):
    data = Counter(lst)
    return max(lst, key=data.get)

Comments

यह कुछ के लिए उपयोगी हो सकता है लेकिन ... दुर्भाग्य से काउंटर एक तानाशाही उपवर्ग है, और ओपी ने कहा कि वह शब्दकोशों का उपयोग नहीं कर सकता है (क्योंकि आइटम धोए नहीं जा सकते हैं)।

— Danimal

इसे प्रेम करें। ऊपर @newacct द्वारा वन-लाइनर सरल हो सकता है, लेकिन यह O (n ^ 2) में चलता है; वह है, जहां n सूची की लंबाई है। यह समाधान O (n) है।

— बोल्ट्जमनब्रेन

सादगी और गति की तरह ... शायद ओपी के लिए आदर्श नहीं है। लेकिन मुझे बहुत अच्छा लगता है!

— Thom

सबसे कम अनुक्रमित आइटम वापस नहीं करता है। most_common एक अनियंत्रित सूची देता है, और हथियाने (1) बस जो कुछ भी चाहता है उसे वापस करता है।

— AgentBawls

@AgentBawls: most_commonबिना क्रमबद्ध किए, गिनती के आधार पर हल किया जाता है। उसने कहा, यह संबंधों के मामले में पहला तत्व नहीं उठाएगा; मैंने काउंटर का उपयोग करने के लिए एक और तरीका जोड़ा है जो पहला तत्व चुनता है।

— user2357112

Answer 4

आप जो चाहते हैं उसे मोड के रूप में आँकड़ों में जाना जाता है, और निश्चित रूप से पायथन में आपके लिए बिल्ट-इन फ़ंक्शन है।

>>> from statistics import mode
>>> mode([1, 2, 2, 3, 3, 3, 3, 3, 4, 5, 6, 6, 6])
3

ध्यान दें कि अगर कोई "सबसे सामान्य तत्व" नहीं है जैसे कि ऐसे मामले जहां शीर्ष दो बंधे हैं , तो यह बढ़ेगा StatisticsError, क्योंकि सांख्यिकीय रूप से, इस मामले में कोई मोड नहीं है ।

Comments

यह ओपी की आवश्यकता को पूरा नहीं करता है जब एक से अधिक सामान्य मूल्य होने पर क्या वापस लौटना है - एक आँकड़े। सांख्यिकीशास्त्र उठाया जाता है

— कीथ हॉल

ओह, इसे पढ़ते समय आवश्यकता याद आती है। मेरा मानना ​​है कि यह उत्तर हालांकि मूल्य रखता है, क्योंकि किसी ने भी इस प्रश्न में सुझाव नहीं दिया है, और यह कम से कम प्रतिबंधात्मक आवश्यकताओं वाले लोगों के लिए समस्या का एक अच्छा समाधान है। यह "सूची अजगर में सबसे आम आइटम" के लिए शीर्ष परिणामों में से एक है

— लुइज़ बर्टी

उस स्थिति में पांडा डेटाफ़्रेम में मोड फ़ंक्शन का उपयोग करें।

— Elmex80s

अप वोट, यह एक उच्च होना चाहिए। और यह सरल प्रयास के अलावा ओपी की आवश्यकता को पूरा करने के लिए मुश्किल नहीं है (सिवाय मेरी stackoverflow.com/a/52952300/6646912 )

— krassowski

@BreakBadSP आपका उत्तर अतिरिक्त के कारण अधिक मेमोरी का उपयोग करता है set, और यह संभव है O(n^3)।

— लुइज़ बर्टी

Answer 5

यदि वे धोने योग्य नहीं हैं, तो आप उन्हें सॉर्ट कर सकते हैं और परिणाम गिनने पर एक ही लूप कर सकते हैं (समान आइटम एक दूसरे के बगल में होंगे)। लेकिन यह उन्हें धोने योग्य बनाने और एक तानाशाह का उपयोग करने के लिए तेज़ हो सकता है।

def most_common(lst):
    cur_length = 0
    max_length = 0
    cur_i = 0
    max_i = 0
    cur_item = None
    max_item = None
    for i, item in sorted(enumerate(lst), key=lambda x: x[1]):
        if cur_item is None or cur_item != item:
            if cur_length > max_length or (cur_length == max_length and cur_i < max_i):
                max_length = cur_length
                max_i = cur_i
                max_item = cur_item
            cur_length = 1
            cur_i = i
            cur_item = item
        else:
            cur_length += 1
    if cur_length > max_length or (cur_length == max_length and cur_i < max_i):
        return cur_item
    return max_item

Comments

यहाँ एक सरल तरीका है ideone.com/Nq81vf , एलेक्स के Counter()समाधान के साथ तुलना

— Miguel

Answer 6

यह एक ओ (एन) समाधान है।

mydict   = {}
cnt, itm = 0, ''
for item in reversed(lst):
     mydict[item] = mydict.get(item, 0) + 1
     if mydict[item] >= cnt :
         cnt, itm = mydict[item], item

print itm

(प्रत्यावर्तित का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि यह सबसे कम इंडेक्स आइटम लौटाता है)

Answer 7

सबसे कम सूचकांक के बारे में आवश्यकता के बिना, आप इसके लिए उपयोग कर सकते हैं collections.Counter:

from collections import Counter

a = [1936, 2401, 2916, 4761, 9216, 9216, 9604, 9801] 

c = Counter(a)

print(c.most_common(1)) # the one most common element... 2 would mean the 2 most common
[(9216, 2)] # a set containing the element, and it's count in 'a'

Comments

आसान और तेज। आप मेरे गॉडफादर chain

— चेनस्टेयर

इस उत्तर को और अधिक बढ़ाने की आवश्यकता है क्योंकि यह एक मानक मॉड्यूल और कोड की 2 लाइनों का उपयोग करते हुए एक सूची में तत्व घटनाओं की गणना के सामान्य कार्य को संबोधित करता है

— pcko1

Answer 8

सूची की एक प्रति को क्रमबद्ध करें और सबसे लंबी दौड़ लगाएं। आप प्रत्येक तत्व के सूचकांक के साथ छँटाई करने से पहले सूची को सजा सकते हैं, और फिर एक टाई के मामले में सबसे कम सूचकांक के साथ शुरू होने वाले रन को चुनें।

Comments

आइटम तुलनीय नहीं हो सकते हैं।

— पावेल फुरमानीक

Answer 9

एक-लाइनर:

def most_common (lst):
    return max(((item, lst.count(item)) for item in set(lst)), key=lambda a: a[1])[0]

Answer 10

# use Decorate, Sort, Undecorate to solve the problem

def most_common(iterable):
    # Make a list with tuples: (item, index)
    # The index will be used later to break ties for most common item.
    lst = [(x, i) for i, x in enumerate(iterable)]
    lst.sort()

    # lst_final will also be a list of tuples: (count, index, item)
    # Sorting on this list will find us the most common item, and the index
    # will break ties so the one listed first wins.  Count is negative so
    # largest count will have lowest value and sort first.
    lst_final = []

    # Get an iterator for our new list...
    itr = iter(lst)

    # ...and pop the first tuple off.  Setup current state vars for loop.
    count = 1
    tup = next(itr)
    x_cur, i_cur = tup

    # Loop over sorted list of tuples, counting occurrences of item.
    for tup in itr:
        # Same item again?
        if x_cur == tup[0]:
            # Yes, same item; increment count
            count += 1
        else:
            # No, new item, so write previous current item to lst_final...
            t = (-count, i_cur, x_cur)
            lst_final.append(t)
            # ...and reset current state vars for loop.
            x_cur, i_cur = tup
            count = 1

    # Write final item after loop ends
    t = (-count, i_cur, x_cur)
    lst_final.append(t)

    lst_final.sort()
    answer = lst_final[0][2]

    return answer

print most_common(['x', 'e', 'a', 'e', 'a', 'e', 'e']) # prints 'e'
print most_common(['goose', 'duck', 'duck', 'goose']) # prints 'goose'

Answer 11

सरल एक लाइन समाधान

moc= max([(lst.count(chr),chr) for chr in set(lst)])

यह अपनी आवृत्ति के साथ सबसे लगातार तत्व लौटाएगा।

Answer 12

आपको शायद अब इसकी आवश्यकता नहीं है, लेकिन यह वही है जो मैंने एक समान समस्या के लिए किया था। (टिप्पणियों की वजह से यह अधिक लंबा दिखता है।)

itemList = ['hi', 'hi', 'hello', 'bye']

counter = {}
maxItemCount = 0
for item in itemList:
    try:
        # Referencing this will cause a KeyError exception
        # if it doesn't already exist
        counter[item]
        # ... meaning if we get this far it didn't happen so
        # we'll increment
        counter[item] += 1
    except KeyError:
        # If we got a KeyError we need to create the
        # dictionary key
        counter[item] = 1

    # Keep overwriting maxItemCount with the latest number,
    # if it's higher than the existing itemCount
    if counter[item] > maxItemCount:
        maxItemCount = counter[item]
        mostPopularItem = item

print mostPopularItem

Comments

आप काउंटर का उपयोग कर सकते हैं [आइटम] = counter.get (आइटम, 0) + 1 को बदलने के लिए / भाग को छोड़कर

— XueYu

Answer 13

पर बिल्डिंग लुइज़ का जवाब है, लेकिन "संतोषजनक सबसे कम सूचकांक के साथ आइटम ड्रॉ के मामले में वापस आ जाना चाहिए " हालत:

from statistics import mode, StatisticsError

def most_common(l):
    try:
        return mode(l)
    except StatisticsError as e:
        # will only return the first element if no unique mode found
        if 'no unique mode' in e.args[0]:
            return l[0]
        # this is for "StatisticsError: no mode for empty data"
        # after calling mode([])
        raise

उदाहरण:

>>> most_common(['a', 'b', 'b'])
'b'
>>> most_common([1, 2])
1
>>> most_common([])
StatisticsError: no mode for empty data

Answer 14

यहाँ:

def most_common(l):
    max = 0
    maxitem = None
    for x in set(l):
        count =  l.count(x)
        if count > max:
            max = count
            maxitem = x
    return maxitem

मुझे लगता है कि मानक पुस्तकालय में कहीं न कहीं एक विधि है जो आपको प्रत्येक तत्व की गिनती देगा, लेकिन मुझे यह नहीं मिल रहा है।

Comments

'अधिकतम' एक विधि है। क्या आप चर का नाम बदल देंगे?

— प्रतीक देवघर 7

ध्यान दें कि इस मामले में समाधान के लिए सेट () को भी धोने योग्य वस्तुओं की आवश्यकता होती है।

— लुकास लालकिंसी

रुको, मैं याद नहीं किया जा रहा है कि हिस्सा नहीं है। लेकिन अगर वस्तुओं में समानता है, तो उन्हें धोने योग्य बनाना आसान होना चाहिए।

— लेन्नर्ट रेग्रोब

Answer 15

यह स्पष्ट धीमा समाधान (O (n ^ 2)) है यदि न तो छंटाई और न ही हैशिंग संभव है, लेकिन समानता तुलना ( ==) उपलब्ध है:

def most_common(items):
  if not items:
    raise ValueError
  fitems = [] 
  best_idx = 0
  for item in items:   
    item_missing = True
    i = 0
    for fitem in fitems:  
      if fitem[0] == item:
        fitem[1] += 1
        d = fitem[1] - fitems[best_idx][1]
        if d > 0 or (d == 0 and fitems[best_idx][2] > fitem[2]):
          best_idx = i
        item_missing = False
        break
      i += 1
    if item_missing:
      fitems.append([item, 1, i])
  return items[best_idx]

लेकिन आपकी वस्तुओं को हैज़ेबल या छांटने योग्य (जैसा कि अन्य उत्तरों द्वारा सुझाया गया है) लगभग हमेशा सबसे सामान्य तत्व को खोजने में तेजी लाएगा यदि आपकी सूची (n) की लंबाई बड़ी है। ओ (एन) हैशिंग के साथ औसतन, और ओ (एन * लॉग (एन)) छँटाई के लिए सबसे खराब है।

Comments

डाउनवॉटर को: इस उत्तर में क्या गलत है? क्या कोई अन्य उत्तर तब हल करता है जब न तो छँटाई होती है और न ही हैशिंग संभव है?

— अंक

Answer 16

>>> li  = ['goose', 'duck', 'duck']

>>> def foo(li):
         st = set(li)
         mx = -1
         for each in st:
             temp = li.count(each):
             if mx < temp:
                 mx = temp 
                 h = each 
         return h

>>> foo(li)
'duck'

Comments

यह बड़ा होने पर भयानक प्रदर्शन विशेषता है और विशिष्ट तत्वों की संख्या बड़ी है: O (n) एक सेट में रूपांतरण के लिए और O (m * n) = O (n ^ 2) गिनती के लिए (जहाँ m uniques की संख्या है)। सॉर्ट और चलना ओ (एन लॉग एन) सॉर्ट के लिए और 0 (एन) वॉक के लिए है।

— jmucchiello

हां आप सही हैं। अब मुझे पता है कि यह एक भयानक समाधान है और क्यों। टिप्पणी के लिए धन्यवाद!! :-)

— प्रतिका देवघरे

Answer 17

मुझे हाल के एक कार्यक्रम में ऐसा करने की आवश्यकता थी। मैं इसे स्वीकार करता हूं, मैं एलेक्स के जवाब को समझ नहीं सका, इसलिए मैंने यही किया।

def mostPopular(l):
    mpEl=None
    mpIndex=0
    mpCount=0
    curEl=None
    curCount=0
    for i, el in sorted(enumerate(l), key=lambda x: (x[1], x[0]), reverse=True):
        curCount=curCount+1 if el==curEl else 1
        curEl=el
        if curCount>mpCount \
        or (curCount==mpCount and i<mpIndex):
            mpEl=curEl
            mpIndex=i
            mpCount=curCount
    return mpEl, mpCount, mpIndex

मैंने इसे एलेक्स के समाधान के खिलाफ समय दिया और यह छोटी सूचियों के लिए लगभग 10-15% तेज है, लेकिन एक बार जब आप 100 से अधिक तत्व या अधिक (200000 तक परीक्षण किए गए) जाते हैं, तो यह लगभग 20% धीमा होता है।

Answer 18

नमस्ते यह बड़े ओ (एन) के साथ एक बहुत ही सरल उपाय है

L = [1, 4, 7, 5, 5, 4, 5]

def mode_f(L):
# your code here
    counter = 0
    number = L[0]
    for i in L:
        amount_times = L.count(i)
        if amount_times > counter:
            counter = amount_times
            number = i

    return number

सूची में उस तत्व की संख्या, जो अधिकांश समय दोहराता है

Answer 19

def mostCommonElement(list):
  count = {} // dict holder
  max = 0 // keep track of the count by key
  result = None // holder when count is greater than max
  for i in list:
    if i not in count:
      count[i] = 1
    else:
      count[i] += 1
    if count[i] > max:
      max = count[i]
      result = i
  return result

mostCommonElement (["a", "b", "a", "c"]) -> "a"

Comments

अन्य सभी उत्तर। क्या आप मुझे उन्हें लिंक करना चाहेंगे?

— ग्रिड में 12 rhombi कोई कोने नहीं

Answer 20

 def most_common(lst):
    if max([lst.count(i)for i in lst]) == 1:
        return False
    else:
        return max(set(lst), key=lst.count)

Comments

कृपया अपने कोड के बारे में कुछ जानकारी प्रदान करें, बस पोस्टिंग कोड एक पूर्ण उत्तर नहीं है

— jhhoff02

क्या कोई कारण है कि किसी को 15 अन्य उत्तरों पर इसका उपयोग करना चाहिए?

— सभी कार्यकर्ता

Answer 21

def popular(L):
C={}
for a in L:
    C[a]=L.count(a)
for b in C.keys():
    if C[b]==max(C.values()):
        return b
L=[2,3,5,3,6,3,6,3,6,3,7,467,4,7,4]
print popular(L)