दिलचस्प पोस्ट
एकाधिक INNER SQL एक्सेस में शामिल हों UWP ऐप में ओवरव्राइड पिवट हेडर अग्रभूमि ब्रश (10 आरटीएम एसडीके जीतें) जावा में चर परिभाषा के लिए इंटरफ़ेस या प्रकार का उपयोग करें? WPF में, मैं यह कैसे निर्धारित कर सकता हूं कि नियंत्रण उपयोगकर्ता के लिए दिखाई दे रहा है? मैं सप्ताह के दिन को पायथन में दिनांक कैसे प्राप्त करूं? बाइट इवेंट को राइट माउस क्लिक करें HTTP के माध्यम से दर्शकों को फायरबेज की सूचनाएं कैसे भेजें पृष्ठभूमि का उपयोग करने और अधिसूचना बनाने के लिए सेवा का उपयोग करना लापता पुश अधिसूचना एंटाइटेलमेंट फायरबसे पर छवियों को कैसे संग्रहीत और देखना है? JSFiddle कोड मेरे अपने पृष्ठ में काम नहीं कर रहा है सी # – एक System.Drawing.Bitmap करने के लिए WPF Image.source कन्वर्ट जावा पर एक संग्रह से आइटम्स हटाने पर इसे फिर से चलाना पीएचपी के साथ दूसरे पेज पर फॉर्म डेटा पास करें आईईईई फ्लोट्स की तुलना और समानता के लिए युगल

यदि कोई संख्या प्रधान है तो यह निर्धारित करना

मैंने इस विषय पर बहुत सारे कोड देखे हैं, लेकिन उनमें से ज्यादातर संख्याओं का उत्पादन करते हैं जो इनपुट संख्या तक सभी तरह के प्रमुख हैं। हालांकि, मुझे कोड की आवश्यकता है जो केवल जांचता है कि क्या दिया गया इनपुट संख्या प्रधान है

यहां मैं जो लिखने में सक्षम था, लेकिन यह काम नहीं करता है:

void primenumber(int number) { if(number%2!=0) cout<<"Number is prime:"<<endl; else cout<<"number is NOt prime"<<endl; } 

मैं इसकी सराहना करता हूं अगर कोई मुझे इस काम को ठीक से कैसे तैयार करने के बारे में सलाह दे सकता है

अद्यतन करें

मैंने इसे संशोधित करने के लिए सभी नंबरों पर लूप के लिए जांच की।

 void primenumber(int number) { for(int i=1; i<number; i++) { if(number%i!=0) cout<<"Number is prime:"<<endl; else cout<<"number is NOt prime"<<endl; } } 

Solutions Collecting From Web of "यदि कोई संख्या प्रधान है तो यह निर्धारित करना"

आपको कुछ और जांच करने की आवश्यकता है अभी, आप केवल जांच कर रहे हैं कि संख्या 2 से विभाज्य है। 2, 3, 4, 5, 6, … के लिए number ऊपर के number । संकेत: एक पाश का उपयोग करें

आप इसका समाधान करने के बाद, ऑप्टिमाइज़ेशन की तलाश करने का प्रयास करें। संकेत: आपको केवल संख्याओं के वर्गमूल तक सभी नंबरों को जांचना होगा

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

 __int64 power(int a, int n, int mod) { __int64 power=a,result=1; while(n) { if(n&1) result=(result*power)%mod; power=(power*power)%mod; n>>=1; } return result; } bool witness(int a, int n) { int t,u,i; __int64 prev,curr; u=n/2; t=1; while(!(u&1)) { u/=2; ++t; } prev=power(a,u,n); for(i=1;i<=t;++i) { curr=(prev*prev)%n; if((curr==1)&&(prev!=1)&&(prev!=n-1)) return true; prev=curr; } if(curr!=1) return true; return false; } inline bool IsPrime( int number ) { if ( ( (!(number & 1)) && number != 2 ) || (number < 2) || (number % 3 == 0 && number != 3) ) return (false); if(number<1373653) { for( int k = 1; 36*k*k-12*k < number;++k) if ( (number % (6*k+1) == 0) || (number % (6*k-1) == 0) ) return (false); return true; } if(number < 9080191) { if(witness(31,number)) return false; if(witness(73,number)) return false; return true; } if(witness(2,number)) return false; if(witness(7,number)) return false; if(witness(61,number)) return false; return true; /*WARNING: Algorithm deterministic only for numbers < 4,759,123,141 (unsigned int's max is 4294967296) if n < 1,373,653, it is enough to test a = 2 and 3. if n < 9,080,191, it is enough to test a = 31 and 73. if n < 4,759,123,141, it is enough to test a = 2, 7, and 61. if n < 2,152,302,898,747, it is enough to test a = 2, 3, 5, 7, and 11. if n < 3,474,749,660,383, it is enough to test a = 2, 3, 5, 7, 11, and 13. if n < 341,550,071,728,321, it is enough to test a = 2, 3, 5, 7, 11, 13, and 17.*/ } 

का उपयोग करने के लिए, अपने कार्यक्रम के शीर्ष में कोड कॉपी और पेस्ट करें। इसे बुलाओ, और यह एक BOOL मान देता है, या तो सत्य या गलत।

 if(IsPrime(number)) { cout << "It's prime"; } else { cout<<"It's composite"; } 

अगर आपको "__int64" के साथ संकलन करने में समस्या आती है, तो इसे "लंबा" के साथ बदलें यह VS2008 और VS2010 के तहत ठीक संकलित

यह कैसे काम करता है: फ़ंक्शन के तीन भाग हैं। यह देखने के लिए कि क्या यह दुर्लभ अपवादों (नकारात्मक संख्याएं, 1) में से एक है, और प्रोग्राम के चलने को अवरुद्ध करता है,

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

यदि आप एक ब्रूट बल विधि पर जोर देते हैं, तो यहां केवल मेरे अनुकूलित ब्रूट बल ISPrime () फ़ंक्शन है:

 inline bool IsPrime( int number ) { if ( ( (!(number & 1)) && number != 2 ) || (number < 2) || (number % 3 == 0 && number != 3) ) return (false); for( int k = 1; 36*k*k-12*k < number;++k) if ( (number % (6*k+1) == 0) || (number % (6*k-1) == 0) ) return (false); return true; } } 

यह क्रूर बल टुकड़ा कैसे काम करता है: सभी प्रमुख संख्याएं (2 और 3 को छोड़कर) 6k + 1 या 6k-1 के रूप में व्यक्त की जा सकती हैं, जहां कश्मीर एक सकारात्मक पूर्ण संख्या है। यह कोड इस तथ्य का उपयोग करता है, और प्रश्न में संख्या के वर्गमूल से 6k + 1 या 6k-1 के रूप में सभी नंबरों का परीक्षण करता है। यह टुकड़ा मेरे बड़े आईएसपीआरएम () फ़ंक्शन (पहले दिखाए गए फ़ंक्शन) में एकीकृत किया गया है।

यदि आपको किसी संख्या के नीचे सभी प्रमुख संख्याओं को खोजने की आवश्यकता है, तो 1000 से नीचे की सभी प्रमुख संख्याओं को ढूंढें, सिरा ऑफ इरोटोथिनेस में देखें। मेरा एक और पसंदीदा

एक अतिरिक्त नोट के रूप में, मुझे एल्प्टीकल वक्र विधि एल्गोरिथ्म को लागू करने के लिए किसी को भी देखना अच्छा लगेगा, यह देखने के लिए कि कुछ समय के लिए सी ++ में कार्यान्वित किया गया है, मैंने इसे अपना क्रियान्वयन खो दिया है सैद्धांतिक रूप से, यह नियन्त्रणवादी रबीन मिलर एल्गोरिथम के मुकाबले कहीं ज्यादा तेज है, हालांकि मुझे यकीन नहीं है कि यह 4 अरब से कम की संख्या के लिए सही है।

 bool isPrime(int number){ if(number < 2) return false; if(number == 2) return true; if(number % 2 == 0) return false; for(int i=3; (i*i)<=number; i+=2){ if(number % i == 0 ) return false; } return true; } 

मुझे लगता है कि sqrt लेने और foreach frpm 2 को sqrt + 1 पर चलाना होगा अगर (इनपुट% संख्या! = 0) वापस लौट आए; एक बार जब आप एसक्यूआरटी + 1 तक पहुंच जाते हैं तो आप यह सुनिश्चित कर सकते हैं कि इसके प्रधान

यदि आप इनपुट की सीमा जानते हैं (जो आप करते हैं, तो आपका फ़ंक्शन किसी int लेता है), तो आप अधिकतम इनपुट (इस मामले में 2 ^ 31-1) के वर्गमूल से कम या उसके बराबर की एक तालिका की प्रीकंपूप्शन कर सकते हैं। और फिर तालिका में हर प्रधान के द्वारा विभाज्यता के लिए जांच की गई संख्या के वर्गमूल से कम या उसके बराबर की परीक्षा।

 // C++ bool isPrime(int number){ if (number != 2){ if (number < 2 || number % 2 == 0) { return false; } for(int i=3; (i*i)<=number; i+=2){ if(number % i == 0 ){ return false; } } } return true; } // JS function isPrime(number) { if (number !== 2) { if (number < 2 || number % 2 === 0) { return false; } for (var i=3; (i*i)<=number; i+=2) { if (number % 2 === 0){ return false; } } } return true; } // Python def isPrime(number): if (number != 2): if (number < 2 or number % 2 == 0): return False i = 3 while (i*i) < number: if(number % i == 0 ): return False; i += 2 return True; 

यह कोड केवल जांचता है कि संख्या दो से विभाज्य है या नहीं। एक संख्या के लिए प्रधान होने के लिए, यह सभी पूर्णांक से समान रूप से विभाजित नहीं होना चाहिए जो अपने आप से कम है । यह भरोसेमंद रूप से जांच कर लागू किया जा सकता है कि क्या यह floor(sqrt(n)) से कम के सभी पूर्णांकों से विभाज्य है, जो किसी लूप में है। यदि आप रुचि रखते हैं, तो अस्तित्व में बहुत अधिक तेजी से एल्गोरिदम हैं।

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

मैं एक ही एल्गोरिथ्म का अनुसरण करता हूं, लेकिन अलग-अलग कार्यान्वयन के लिए चरण 2 के साथ केवल दो अंकों के साथ sqrt (n) का लूप क्योंकि मैं जांचता हूं कि यदि यह 2 या 2 * कश्मीर से विभाजित है तो यह गलत है। यहाँ मेरा कोड है

 public class PrimeTest { public static boolean isPrime(int i) { if (i < 2) { return false; } else if (i % 2 == 0 && i != 2) { return false; } else { for (int j = 3; j <= Math.sqrt(i); j = j + 2) { if (i % j == 0) { return false; } } return true; } } /** * @param args */ public static void main(String[] args) { for (int i = 1; i < 100; i++) { if (isPrime(i)) { System.out.println(i); } } } } 

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

  bool is_Prime(int n) { int square_root = sqrt(n); // use math.h int toggle = 1; for(int i = 2; i <= square_root; i++) { if(n%i==0) { toggle = 0; break; } } if(toggle) return true; else return false; } 
 bool check_prime(int num) { for (int i = num - 1; i > 1; i--) { if ((num % i) == 0) return false; } return true; } 

किसी भी संख्या के लिए चेक अगर यह एक प्रमुख संख्या है

यहां कार्यक्रम देखें: http://www.cplusplus.com/forum/general/1125/

इस समस्या के कई अलग-अलग अनुमोदन हैं
"औपचारिक" विधि: सभी (अजीब) संख्याओं की संख्या (मूल) तक की कोशिश करें
बेहतर "निष्क्रिय" विधि: केवल हर 6 एन ± 1 की कोशिश करें
संभाव्य परीक्षण: मिलर-राबिन, सोलोवे-स्ट्रास, आदि।

कौन सा दृष्टिकोण सूट आप निर्भर करता है और आप प्रधानमंत्री के साथ क्या कर रहे हैं।
आपको प्राइमलिटी टेस्टिंग पर कम से कम पढ़ना चाहिए।

 // PrimeDef.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include<iostream> #include<stdlib.h> using namespace std; const char PRIME = 176; const char NO_PRIME = 178; const int LAST_VALUE = 2000; bool isPrimeNumber( int value ) { if( !( value / 2 ) ) return false; for( int i = 1; ++i <= value / 2; ) if( 0 == value % i ) return false; return true; } int main( int argc, char *argv[ ] ) { char mark; for( int i = -1, count = 1; ++i < LAST_VALUE; count++ ) { mark = NO_PRIME; if( isPrimeNumber( i ) ) mark = PRIME; cout << mark; if(i > 0 && !( count % 50 ) ) cout << endl; } return 0; } 

यहां छवि विवरण दर्ज करें

मैं इस के साथ आया था:

 int counter = 0; bool checkPrime(int x) { for (int y = x; y > 0; y--){ if (x%y == 0) { counter++; } } if (counter == 2) { counter = 0; //resets counter for next input return true; //if its only divisible by two numbers (itself and one) its a prime } else counter = 0; return false; 

}

यदि एन 2 है, तो यह प्रमुख है

यदि एन 1 है, तो यह प्रधानमंत्री नहीं है

यदि एन भी है, तो यह प्रधानमंत्री नहीं है

यदि n अजीब है, 2 से बड़ा है, तो हमें सभी अजीब नंबरों की जांच करनी होगी। 3. sqrt (n) +1, यदि इनमें से कोई संख्या n को विभाजित कर सकती है, n प्रधानमंत्री नहीं है, अन्यथा, एन प्रधान है

बेहतर प्रदर्शन के लिए मैं सुझाव देता हूं कि इरेटोस्टेनेस का छलनी

यहां कोड नमूना है:

 bool is_prime(int n) { if (n == 2) return true; if (n == 1 || n % 2 == 0) return false; for (int i = 3; i*i < n+1; i += 2) { if (n % i == 0) return false; } return true; } 

यदि नंबर प्राइम या नहीं है तो मैं खोज के लिए इस आइडिया का प्रयोग कर रहा हूं:

 #include <conio.h> #include <iostream> using namespace std; int main() { int x, a; cout << "Enter The No. :"; cin >> x; int prime(unsigned int); a = prime(x); if (a == 1) cout << "It Is A Prime No." << endl; else if (a == 0) cout << "It Is Composite No." << endl; getch(); } int prime(unsigned int x) { if (x == 1) { cout << "It Is Neither Prime Nor Composite"; return 2; } if (x == 2 || x == 3 || x == 5 || x == 7) return 1; if (x % 2 != 0 && x % 3 != 0 && x % 5 != 0 && x % 7 != 0) return 1; else return 0; } 
 #define TRUE 1 #define FALSE -1 int main() { /* Local variables declaration */ int num = 0; int result = 0; /* Getting number from user for which max prime quadruplet value is to be found */ printf("\nEnter the number :"); scanf("%d", &num); result = Is_Prime( num ); /* Printing the result to standard output */ if (TRUE == result) printf("\n%d is a prime number\n", num); else printf("\n%d is not a prime number\n", num); return 0; } int Is_Prime( int num ) { int i = 0; /* Checking whether number is negative. If num is negative, making it positive */ if( 0 > num ) num = -num; /* Checking whether number is less than 2 */ if( 2 > num ) return FALSE; /* Checking if number is 2 */ if( 2 == num ) return TRUE; /* Checking whether number is even. Even numbers are not prime numbers */ if( 0 == ( num % 2 )) return FALSE; /* Checking whether the number is divisible by a smaller number 1 += 2, is done to skip checking divisibility by even numbers. Iteration reduced to half */ for( i = 3; i < num; i += 2 ) if( 0 == ( num % i )) /* Number is divisible by some smaller number, hence not a prime number */ return FALSE; return TRUE; } 
 if(number%2!=0) cout<<"Number is prime:"<<endl; 

कोड अविश्वसनीय रूप से गलत है। 33 से विभाजित 2 1 के अनुस्मारक के साथ 16 है, लेकिन यह एक प्रमुख संख्या नहीं है …