दिलचस्प पोस्ट
अजगर में कोशिश बनाम बनाम का उपयोग करना एंड्रॉइड एमुलेटर परिदृश्य को घूमते नहीं हैं छवि के एक भाग को क्लिक करने योग्य लिंक कैसे बना सकता है इकाई के लिए लिनक – एसक्यूएल "इन" क्लॉज वसंत जेसन अनुरोध 406 प्राप्त करना (स्वीकार्य नहीं) Python3.2 के साथ matplotlib कैसे स्थापित करें आप दो आयामी सरणी कैसे घुमाएं? जावा परावर्तन का उपयोग करते हुए इनहेरिट किए गए विशेषता नामों / मानों को पुनर्प्राप्त करना multiprocessing.Pool: map_async और imap के बीच अंतर क्या है? पुराने पासवर्ड के साथ प्रमाणीकरण अब समर्थित नहीं है, 4.1 शैली पासवर्ड का उपयोग करें सी ++ कोड के साथ स्थिर सी लाइब्रेरी को लिंक करते समय "अपरिभाषित संदर्भ" त्रुटियाँ अजगर में पंक्ति द्वारा दो अलग-अलग फाइलों की रेखा की तुलना करें Windows बैच स्क्रिप्ट (.bat) में दिए गए तर्कों की सूची प्राप्त करें JSON को DataTable में कनवर्ट करें मैं किसी वेबएएसएसम्बंक्शन फ़ंक्शन से जावास्क्रिप्ट स्ट्रिंग कैसे वापस कर सकता हूं

क्या एक सरल एल्गोरिथ्म है जो यह निर्धारित कर सकता है कि एक्स प्रधान है, और केवल एक नर्तक प्रोग्रामर को भ्रमित न करें?

मैं प्रोजेक्ट यूलर के माध्यम से अपना रास्ता काम करने की कोशिश कर रहा हूं, और कुछ मुसीबतों पर ध्यान दिया है कि आप के लिए इसे एक भाग के रूप में एक प्रमुख संख्या निर्धारित करने के लिए पूछें।

1) मुझे पता है कि मैं सिर्फ 2, 3, 4, 5, …, x का वर्गमूल और यदि मैं वर्गमूल पर आ जाता हूं, तो मैं (सुरक्षित रूप से) यह मान सकता हूँ कि संख्या प्रधान है दुर्भाग्य से यह समाधान काफी कलकत्ता लगता है।

2) मैंने बेहतर एल्गोरिदम में यह तय किया है कि कोई संख्या प्रधान है या नहीं, लेकिन तेजी से भ्रमित हो जाने पर।

क्या एक सरल एल्गोरिथ्म है जो यह निर्धारित कर सकता है कि एक्स प्रधान है, और केवल एक नैदानिक ​​प्रोग्रामर को भ्रमित न करें?

बहुत धन्यवाद!

Solutions Collecting From Web of "क्या एक सरल एल्गोरिथ्म है जो यह निर्धारित कर सकता है कि एक्स प्रधान है, और केवल एक नर्तक प्रोग्रामर को भ्रमित न करें?"

पहला एल्गोरिदम काफी अच्छा है और प्रोजेक्ट ऑलर पर बहुत कुछ इस्तेमाल किया है। यदि आपको वह अधिकतम संख्या पता है जिसे आप चाहते हैं तो आप इरटोथेनिनेस की छलनी को भी खोज सकते हैं।

यदि आप प्राइम की सूची बनाए रखते हैं तो आप संख्या के वर्गमूल तक प्राथमिकताओं के साथ केवल विभाजित करने के लिए पहले अलगो को भी परिष्कृत कर सकते हैं।

इन दोनों एल्गोरिदम (विभाजन और छलनी) के साथ आप समस्याओं को हल करने में सक्षम होना चाहिए।

संपादित करें : टिप्पणी में उल्लिखित निश्चित नाम के अनुसार

एक सीमा से कम सभी प्रमुख संख्याएं उत्पन्न करने के लिए इरोटोथिनेस की छलनी (पृष्ठ में 20 प्रोग्रामिंग भाषाओं में वेरिएंट शामिल हैं) सबसे पुराना और सरल समाधान है।

पायथन में:

def iprimes_upto(limit): is_prime = [True] * limit for n in range(2, limit): if is_prime[n]: yield n for i in range(n*n, limit, n): # start at ``n`` squared is_prime[i] = False 

उदाहरण:

 >>> list(iprimes_upto(15)) [2, 3, 5, 7, 11, 13] 

मुझे लगता है कि फर्मट की प्राइमलिटी टेस्ट का सुझाव पहले ही दिया गया है, लेकिन मैं संरचना और इंटरप्रिटेशन ऑफ कम्प्यूटर प्रोग्राम के माध्यम से काम कर रहा हूं, और वे मिलर-राबिन टेस्ट भी देते हैं (देखें अनुभाग 1.2.6, समस्या 1.28) एक अन्य विकल्प के रूप में मैं इसे यूलर समस्याओं के लिए सफलतापूर्वक प्रयोग कर रहा हूं।

यहां आपकी विधि का एक सरल अनुकूलन है जो इरोटोथेनिनेस की काफी छलनी नहीं है, लेकिन कार्यान्वयन करना बहुत आसान है: पहले एक्स 2 और 3 को विभाजित करने का प्रयास करें, फिर j = 1..sqrt (x) / 6 पर लूप को विभाजित करने का प्रयास करें 6 * जे -1 और 6 * जे + 1 तक यह स्वतः 2 या 3 से विभाजित सभी संख्याओं को छोड़ देता है, आपको एक बहुत अच्छा स्थिर कारक त्वरण प्राप्त कर रहा है।

निम्नलिखित तथ्यों को ध्यान में रखते हुए ( मैथ्स चाल्लेजेन से ):

  • 2 को छोड़कर सभी प्राइम अजीब हैं।
  • 3 से अधिक सभी प्रमेय 6k – 1 या 6k + 1 के रूप में लिख सकते हैं
  • आपको n के वर्गमूल का अवलोकन करने की आवश्यकता नहीं है

यहां सी ++ फ़ंक्शन है जो मैं अपेक्षाकृत छोटे एन के लिए उपयोग करता हूं:

 bool isPrime(unsigned long n) { if (n == 1) return false; // 1 is not prime if (n < 4) return true; // 2 and 3 are both prime if ((n % 2) == 0) return false; // exclude even numbers if (n < 9) return true; //we have already excluded 4, 6, and 8. if ((n % 3) == 0) return false; // exclude remaining multiples of 3 unsigned long r = floor( sqrt(n) ); unsigned long f = 5; while (f <= r) { if ((n % f) == 0) return false; if ((n % (f + 2)) == 0) return false; f = f + 6; } return true; // (in all other cases) } 

आप शायद अपने खुद के अधिक अनुकूलन के बारे में सोच सकते हैं

मैं फर्मट की प्रमुखता परीक्षण की सिफारिश करता था यह एक संभाव्य परीक्षण है, लेकिन यह आश्चर्यजनक रूप से अक्सर सही है। और छलनी के साथ तुलना में यह अविश्वसनीय रूप से तेज है।

काफी छोटी संख्या के लिए, sqrt (x) तक के लिए x% n बेहद तेज और कोड के लिए आसान है

साधारण सुधार:

परीक्षा 2 और विषम संख्याएं केवल

परीक्षण 2, 3, और 6 + या – 1 के गुणक (2 या 3 के अलावा अन्य सभी गुण 6 +/- 1 के गुणक हैं, इसलिए आप अनिवार्य रूप से केवल सभी संख्याओं और 3 के सभी गुणकों को छोड़ते हैं

केवल प्राइम नंबरों का परीक्षण करें (sqrt (x) तक सभी प्राइम को गणना या संग्रहीत करने की आवश्यकता है)

आप कुछ प्रामाणिक सीमा तक सभी प्राइम की एक सूची को शीघ्र रूप से जनरेट करने के लिए चलनी पद्धति का उपयोग कर सकते हैं, लेकिन यह मेमोरी गहन होने की संभावना है। आप 6 युटिलिटी के गुणकों का उपयोग स्मृति उपयोग को कम करने के लिए 1/3 प्रति बिट के लिए कर सकते हैं।

मैंने एक साधारण प्रधान वर्ग (सी #) लिखा था जो 6 + 1 के गुणकों और 6-1 के गुणकों के लिए दो बिटफ़िल्ड का उपयोग करता है, फिर एक सरल लुकअप करता है … और यदि मैं परीक्षण कर रहा हूँ, तो चलनी की सीमा से बाहर है, तो यह 2, 3, और 6 +/- 1 के गुणकों पर वापस आना पड़ता है। मुझे लगता है कि बड़ी छलनी पैदा करने में वास्तव में अधिक से अधिक समय लगता है, जो कि अभी तक हल करने वाले ज्यादातर यूलर समस्याओं के लिए मक्खी पर primes की गणना करता है। चुंबन सिद्धांत फिर से हमले!

मैंने एक प्रमुख वर्ग लिखा है जो छद्म का उपयोग करता है जो कि छोटे primes की पूर्व-गणना करता है, फिर छलनी की सीमा के बाहर वाले लोगों के लिए 2, 3, और छह +/- 1 के गुणकों पर निर्भर करता है।

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

मुझे लगता है कि आप जो खोज रहे हैं वह है इरोटोथिनेस की छलनी

आपका सही नमूना सबसे धीमा है आप इसे कुछ हद तक अनुकूलित कर सकते हैं

वर्ग जड़ों के बजाय मापांक का उपयोग करें। अपने primes का ट्रैक रखें आपको केवल 7, 2, 3, और 5 को 6 से विभाजित करने की आवश्यकता है, 2 और 3 का एक बहुमान है, और 4 2 का एक बहु है।

रुलाइट ने एरिकांनोस छलनी का उल्लेख किया यह काफी सीधे आगे है। मैं इसे कई भाषाओं में घर पर है एक टिप्पणी जोड़ें अगर आप मुझे उस कोड को बाद में पोस्ट करना चाहते हैं।


यहां मेरी सी ++ एक है इसमें सुधार के लिए बहुत सारे कमरे हैं, लेकिन यह तेज गतिशील भाषा संस्करणों की तुलना में है।

 // Author: James J. Carman // Project: Sieve of Eratosthenes // Description: I take an array of 2 ... max values. Instead of removeing the non prime numbers, // I mark them as 0, and ignoring them. // More info: http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes #include <iostream> int main(void) { // using unsigned short. // maximum value is around 65000 const unsigned short max = 50000; unsigned short x[max]; for(unsigned short i = 0; i < max; i++) x[i] = i + 2; for(unsigned short outer = 0; outer < max; outer++) { if( x[outer] == 0) continue; unsigned short item = x[outer]; for(unsigned short multiplier = 2; (multiplier * item) < x[max - 1]; multiplier++) { unsigned int searchvalue = item * multiplier; unsigned int maxValue = max + 1; for( unsigned short maxIndex = max - 1; maxIndex > 0; maxIndex--) { if(x[maxIndex] != 0) { maxValue = x[maxIndex]; break; } } for(unsigned short searchindex = multiplier; searchindex < max; searchindex++) { if( searchvalue > maxValue ) break; if( x[searchindex] == searchvalue ) { x[searchindex] = 0; break; } } } } for(unsigned short printindex = 0; printindex < max; printindex++) { if(x[printindex] != 0) std::cout << x[printindex] << "\t"; } return 0; } 

मैं पर्ल और अजगर कोड को उतना ही उतना ही जारी रखूंगा जितना मुझे मिल रहा है। वे शैली में समान हैं, बस कम लाइनें

यहां डी (डिजिटल मंगल) में एक सरल प्राध्यापक परीक्षा है:

 /** * to compile: * $ dmd -run prime_trial.d * to optimize: * $ dmd -O -inline -release prime_trial.d */ module prime_trial; import std.conv : to; import std.stdio : w = writeln; /// Adapted from: http://www.devx.com/vb2themax/Tip/19051 bool isprime(Integer)(in Integer number) { /* manually test 1, 2, 3 and multiples of 2 and 3 */ if (number == 2 || number == 3) return true; else if (number < 2 || number % 2 == 0 || number % 3 == 0) return false; /* we can now avoid to consider multiples * of 2 and 3. This can be done really simply * by starting at 5 and incrementing by 2 and 4 * alternatively, that is: * 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, ... * we don't need to go higher than the square root of the number */ for (Integer divisor = 5, increment = 2; divisor*divisor <= number; divisor += increment, increment = 6 - increment) if (number % divisor == 0) return false; return true; // if we get here, the number is prime } /// print all prime numbers less then a given limit void main(char[][] args) { const limit = (args.length == 2) ? to!(uint)(args[1]) : 100; for (uint i = 0; i < limit; ++i) if (isprime(i)) w(i); } 

मैं परियोजना यूलर समस्याओं के माध्यम से और वास्तव में केवल # 3 (आईडी के अनुसार) काम कर रहा हूं जो कि समग्र संख्या के सबसे उच्चतम कारक के लिए खोज है (संख्या 600851475143 है?)

मैंने प्रमेय पर सभी जानकारी (पहले से उल्लेख किया गया छलनी तंत्र) पर देखा, और विकिपीडिया पर पूर्णांक कारक पर और एक बाध्य बल परीक्षण डिवीजन एल्गोरिथ्म के साथ आया जो मैंने तय किया था।

इसलिए जैसे कि मैं रूबी जानने के लिए यूलर की समस्याएं कर रहा हूं, मैं अपने एल्गोरिदम को कोडिंग में देख रहा था और मठ पुस्तकालय में ठोकर खाई थी जिसमें प्राइम क्लास और पूर्णांक वर्ग को प्राइम_डिविजन विधि के साथ है। कितना मजेदार था वो। मैं इस रूबी स्निपेट के साथ समस्या का सही उत्तर प्राप्त करने में सक्षम था:

 require "mathn.rb" puts 600851475143.prime_division.last.first 

यह स्निपेट कंसोल के सही उत्तर का उत्पादन करता है बेशक मैं इस छोटे से सौंदर्य पर ठोकर लेने से पहले पढ़ने और सीखने का एक टन कर रहा था, मैंने सोचा कि मैं इसे सभी के साथ साझा करेगा …

एकेएस प्राइम परीक्षण एल्गोरिदम:

 Input: Integer n > 1 if (n is has the form ab with b > 1) then output COMPOSITE r := 2 while (r < n) { if (gcd(n,r) is not 1) then output COMPOSITE if (r is prime greater than 2) then { let q be the largest factor of r-1 if (q > 4sqrt(r)log n) and (n(r-1)/q is not 1 (mod r)) then break } r := r+1 } for a = 1 to 2sqrt(r)log n { if ( (xa)n is not (xn-a) (mod xr-1,n) ) then output COMPOSITE } output PRIME; 

मुझे यह अजगर कोड पसंद है।

 def primes(limit) : limit += 1 x = range(limit) for i in xrange(2,limit) : if x[i] == i: x[i] = 1 for j in xrange(i*i, limit, i) : x[j] = i return [j for j in xrange(2, limit) if x[j] == 1] 

इसका एक रूप संख्या का कारक उत्पन्न करने के लिए इस्तेमाल किया जा सकता है

 def factors(limit) : limit += 1 x = range(limit) for i in xrange(2,limit) : if x[i] == i: x[i] = 1 for j in xrange(i*i, limit, i) : x[j] = i result = [] y = limit-1 while x[y] != 1 : divisor = x[y] result.append(divisor) y /= divisor result.append(y) return result 

बेशक, अगर मैं संख्याओं का बैच फैक्टर कर रहा था, तो मैं कैश का पुनर्गणना नहीं करूँगा; मैं इसे एक बार करूँगा और इसमें लुकअप करूँगा।

आश्चर्य की बात है कि कोई भी कोई भी PHP संस्करण सबमिट नहीं करता, इसलिए यह मेरा सबमिशन है:

 function sieve_of_erathosthenes($max) { // populate array for ($i = 2; $i <= $max; $i++) { $array[] = $i; } // sieve of eratosthenes algo for ($i = 0, $j = count($array); $i < $j; $i++) { $prime[] = $p = array_shift($array); foreach ($array as $k => $v) { if ($v % $p == 0){ unset($array[$k]); $j--; } } } return $prime; } 

अनुकूलित नहीं है लेकिन यह एक बहुत सरल कार्य है

  function isprime(number){ if (number == 1) return false; var times = 0; for (var i = 1; i <= number; i++){ if(number % i == 0){ times ++; } } if (times > 2){ return false; } return true; } 

अजगर में एक और तरीका यह है:

 import math def main(): count = 1 while True: isprime = True for x in range(2, int(math.sqrt(count) + 1)): if count % x == 0: isprime = False break if isprime: print count count += 2 if __name__ == '__main__': main()