प्राइम नंबर खोजने के लिए सबसे तेज़ एल्गोरिथम कौन सा है?

Question

C ++ का उपयोग करके अभाज्य संख्या ज्ञात करने के लिए सबसे तेज़ एल्गोरिथम कौन सा है? मैंने छलनी के एल्गोरिथ्म का उपयोग किया है लेकिन मैं अभी भी इसे और तेज करना चाहता हूं!

Comments

एक पुराना लेख जो मुझे मिला, लेकिन दिलचस्प लग रहा है: फन विद प्राइम नंबर

— एमवॉइल

@ जैदर यह संख्या 7 (111) से कम है। यह 1001 = 9 के लिए भी विफल रहता है। और स्पष्ट रूप से यह सामान्य रूप से लगभग सभी अपराधों के लिए विफल रहता है (मामला 2 ^ p - 1 को कवर नहीं करता है, जो मेर्सन प्राइम नंबर हैं - शास्त्रीय रूप से उत्पन्न उदाहरण - जो हमेशा 111 के रूप में होगा ... 1)

— डैनियल कैट

@ कैस्परस्की - आपने किस छलनी का उल्लेख नहीं किया? आप शायद मतलब Eranthoses की छलनी!

— user2618142

— एराटोस्थनीज

Answer 1

Atkin की छलनी का एक बहुत तेजी से कार्यान्वयन डैन बर्नस्टीन का प्रमुख है । यह चलनी से अधिक कुशल है एरेटोस्थेनेज की चलनी । उनके पेज पर कुछ बेंचमार्क जानकारी है।

Comments

वास्तव में मुझे नहीं लगता कि प्रजेन सबसे तेज है, या दूसरी सबसे तेज भी है; yafu और primesieve, दोनों सामान्य रूप से तेज़ हैं, मुझे लगता है, और निश्चित रूप से 2 ^ 32 से अधिक है। दोनों एटकिन-बर्नस्टीन चलनी के बजाय एराटोस्थनीज के संशोधित (संशोधित) हैं।

— चार्ल्स

Eratosthenes (SoE) की प्राइमिसिव छलनी सबसे तेज़ संभव एल्गोरिथ्म है और हमेशा बर्नस्टीन के साथ ही Atkin SoA की छलनी के किसी भी क्रियान्वयन की तुलना में तेज़ होगी क्योंकि इस उत्तर में लिंक किया गया है क्योंकि primesieve, SoA की तुलना में संचालन की संख्या को कम कर देता है: 32- के लिए बिट संख्या सीमा (2 ^ 32 - 1), प्राइमिसेव लगभग 1.2 बिलियन कल्स करता है जबकि सोआ कुल 1.4 बिलियन संयुक्त टॉगल और स्क्वायर फ्री ऑपरेशंस करता है, दोनों ऑपरेशन एक ही जटिलता के बारे में होते हैं और लगभग उसी में अनुकूलित होने में सक्षम होते हैं मार्ग।

— गॉर्डनबूड

जारी: बर्नस्टीन ने केवल SoA के लिए उसी प्रभावी पहिया कारक का उपयोग करते हुए SoE की तुलना की, जो कि एक 2; 3; 5 पहिया है, जिसमें व्हील का उपयोग करने पर लगभग 1.83 बिलियन से अधिक 32-बिट संख्या सीमा होती है; यह एसओई को लगभग 30% तेज बनाता है जब बराबर अन्य अनुकूलन के लिए SoE के इस प्रतिबंधित संस्करण की तुलना करता है । हालाँकि, प्राइमिसेव एल्गोरिथ्म एक 2; 3; 5; 7 व्हील को 2, 3; 5; 7; 11; 13; 13 व्हील सेगमेंट के पूर्व-कलन के संचालन की संख्या को कम करने के लिए लगभग 1.2 बिलियन का उपयोग करता है। एसओए की तुलना में 16.7% तेज ऑपरेशन लूप अनुकूलन के साथ।

— गॉर्डनबूड

Continued2: SoA con में 2 के रूप में बहुत अंतर करने के लिए उपयोग किए जाने वाले उच्च कारक पहिया कारक नहीं हैं; 3; 5 कारक पहियाकरण एल्गोरिथ्म का एक "बेक्ड-इन" भाग है।

— गॉर्डनबूड

@ ईमोन नेरबोन, WP सही है; हालांकि, बस थोड़ा बेहतर कम्प्यूटेशनल जटिलता होने से सामान्य उपयोग के लिए एक तेज एल्गोरिदम नहीं बनता है। इन टिप्पणियों में, मैं उस Sieve of Eratosthenes (SoE) के अधिकतम पहिया कारक का उल्लेख कर रहा हूं (जो कि Sieve of Atkin- SoA के लिए संभव नहीं है) SoE के लिए लगभग एक अरब की सीमा तक थोड़े कम परिचालन करता है। उस बिंदु से बहुत ऊपर, आम तौर पर मेमोरी सीमाओं को दूर करने के लिए पेज सेगमेंटेशन का उपयोग करने की आवश्यकता होती है, और यही वह जगह है जहां बढ़ती सीमा के साथ निरंतर ओवरहेड की तेजी से बढ़ती मात्रा लेते हुए, सोआ विफल रहता है।

— गॉर्डनबूड

Answer 2

यदि इसे वास्तव में तेज़ होना है तो आप primes की सूची शामिल कर सकते हैं:
http://www.bigprimes.net/archive/prime/

यदि आपको बस यह जानना है कि एक निश्चित संख्या एक अभाज्य संख्या है, तो विकिपीडिया पर सूचीबद्ध विभिन्न प्राइम टेस्ट हैं । वे शायद यह निर्धारित करने के लिए सबसे तेज़ विधि हैं कि क्या बड़ी संख्याएँ primes हैं, खासकर क्योंकि वे आपको बता सकते हैं कि क्या संख्या एक प्रमुख नहीं है।

Comments

सभी primes की एक सूची? मुझे लगता है कि आप पहले कुछ primes की सूची का मतलब है ... :)

— j_random_hacker

अगर आप 100000000 पर कुछ कॉल करते हैं, तो हाँ। :)

— जॉर्ज शॉली

निश्चित रूप से 100000000 अनन्तता की तुलना में "कुछ" है;

— टिमोफेई

आपको क्यों लगता है कि एटकिनस्थनीज़ (एसओई) की छलनी की तुलना में एटकी (सोआ) की छलनी तेज़ है? यह निश्चित रूप से नहीं है जब कोई छद्म कोड का उपयोग करके किसी प्रोग्राम को लागू करता है जैसा कि आपके द्वारा विकिपीडिया लेख से जुड़ा हुआ है। यदि SoE को समान स्तर के संभावित अनुकूलन के साथ लागू किया जाता है, जैसा कि SoA के साथ उपयोग किया जाता है, तो SoE की तुलना में SoA के लिए बहुत बड़ी sieving पर्वतमाला के लिए थोड़ा कम संचालन होता है, लेकिन यह लाभ आमतौर पर बढ़ी हुई जटिलता और ऑफसेट से अधिक होता है इस कम्प्यूटेशनल जटिलता के अतिरिक्त निरंतर कारक ओवरहेड व्यावहारिक अनुप्रयोगों के लिए SoE बेहतर है।

— गॉर्डनबूड

Answer 3

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

अब तक, मेरा मानना ​​है कि सबसे तेज़ प्राइम नंबर टेस्टिंग एल्गोरिदम स्ट्रॉन्ग प्रोबेबल प्राइम (SPRP) है। मैं एनवीडिया क्यूडा मंचों से उद्धृत कर रहा हूं:

संख्या सिद्धांत में अधिक व्यावहारिक आला समस्याओं में से एक को प्रमुख संख्याओं की पहचान करना है। N को देखते हुए, आप यह कैसे कुशलतापूर्वक निर्धारित कर सकते हैं कि यह प्रधान है या नहीं? यह सिर्फ एक थेरेटिकल समस्या नहीं है, यह कोड में एक वास्तविक आवश्यकता हो सकती है, शायद जब आपको कुछ सीमाओं के भीतर एक प्रमुख हैश तालिका आकार को गतिशील रूप से खोजने की आवश्यकता हो। यदि 2 ^ 30 के आदेश पर एन कुछ है, तो क्या आप वास्तव में किसी भी कारक की खोज के लिए 30000 डिवीजन परीक्षण करना चाहते हैं? बेशक नहीं।

इस समस्या का सामान्य व्यावहारिक समाधान एक सरल परीक्षण है जिसे यूलर प्रोबेबल प्राइम टेस्ट कहा जाता है, और एक अधिक शक्तिशाली सामान्यीकरण जिसे स्ट्रॉन्ग प्रोबेबल प्राइम (SPRP) कहा जाता है। यह एक परीक्षण है कि एक पूर्णांक के लिए N संभावित रूप से इसे प्रधान या नहीं के रूप में वर्गीकृत कर सकता है, और बार-बार परीक्षण सुधारात्मक संभावना को बढ़ा सकते हैं। परीक्षण के धीमे हिस्से में ज्यादातर A ^ (N-1) modulo N के समान मान शामिल होता है। RSA सार्वजनिक कुंजी एन्क्रिप्शन वेरिएंट को लागू करने वाले किसी भी व्यक्ति ने इस एल्गोरिथम का उपयोग किया है। यह विशाल पूर्णांक (जैसे 512 बिट्स) के साथ-साथ सामान्य 32 या 64 बिट इनट्स के लिए उपयोगी है।

परीक्षण को संभाव्य अस्वीकृति से एक निश्चित प्रमाण में प्रयोग किया जाता है जो कुछ परीक्षण इनपुट मापदंडों को पूर्वसंचालित करके प्रायोगिकता के एक निश्चित प्रमाण में बदल जाता है जो हमेशा एन की श्रेणियों के लिए सफल होते हैं। दुर्भाग्य से इन "सर्वश्रेष्ठ ज्ञात परीक्षणों" की खोज प्रभावी रूप से एक विशाल की खोज है। वास्तव में अनंत) डोमेन। 1980 में, कार्ल पोमेरेंस द्वारा प्रसिद्ध परीक्षणों की एक पहली सूची बनाई गई थी (जो उनके द्विघात सीव एल्गोरिथ्म के साथ एक कारक RSA-129 के लिए प्रसिद्ध है।) बाद में जैशेके ने 1993 में परिणामों में काफी सुधार किया। 2004 में, जांग और तांग ने सिद्धांत में सुधार किया। और खोज डोमेन की सीमा। Greathouse और Livingstone ने वेब पर अब तक के सबसे आधुनिक परिणामों को http://math.crg4.com/primes.html पर जारी किया है , जो एक विशाल खोज डोमेन का सबसे अच्छा परिणाम है।

अधिक जानकारी के लिए यहां देखें: http://primes.utm.edu/prove/prove2_3.html और http://forums.nvidia.com/index.php?showtopic=70483

यदि आपको बहुत बड़ी अभाज्य संख्याएँ उत्पन्न करने की आवश्यकता है और सभी अभाज्य संख्याएँ उत्पन्न करने की परवाह नहीं है <पूर्णांक n, तो आप Mersenne अभाज्य संख्याओं को सत्यापित करने के लिए Lucas-Lehmer परीक्षण का उपयोग कर सकते हैं। एक मेर्सन प्राइम नंबर 2 ^ पी -1 के रूप में है। मुझे लगता है कि लुकास-लेहमर परीक्षण सबसे तेज एल्गोरिथ्म है जो मेरसेन प्राइम नंबर के लिए खोजा गया है।

और अगर आप न केवल सबसे तेज़ एल्गोरिदम बल्कि सबसे तेज़ हार्डवेयर का भी उपयोग करना चाहते हैं, तो Nvidia CUDA का उपयोग करके इसे लागू करने का प्रयास करें, CUDA के लिए एक कर्नेल लिखें और इसे GPU पर चलाएं।

यदि आप बड़े प्राइम नंबर की खोज करते हैं तो आप कुछ पैसे भी कमा सकते हैं, EFF $ 50K से $ 250K तक पुरस्कार दे रहा है: https://www.eff.org/awards/coop

Answer 4

एक 100% गणितीय परीक्षण है जो यह जाँच करेगा कि कोई संख्या Pअभाज्य या मिश्रित है, जिसे AKS Primality Test कहा जाता है ।

अवधारणा सरल है: एक संख्या दी गई है P, यदि सभी गुणांक (x-1)^P - (x^P-1)विभाज्य हैं P, तो Pएक अभाज्य संख्या है, अन्यथा यह एक संयुक्त संख्या है।

उदाहरण के लिए, दिया गया P = 3, बहुपद देगा:

   (x-1)^3 - (x^3 - 1)
 = x^3 + 3x^2 - 3x - 1 - (x^3 - 1)
 = 3x^2 - 3x

और गुणांक दोनों द्वारा विभाज्य हैं 3, इसलिए संख्या प्रमुख है।

और उदाहरण के लिए P = 4, जहां एक प्रमुख उपज नहीं है:

   (x-1)^4 - (x^4-1)
 = x^4 - 4x^3 + 6x^2 - 4x + 1 - (x^4 - 1)
 = -4x^3 + 6x^2 - 4x

और यहाँ हम देख सकते हैं कि गुणांक 6विभाज्य नहीं है 4, इसलिए यह अभाज्य नहीं है।

बहुपद शर्तों का उपयोग (x-1)^Pकरेगा P+1और संयोजन का उपयोग करके पाया जा सकता है। तो, यह परीक्षण O(n)रनटाइम में चलेगा , इसलिए मुझे नहीं पता कि यह कितना उपयोगी होगा क्योंकि आप केवल i0 से अधिक तक पुनरावृत्ति कर सकते हैं pऔर शेष के लिए परीक्षण कर सकते हैं ।

Comments

AKS व्यवहार में एक बहुत ही धीमी विधि है, अन्य ज्ञात विधियों के साथ प्रतिस्पर्धात्मक नहीं है। आपके द्वारा वर्णित विधि एकेएस नहीं है, लेकिन एक खोलने वाली लम्मा है जो बिना परीक्षण किए गए परीक्षण विभाजन की तुलना में धीमी है (जैसा कि आप बताते हैं)।

— दनाज

हैलो @Kousha, क्या xके लिए खड़ा है? में है (x-1)^P - (x^P-1)। क्या आपके पास इसके लिए एक नमूना कोड है? C ++ में यह निर्धारित करने के लिए कि पूर्णांक प्रमुख है या नहीं?

— kiLLua

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

— कुसहा

Answer 5

क्या आपकी समस्या यह तय करने के लिए है कि क्या एक विशेष संख्या प्रमुख है? तब आपको एक परिक्षण परीक्षा (आसान) की आवश्यकता होती है। या क्या आपको किसी दिए गए नंबर तक सभी primes की आवश्यकता है? उस मामले में प्रमुख sieves अच्छे हैं (आसान है, लेकिन स्मृति की आवश्यकता है)। या क्या आपको किसी संख्या के प्रमुख कारकों की आवश्यकता है? इसके लिए फैक्टराइजेशन की आवश्यकता होगी (बड़ी संख्या के लिए मुश्किल अगर आप वास्तव में सबसे कुशल तरीके चाहते हैं)। आप कितनी बड़ी संख्या में देख रहे हैं? 16 बिट्स? 32 बिट्स? बड़ा?

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

Comments

एक अच्छा प्रायोगिक परीक्षण मुख्य तालिकाओं के लिए मुख्य मेमोरी विलंबता के साथ प्रतिस्पर्धी है जो यथोचित रूप से फिट हो सकता है, इसलिए मैं इसका उपयोग तब तक नहीं करूंगा जब तक कि यह L2 में फिट नहीं हो सकता।

— चार्ल्स

Answer 6

राबिन-मिलर एक मानक संभाव्य प्राणिकता परीक्षण है। (आप इसे K बार चलाते हैं और इनपुट नंबर या तो निश्चित रूप से समग्र है, या यह संभवतः त्रुटि 4 ^-K की संभावना के साथ प्रमुख है । (कुछ सौ पुनरावृत्तियों और यह लगभग निश्चित रूप से आपको सच्चाई बता रहा है)

राबिन मिलर का एक गैर-संभाव्य (निर्धारक) संस्करण है ।

द ग्रेट इंटरनेट मर्सन प्राइम सर्च (GIMPS) जिसने जून 2017 तक सबसे बड़ा सिद्ध प्रधान (2 ^74,207,281 - 1 ) के लिए दुनिया का रिकॉर्ड पाया है , कई एल्गोरिदम का उपयोग करता है , लेकिन ये विशेष रूपों में प्राइम हैं। हालाँकि ऊपर दिए गए GIMPS पृष्ठ में कुछ सामान्य नियतात्मक परिक्षण परीक्षण शामिल हैं। वे यह इंगित करने के लिए दिखाई देते हैं कि कौन सा एल्गोरिथ्म "सबसे तेज़" है, परीक्षण किए जाने वाले संख्या के आकार पर निर्भर करता है। यदि आपकी संख्या 64 बिट्स में फिट होती है, तो संभवत: आपको कई मिलियन अंकों के अपराधों पर काम करने के लिए एक विधि का उपयोग नहीं करना चाहिए।

Answer 7

यह आपके आवेदन पर निर्भर करता है। कुछ विचार हैं:

• क्या आपको केवल जानकारी की आवश्यकता है कि क्या कुछ संख्याएँ प्राइम हैं, क्या आपको एक निश्चित सीमा तक सभी प्राइम नंबरों की आवश्यकता है, या क्या आपको सभी प्राइम नंबरों की आवश्यकता है (संभावित रूप से)?
• आपको कितनी बड़ी संख्या से निपटना है?

मिलर-राबिन और एनालॉग परीक्षण केवल एक निश्चित आकार से अधिक संख्या में छलनी से तेज होते हैं (कुछ मिलियन के आसपास, मुझे विश्वास है)। उसके नीचे, एक ट्रायल डिवीजन (यदि आपके पास बस कुछ नंबर हैं) या एक छलनी का उपयोग करना तेज है।

Answer 8

मैं हमेशा छलनी एल्गोरिथ्म के साथ प्राइम नंबर की गणना के लिए इस विधि का उपयोग करता हूं।

void primelist()
 {
   for(int i = 4; i < pr; i += 2) mark[ i ] = false;
   for(int i = 3; i < pr; i += 2) mark[ i ] = true; mark[ 2 ] = true;
   for(int i = 3, sq = sqrt( pr ); i < sq; i += 2)
       if(mark[ i ])
          for(int j = i << 1; j < pr; j += i) mark[ j ] = false;
  prime[ 0 ] = 2; ind = 1;
  for(int i = 3; i < pr; i += 2)
    if(mark[ i ]) ind++; printf("%d\n", ind);
 }

Answer 9

मैं आपको तय करने दूंगा कि यह सबसे तेज है या नहीं।

using System;
namespace PrimeNumbers
{

public static class Program
{
    static int primesCount = 0;


    public static void Main()
    {
        DateTime startingTime = DateTime.Now;

        RangePrime(1,1000000);   

        DateTime endingTime = DateTime.Now;

        TimeSpan span = endingTime - startingTime;

        Console.WriteLine("span = {0}", span.TotalSeconds);

    }


    public static void RangePrime(int start, int end)
    {
        for (int i = start; i != end+1; i++)
        {
            bool isPrime = IsPrime(i);
            if(isPrime)
            {
                primesCount++;
                Console.WriteLine("number = {0}", i);
            }
        }
        Console.WriteLine("primes count = {0}",primesCount);
    }



    public static bool IsPrime(int ToCheck)
    {

        if (ToCheck == 2) return true;
        if (ToCheck < 2) return false;


        if (IsOdd(ToCheck))
        {
            for (int i = 3; i <= (ToCheck / 3); i += 2)
            {
                if (ToCheck % i == 0) return false;
            }
            return true;
        }
        else return false; // even numbers(excluding 2) are composite
    }

    public static bool IsOdd(int ToCheck)
    {
        return ((ToCheck % 2 != 0) ? true : false);
    }
}
}

यह लेता है लगभग 82 सेकंड खोजने के लिए और एक 2.40 GHz प्रोसेसर के साथ 1,000,000 1 की एक सीमा के भीतर रूढ़ अंक प्रिंट, मेरे कोर 2 डुओ लैपटॉप पर करने के लिए। और इसमें 78,498 प्राइम नंबर पाए गए ।

Comments

यह रास्ता बहुत धीमा है। समस्या यह है i <= (ToCheck / 3)। यह होना चाहिए i <= (ToCheck / i)। इसके साथ, यह बजाय 0.1 सेकंड में चल सकता है।

— विल नेस

Answer 10

#include<stdio.h>
main()
{
    long long unsigned x,y,b,z,e,r,c;
    scanf("%llu",&x);
    if(x<2)return 0;
    scanf("%llu",&y);
    if(y<x)return 0;
    if(x==2)printf("|2");
    if(x%2==0)x+=1;
    if(y%2==0)y-=1;
    for(b=x;b<=y;b+=2)
    {
        z=b;e=0;
        for(c=2;c*c<=z;c++)
        {
            if(z%c==0)e++;
            if(e>0)z=3;
        }
        if(e==0)
        {
            printf("|%llu",z);
            r+=1;
        }
    }
    printf("|\n%llu outputs...\n",r);
    scanf("%llu",&r);
}    

Comments

आर का उपयोग आरंभिक होने से पहले किया जाता है

— zumalifeguard

Answer 11

मैं किसी पूर्वनिर्धारित एल्गोरिथ्म के बारे में नहीं जानता, लेकिन मैंने अपना स्वयं का बनाया जो बहुत तेज़ है। यह 1 सेकंड से भी कम समय में 20 अंकों की संख्या को संसाधित कर सकता है। इस कार्यक्रम की अधिकतम क्षमता 18446744073709551615 है। यह कार्यक्रम है:

#include <iostream>
#include <cmath>
#include <stdlib.h>

using namespace std;

unsigned long long int num = 0;

bool prime() {
    if (num % 2 == 0 || num == 1) {
        return false;
    }

    unsigned long int square_root = sqrt(num);
    for (unsigned long int i = 3; i <= square_root; i += 2) {
        if (num % i == 0) {
            return false;
        }
    }

    return true;
}

int main() {
    do {
        system("cls");
        cout << "Enter number : ";
        cin >> num;

        if (prime()) {
            cout << "The number is a prime number" << endl << endl << endl << endl;
        } else {
            cout << "The number is not a prime number" << endl << endl << endl << endl;
        }
        system("pause");
    } while (1);

    return 0;
}

Answer 12

#include <iostream>

using namespace std;

int set [1000000];

int main (){

    for (int i=0; i<1000000; i++){
        set [i] = 0;
    }
    int set_size= 1000;
    set [set_size];
    set [0] = 2;
    set [1] = 3;
    int Ps = 0;
    int last = 2;

    cout << 2 << " " << 3 << " ";

    for (int n=1; n<10000; n++){
        int t = 0;
        Ps = (n%2)+1+(3*n);
        for (int i=0; i==i; i++){
            if (set [i] == 0) break;
            if (Ps%set[i]==0){
                t=1;
                break;
            }
        }
        if (t==0){
            cout << Ps << " ";
            set [last] = Ps;
            last++;
        }
    }
    //cout << last << endl;


    cout << endl;

    system ("pause");
    return 0;
}

Comments

यह "वास्तव में GOTO का उपयोग किए बिना असंरचित कोड कैसे लिखना है" पर एक उत्तर होना चाहिए। यह सब सिर्फ एक साधारण परीक्षण विभाजन को कोड करने के लिए भ्रम की स्थिति है! (n%2)+1+(3*n)हालांकि अच्छा की तरह है। :)

— विल नेस

@Will Ness मैंने उस प्रश्न के उत्तर के रूप में इसे अस्वीकृत कर दिया होगा; लूप के लिए एक मैक्रो का उपयोग क्यों करेंगे? :)

— रोब अनुदान

Answer 13

मुझे पता है कि यह कुछ समय बाद है, लेकिन यह खोज से यहां पहुंचने वाले लोगों के लिए उपयोगी हो सकता है। वैसे भी, यहां कुछ जावास्क्रिप्ट इस तथ्य पर निर्भर करती है कि केवल प्रमुख कारकों का परीक्षण करने की आवश्यकता है, इसलिए कोड द्वारा उत्पन्न पहले के primes का उपयोग बाद के लोगों के लिए परीक्षण कारकों के रूप में फिर से किया जाता है। बेशक, सभी समान और आधुनिक 5 मान पहले फ़िल्टर किए गए हैं। परिणाम सरणी P में होगा, और यह कोड एक i7 पीसी (या लगभग 20 में 100 मिलियन) पर 1.5 सेकंड से कम में 10 मिलियन prunch को क्रंच कर सकता है। सी में फिर से लिखा यह बहुत तेज होना चाहिए।

var P = [1, 2], j, k, l = 3

for (k = 3 ; k < 10000000 ; k += 2)
{
  loop: if (++l < 5)
  {
    for (j = 2 ; P[j] <= Math.sqrt(k) ; ++j)
      if (k % P[j] == 0) break loop

    P[P.length] = k
  }
  else l = 0
}

Comments

यदि आप बड़ी संख्या में प्राइम उत्पन्न कर रहे हैं, तो आपको बहुत सारी परेशानियाँ मिलेंगी, और तुलनाओं के लिए, बेहतर उपयोग पी [जे] * पी [जे] <= k, क्योंकि sqrt बहुत धीमा है

— साइमन

Answer 14

#include<iostream>
using namespace std;

void main()
{
    int num,i,j,prime;
    cout<<"Enter the upper limit :";
    cin>>num;

    cout<<"Prime numbers till "<<num<<" are :2, ";

    for(i=3;i<=num;i++)
    {
        prime=1;
        for(j=2;j<i;j++)
        {
            if(i%j==0)
            {
                prime=0;
                break;
            }
        }

        if(prime==1)
            cout<<i<<", ";

    }
}

Comments

यह इस बारे में सबसे धीमी गति से हो सकता है।

— विल नेस

यह बहुत धीमा है, अगर ऊपरी सीमा 10000000 बताती है तो यह कोड बहुत समय लेगा !!

— दीक्षित सिंगला

यह कोड O (N ^ 2 / log N) है। इसके बिना break;भी धीमा होगा, हे (एन ^ 2), लेकिन इसे पहले से ही कोडिंग त्रुटि के रूप में देखा जा सकता है। primes द्वारा बचत और परीक्षण O (N ^ 2 / (log N) ^ 2) है, और केवल संख्या वर्गमूल से नीचे के primes द्वारा परीक्षण O (N ^ 1.5 / (log N) ^ 2) है।

— विल नेस

@WillNess शायद थोड़ा अतिशयोक्तिपूर्ण है। वह आसानी से 2 के बजाय 1 से लूप के लिए शुरू कर सकता था, और j <i के बजाय j <= i जोड़ा। :)

— केनी कैसन

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

— विल नेस