दिलचस्प पोस्ट
कैसे Sass में एक वैश्विक चर को असाइन करने के लिए? कुकीज़ के बिना PHP सत्र मैं C # में एक यादृच्छिक इंटेल नंबर कैसे उत्पन्न करूं? एक अमीर टेक्स्ट बॉक्स के अंदर पेस्ट ईवेंट होने पर इसका पता लगाया जा रहा है गतिशील रूप से बूटस्ट्रैप के 'पॉपओवर' कंटेनर को एक क्लास जोड़ें क्या jQuery सीखने से पहले जावास्क्रिप्ट सीखना अच्छा है? डब्ल्यूसीएफ: केवल पढ़ने के लिए डेटामेम्बर के गुणों को सेट किए बिना खुलता है? Prolog के तर्कों में तात्कालिकता मोड संकेतक का अर्थ है पासवर्ड_हाश का उपयोग कैसे करें शीर्ष एक्शनबार पर एंड्रॉइड नेविगेशन ड्रॉवर कोणीय 2/4 IE11 में काम नहीं कर रहा है गतिशील एसक्यूएल (पैरामीटर के रूप में तालिका का नाम देना) एंड्रॉइड में वर्तमान महीना फेसबुक दोस्तों के जन्मदिन क्या मुझे अपने एन्क्रिप्शन के साथ एक आरम्भिकरण वेक्टर (IV) का उपयोग करना चाहिए? कैसे mysql में levenshtein समारोह जोड़ने के लिए?

एक नंबर का सबसे बड़ा कारक

संख्या के सबसे बड़े कारक की गणना करने का सबसे अच्छा तरीका क्या है?

मैं सोच रहा हूं कि सबसे प्रभावी होगा निम्नलिखित:

  1. सबसे कम प्राथमिक संख्या खोजें, जो साफ रूप से विभाजित है
  2. जांचें कि विभाजन का परिणाम प्रधान है
  3. यदि नहीं, तो अगले न्यूनतम खोजें
  4. 2 पर जाएं

मैं इस धारणा को आधार बना रहा हूं कि छोटे प्रमुख कारकों की गणना करना आसान है। क्या यह सही है? मुझे किन अन्य तरीकों पर गौर करना चाहिए?

संपादित करें: अब मुझे एहसास हुआ कि मेरा दृष्टिकोण व्यर्थ है अगर नाटक में 2 से अधिक प्रमुख कारक हैं, क्योंकि चरण 2 विफल रहता है, जब परिणाम दो अन्य प्राइम का उत्पाद होता है, इसलिए एक रिकर्सिव एल्गोरिदम की आवश्यकता होती है।

फिर से संपादित करें: और अब मुझे एहसास हुआ है कि यह अभी भी काम करता है, क्योंकि अंतिम मिली मुख्य संख्या को सर्वोच्चतम होना है, इसलिए चरण 2 के गैर-प्रधान परिणाम के आगे परीक्षण के परिणामस्वरूप एक छोटे प्रधानमंत्र होगा

वेब के समाधान से एकत्रित समाधान "एक नंबर का सबसे बड़ा कारक"

दरअसल, बड़ी संख्या के कारकों को खोजने के लिए कई अधिक कुशल तरीके हैं (छोटे लोगों के लिए परीक्षण डिवीजन काफी अच्छा काम करता है)

एक विधि जो बहुत तेजी से है यदि इनपुट संख्या में दो वर्ग गुण हैं जो उसके वर्गमूल के बहुत करीब हैं, जिसे फ़र्मेट फैक्टरसिगेशन कहा जाता है यह पहचान N = (a + b) (a – b) = एक ^ 2 – b ^ 2 का उपयोग करता है और समझने और लागू करने में आसान है दुर्भाग्य से यह सामान्य रूप से बहुत तेजी से नहीं है

100 अंक तक फैक्टरिंग संख्याओं के लिए सबसे अच्छी तरह से ज्ञात विधि है द्विघात छलनी । एक बोनस के रूप में, एल्गोरिदम का हिस्सा आसानी से समानांतर प्रसंस्करण के साथ किया जाता है।

मैंने सुना है कि एक और एल्गोरिथ्म पोलार्ड की रो एल्गोरिदम है । यह सामान्य रूप से द्विघात छलनी के रूप में कुशल नहीं है, लेकिन कार्यान्वयन करना आसान लगता है


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

प्राइवेरी कतार बनाएं, जो शुरू में नंबर खुद को स्टोर करता है। प्रत्येक पुनरावृत्ति, आप कतार से उच्चतम संख्या निकाल देते हैं, और इसे दो कारकों में विभाजित करने का प्रयास करते हैं (1 को उन कारकों में से एक होने की अनुमति नहीं देते, बिल्कुल)। यदि यह चरण विफल रहता है, तो संख्या प्रधान है और आपका उत्तर है! अन्यथा आप कतार में दो कारक जोड़ते हैं और दोहराते हैं।

मैं जानता हूँ कि सबसे अच्छा एल्गोरिथ्म है (पायथन में)

 def prime_factors(n): """Returns all the prime factors of a positive integer""" factors = [] d = 2 while n > 1: while n % d == 0: factors.append(d) n /= d d = d + 1 return factors pfs = prime_factors(1000) largest_prime_factor = max(pfs) # The largest element in the prime factor list 

उपरोक्त विधि सबसे खराब स्थिति में O(n) में चलता है (जब इनपुट एक प्रमुख संख्या है)।

संपादित करें:
टिप्पणी में सुझाव दिया गया है, नीचे O(sqrt(n)) संस्करण है। यहाँ कोड है, एक बार फिर

 def prime_factors(n): """Returns all the prime factors of a positive integer""" factors = [] d = 2 while n > 1: while n % d == 0: factors.append(d) n /= d d = d + 1 if d*d > n: if n > 1: factors.append(n) break return factors pfs = prime_factors(1000) largest_prime_factor = max(pfs) # The largest element in the prime factor list 

मेरा जवाब ट्रिप्टिक के आधार पर है, लेकिन इस पर बहुत कुछ सुधार है I यह इस तथ्य पर आधारित है कि 2 और 3 से परे, सभी प्रमुख संख्या 6n-1 या 6n + 1 प्रपत्र के हैं

 var largestPrimeFactor; if(n mod 2 == 0) { largestPrimeFactor = 2; n = n / 2 while(n mod 2 == 0); } if(n mod 3 == 0) { largestPrimeFactor = 3; n = n / 3 while(n mod 3 == 0); } multOfSix = 6; while(multOfSix - 1 <= n) { if(n mod (multOfSix - 1) == 0) { largestPrimeFactor = multOfSix - 1; n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0); } if(n mod (multOfSix + 1) == 0) { largestPrimeFactor = multOfSix + 1; n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0); } multOfSix += 6; } 

मैंने हाल ही में एक ब्लॉग लेख समझाया है कि यह एल्गोरिथ्म कैसे काम करता है

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

सभी संख्याएं प्राइम्स के उत्पाद के रूप में व्यक्त की जा सकती हैं, जैसे:

 102 = 2 x 3 x 17 712 = 2 x 2 x 2 x 89 

आप इन्हें केवल 2 से शुरू करके पा सकते हैं और जब तक आपके नंबर का नतीजा नहीं होता है, तब तक केवल विभाजित करना जारी रखेगा:

 712 / 2 = 356 .. 356 / 2 = 178 .. 178 / 2 = 89 .. 89 / 89 = 1 

इस पद्धति का उपयोग करके आपको वास्तव में किसी भी प्राइम की गणना करने की ज़रूरत नहीं है: वे सभी प्राइम होंगे, इस तथ्य के आधार पर कि आप पहले से ही सभी पूर्ववर्ती संख्याओं के साथ जितना संभव हो उतना संख्या को बढ़ाया है।

 number = 712; currNum = number; // the value we'll actually be working with for (currFactor in 2 .. number) { while (currNum % currFactor == 0) { // keep on dividing by this number until we can divide no more! currNum = currNum / currFactor // reduce the currNum } if (currNum == 1) return currFactor; // once it hits 1, we're done. } 
  //this method skips unnecessary trial divisions and makes //trial division more feasible for finding large primes public static void main(String[] args) { long n= 1000000000039L; //this is a large prime number long i = 2L; int test = 0; while (n > 1) { while (n % i == 0) { n /= i; } i++; if(i*i > n && n > 1) { System.out.println(n); //prints n if it's prime test = 1; break; } } if (test == 0) System.out.println(i-1); //prints n if it's the largest prime factor } 

सबसे आसान समाधान पारस्परिक रूप से पुनरावर्ती कार्यों की एक जोड़ी है।

पहला फंक्शन सभी प्रमुख संख्याओं को उत्पन्न करता है:

  1. एक सूची के साथ शुरू करें जिसमें 2 और सभी विषम संख्याएं 2 से अधिक होती हैं
  2. उन सभी नंबरों को निकालें जो प्रधानमंत्री नहीं हैं। अर्थात्, संख्याएं जिनके पास कोई मुख्य कारक नहीं है (स्वयं के अलावा) निचे देखो।

दूसरी फ़ंक्शन एक क्रम संख्या के मुख्य कारणों को बढ़ाता है। रणनीति प्रत्येक प्रधानमंत्री द्वारा विभाजित करने की कोशिश करना है जो संभवत: उसके विभाजक हो सकता है:

  1. बढ़ते क्रम में सभी प्राइम की एक सूची लें (ऊपर देखें)।
  2. चलो उस सूची में प्रधान हो, और ps n/p के प्रमुख कारक हो (चरण 1 देखें)।
    • यदि p वर्ग हमारी संख्या n से बड़ा है, तो n प्रधान है हमारा हो गया।
    • यदि p n विभाजित करता है, तो p n का एक प्रमुख कारक है। अन्य कारक हैं ps
    • अन्यथा p n का एक प्रमुख कारक नहीं है

n का सबसे बड़ा प्रमुख कारक दूसरे फ़ंक्शन द्वारा दी गई अंतिम संख्या है।

स्पष्टीकरण के लिए, यहां हास्केल में उपरोक्त कोड है:

 import Control.Monad -- All the primes primes = 2 : filter (ap (<=) (head . primeFactors)) [3,5..] -- Gives the prime factors of its argument primeFactors = factor primes where factor [] n = [] factor xs@(p:ps) n = if p*p > n then [n] else let (d,r) = divMod np in if r == 0 then p : factor xs d else factor ps n -- Gives the largest prime factor of its argument largestFactor = last . primeFactors 

स्वीकृत उत्तर पहले से ही बताते हैं कि दी गई संख्या के मुख्य कारकों को पाने के लिए अधिक कुशल तरीके (जैसे द्विघात चलनी) मौजूद हैं, लेकिन फिर भी मिलकर-राबिन की मदद से ट्रायल डिवीजन पर्याप्त और छोटी संख्या के लिए भी जल्दी है। इसलिए मैं मिलर-राबिन का उपयोग करके परीक्षण डिवीजन को सुधारने के तरीके को दिखाने के लिए तैयार नहीं हूं:

नोट: मिलर-राबिन एल्गोरिथ्म का कोड रोसेटटा कोड से एक अनुकूलित, थोड़ा सुधारित संस्करण है। कोड को Python 2.7.8 और Python 3.4.1 का उपयोग कर परीक्षण किया गया था

 def int_sqrt(n): x = n y = (x + 1) >> 1 while y < x: x = y y = (x + n // x) >> 1 return x def is_composite(a, d, n, s): if pow(a, d, n) == 1: return False for i in range(s): if pow(a, 2**i * d, n) == n-1: return False return True # n is definitely composite def is_prime(n): if n < 5: if n == 2 or n == 3: return True return False p = n % 6 if p != 1 and p != 5: return False d, s = n - 1, 0 while not d % 2: d, s = d >> 1, s + 1 if n < 2047: return not is_composite(2, d, n, s) if n < 1373653: return not any(is_composite(a, d, n, s) for a in (2, 3)) if n < 9080191: return not any(is_composite(a, d, n, s) for a in (31, 73)) if n < 25326001: return not any(is_composite(a, d, n, s) for a in (2, 3, 5)) if n < 118670087467: if n == 3215031751: return False return not any(is_composite(a, d, n, s) for a in (2, 3, 5, 7)) if n < 2152302898747: return not any(is_composite(a, d, n, s) for a in (2, 3, 5, 7, 11)) if n < 3474749660383: return not any(is_composite(a, d, n, s) for a in (2, 3, 5, 7, 11, 13)) if n < 341550071728321: return not any(is_composite(a, d, n, s) for a in (2, 3, 5, 7, 11, 13, 17)) if n < 3825123056546413051: return not any(is_composite(a, d, n, s) for a in (2, 3, 5, 7, 11, 13, 17, 19, 23)) return not any(is_composite(a, d, n, s) for a in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53)) def factorize(n): factors = [] if n < 2: return factors if is_prime(n): factors.append(n) return factors while n % 2 == 0: n >>= 1 factors.append(2) if n == 1: return factors max = int_sqrt(n) + 1 i = 3 while i < max: while n % i == 0: n = n // i factors.append(i) if n == 1: return factors if is_prime(n): factors.append(n) return factors i += 2 return [] print(factorize(98768765456789876)) 

आउटपुट है:

 [2, 2, 7, 23, 153367648224829] 

मुझे पता है कि यह एक तेज़ समाधान नहीं है धीमे समाधान समझने के लिए उम्मीद के मुताबिक आसान।

  public static long largestPrimeFactor(long n) { // largest composite factor must be smaller than sqrt long sqrt = (long)Math.ceil(Math.sqrt((double)n)); long largest = -1; for(long i = 2; i <= sqrt; i++) { if(n % i == 0) { long test = largestPrimeFactor(n/i); if(test > largest) { largest = test; } } } if(largest != -1) { return largest; } // number is prime return n; } 

जावास्क्रिप्ट कोड:

 'option strict'; function largestPrimeFactor(val, divisor = 2) { let square = (val) => Math.pow(val, 2); while ((val % divisor) != 0 && square(divisor) <= val) { divisor++; } return square(divisor) <= val ? largestPrimeFactor(val / divisor, divisor) : val; } 

उपयोग उदाहरण:

 let result = largestPrimeFactor(600851475143); 

यहां कोड का एक उदाहरण है :

 n = abs(number); result = 1; if (n mod 2 == 0) { result = 2; while (n mod 2 = 0) n /= 2; } for(i=3; i<sqrt(n); i+=2) { if (n mod i == 0) { result = i; while (n mod i = 0) n /= i; } } return max(n,result) 

ऐसे कुछ मॉड्यूलो परीक्षण हैं जो अतिप्रवाह होते हैं, क्योंकि एन को 6 से विभाजित नहीं किया जा सकता है अगर सभी कारक 2 और 3 को निकाल दिया गया है। आप केवल मैं के लिए primes की अनुमति दे सकते हैं, जो यहां कई अन्य उत्तरों में दिखाया गया है।

आप वास्तव में इरोटोथिनेस की छलनी को यहां जोड़ सकते हैं:

  • पहले sqrt (n) तक पूर्णांकों की सूची बनाएं
  • लूप मार्क के लिए सभी गुणकों को मैं नए sqrt (n) के रूप में प्रधानमंत्री के रूप में नहीं, और इसके बजाय एक लूप का उपयोग करें।
  • सूची में अगले प्रधान संख्या को सेट करें I

इस सवाल को भी देखें

नंबर से सभी प्रमुख कारकों को हटाकर पायथन इटरएटिव दृष्टिकोण

 def primef(n): if n <= 3: return n if n % 2 == 0: return primef(n/2) elif n % 3 ==0: return primef(n/3) else: for i in range(5, int((n)**0.5) + 1, 6): #print i if n % i == 0: return primef(n/i) if n % (i + 2) == 0: return primef(n/(i+2)) return n 

मैं एल्गोरिथ्म का उपयोग कर रहा हूं जो कि संख्या को वर्तमान प्राइम फैक्टर द्वारा विभाजित करता है।

अजगर 3 में मेरा समाधान:

 def PrimeFactor(n): m = n while n%2==0: n = n//2 if n == 1: # check if only 2 is largest Prime Factor return 2 i = 3 sqrt = int(m**(0.5)) # loop till square root of number last = 0 # to store last prime Factor ie Largest Prime Factor while i <= sqrt : while n%i == 0: n = n//i # reduce the number by dividing it by it's Prime Factor last = i i+=2 if n> last: # the remaining number(n) is also Factor of number return n else: return last print(PrimeFactor(int(input()))) 

इनपुट: 10 आउटपुट: 5

इनपुट: 600851475143 आउटपुट: 6857

सबसे बड़ा प्रमुख कारक की गणना करने के लिए यहां मेरा दृष्टिकोण है यह इस तथ्य पर आधारित है कि संशोधित x में गैर-प्रमुख कारक नहीं होते हैं इसे प्राप्त करने के लिए, हम एक घटक के रूप में जल्द ही x को विभाजित करते हैं। फिर, केवल एक चीज छोड़ना सबसे बड़ा कारक वापस करना है। यह पहले से ही प्रधान होगा

कोड (हास्केल):

 f max' xi | i > x = max' | x `rem` i == 0 = fi (x `div` i) i -- Divide x by its factor | otherwise = f max' x (i + 1) -- Check for the next possible factor gx = f 2 x 2 

निम्न C ++ एल्गोरिदम सबसे अच्छा नहीं है, लेकिन यह एक अरब के तहत संख्याओं के लिए काम करता है और इसका बहुत तेज है

 #include <iostream> using namespace std; // ------ is_prime ------ // Determines if the integer accepted is prime or not bool is_prime(int n){ int i,count=0; if(n==1 || n==2) return true; if(n%2==0) return false; for(i=1;i<=n;i++){ if(n%i==0) count++; } if(count==2) return true; else return false; } // ------ nextPrime ------- // Finds and returns the next prime number int nextPrime(int prime){ bool a = false; while (a == false){ prime++; if (is_prime(prime)) a = true; } return prime; } // ----- MAIN ------ int main(){ int value = 13195; int prime = 2; bool done = false; while (done == false){ if (value%prime == 0){ value = value/prime; if (is_prime(value)){ done = true; } } else { prime = nextPrime(prime); } } cout << "Largest prime factor: " << value << endl; } 

मुझे लगता है कि दिए गए एल्गोरिथम के चरण # 2 को सभी कुशल एक दृष्टिकोण नहीं होने जा रहा है आपके पास कोई उचित उम्मीद नहीं है कि यह प्रमुख है।

इसके अलावा, पिछला उत्तर इरोटोथिनेस की छलनी का सुझाव बिल्कुल गलत है। मैंने अभी 123456789 के कारक के लिए दो प्रोग्राम लिखे हैं। एक सिविए पर आधारित था, एक निम्न पर आधारित था:

 1) Test = 2 2) Current = Number to test 3) If Current Mod Test = 0 then 3a) Current = Current Div Test 3b) Largest = Test 3c) Goto 3. 4) Inc(Test) 5) If Current < Test goto 4 6) Return Largest 

इस संस्करण में छलनी की तुलना में 9 0x तेज थी

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

ध्यान दें, यह भी कि मेरे पहचानने वाले कारकों को विभाजित करना उन जगहों को कम कर देता है जिन्हें जांचना चाहिए।

सबसे पहले प्राथमिक संख्याओं को संग्रहित करने वाली सूची की गणना करें, उदाहरण के लिए, 2 3 5 7 11 13 …

हर बार जब आप प्रधानांक को एक संख्या में विभाजित करते हैं, तो त्रिप्टिक द्वारा कार्यान्वयन का उपयोग करते हैं लेकिन प्राकृतिक पूर्णांक के बजाय मुख्य संख्याओं की सूची को दोहराते हैं।

यहाँ सी # में मेरा प्रयास है अंतिम प्रिंट आउट संख्या का सबसे बड़ा प्रमुख कारक है। मैंने चेक किया और यह काम करता है

 namespace Problem_Prime { class Program { static void Main(string[] args) { /* The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143 ? */ long x = 600851475143; long y = 2; while (y < x) { if (x % y == 0) { // y is a factor of x, but is it prime if (IsPrime(y)) { Console.WriteLine(y); } x /= y; } y++; } Console.WriteLine(y); Console.ReadLine(); } static bool IsPrime(long number) { //check for evenness if (number % 2 == 0) { if (number == 2) { return true; } return false; } //don't need to check past the square root long max = (long)Math.Sqrt(number); for (int i = 3; i <= max; i += 2) { if ((number % i) == 0) { return false; } } return true; } } } 

जावा के साथ:

int मानों के लिए:

 public static int[] primeFactors(int value) { int[] a = new int[31]; int i = 0, j; int num = value; while (num % 2 == 0) { a[i++] = 2; num /= 2; } j = 3; while (j <= Math.sqrt(num) + 1) { if (num % j == 0) { a[i++] = j; num /= j; } else { j += 2; } } if (num > 1) { a[i++] = num; } int[] b = Arrays.copyOf(a, i); return b; } 

long मानों के लिए:

 static long[] getFactors(long value) { long[] a = new long[63]; int i = 0; long num = value; while (num % 2 == 0) { a[i++] = 2; num /= 2; } long j = 3; while (j <= Math.sqrt(num) + 1) { if (num % j == 0) { a[i++] = j; num /= j; } else { j += 2; } } if (num > 1) { a[i++] = num; } long[] b = Arrays.copyOf(a, i); return b; } 
 #python implementation import math n = 600851475143 i = 2 factors=set([]) while i<math.sqrt(n): while n%i==0: n=n/i factors.add(i) i+=1 factors.add(n) largest=max(factors) print factors print largest 

C ++ में पुनरावर्ती का उपयोग करते हुए किसी संख्या के सबसे बड़े कारक की गणना करता है कोड का काम नीचे समझाया गया है:

 int getLargestPrime(int number) { int factor = number; // assumes that the largest prime factor is the number itself for (int i = 2; (i*i) <= number; i++) { // iterates to the square root of the number till it finds the first(smallest) factor if (number % i == 0) { // checks if the current number(i) is a factor factor = max(i, number / i); // stores the larger number among the factors break; // breaks the loop on when a factor is found } } if (factor == number) // base case of recursion return number; return getLargestPrime(factor); // recursively calls itself } 

मुझे लगता है कि यह संभव है कि कहीं भी संभवतः सभी संभावित प्राइम को स्टोर करना अच्छा होगा और सबसे बड़ा डिवीज़ियर ढूंढने के लिए उनके द्वारा फिर से दोहराएं। आप प्राइम- numbers.org से primes प्राप्त कर सकते हैं

बेशक मुझे लगता है कि आपका नंबर बहुत बड़ा नहीं है 🙂

यह संभवतः हमेशा तेज़ नहीं है, लेकिन इसके बारे में अधिक आशावादी है कि आपको एक बड़ा प्रमुख विभाजक लगता है:

  1. N आपका नंबर है
  2. यदि यह प्रधान है तो return(N)
  3. Sqrt(N) तक Sqrt(N) गणना करें
  4. निचले क्रम में प्राइम्स के माध्यम से जाएं (सबसे पहले सबसे पहले)
    • यदि N is divisible by Prime तो Return(Prime)

संपादित करें: चरण 3 में आप एरीटोथेनिनेस की छलनी या एटकिन्स की छलनी या आप जो भी चाहें उपयोग कर सकते हैं, लेकिन स्वयं के द्वारा छलनी आपको सबसे बड़ा प्रमुख कारक नहीं मिलेगा (यही वजह है कि मैं एक आधिकारिक उत्तर के रूप में SQLMenace के पद का चयन नहीं करता …)

तेज़ नहीं, लेकिन यह काम करता है!

  static bool IsPrime(long num) { long checkUpTo = (long)Math.Ceiling(Math.Sqrt(num)); for (long i = 2; i <= checkUpTo; i++) { if (num % i == 0) return false; } return true; } 

यहां एक समान कार्य है @ त्रिप्टिक जिसे जनरेटर के रूप में प्रदान किया गया है, जिसे थोड़ा सा सरलीकृत किया गया है।

 def primes(n): d = 2 while (n > 1): while (n%d==0): yield d n /= d d += 1 

तो अधिकतम प्राइम का प्रयोग करके इसका उपयोग किया जा सकता है:

 n= 373764623 max(primes(n)) 

और कारकों की एक सूची का उपयोग करते हुए पाया:

 list(primes(n)) 
 #include<stdio.h> #include<conio.h> #include<math.h> #include <time.h> factor(long int n) { long int i,j; while(n>=4) { if(n%2==0) { n=n/2; i=2; } else { i=3; j=0; while(j==0) { if(n%i==0) {j=1; n=n/i; } i=i+2; } i-=2; } } return i; } void main() { clock_t start = clock(); long int n,sp; clrscr(); printf("enter value of n"); scanf("%ld",&n); sp=factor(n); printf("largest prime factor is %ld",sp); printf("Time elapsed: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC); getch(); }