एक फ़ंक्शन कैसे लिखें जो n के लिए (c_i, k_i) जैसे टुपल्स की सूची देता है जैसे कि n = c1^k1 * c2^k2 * ... , ci एक प्रमुख संख्या है।
उदाहरण के लिए: 12600 = 2^3 * 3^2 * 5^2 * 7^1
वांछित आउटपुट: [(2, 3), (3, 2), (5, 2), (7, 1)]
मुझे पता है कि इसे while के साथ कैसे करना है, लेकिन क्या सूची समझ का उपयोग करके इसे करना संभव है? इस कार्य में दक्षता की आवश्यकता नहीं है।

# naive function 
def is_prime(n):
    return n > 1 and all(n % i != 0 for i in range(2, n))

# while version
def factorization_while(n):
    res = []
    for i in range(1, n + 1):
        if is_prime(i):
            j = 0
            while n % i == 0:
                n = n // i
                j += 1
            if j != 0:
                res.append((i, j))
    return res

# list comprehension version
def factorization(n):
    return [
        (i, j) for i in range(1, n + 1) if is_prime(i) \
        and n % i == 0 ... # add smth
    ]
1
Moris Huxley 29 अक्टूबर 2018, 16:14

1 उत्तर

सबसे बढ़िया उत्तर

मुझे नहीं लगता कि यह बहुत कठिन होना चाहिए। आपको इसके प्रमुख कारकों को खोजने के लिए वास्तव में n को संशोधित करने की आवश्यकता नहीं है, वे सभी एक दूसरे से पूरी तरह से स्वतंत्र हैं। तो बस उपयुक्त अपराधों के माध्यम से पुनरावृति करें, और काम करने वाली अधिकतम शक्ति का पता लगाएं!

from math import log

def prime_factors(n):
    return [(prime, max(power for power in range(1, int(log(n, prime))+1)
                              if n % prime**power == 0))
            for prime in range(2, n+1) if n % prime == 0 and isprime(prime)]

कुछ तरीके हैं जिनसे आप इसे और बेहतर बना सकते हैं। आप शक्तियों के अनंत जनरेटर पर itertools.takewhile का उपयोग कर सकते हैं (उदाहरण के लिए itertools.count), क्योंकि एक बार आपको पहली शक्ति मिल जाती है जैसे कि prime**power n का कारक नहीं है, इनमें से कोई भी नहीं बाद वाले या तो होंगे। इससे आप log कॉल से बच सकेंगे।

और प्राइम्स पर कुशलता से पुनरावृति करने के तरीकों का एक पूरा समूह है (उदाहरण के लिए देखें, बहुत ही सरल जनरेटर ने सुझाव दिया है यहां, या उच्चतर प्रदर्शन संस्करण जो आपको कुछ विभिन्न प्रश्न यहाँ SO पर)।

3
Blckknght 29 अक्टूबर 2018, 20:04