Thuật toán tìm hệ số nguyên tố lớn nhất của một số

Cách tiếp cận tốt nhất để tính hệ số nguyên tố lớn nhất của một số là gì?

Tôi nghĩ rằng hiệu quả nhất sẽ là như sau:

1. Tìm số nguyên tố thấp nhất phân chia sạch
2. Kiểm tra xem kết quả của phép chia là số nguyên tố
3. Nếu không, tìm mức thấp nhất tiếp theo
4. Chuyển đến 2.

Tôi dựa trên giả định này để dễ dàng tính toán các thừa số nguyên tố nhỏ. Đây có phải là về phải không? Những cách tiếp cận khác tôi nên xem xét?

Chỉnh sửa: Bây giờ tôi đã nhận ra rằng cách tiếp cận của tôi là vô ích nếu có nhiều hơn 2 yếu tố chính, vì bước 2 thất bại khi kết quả là sản phẩm của hai số nguyên tố khác, do đó cần có thuật toán đệ quy.

Chỉnh sửa lại: Và bây giờ tôi đã nhận ra rằng điều này vẫn hoạt động, bởi vì số nguyên tố tìm thấy cuối cùng phải là số cao nhất, do đó, bất kỳ thử nghiệm nào nữa về kết quả không chính từ bước 2 sẽ dẫn đến một số nguyên tố nhỏ hơn.

Trên thực tế, có một số cách hiệu quả hơn để tìm các yếu tố của số lượng lớn (đối với các phân chia thử nghiệm nhỏ hơn hoạt động hợp lý).

Một phương pháp rất nhanh nếu số đầu vào có hai yếu tố rất gần với căn bậc hai của nó được gọi là hệ số Fermat . Nó sử dụng danh tính N = (a + b) (a - b) = a ^ 2 - b ^ 2 và rất dễ hiểu và thực hiện. Thật không may, nói chung nó không nhanh lắm.

Phương pháp được biết đến nhiều nhất để bao thanh toán các số dài tới 100 chữ số là rây Quadratic . Là một phần thưởng, một phần của thuật toán được thực hiện dễ dàng với xử lý song song.

Một thuật toán khác mà tôi đã nghe nói là thuật toán Rho của Pollard . Nó không hiệu quả như Quadratic Sàng nói chung nhưng dường như dễ thực hiện hơn.

Khi bạn đã quyết định cách chia một số thành hai yếu tố, đây là thuật toán nhanh nhất tôi có thể nghĩ ra để tìm ra thừa số nguyên tố lớn nhất của một số:

Tạo một hàng đợi ưu tiên mà ban đầu lưu trữ số đó. Mỗi lần lặp, bạn loại bỏ số cao nhất khỏi hàng đợi và cố gắng chia nó thành hai yếu tố (tất nhiên không cho phép 1 là một trong những yếu tố đó). Nếu bước này không thành công, số là số nguyên tố và bạn có câu trả lời của mình! Nếu không, bạn thêm hai yếu tố vào hàng đợi và lặp lại.

Đây là thuật toán tốt nhất mà tôi biết (bằng Python)

def prime_factors(n):
    """Returns all the prime factors of a positive integer"""
    factors = []
    d = 2
    while n > 1:
        while n % d == 0:
            factors.append(d)
            n /= d
        d = d + 1

    return factors


pfs = prime_factors(1000)
largest_prime_factor = max(pfs) # The largest element in the prime factor list

Phương pháp trên chạy trong O(n) trường hợp xấu nhất (khi đầu vào là số nguyên tố).

EDIT:
Dưới đây là O(sqrt(n))phiên bản, như được đề xuất trong bình luận. Đây là mã, một lần nữa.

def prime_factors(n):
    """Returns all the prime factors of a positive integer"""
    factors = []
    d = 2
    while n > 1:
        while n % d == 0:
            factors.append(d)
            n /= d
        d = d + 1
        if d*d > n:
            if n > 1: factors.append(n)
            break
    return factors


pfs = prime_factors(1000)
largest_prime_factor = max(pfs) # The largest element in the prime factor list

Câu trả lời của tôi dựa trên Triptych , nhưng cải thiện rất nhiều về nó. Nó dựa trên thực tế là ngoài 2 và 3, tất cả các số nguyên tố có dạng 6n-1 hoặc 6n + 1.

var largestPrimeFactor;
if(n mod 2 == 0)
{
    largestPrimeFactor = 2;
    n = n / 2 while(n mod 2 == 0);
}
if(n mod 3 == 0)
{
    largestPrimeFactor = 3;
    n = n / 3 while(n mod 3 == 0);
}

multOfSix = 6;
while(multOfSix - 1 <= n)
{
    if(n mod (multOfSix - 1) == 0)
    {
        largestPrimeFactor = multOfSix - 1;
        n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0);
    }

    if(n mod (multOfSix + 1) == 0)
    {
        largestPrimeFactor = multOfSix + 1;
        n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0);
    }
    multOfSix += 6;
}

Gần đây tôi đã viết một bài viết trên blog giải thích cách thức hoạt động của thuật toán này.

Tôi sẽ mạo hiểm rằng một phương pháp không cần thử nghiệm tính nguyên thủy (và không có cấu trúc sàng) sẽ chạy nhanh hơn phương pháp sử dụng phương pháp đó. Nếu đó là trường hợp, đây có lẽ là thuật toán nhanh nhất ở đây.

Mã JavaScript:

'option strict';

function largestPrimeFactor(val, divisor = 2) { 
    let square = (val) => Math.pow(val, 2);

    while ((val % divisor) != 0 && square(divisor) <= val) {
        divisor++;
    }

    return square(divisor) <= val
        ? largestPrimeFactor(val / divisor, divisor)
        : val;
}

Ví dụ sử dụng:

let result = largestPrimeFactor(600851475143);

Đây là một ví dụ về mã :

Tương tự như câu trả lời @Triptych nhưng cũng khác. Trong ví dụ này danh sách hoặc từ điển không được sử dụng. Mã được viết bằng Ruby

def largest_prime_factor(number)
  i = 2
  while number > 1
    if number % i == 0
      number /= i;
    else
      i += 1
    end
  end
  return i
end

largest_prime_factor(600851475143)
# => 6857

Tất cả các số có thể được biểu thị dưới dạng tích của số nguyên tố, ví dụ:

102 = 2 x 3 x 17
712 = 2 x 2 x 2 x 89

Bạn có thể tìm thấy những thứ này bằng cách bắt đầu từ 2 và chỉ cần tiếp tục chia cho đến khi kết quả không phải là bội số của bạn:

712 / 2 = 356 .. 356 / 2 = 178 .. 178 / 2 = 89 .. 89 / 89 = 1

sử dụng phương pháp này, bạn không thực sự phải tính toán bất kỳ số nguyên tố nào: tất cả chúng đều là số nguyên tố, dựa trên thực tế là bạn đã tính đến số càng nhiều càng tốt với tất cả các số trước đó.

number = 712;
currNum = number;    // the value we'll actually be working with
for (currFactor in 2 .. number) {
    while (currNum % currFactor == 0) {
        // keep on dividing by this number until we can divide no more!
        currNum = currNum / currFactor     // reduce the currNum
    }
    if (currNum == 1) return currFactor;    // once it hits 1, we're done.
}

    //this method skips unnecessary trial divisions and makes 
    //trial division more feasible for finding large primes

    public static void main(String[] args) 
    {
        long n= 1000000000039L; //this is a large prime number 
        long i = 2L;
        int test = 0;

        while (n > 1)
        {
            while (n % i == 0)
            {
                n /= i;     
            }

            i++;

            if(i*i > n && n > 1) 
            {
                System.out.println(n); //prints n if it's prime
                test = 1;
                break;
            }
        }

        if (test == 0)  
            System.out.println(i-1); //prints n if it's the largest prime factor
    }

Giải pháp đơn giản nhất là một cặp hàm đệ quy lẫn nhau .

Hàm đầu tiên tạo ra tất cả các số nguyên tố:

1. Bắt đầu với một danh sách tất cả các số tự nhiên lớn hơn 1.
2. Xóa tất cả các số không phải là số nguyên tố. Đó là, những con số không có yếu tố chính (ngoài bản thân chúng). Xem bên dưới.

Hàm thứ hai trả về các thừa số nguyên tố của một số đã cho ntheo thứ tự tăng dần.

1. Lấy một danh sách của tất cả các số nguyên tố (xem ở trên).
2. Xóa tất cả các số không phải là yếu tố của n.

Hệ số nguyên tố lớn nhất nlà số cuối cùng được cho bởi hàm thứ hai.

Thuật toán này yêu cầu một danh sách lười biếng hoặc một ngôn ngữ (hoặc cấu trúc dữ liệu) với nhu cầu gọi ngữ nghĩa theo yêu .

Để làm rõ, đây là một triển khai (không hiệu quả) ở trên trong Haskell:

import Control.Monad

-- All the primes
primes = 2 : filter (ap (<=) (head . primeFactors)) [3,5..]

-- Gives the prime factors of its argument
primeFactors = factor primes
  where factor [] n = []
        factor xs@(p:ps) n =
          if p*p > n then [n]
          else let (d,r) = divMod n p in
            if r == 0 then p : factor xs d
            else factor ps n

-- Gives the largest prime factor of its argument
largestFactor = last . primeFactors

Làm cho điều này nhanh hơn chỉ là vấn đề thông minh hơn trong việc phát hiện các số nào là số nguyên tố và / hoặc các yếu tố của n, nhưng thuật toán vẫn giữ nguyên.

n = abs(number);
result = 1;
if (n mod 2 == 0) {
  result = 2;
  while (n mod 2 = 0) n /= 2;
}
for(i=3; i<sqrt(n); i+=2) {
  if (n mod i == 0) {
    result = i;
    while (n mod i = 0)  n /= i;
  }
}
return max(n,result)

Có một số thử nghiệm modulo là không cần thiết, vì n không bao giờ có thể chia cho 6 nếu tất cả các yếu tố 2 và 3 đã bị loại bỏ. Bạn chỉ có thể cho phép các số nguyên tố cho i, được hiển thị trong một số câu trả lời khác ở đây.

Bạn thực sự có thể đan xen sàng của Eratosthenes ở đây:

• Đầu tiên tạo danh sách các số nguyên lên đến sqrt (n).
• Trong vòng lặp for, tất cả các bội số của i cho đến sqrt (n) mới là không phải là số nguyên tố và thay vào đó sử dụng vòng lặp while.
• đặt i thành số nguyên tố tiếp theo trong danh sách.

Cũng xem câu hỏi này .

Tôi biết đây không phải là một giải pháp nhanh. Gửi bài như hy vọng dễ hiểu hơn giải pháp chậm.

 public static long largestPrimeFactor(long n) {

        // largest composite factor must be smaller than sqrt
        long sqrt = (long)Math.ceil(Math.sqrt((double)n));

        long largest = -1;

        for(long i = 2; i <= sqrt; i++) {
            if(n % i == 0) {
                long test = largestPrimeFactor(n/i);
                if(test > largest) {
                    largest = test;
                }
            }
        }

        if(largest != -1) {
            return largest;
        }

        // number is prime
        return n;
    } 

Phương pháp lặp Python bằng cách loại bỏ tất cả các thừa số nguyên tố khỏi số

def primef(n):
    if n <= 3:
        return n
    if n % 2 == 0:
        return primef(n/2)
    elif n % 3 ==0:
        return primef(n/3)
    else:
        for i in range(5, int((n)**0.5) + 1, 6):
            #print i
            if n % i == 0:
                return primef(n/i)
            if n % (i + 2) == 0:
                return primef(n/(i+2))
    return n

Tôi đang sử dụng thuật toán tiếp tục chia số cho Prime Factor hiện tại.

Giải pháp của tôi trong python 3:

def PrimeFactor(n):
    m = n
    while n%2==0:
        n = n//2
    if n == 1:         # check if only 2 is largest Prime Factor 
        return 2
    i = 3
    sqrt = int(m**(0.5))  # loop till square root of number
    last = 0              # to store last prime Factor i.e. Largest Prime Factor
    while i <= sqrt :
        while n%i == 0:
            n = n//i       # reduce the number by dividing it by it's Prime Factor
            last = i
        i+=2
    if n> last:            # the remaining number(n) is also Factor of number 
        return n
    else:
        return last
print(PrimeFactor(int(input()))) 

Đầu vào: 10 Đầu ra:5

Đầu vào: 600851475143 Đầu ra:6857

Đây là nỗ lực của tôi trong c #. Bản in cuối cùng là yếu tố chính lớn nhất của số. Tôi đã kiểm tra và nó hoạt động.

namespace Problem_Prime
{
  class Program
  {
    static void Main(string[] args)
    {
      /*
       The prime factors of 13195 are 5, 7, 13 and 29.

      What is the largest prime factor of the number 600851475143 ?
       */
      long x = 600851475143;
      long y = 2;
      while (y < x)
      {
        if (x % y == 0)
        {
          // y is a factor of x, but is it prime
          if (IsPrime(y))
          {
            Console.WriteLine(y);
          }
          x /= y;
        }

        y++;

      }
      Console.WriteLine(y);
      Console.ReadLine();
    }
    static bool IsPrime(long number)
    {
      //check for evenness
      if (number % 2 == 0)
      {
        if (number == 2)
        {
          return true;
        }
        return false;
      }
      //don't need to check past the square root
      long max = (long)Math.Sqrt(number);
      for (int i = 3; i <= max; i += 2)
      {
        if ((number % i) == 0)
        {
          return false;
        }
      }
      return true;
    }

  }
}

#python implementation
import math
n = 600851475143
i = 2
factors=set([])
while i<math.sqrt(n):
   while n%i==0:
       n=n/i
       factors.add(i)
   i+=1
factors.add(n)
largest=max(factors)
print factors
print largest

Tính hệ số nguyên tố lớn nhất của một số bằng cách sử dụng đệ quy trong C ++. Hoạt động của mã được giải thích dưới đây:

int getLargestPrime(int number) {
    int factor = number; // assumes that the largest prime factor is the number itself
    for (int i = 2; (i*i) <= number; i++) { // iterates to the square root of the number till it finds the first(smallest) factor
        if (number % i == 0) { // checks if the current number(i) is a factor
            factor = max(i, number / i); // stores the larger number among the factors
            break; // breaks the loop on when a factor is found
        }
    }
    if (factor == number) // base case of recursion
        return number;
    return getLargestPrime(factor); // recursively calls itself
}

Dưới đây là cách tiếp cận của tôi để nhanh chóng tính toán yếu tố nguyên tố lớn nhất. Nó dựa trên thực tế rằng sửa đổi xkhông chứa các yếu tố không chính. Để đạt được điều đó, chúng tôi chia xngay khi một yếu tố được tìm thấy. Sau đó, điều duy nhất còn lại là trả lại yếu tố lớn nhất. Nó sẽ là nguyên tố.

Mã (Haskell):

f max' x i | i > x = max'
           | x `rem` i == 0 = f i (x `div` i) i  -- Divide x by its factor
           | otherwise = f max' x (i + 1)  -- Check for the next possible factor

g x = f 2 x 2

Thuật toán C ++ sau đây không phải là thuật toán tốt nhất, nhưng nó hoạt động với số lượng dưới một tỷ và khá nhanh

#include <iostream>
using namespace std;

// ------ is_prime ------
// Determines if the integer accepted is prime or not
bool is_prime(int n){
    int i,count=0;
    if(n==1 || n==2)
      return true;
    if(n%2==0)
      return false;
    for(i=1;i<=n;i++){
    if(n%i==0)
        count++;
    }
    if(count==2)
      return true;
    else
      return false;
 }
 // ------ nextPrime -------
 // Finds and returns the next prime number
 int nextPrime(int prime){
     bool a = false;
     while (a == false){
         prime++;
         if (is_prime(prime))
            a = true;
     }
  return prime;
 }
 // ----- M A I N ------
 int main(){

      int value = 13195;
      int prime = 2;
      bool done = false;

      while (done == false){
          if (value%prime == 0){
             value = value/prime;
             if (is_prime(value)){
                 done = true;
             }
          } else {
             prime = nextPrime(prime);
          }
      }
        cout << "Largest prime factor: " << value << endl;
 }

Tìm thấy giải pháp này trên web bởi "James Wang"

public static int getLargestPrime( int number) {

    if (number <= 1) return -1;

    for (int i = number - 1; i > 1; i--) {
        if (number % i == 0) {
            number = i;
        }
    }
    return number;
}

Yếu tố chính sử dụng sàng:

#include <bits/stdc++.h>
using namespace std;
#define N 10001  
typedef long long ll;
bool visit[N];
vector<int> prime;

void sieve()
{
            memset( visit , 0 , sizeof(visit));
            for( int i=2;i<N;i++ )
            {
                if( visit[i] == 0)
                {
                    prime.push_back(i);
                    for( int j=i*2; j<N; j=j+i )
                    {
                        visit[j] = 1;
                    }
                }
            }   
}
void sol(long long n, vector<int>&prime)
{
            ll ans = n;
            for(int i=0; i<prime.size() || prime[i]>n; i++)
            {
                while(n%prime[i]==0)
                {
                    n=n/prime[i];
                    ans = prime[i];
                }
            }
            ans = max(ans, n);
            cout<<ans<<endl;
}
int main() 
{
           ll tc, n;
           sieve();

           cin>>n;
           sol(n, prime);

           return 0;
}

Dường như với tôi, bước # 2 của thuật toán được đưa ra sẽ không phải là một cách tiếp cận hiệu quả. Bạn không có kỳ vọng hợp lý rằng nó là nguyên tố.

Ngoài ra, câu trả lời trước đây cho thấy Sàng của Eratosthenes là hoàn toàn sai. Tôi vừa viết hai chương trình cho nhân tố 123456789. Một chương trình dựa trên Sàng, một chương trình dựa trên:

1)  Test = 2 
2)  Current = Number to test 
3)  If Current Mod Test = 0 then  
3a)     Current = Current Div Test 
3b)     Largest = Test
3c)     Goto 3. 
4)  Inc(Test) 
5)  If Current < Test goto 4
6)  Return Largest

Phiên bản này nhanh hơn 90 lần so với Sàng.

Vấn đề là, trên các bộ xử lý hiện đại, loại hoạt động quan trọng hơn rất nhiều so với số lượng hoạt động, chưa kể thuật toán ở trên có thể chạy trong bộ đệm, Sàng không thể. Sàng sử dụng rất nhiều thao tác nổi bật trong tất cả các số tổng hợp.

Ngoài ra, cũng lưu ý rằng các yếu tố phân chia của tôi khi chúng được xác định sẽ làm giảm không gian phải được kiểm tra.

Trước tiên, tính toán một danh sách lưu các số nguyên tố, ví dụ 2 3 5 7 11 13 ...

Mỗi khi bạn xác định số nguyên tố, hãy sử dụng triển khai bằng Triptych nhưng lặp lại danh sách các số nguyên tố này thay vì số nguyên tự nhiên.

Với Java:

Đối với intcác giá trị:

public static int[] primeFactors(int value) {
    int[] a = new int[31];
    int i = 0, j;
    int num = value;
    while (num % 2 == 0) {
        a[i++] = 2;
        num /= 2;
    }
    j = 3;
    while (j <= Math.sqrt(num) + 1) {
        if (num % j == 0) {
            a[i++] = j;
            num /= j;
        } else {
            j += 2;
        }
    }
    if (num > 1) {
        a[i++] = num;
    }
    int[] b = Arrays.copyOf(a, i);
    return b;
}

Đối với longcác giá trị:

static long[] getFactors(long value) {
    long[] a = new long[63];
    int i = 0;
    long num = value;
    while (num % 2 == 0) {
        a[i++] = 2;
        num /= 2;
    }
    long j = 3;
    while (j <= Math.sqrt(num) + 1) {
        if (num % j == 0) {
            a[i++] = j;
            num /= j;
        } else {
            j += 2;
        }
    }
    if (num > 1) {
        a[i++] = num;
    }
    long[] b = Arrays.copyOf(a, i);
    return b;
}

Điều này có lẽ không phải lúc nào cũng nhanh hơn nhưng lạc quan hơn về việc bạn tìm thấy một ước số lớn:

1. N là số của bạn
2. Nếu là số nguyên tố thì return(N)
3. Tính số nguyên tố cho đến khi Sqrt(N)
4. Đi qua các số nguyên tố theo thứ tự giảm dần (lớn nhất trước)
   • Nếu N is divisible by Primesau đóReturn(Prime)

Chỉnh sửa: Ở bước 3, bạn có thể sử dụng Sàng của Eratosthenes hoặc Sàng Atkins hoặc bất cứ thứ gì bạn thích, nhưng bản thân rây sẽ không tìm thấy bạn là yếu tố chính lớn nhất. (Đó là lý do tại sao tôi không chọn bài đăng của SQLMenace làm câu trả lời chính thức ...)

Tôi nghĩ sẽ tốt hơn nếu lưu trữ ở đâu đó tất cả các số nguyên tố có thể nhỏ hơn n và chỉ cần lặp qua chúng để tìm ra số chia lớn nhất. Bạn có thể lấy số nguyên tố từ Prime-numbers.org .

Tất nhiên tôi cho rằng số của bạn không quá lớn :)

Không phải là nhanh nhất nhưng nó hoạt động!

    static bool IsPrime(long num)
    {
        long checkUpTo = (long)Math.Ceiling(Math.Sqrt(num));
        for (long i = 2; i <= checkUpTo; i++)
        {
            if (num % i == 0)
                return false;
        }
        return true;
    }

Đây là chức năng tương tự @ Triptych được cung cấp như một trình tạo, cũng đã được đơn giản hóa một chút.

def primes(n):
    d = 2
    while (n > 1):
        while (n%d==0):
            yield d
            n /= d
        d += 1

số nguyên tố tối đa có thể được tìm thấy bằng cách sử dụng:

n= 373764623
max(primes(n))

và một danh sách các yếu tố được tìm thấy bằng cách sử dụng:

list(primes(n))

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include <time.h>

factor(long int n)
{
long int i,j;
while(n>=4)
 {
if(n%2==0) {  n=n/2;   i=2;   }

 else
 { i=3;
j=0;
  while(j==0)
  {
   if(n%i==0)
   {j=1;
   n=n/i;
   }
   i=i+2;
  }
 i-=2;
 }
 }
return i;
 }

 void main()
 { 
  clock_t start = clock();
  long int n,sp;
  clrscr();
  printf("enter value of n");
  scanf("%ld",&n);
  sp=factor(n);
  printf("largest prime factor is %ld",sp);

  printf("Time elapsed: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC);
  getch();
 }