सूची में अधिकतम तत्व ढूँढना

तो, यह एक प्रश्न है जिसे मुझे असाइनमेंट में दिया गया है:

एक फ़ंक्शन, बहुमत (ए) लिखें, जो उसमें एक मान देता है जो कम से कम लेन (ए)//2 + 1 बार होता है। यदि कोई ऐसा तत्व मौजूद नहीं है, तो यह फ़ंक्शन कोई नहीं देता है।

असाइनमेंट में विचार सबसे तेज़ तरीका संभव है।

मेरा विचार प्रत्येक तत्व की गिनती के साथ एक शब्दकोश को रख रहा था, और फिर यह देखने के लिए शब्दकोश के माध्यम से लूपिंग कर रहा था कि क्या किसी तत्व के पास लेन (ए)//2 +1 की गिनती है।

लेकिन यह बहुत अच्छा काम नहीं लग रहा था। क्या कोई मुझे बेहतर समाधान दे सकता है और इसे मुझे समझा सकता है? किसी कारण से यह मुझे जंगली चला रहा है।

यह मेरा खराब संरचित कोड था:

numTimes = dict()

target = (len(a)//2)+1
for i in range(0, len(a)):
    numTimes[str(a[i])] += 1

for k, v in numTimes.iteritems():
    if v==str(target):
        return v

return None

जिसने मुझे एक नया शब्द तत्व जोड़ने की कोशिश की, मुझे एक महत्वपूर्ण त्रुटि मिल रही थी, हालांकि इस सवाल से कोई लेना देना नहीं था।

0
जोड़ा संपादित
विचारों: 1
कोड जोड़ा गया।
जोड़ा लेखक user2417731, स्रोत
आप पाइथन का किस संस्करण का उपयोग कर रहे हैं? 2.7 और 3.x में collections.Counter क्लास है जो इसे सरल बना सकती है यदि आपका असाइनमेंट इसे प्रतिबंधित नहीं करता है। अगर मैं असाइनमेंट लिख रहा था, तो यह वर्ग होगा क्योंकि वह वर्ग पूरी तरह से तुच्छ बनाता है।
जोड़ा लेखक Peter DeGlopper, स्रोत
आप यह देखने के लिए क्यों परीक्षण कर रहे हैं कि संख्या के रूप में गणना स्ट्रिंग के रूप में लक्ष्य के बराबर है या नहीं?
जोड़ा लेखक Ignacio Vazquez-Abrams, स्रोत
दिलचस्प सवाल! क्या आप अपने शब्दकोश का एक उदाहरण प्रदान कर सकते हैं? डेटा निर्माण के साथ किसी प्रश्न का उत्तर देना मुश्किल है, यह जानने के बिना कि डेटा कैसे संरचित किया जाता है।
जोड़ा लेखक rickcnagy, स्रोत

3 उत्तर

मैंने पाया कि यह सबसे कुशल तरीका था:

numTimes = dict()
target = (len(a)//2)+1

for ele in a:
    if ele not in numTimes:
        numTimes[ele] = 1
    else:
        numTimes[ele] +=1

    if numTimes[ele] == target:
        return ele

जब हम जोड़ रहे हैं, तो हम जांच सकते हैं कि समय की संख्या हमारे लक्षित मध्य बिंदु के बराबर है या नहीं।

0
जोड़ा

सबसे पहले, मान लें कि लेन (सूची)//2 + 1 का अर्थ है कि प्रश्न में तत्व को सूची का बहुमत होना आवश्यक है। केवल एक मूल्य या कोई मूल्य नहीं हो सकता है जो इसे संतुष्ट करता है।

एक शब्दकोश का उपयोग करने की आपकी समझ सही है। आप प्रत्येक तत्व की गणना को प्रत्येक तत्व की गणना के लिए मानचित्र बना सकते हैं। यदि किसी तत्व की गणना लेन (सूची)//2 + 1 से अधिक है तो यह आपका उत्तर है।

सूची में तत्वों को गिनने का सबसे आसान तरीका यहां है (कम से कम लाइब्रेरी का उपयोग किए बिना):

def majority(li):
    ''' test list li if any single element occurs in li more than len(li)//2+1 times '''
    count=dict()
    tgt=len(li)//2+1
    # count each element in li:
    for key in li:
        if key in count:
            count[key]+=1
        else:
            count[key]=1    

    print count 
    for k, v in count.items():
        if v>=tgt:
            return k     

    return None   

दो चीजों पर ध्यान दें। चूंकि आप अंततः li से 0 के प्रत्येक मान को सेट करेंगे, तो आप fromkeys() विधि एक सेट के साथ उन्हें एक साथ सेट करने के लिए:

count={}.fromkeys(set(li),0)

आप यह देखने के लिए भी देख सकते हैं कि क्या आप बहुमत प्राप्त कर चुके हैं क्योंकि आप तत्व जोड़ रहे हैं:

def majority2(li):
    ''' test list li if any single element occurs in li more than len(li)//2+1 times '''
    count={}.fromkeys(set(li),0)
    tgt=len(li)//2+1
    # count each element in li:
    for key in li:
        count[key]+=1 
        if count[key]>=tgt:
            return key
    return None     

परिक्षण:

>>> a=['1']*10+['2']*11
>>> majority(a)
{'1': 10, '2': 11}
'2'
>>> majority2(a)
'2'
>>> a=['1']*10+['2']*10
>>> majority2(a)
None
0
जोड़ा
(डाउनवोट शैली के लिए था, विशिष्ट चर नाम, टिप्पणियों की कमी।)
जोड़ा लेखक stalepretzel, स्रोत
आह कूल। अब डाउनवोट-योग्य नहीं, डाउनवोट हटा दिया गया! :) जबकि हम शैली के विषय पर हैं, मुझे शायद पीईपी 8 प्लग करना चाहिए ( python.org/dev/peps/pep-0008 )।
जोड़ा लेखक stalepretzel, स्रोत
@stalepretzel: आप सही थे। मैंने इसे काफी हद तक बदल दिया। रचनात्मक प्रतिक्रिया के लिए धन्यवाद।
जोड़ा लेखक dawg, स्रोत

मैं संग्रह से काउंटर लाइब्रेरी का उपयोग करूंगा। यह dict का उप-वर्ग है।

from collections import Counter

def majority(iterable):
    c = Counter(iterable)
    value, count = c.most_common(1)[0]
    target = (len(iterable)//2) + 1
    if (count >= target):
        return value
    else:
        return None
0
जोड़ा
मुझे किसी भी पुस्तकालय का उपयोग करने की अनुमति नहीं है।
जोड़ा लेखक user2417731, स्रोत