欢迎使用优快云-markdown编辑器

最新推荐文章于 2021-01-07 23:01:28 发布

原创最新推荐文章于 2021-01-07 23:01:28 发布 · 266 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#sicily #互联网

c++ 专栏收录该内容

7 篇文章

订阅专栏

本文深入探讨了如何通过特定算法计算所有小于2^k（k<=63）的Mersenne复合数，并揭示了它们背后的数学原理。通过将每个复合数分解为质因数并展示其形成过程，读者将领略到数学与计算机科学的完美结合。

Mersenne Composite N

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

Description

One of the world-wide cooperative computing tasks is the “Grand Internet Mersenne Prime Search” – GIMPS – striving to find ever-larger prime numbers by examining a particular category of such numbers.
A Mersenne number is defined as a number of the form (2p–1), where p is a prime number – a number divisible only by one and itself. (A number that can be divided by numbers other than itself and one are called “composite” numbers, and each of these can be uniquely represented by the prime numbers that can be multiplied together to generate the composite number — referred to as its prime factors.)
Initially it looks as though the Mersenne numbers are all primes.
Prime Corresponding Mersenne Number
2 4–1 = 3 – prime
3 8–1 = 7 – prime
5 32–1 = 31 – prime
7 128–1 = 127 – prime
If, however, we are having a “Grand Internet” search, that must not be the case.
Where k is an input parameter, compute all the Mersenne composite numbers less than 2k – where k <= 63 (that is, it will fit in a 64-bit signed integer on the computer). In Java, the “long” data type is a signed 64 bit integer. Under gcc and g++ (C and C++ in the programming contest environment), the “long long” data type is a signed 64 bit integer.
Input

Input is from file a. in. It contains a single number, without leading or trailing blanks, giving the value of k. As promised, k <= 63.

Output

One line per Mersenne composite number giving first the prime factors (in increasing order) separate by asterisks, an equal sign, the Mersenne number itself, an equal sign, and then the explicit statement of the Mersenne number, as shown in the sample output. Use exactly this format. Note that all separating white space fields consist of one blank.

Sample Input

31
Sample Output

23 * 89 = 2047 = ( 2 ^ 11 ) - 1
47 * 178481 = 8388607 = ( 2 ^ 23 ) - 1
233 * 1103 * 2089 = 536870911 = ( 2 ^ 29 ) - 1

#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
using namespace std;

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

int main(int argc, char **argv)
{
    int k;
    cin >> k;
    int i;
    for (i = 3; i < k; i += 2) {
        if (!isPrime(i)) continue;
        //如果是素数，对其进行分解
        long long bigNum = (long long) pow(2.0, i) - 1;
        long long temp;
        temp  = bigNum;
        bool first = false, isCome = false;
        for (long long j = 3; j * j <= bigNum; j += 2) {
            if (bigNum % j == 0 && isPrime(j)) { //不是素数
                if (first == false)  cout << j;
                else cout << " * " << j;
                bigNum /= j;
                j = 3;
                first = true;
                isCome = true;
            }
        }

        if (isCome) {
            cout << " * " << bigNum;
            cout << " = " << temp  << " = ( 2 ^ " <<  i << " ) - 1" << endl;
        }

    }
    return 0;
}