Find Common Prime Divisors in Java

It is a primary number-theoretic problem that can be severely applied in different areas, for instance, cryptography and algebra. The specific divisors of a number are all the prime numbers that are able to divide a said number. Actually, the problem being solved here includes the determination of these prime numbers that are present in the two input integers.

This problem can be solved by using different algorithms, and other time and space complexity can occur based on its approaches. In the following section, several algorithms and their Java programs for finding common divisors are described: the conventional method, Euclidean algorithm, polynomial GCD algorithm and Stein's algorithm; furthermore, their complexities are provided as well.

Approaches

1. Basic Iteration for Prime Factorization

The first iteration or Benefit here is simply the Basic Iteration approach for doing the Prime Factorization.

The first and rather direct approach is to try dividing the given number by each integer from 2 up to the number itself. It is easy to understand, but computation time increases exponentially as the value of n increases because of the loops used in the process.

File Name: CommonPrimeDivisorsBasic.java

 
import java.util.*;
public class CommonPrimeDivisorsBasic {
    public static List<Integer> findPrimeFactors(int num) {
        List<Integer> Factors = new ArrayList<>();
        for (int i = 2; i <= num; i++) {
            while (num % i == 0) {
                Factors.add(i); // Add the factor to the list
                num /= i; // Divide the number by the found factor
            }
        }
        return Factors;
    }
    // Method to find common prime divisors of two numbers
    public static Set<Integer> CommonPrimeDivisors(int num1, int num2) {
        List<Integer> primeFactors1 = findPrimeFactors(num1);
        List<Integer> primeFactors2 = findPrimeFactors(num2);
        Set<Integer> commonPrimeDivisors = new HashSet<>(primeFactors1);
        commonPrimeDivisors.retainAll(primeFactors2); // Retain only common factors
        return commonPrimeDivisors;
    }
    public static void main(String[] args) {
        int num1 = 98;
        int num2 = 80;
        Set<Integer> commonPrimes = CommonPrimeDivisors(num1, num2);
        System.out.println("Common prime divisors of " + num1 + " and " + num2 + " are: " + commonPrimes);
    }
}   

Output:

 
Common prime divisors of 98 and 80 are: [2]

Explanation: Since the number to be split is a whole number, it divides the number with entire numbers starting from 2 and records the numbers that evenly divide the overall number. It is a straightforward process; however, if there is a large quantity to factor, it becomes time-consuming because of the number of cycles that are run. The work done as a result of executing the following is an algorithm whose time complexity is O(n); meanwhile, the factors held are of space complexity O(log n).

Time Complexity: O(n), which is linear for the worst case when deciding with 'n' input numbers.

Space Complexity: At a linear rate to log(n) of the assumption for the number of prime factors, the space complexity to store the input's prime factors is O(log n).

2. Enhanced Prime Factorization Mainly Relying On Sieve of Eratosthenes

Another method to find these prime factors cuts down the temporal complexity because, through the Sieve of Eratosthenes, it can find all the prime numbers up to a given number. The provided numbers are then using these precomputed primes factored into their primes.

File Name: CommonPrimeDivisorsSieve.java

 
import java.util.*;
public class CommonPrimeDivisorsSieve {
    // Method to generate prime numbers up to a given maximum using Sieve of Eratosthenes
    public static List<Integer> generatePrimes(int max) {
        boolean[] isPrime = new boolean[max + 1];
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= max; i++) {
            if (!isPrime[i]) {
                primes.add(i); // Add prime number to the list
                for (int j = i * 2; j <= max; j += i) {
                    isPrime[j] = true; // Mark multiples of i as non-prime
                }
            }
        }
        return primes;
    }
    // Method to find prime factors using the precomputed list of primes
    public static List<Integer> findPrimeFactors(int num, List<Integer> primes) {
        List<Integer> primeFactors = new ArrayList<>();
        for (int prime : primes) {
            if (prime > num) break; // If prime exceeds num, stop
            while (num % prime == 0) {
                primeFactors.add(prime); // Add the prime factor
                num /= prime; // Divide the number by the prime factor
            }
        }
        return primeFactors;
    }
    // Method to find common prime divisors of two numbers using precomputed primes
    public static Set<Integer> findCommonPrimeDivisors(int num1, int num2) {
        int max = Math.max(num1, num2);
        List<Integer> primes = generatePrimes(max);
        List<Integer> primeFactors1 = findPrimeFactors(num1, primes);
        List<Integer> primeFactors2 = findPrimeFactors(num2, primes);
        Set<Integer> commonPrimeDivisors = new HashSet<>(primeFactors1);
        commonPrimeDivisors.retainAll(primeFactors2); // Retain only common factors
        return commonPrimeDivisors;
    }
    public static void main(String[] args) {
        int num1 = 48;
        int num2 = 180;
        Set<Integer> commonPrimes = findCommonPrimeDivisors(num1, num2);
        System.out.println("Common prime divisors of " + num1 + " and " + num2 + " are: " + commonPrimes);
    }
}   

Output:

 
Common prime divisors of 48 and 180 are: [2, 3]

Explanation: This method reduces complexity because it employs a list of premature numbers obtained by the method of Sieve of Eratosthenes up to the highest number in the factorization. It makes the time complexity of the generation of primes equal to O(n log log n) and of the factorization to O(n), which implies that the proposed method is faster and more efficient with more significant numbers.

Time Complexity: O(n log log n) for sieve to get the primes, and O(n) for factorization per the number.

Space Complexity: O(n) for storing each element in the sieve as well as the list of the prime numbers.

3. GCD-Based Approach

This approach goes further to determine the gcd of the two numbers and then proceeds to find the prime factors of the gcd. Because only the prime divisors of two numbers need to be calculated and all non-common primes are eliminated due to division, this strategy is efficient and saves time.

File Name: CommonPrimeDivisorsGCD.java

 
import java.util.ArrayList;
import java.util.List;
public class CommonPrimeDivisorsGCD {
    // Method to compute the Greatest Common Divisor (GCD) using the Euclidean algorithm
    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
    // Method to find prime factors of a given number
    public static List<Integer> findPrimeFactors(int num) {
        List<Integer> primeFactors = new ArrayList<>();
        for (int i = 2; i <= num; i++) {
            while (num % i == 0) {
                primeFactors.add(i); // Add the factor to the list
                num /= i; // Divide the number by the found factor
            }
        }
        return primeFactors;
    }
    public static void main(String[] args) {
        int num1 = 48;
        int num2 = 180;
        // Compute the GCD of the two numbers
        int gcdValue = gcd(num1, num2);
        System.out.println("GCDs of " + num1 + " and " + num2 + " is: " + gcdValue);
        // Find and print the prime factors of the GCD
        List<Integer> primeFactors = findPrimeFactors(gcdValue);
        System.out.println("Common prime divisors (prime factors of GCD): " + primeFactors);
    }
}   

Output:

 
GCDs of 48 and 180 is: 12
Common prime divisors (prime factors of GCD): [2, 2, 3]

Explanation: Before that, in finding the common factors, the GCD of two numbers is first computed and then it factorizes only the GCD to find out common prime factors. This method is efficient since it brings the problem to a much smaller one, which is the GCD itself. It takes O(log(min(a, b))) time for GCD computation and O(n) time to factorize the GCD.

Time Complexity: log(min (a, b)) for GCD and n for factoring the GCD.

Space Complexity: O(log G) on average for the number of times D has to be divided to obtain G and for storing the prime factors of G.

Conclusion

In conclusion, the method, which can be used for a complete determination of the number of divisors that are common to the given pair of numbers, is the central part of the presented algorithms, and it can be solved by using several approaches that have their strengths and weaknesses.

Here is the one that can be considered as the simplest: Basic Iteration for Prime Factorization The metrics used in it involve divisional operations only. However, for large numbers it becomes ineffective because it demands a high amount of time to solve equations.

The Optimized Prime Factorization Using the Sieve of Eratosthenes is more efficient as it uses a pre-generated list of prime numbers, so the number of divisions required is lesser. This method becomes somewhat effective in the case of significant inputs by virtue of the fact the sieve facilitates the identification of the prime factors at a faster pace.

It is also noteworthy that the Gcd-based approach is reasonably practical and rather elegant. This method makes the problem simpler because the GCD of the two numbers is the most significant standard number that has the most prime divisors, as figured out from the two numbers entered by the user. This is rather time and space-saving especially when the common divisor is little, or in other words, it is efficient.

Thus, the choice of the method is determined by the size of input numbers and the required computational speed. Each resolution method is effectual for definite problem conditions and can be chosen according to the problem requirements which means that they are helpful for the number theory and computational mathematics.

Next TopicFind-longest-substring-containing-exactly-k-vowels-in-java

← prev next →