📜  离散数学中的素数

📅  最后修改于: 2021-09-28 10:18:42             🧑  作者: Mango

概述 :
整数 p>1 称为素数,如果 p 的唯一正除数是 1 和 p,则称为素数。不是素数的整数 q>1 称为合数。

例子 –
整数2、3、5、7和11是素数,整数4、6、8和9是合数。

定理 1:
整数 p>1 是素数当且仅当对于所有整数 a 和 b,p 除 ab 意味着 p 除 a 或 p 除 b。

例子 –
考虑整数 12。现在 12 除以 120 = 30 x 4 但 12|30 和 12|4。因此,12 不是质数。

定理2:
每个整数 n>=2 都有一个质因数。

定理3:
如果 n 是合整数,则 n 有一个不超过 √n 的素因数。

示例-1:
确定以下哪些整数是素数?

a) 293 b) 9823

解决方案 –

  1. 我们首先找到所有质数 p 使得 p 2 < = 293。这些质数是 2,3,5,7,11,13 和 17。现在,这些质数都不能整除 293。因此,293 是质数。
  2. 我们考虑素数 p 使得 p2< = 9823。这些素数是 2,3,5,7,11,13,17 等。2,3,5,7 都不能整除 9823。然而,11 整除 9823。因此, 9823 不是质数。

示例 2 :
令n 是一个正整数,使得n 2 -1 是素数。那么 n =?

解决方案 –
我们可以写出,n 2 -1 = (n-1)(n 2 +n+1)。因为n 3 -1 是素数,要么n-1 = 1,要么n 2 +n+1 = 1。现在n>=1,所以n 2 +n+1 > 1,即n 2 +n+1 != 1.因此,我们必须有 n-1 = 1。这意味着 n = 2。

示例 3 :
令 p 为质数,使得 gcd(a, p 3 )=p 和 gcd(b,p 4 )=p。找到 gcd(ab,p 7 )。

解决方案 –
根据给定条件,gcd(a,p 3 )=p。因此,p |一种。此外,p 2 |a.(如果p 2 | a,则gcd (a,p 3 )>=p 2 >p,这是一个矛盾。)现在a 可以写成素数的乘积。因为 p|a 和 p 2 | a,因此 p 出现在 a 的素数分解中的一个因子,但是 p k ,其中 k>=2,没有出现在那个素数分解中。类似地,gcd(b,p 4 )=p 意味着 p|b 和 p 2 |b。和以前一样,p 出现在 a 的素数分解中的一个因子,但是 p k ,其中 k>=2,没有出现在那个素数分解中。现在得到 p 2 |ab 和 p 3 |ab。因此, gcd(b,p 7 ) = p 2

素性测试算法:

for i: [2,N-1]
  if i divides N
     return "Composite"
     
return "Prime"        

例子 –
举个例子,让算法更高效,36=

1×36
2×18
3×12
(a=4)x(b=9)
6×6
9×4 (repeated)
12×3 (repeated)
18×2 (repeated)
36×1 (repeated)
Take the inputs of a and b until,    
 a<=b
                                                                
 a . b = N
 a . N/a = N

修改后的算法:

for i : [2,√n]
   if i divides N
     return "Composite"
     
return "Prime"    
C++
// C++ program to check primality of a number
#include 
using namespace std;
  
bool is_prime(int n){
   for(int i = 2; i * i <= n; i++){
     if(n % i == 0){
       return false; 
       //if the number is composite or not prime.
     }
   }
  return true; 
    // number is prime.
} 
int main() {
  
    int n;
    cin >> n;
    cout << is_prime(n) ? "prime" : "composite";
    return 0;
}


Java
// Java program to check primality of a number
  
/*package whatever //do not write package name here */
  
import java.util.*;
class prime{
    public Boolean is_prime(int n){
        for(int i = 2; i * i <= n; i++){
            if(n % i == 0){
                return false; 
              //if the number is composite or not prime.
            }
        }
        return true;
      // number is prime.
    }
  
}
  
class GFG {
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        prime ob = new prime();
        System.out.println(ob.is_prime(n) ? "Prime" : "Composite");
    }
}


求素数的算法:
在数学中,Eratosthenes 筛法是一种古老的算法,用于查找任何给定限制内的所有素数。

Algorithm Sieve of Eratosthenes is input: an integer n > 1.
output : all prime numbers from 2 through n.

let A be an array of Boolean values, indexed by integers 2 to n,
initially all set to true.
    
    for i = 2, 3, 4, ..., not exceeding √n do
        if A[i] is true
            for j = i2, i2+i, i2+2i, i2+3i, ..., not exceeding n do
                A[j] := false

    return all i such that A[i] is true.