একটি তালিকায় সর্বাধিক সাধারণ উপাদানটি সন্ধান করুন


174

পাইথন তালিকার সর্বাধিক সাধারণ উপাদানটি খুঁজে পাওয়ার কার্যকর উপায় কী?

আমার তালিকার আইটেমগুলি হ্যাশ করতে পারে না তাই অভিধান ব্যবহার করতে পারে না। এছাড়াও সর্বনিম্ন সূচকের সাথে আইটেমটি আঁকার ক্ষেত্রে ফেরত দেওয়া উচিত। উদাহরণ:

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

2
তালিকার আইটেমগুলি যদি হ্যাশযোগ্য না হয়, তবে তারা 'সমান' হলে আপনি কীভাবে তা নির্ধারণ করবেন? নন-হ্যাশযোগ্য আইটেমগুলির জন্য সাম্যতা নির্ধারণের দক্ষতা হ্রাস সম্ভবত কোনও ভাল অ্যালগরিদম দিয়ে আপনি যে দক্ষতা অর্জন করবেন বলে আশা করছেন তা হ্রাস করবে :)
এইচএস।

3
আমি মনে করি তিনি এর মানে হল যে আইটেম চপল এবং এইভাবে যোগ্য নয় hashmap মধ্যে কী হতে পারেন ...
ফোরট্রান

1
হ্যাঁ এটাই আমি বোঝাতে চেয়েছিলাম - কখনও কখনও এটিতে তালিকাগুলি থাকবে
hoju


শ্রেষ্ঠ উপায় stackoverflow.com/a/50227350/7918560
BreakBadSP

উত্তর:


96

প্রস্তাবিত অনেকগুলি সমাধান সহ, আমি অবাক হয়েছি কারও প্রস্তাবিত প্রস্তাব আমি কী প্রকাশ্য হিসাবে বিবেচনা করব (নন-হ্যাশযোগ্য কিন্তু তুলনীয় উপাদানগুলির জন্য) - [ itertools.groupby] [1]। 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) সহায়ক স্থান (গ্রুপগুলির তালিকায় পুনরাবৃত্ত হওয়ার জন্য) এবং হে (এন স্কোয়ার) সময় ( L.indexপ্রতিটি আইটেমের জন্য) । যদিও অকালীন অপ্টিমাইজেশান প্রোগ্রামিংয়ের সমস্ত অশুভের মূল, যখন ও (এন লগ এন) পাওয়া যায় তখন ইচ্ছাকৃতভাবে একটি ও (এন স্কোয়ার্ড) পদ্ধতির বাছাই করা হয় যখন স্কেলাবিলিটির শস্যের বিপরীতে খুব বেশি যায়! -)

পরিশেষে, যারা স্বচ্ছতা এবং পারফরম্যান্সের জন্য "oneliners" পছন্দ করেন তাদের পক্ষে উপযুক্তভাবে ম্যাংলেড নামের একটি বোনাস 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]

3
যদি আপনার তালিকায় বিভিন্ন ধরণের থাকে তবে পাইথন 3 এ এটি বিরতি।
অ্যালেক্সLordThorsen

2
groupbyপ্রথমে বাছাই করা দরকার (O (NlogN)); এর Counter()সাথে একটি ব্যবহার most_common()এটি হারাতে পারে কারণ এটি সর্বোচ্চ ফ্রিকোয়েন্সি আইটেমটি সন্ধান করতে একটি হ্যাপক ব্যবহার করে (কেবলমাত্র 1 আইটেমের জন্য, এটি ও (এন) সময়)। হিসাবে Counter()এখন প্রচন্ডভাবে (কাউন্টিং একটি সি লুপ মধ্যে সঞ্চালিত হয়) অপ্টিমাইজ করা হয়, এটি সহজে এমনকি ছোট তালিকার জন্য এই সমাধান বীট করতে পারেন। এটি এটিকে বড় তালিকার জন্য পানির বাইরে ফেলে দেয়।
মার্টিজন পিটারস

সম্পর্কের জন্য কেবলমাত্র 'সর্বনিম্ন সূচক' প্রয়োজনীয়তা কেবলমাত্র এই সমস্যার জন্য এটি একটি বৈধ সমাধান করে। আরও সাধারণ ক্ষেত্রে আপনার অবশ্যই কাউন্টারের পদ্ধতির ব্যবহার করা উচিত।
মার্টিজন পিটারস

@ মার্তিজজনপিটারস সম্ভবত আপনি প্রশ্নের অংশটি মিস করেছেন যেখানে এটি বলেছে যে আইটেমগুলি অছাত্র হতে পারে।
উইম

@ উইম ডান, এবং যদি আইটেমগুলি না ঝরানো যায়। যা সেটে ভোট দেয় এবং সর্বোচ্চটি আরও বেশি অসুবিধে হয়।
মার্টিজন পিটারস

442

একটি সহজ এক-লাইনার:

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

24
ওপিতে বলা হয়েছে যে [..] সর্বনিম্ন সূচকের সাথে আইটেমটি আঁকার ক্ষেত্রে ফেরত দেওয়া উচিত। এই কোডটি সাধারণভাবে সেই প্রয়োজনীয়তা পূরণ করে না।
স্টেফান202

2
এছাড়াও, ওপি জানিয়েছে যে উপাদানগুলি অবশ্যই হ্যাশেবল হতে পারে: সেটে অবশ্যই হ্যাশযোগ্য বস্তু থাকতে হবে।
এরিক হে লেবিগোট

2
এছাড়াও, এই পদ্ধতিটি অ্যালগরিদমিকভাবে ধীরে ধীরে (প্রতিটি উপাদানগুলির জন্য set(lst), পুরো তালিকাটি আবার অবশ্যই পরীক্ষা করা উচিত)… সম্ভবত বেশিরভাগ ব্যবহারের জন্য যথেষ্ট দ্রুত, যদিও…
এরিক হে লেবিগোট

9
আপনি এর set(lst)সাথে প্রতিস্থাপন করতে পারেন lstএবং এটি নন-হ্যাশযোগ্য উপাদানগুলির সাথেও কাজ করবে; ধীর হলেও।
newacct

24
এই হতে পারে চেহারা আকর্ষণীয় কিন্তু দৃশ্য একজন আলগোরিদিমিক বিন্দু থেকে এই ভয়াবহ উপদেশ। list.count()তালিকাটিকে পুরোপুরি অতিক্রম করতে হবে এবং আপনি তালিকার প্রতিটি একক অনন্য আইটেমের জন্য এটি করেন। এটি এটিকে একটি ও (এনকে) সমাধান করে তোলে (সবচেয়ে খারাপ ক্ষেত্রে ও (এন ^ 2))। Counter()একমাত্র ব্যবহার করতে O (N) সময় লাগে!
মার্টিজন পিটারস

185

এখান থেকে ধার নেওয়া , এটি পাইথন ২.on এর সাথে ব্যবহার করা যেতে পারে:

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)

3
এটি কারও পক্ষে কার্যকর হতে পারে তবে ... দুর্ভাগ্যক্রমে কাউন্টার হ'ল একটি ডিক সাবক্লাস, এবং ওপি বলেছে যে তিনি অভিধান ব্যবহার করতে পারেন না (কারণ আইটেমগুলি হ্যাশযোগ্য নয়)।
দানিমাল

13
এটা খুবই পছন্দ করি. উপরের @ নিউভ্যাক্টের ওয়ান-লাইনারটি সহজ হতে পারে তবে এটি ও (এন ^ 2) এ চলে; এটি হল যেখানে n তালিকার দৈর্ঘ্য। এই সমাধানটি হ'ল ও (এন)।
বোল্টজমানব্রাইন

5
সরলতা এবং গতির মতো ... সম্ভবত ওপি জন্য আদর্শ নয়। তবে আমার দারুণ মামলা!
থম

সর্বনিম্ন সূচকযুক্ত আইটেমটি ফেরত দেয় না। Most_common একটি নিরবচ্ছিন্ন তালিকা প্রদান করে এবং দখল (1) কেবল যা খুশি তা ফিরিয়ে দেয়।
এজেন্টবোলস

@ এজেন্টবোলস: most_commonগণনা অনুসারে বাছাই করা হয়, বিনা অর্ডারযুক্ত। এটি বলেছিল, সম্পর্কের ক্ষেত্রে এটি প্রথম উপাদানটি বেছে নেবে না; আমি কাউন্টারটি ব্যবহার করার জন্য অন্য উপায় যুক্ত করেছি যা প্রথম উপাদানটি বেছে নেয়।
ব্যবহারকারী 2357112 0: 21-এ মনিকা

58

আপনি যা চান তা পরিসংখ্যান হিসাবে মোড হিসাবে পরিচিত এবং পাইথন অবশ্যই আপনার জন্য ঠিক এটি করতে একটি অন্তর্নির্মিত ফাংশন রয়েছে:

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

মনে রাখবেন যে যদি শীর্ষস্থানীয় দুটি বাঁধা ক্ষেত্রে যেমন "সবচেয়ে সাধারণ উপাদান" না থাকে তবে এটি উত্থাপন করবে StatisticsErrorকারণ পরিসংখ্যানগতভাবে বলতে গেলে এই ক্ষেত্রে কোনও মোড নেই ।


8
একাধিক সাধারণ মানের - যখন একটি পরিসংখ্যান রয়েছে তখন কী ফিরিয়ে দিতে হবে তা ওপি'র প্রয়োজনীয়তা পূরণ করে না
কিথ হল

5
ওহো, এটি পড়ার সময় প্রয়োজনীয়তাটি মিস করেছি। আমি এখনও বিশ্বাস করি যে এই জবাবটির মূল্য রয়েছে যদিও এই প্রশ্নটিতে কেউ এর পরামর্শ দেয়নি, এবং এটি ন্যূনতম সীমাবদ্ধ প্রয়োজনীয়তা সম্পন্ন লোকদের সমস্যার জন্য একটি ভাল সমাধান। এটি "তালিকার পাইথনের সর্বাধিক সাধারণ আইটেম" এর শীর্ষ ফলাফলগুলির মধ্যে একটি
লুইজ বার্তি

1
সেক্ষেত্রে প্যান্ডাস ডেটাফ্রেমে মোড ফাংশনটি ব্যবহার করুন।
Elmex80s

1
আপ-ভোট, এটির চেয়ে বেশি হওয়া উচিত। এবং এটা যে কঠিন সঙ্গে ওপি এর প্রয়োজন সন্তুষ্ট নয় সহজ করে দেখুন-ছাড়া (আমার দেখতে stackoverflow.com/a/52952300/6646912 )
krassowski

1
@ ব্র্যাকব্যাডএসপি অতিরিক্ত উত্তর দেওয়ার কারণে আপনার উত্তরটি আরও মেমরি ব্যবহার করে setএবং প্রশংসনীয় O(n^3)
লুইজ বার্তি

9

যদি সেগুলি হ্যাশযোগ্য না হয় তবে আপনি এগুলি বাছাই করতে পারেন এবং ফলাফলগুলি গণনা করে একক লুপ করতে পারেন (অভিন্ন আইটেমগুলি একে অপরের পাশে থাকবে)। তবে এগুলি হ্যাশযোগ্য এবং ডিক ব্যবহার করা দ্রুততর হতে পারে।

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

অ্যালেক্সের সমাধানটির সাথে তুলনা করার জন্য এখানে একটি সহজ উপায়ে আইডিয়োন.com / Nq81vfCounter()
মিগুয়েল

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

(বিপরীতটি এটি সর্বনিম্ন সূচক আইটেমটি ফেরত দেয় তা নিশ্চিত করার জন্য ব্যবহৃত হয়)


6

সর্বনিম্ন সূচক সম্পর্কে প্রয়োজনীয়তা ছাড়াই আপনি এটি ব্যবহার করতে পারেন 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'

সহজ এবং দ্রুত। আপনি আমার গডফাদার r
চেইনস্টায়ার

1
এই উত্তরটির আরও বেশি প্রয়োজনীয়তা রয়েছে কারণ এটি একটি স্ট্যান্ডার্ড মডিউল এবং কোডের 2 টি লাইন ব্যবহার করে একটি তালিকায় উপাদান উপস্থিতি গণনার সাধারণ টাস্ককে সম্বোধন করে
pcko1

5

তালিকার একটি অনুলিপি বাছাই করুন এবং দীর্ঘতম রানটি সন্ধান করুন। আপনি প্রতিটি উপাদানের সূচক দিয়ে বাছাই করার আগে তালিকাটি সাজাতে পারেন এবং তারপরে টাইয়ের ক্ষেত্রে সর্বনিম্ন সূচী দিয়ে শুরু হওয়া রানটি চয়ন করতে পারেন।


আইটেম তুলনাযোগ্য নাও হতে পারে।
পাভেল ফুরমানিয়াক

4

একটি ওয়ানলাইনার:

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

3
# 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'

3

সহজ এক লাইন সমাধান

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

এটি তার ঘনত্বের সাথে সর্বাধিক ঘন উপাদান ফিরে আসবে।


2

আপনার আর সম্ভবত এটির দরকার নেই, তবে অনুরূপ সমস্যার জন্য আমি এটি করেছি। (মন্তব্যগুলির কারণে এটি বেশি দীর্ঘ দেখায়))

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

1
আপনি কাউন্টার [আইটেম] = কাউন্টার.জেট (আইটেম, 0) + 1 ব্যবহার করে প্রতিস্থাপন করতে পারবেন / অংশ ব্যতীত
XueYu

1

লুইজের উত্তরের ভিত্তিতে বিল্ডিং করা , তবে " সর্বনিম্ন সূচকের সাথে আইটেম আঁকার ক্ষেত্রে সন্তুষ্ট হওয়া " শর্ত:

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

0

এখানে:

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

আমার একটি অস্পষ্ট অনুভূতি আছে যে কোনও স্থানে স্ট্যান্ডার্ড লাইব্রেরিতে এমন একটি পদ্ধতি রয়েছে যা আপনাকে প্রতিটি উপাদানগুলির গণনা দেবে, তবে আমি এটি খুঁজে পাচ্ছি না।


3
'সর্বোচ্চ' একটি পদ্ধতি। আপনি কি ভেরিয়েবলের নাম পরিবর্তন করবেন?
প্রতীক দেওঘরে

1
নোট করুন যে সেটটি () এর জন্যও হ্যাশযোগ্য আইটেমগুলির প্রয়োজন আছে, সমাধানটিতে এই ক্ষেত্রে কাজ করবে না।
লুকা লালিনস্কে

অপেক্ষা করুন, আমি অংশটি হ্যাশেবল না হয়ে মিস করেছি। তবে বস্তুর যদি সাম্য থাকে তবে এগুলি হ্যাশযোগ্য করে তোলা সহজ হওয়া উচিত।
লেনার্ট রেজেব্রো

0

এটি স্পষ্ট ধীর সমাধান (ও (এন ^ 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]

তবে আপনার আইটেমগুলি হ্যাশযোগ্য বা বাছাইযোগ্য (অন্যান্য উত্তরগুলির দ্বারা প্রস্তাবিত হিসাবে) তৈরি করা আপনার তালিকার (এন) দৈর্ঘ্য বড় হলে প্রায় সর্বদা সর্বাধিক সাধারণ উপাদানটি দ্রুততর করে তুলতে পারে। হ্যাশিং সহ গড়ে ও (এন) এবং বাছাইয়ের জন্য সবচেয়ে খারাপ এ ও (এন * লগ (এন))।


ডাউনওয়োটারের কাছে: এই উত্তরটিতে কী দোষ আছে? বাছাই করা বা হ্যাশিং সম্ভব না হলে অন্য উত্তরগুলির কোনওটি কি সমাধান সরবরাহ করে?
pts

0
>>> 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'

এটির ক্ষেত্রে বিরাট পারফরম্যান্স বৈশিষ্ট্য রয়েছে যখন এন বড় হয় এবং অনন্য উপাদানের সংখ্যাও বড় হয়: ও (এন) একটি সেটে রূপান্তর করার জন্য এবং ও (এম * এন) = ও (এন ^ 2) গণনার জন্য (যেখানে মি জ্ঞানের সংখ্যা)। বাছাই করার জন্য ও (হে লগ এন) সাজানোর জন্য এবং হাঁটার জন্য 0 (এন)।
jmucchiello

1
হাঁ আপনি ঠিক. এখন আমি জানি এটি একটি ভয়ঙ্কর সমাধান এবং কেন। মন্তব্যের জন্য ধন্যবাদ !! :-)
প্রতীক দেওঘরে

0

সাম্প্রতিক একটি প্রোগ্রামে আমার এটি করা দরকার ছিল। আমি এটি স্বীকার করব, আমি অ্যালেক্সের উত্তর বুঝতে পারি না, তাই এটিই শেষ হয়েছিল।

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% ধীর।


-1

হাই এটি বিগ ও (এন) এর সাথে খুব সাধারণ সমাধান

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

তালিকার সেই উপাদানটির সংখ্যা যেখানে বেশিরভাগ সময় পুনরাবৃত্তি হয় number


-2
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"


অন্য সমস্ত উত্তর। আপনি কি আমাকে তাদের লিঙ্ক করতে চান?
গ্রিডে 12 রোম্বি ডাব্লু কোনায় নেই

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

6
দয়া করে আপনার কোড সম্পর্কে কিছু তথ্য সরবরাহ করুন, কেবল পোস্টিং কোড সম্পূর্ণ উত্তর নয়
jhhoff02

1
অন্য 15 টি উত্তরের মধ্যে কারও কারও এটি ব্যবহারের কারণ রয়েছে?
সমস্ত শ্রমিক

-5
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)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.