[Projecte1_] projecteuler_051 (find the minimum prime number that can be obtained by changing the same part)

Source: Internet
Author: User
# Pragma once # include <windows. h> # include <vector> # include <set> using namespace STD; Class moonmath {public: moonmath (void );~ Moonmath (void ); //************************************// method: isint // access: Public // describe: determines whether the double value is very close to an integer in the Epsilon range. // if the value of 1.00005 is greater than 0.00005, It is very close to an integer. // parameter: double doublevalue: the double value to be determined. // parameter: Double Epsilon: The accuracy of the determination. If 0 <Epsilon <0.5 // parameter: int32 & intvalue is close, returns the nearest integer // returns: bool returns true, otherwise, false is returned //*********************************** * Static bool isint (double doublevalue, double Epsilon, int32 & intvalue ); //************************************// method: sign // access: Public // describe: Get the value symbol // parameter: T value to get the value of the symbol // returns: positive, 0, and negative numbers of int32 return 1, 0, and-1, respectively //************************ * *********** template <typename T> static int32 sign (T value ); const static uint32 min_primer = 2; // minimum prime number //********************************** ** // method: isprimer // access: Public // describe: determines whether a number is a prime number. // parameter: uint32 num indicates the number to be judged. // returns: bool indicates a prime number and returns true, otherwise, false is returned //*********************************** * Static bool isprimer (uint32 num ); //************************************// method: isintegersquare // access: public static // describe: determines whether the given number is an integer after the square is opened. // parameter: uint32 num // returns: bool // ************************************ static bool isintegersquare (uint32 num ); //************************************// method: getdiffprimerfactornum // access: public static // describe: gets all the different quality factors of num // parameter: uint32 num // returns: set <uint32> //********************************** ** static set <uint32> moonmath:: getdiffprimerfactornum (uint32 num );};
# Include "moonmath. H" # include <cmath> moonmath: moonmath (void) {} moonmath ::~ Moonmath (void) {}template <typename T> int32 moonmath: Sign (T value) {If (value> 0) {return 1;} else if (value = 0) {return 0;} else {return-1 ;}} bool moonmath: isint (double doublevalue, double Epsilon, int32 & intvalue) {If (epsilon> 0.5 | Epsilon <0) {return false;} If (int32 (doublevalue + epsilon) = int32 (doublevalue-Epsilon) {return false ;} int32 value = int32 (doublevalue); intvalue = (FABS (doublevalue-value)> 0.5 )? (Value + moonmath: Sign (doublevalue): (value); Return true;} bool moonmath: isprimer (uint32 num) {If (Num <min_primer) {return false;} If (num = min_primer) {return true;} // you can determine whether it can be divisible by 2 if (Num & 1) = 0) {return false;} uint32 sqrtofnum = (uint32) SQRT (double) num); // The 2nd power of num // from min_primer to SQRT (Num ), if no number can be divisible by num, num is a prime number, otherwise it is not for (uint32 I = min_primer + 1; I <= sqrtofnum; I + = 2) {If (Num % I = 0) {return false;} return true;} bool moonmath: isintegersquare (uint32 num) {uint32 qurtnum = (uint32) SQRT (double) num ); return (qurtnum * qurtnum) = num;} set <uint32> moonmath: getdiffprimerfactornum (uint32 num) {uint32 halfnum = num/2; set <uint32> factors; for (uint32 I = 2; I <= halfnum; ++ I) {If (! Moonmath: isprimer (I) {continue;} If (Num % I = 0) {factors. insert (I); While (Num % I = 0) {num/= I ;}} return factors ;}
// Prime digit replacements // problem 51 // by replacing the 1st digit of * 3, it turns out that six of the nine possible values: 13, 23, 43, 53, 73, and 83, are all prime. /// by replacing the 3rd and 4th digits of 56 ** 3 with the same digit, this 5-digit number is the first example having seven Primes among the ten generated numbers, yielding the family: 56003,561 13, 56333,564 43, 56663,567 73, and 56993. consequently 56003, being the first member of this family, is the smallest prime with this property. /// find the smallest prime which, by replacing part of the number (not necessarily adjacent digits) with the same digit, is part of an eight prime value family. /// Question 51: Find the minimum number of prime numbers that can be obtained by changing the same part. // Six of the 9 Numbers obtained by replacing the first digit of * 3 are prime numbers:, 53, 73, and 83. /// Replace the third and fourth digits of 56 ** 3 with the same number. The fifth digit is the first digit that can obtain seven prime numbers. The prime number obtained is: 56003,561 13, 56333,564 43, 56663,567 73, and 56993. Therefore, the minimum 56003 is the smallest prime number with this property. /// Find the minimum prime number. You can use the same number to replace a portion of the prime number (not necessarily adjacent) to obtain eight prime numbers. # Include <iostream> # include <windows. h> # include <ctime> # include <assert. h> # include <vector> # include <moonmath. h> using namespace STD; // class detailprinter {public: void start (); void end (); detailprinter (); Private: large_integer timestart; large_integer timeend; large_integer freq ;}; detailprinter: detailprinter () {queryperformancefrequency (& freq );} //************************************// me Thod: Start // access: Public // describe: Call before executing each method // returns: void // *********************************** void detailprinter:: Start () {queryperformancecounter (& timestart );} //************************************// method: end // access: Public // describe: Call each method after execution // returns: void // *********************************** void detailprinter:: end () {queryperformancecounter (& timeend); cout <"Total millisec Onds is "<(double) (timeend. quadpart-timestart. quadpart) * 1000/freq. quadpart <Endl; const char beep_char = '\ 007 '; cout <Endl <"by godmoon" <Endl <_ timestamp _ <beep_char <Endl; System ("pause ");} ************ * *******************/const uint32 radio = 10; // In hexadecimal notation // The minimum Prime Number of a record, the number that can be increased and the number of times that can be increased. // For example, 56003, the number that can be increased is 100,110, 10, and the number of times that can be increased is 9, 9, respectively, 9 struct fitinfo {uint32 Num; vector <uint32> incnums; vector <uint32> maxinctimes; void clear (); void addincnum (uint32 incnum, uint32 maxinctimes );}; //************************************// method: clear // access: Public // describe: clear information // returns: void // *********************************** void fitinfo:: clear () {num = 0; incnums. clear (); maxinctimes. clear ();} //************************************// method: addincnum // ACC ESS: Public // describe: // parameter: uint32 incnum // parameter: uint32 maxinctimes // returns: void // *********************************** void fitinfo:: addincnum (uint32 incnum, uint32 maxinctimes) {incnums. push_back (incnum); maxinctimes. push_back (maxinctimes );} //************************************// method: getfitinfo // access: Public // describe: Get the information of this number, replace the same continuous number // parameter: uint32 num // paramet Er: fitinfo & fitinfo // returns: void // *********************************** void getadjacentfitinfo (uint32 num, fitinfo & fitinfo, uint32 familyprimercount) {uint32 numbak = num; // back up num for loop uint32 currdigit; // the number currently processed uint32 lastdigit = num % radio; // The number processed in the previous step. It is initialized to the first digit uint32 currweight = 1; // the weight of the current bit, which is 100 ...... Uint32 currincnum = 0; // number of available numbers of the current num uint32 addnum; // used to incrementally calculate the number of continuously available increments uint32 incnum; // used to save the continuously available increments fitinfo. clear (); fitinfo. num = num; while (numbak! = 0) {currdigit = numbak % radio; If (currdigit <= radio-familyprimercount) {// if the previous number is the same as the current number, add the combination to fitinfo if (lastdigit = currdigit) {currincnum + = currweight; addnum = currweight; For (incnum = currweight; incnum <currincnum; incnum + = addnum) {addnum/= radio; fitinfo. addincnum (incnum, radio-currdigit-1) ;}} if the else is inconsistent, add only currweight currincnum = currweight;} fitinfo. addincnum (C Urrincnum, radio-currdigit-1);} else {currincnum = 0;} currweight * = 10; lastdigit = currdigit; numbak/= radio ;}} //************************************// method: getnummap // access: Public // describe: Get // parameter: uint32 num // parameter: uint32 digitincnum [] binary number map, the location of the index number in decimal format. // parameter: uint32 radio // returns: void // *********************************** void getnummap (uint32 Num, uint32 digitincmap [], uint32 radio) {uint32 currdigit; uint32 currweight = 1; while (num! = 0) {currdigit = num % radio; digitincmap [currdigit] | = currweight; currweight <= 1; num/= radio ;}} //************************************// method: getincweight // access: Public // describe: Obtain the weighted value according to the Binary Map. // parameter: uint32 digitincmap, for example, 1010b // parameter: vector <uint32> & incweight, for example: 1000,10 // returns: void // *********************************** void getincweight (uint32 digitincmap, vector <UI Nt32> & incweight) {uint32 currweight = 1; incweight. Clear (); While (digitincmap! = 0) {If (digitincmap & 1) {incweight. push_back (currweight);} currweight * = radio; digitincmap >>=1 ;}} //************************************// method: getvalue // access: Public // describe: Get the value from map and weight // parameter: uint32 map data bit, for example: 101 // parameter: vector <uint32> & incweight weight, for example: 1000,100, 1 // returns: uint32 value: for example: 1001 // *********************************** uint32 getvalue (uint32 map, const Vector <Uint32> & incweight) {uint32 value; uint32 index; For (value = 0, Index = 0; Map; ++ index) {If (MAP & 1) {value + = incweight [Index];} map >>=1;} return value ;} //************************************// method: parsedigitmap // access: Public // describe: Calculate the fitinfo/parameter: uint32 digitincmap of the corresponding number from digitincmap, which indicates the location of the digit, for example, 10101101 // parameter: uint32 digit range: [0, radio), indicating a number // parameter: Fit Info & fitinfo // returns: void // *********************************** void parsedigitmap (uint32 digitincmap, uint32 digit, fitinfo & fitinfo) {vector <uint32> incweight; getincweight (digitincmap, incweight); uint32 maxmapvalue = 1 <incweight. size (); For (uint32 mapvalue = 1; mapvalue <maxmapvalue; ++ mapvalue) {fitinfo. addincnum (getvalue (mapvalue, incweight), radio-digit-1 );}}//**************** * ****************** // Method: getfitinfo // access: Public // describe: Get the information of this number, replace the inconsistent numbers // parameter: uint32 num // parameter: fitinfo & fitinfo // returns: void // *********************************** void getnotadjacentfitinfo (uint32 num, fitinfo & fitinfo, uint32 familyprimercount) {uint32 digitincmap [radio] = {0}; fitinfo. clear (); fitinfo. num = num; getnummap (Num, digitincmap, radio); For (uint32 Digit = 0; digit <radio; ++ digit) {parsedigitmap (digitincmap [digit], digit, fitinfo );}} //************************************// method: calcmaxprimercount // access: Public // describe: gets the number of prime numbers in this family. // parameter: const fitinfo & fitinfo // returns: uint32 // *********************************** uint32 calcmaxprimercount (const fitinfo & fitinfo, uint32 & maxfitincnum, uint32 & maxfittimes) {uint32 maxprimer Count = 0; uint32 currprimercount = 1; uint32 fitcount = fitinfo. incnums. size (); uint32 currnum; uint32 fitindex; uint32 fitinctimes; uint32 fitinccount; uint32 fitincnum; For (fitindex = 0; fitindex <fitcount; ++ fitindex) {currprimercount = 1; // initialize to 1 because fitinfo. num is already a prime number. currnum = fitinfo. num; fitincnum = fitinfo. incnums [fitindex]; fitinctimes = fitinfo. maxinctimes [fitindex]; for (fitinccount = 0; fitinccount <fitinctimes; ++ fitinccount) {currnum + = fitincnum; If (moonmath: isprimer (currnum) {++ currprimercount; If (currprimercount> maxprimercount) {maxfitincnum = fitincnum; maxfittimes = fitinctimes; maxprimercount = currprimercount ;}}}return maxprimercount;} void testfun1 () {fitinfo; Ratio (100, fitinfo, 8 ); cout <"test OK! "<Endl;} void F1 () {cout <" Void F1 () "<Endl; // testfun1 (); detailprinter. start (); /********************************** algorithm start **** * *************************/const uint32 family_primer_count = 6; // The number of prime numbers in the prime family: fitinfo; uint32 maxfitincnum; uint32 maxfittimes; For (uint32 num = 3; num + = 2) {If (moonmath: isprimer (Num )) {getnotadjacentfitinfo (Num, fitinfo, family_primer_count); If (calcmaxprimercount (fitinfo, maxfitincnum, maxfittimes) >=family_primer_count) {break ;}}} cout <"has at least" <family_primer_count <"the smallest prime number in the prime family of prime numbers is" <fitinfo. num <Endl <"other members of the prime family:"; uint32 primer = fitinfo. num; For (uint32 I = 0; I <maxfittimes; ++ I) {primer + = maxfitincnum; If (moonmath: isprimer (primer )) {cout <primer <"" ;}} cout <Endl; /*********************************** end of the algorithm **** * **************************/detailprinter. end () ;}// main function int main () {F1 (); Return 0 ;}/ * void F1 () the smallest prime in a prime family with at least 6 prime numbers is 13. Other members are 23 43 53 73 83 total milliseconds is 4.50833by godmoonsun Mar 24 21:44:13 2013 void F1 () the smallest prime number in a prime family with at least 7 prime numbers is 56003. Other members: 56113 56333 56443 56663 56773 56993 total milliseconds is 481.138by godmoonsun Mar 24 21:43:49 2013 void F1 () the smallest prime number in a prime family with at least 8 prime numbers is 121313. Other members: 222323 323333 424343 525353 626363 828383 929393 total milliseconds is 1023.6by godmoonsun Mar 24 21:41:17 2013 */
Large-Scale Price Reduction
  • 59% Max. and 23% Avg.
  • Price Reduction for Core Products
  • Price Reduction in Multiple Regions
undefined. /
Connect with us on Discord
  • Secure, anonymous group chat without disturbance
  • Stay updated on campaigns, new products, and more
  • Support for all your questions
undefined. /
Free Tier
  • Start free from ECS to Big Data
  • Get Started in 3 Simple Steps
  • Try ECS t5 1C1G
undefined. /

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.