Number of Common Factors - Practice Coding Problems

Number of Common Factors - Problem

Find the Common Ground!

Given two positive integers a and b, your task is to count how many common factors they share. A common factor is any positive integer that divides both numbers evenly (with no remainder).

What makes this interesting? While it might seem straightforward, this problem teaches you fundamental concepts about divisibility, greatest common divisors, and efficient factorization techniques that are crucial for more advanced number theory problems.

Goal: Return the total count of positive integers that divide both a and b.

Example: For a = 12 and b = 6, the factors of 12 are [1, 2, 3, 4, 6, 12] and factors of 6 are [1, 2, 3, 6]. The common factors are [1, 2, 3, 6], so the answer is 4.

Input & Output

example_1.py — Basic Case

$ Input: a = 12, b = 6

› Output: 4

💡 Note: Factors of 12: [1, 2, 3, 4, 6, 12]. Factors of 6: [1, 2, 3, 6]. Common factors: [1, 2, 3, 6]. Count = 4.

example_2.py — Prime Numbers

$ Input: a = 25, b = 30

› Output: 2

💡 Note: GCD(25, 30) = 5. Factors of 5: [1, 5]. So there are 2 common factors.

example_3.py — Same Numbers

$ Input: a = 1, b = 1

› Output: 1

💡 Note: Both numbers are 1. The only common factor is 1 itself. Count = 1.

Visualization

Tap to expand

Understanding the Visualization

Calculate GCD

Find the greatest common divisor using Euclidean algorithm

Factor the GCD

Count all factors of the GCD efficiently using square root method

Return Count

The factors of GCD are exactly the common factors we need

Key Takeaway

🎯 Key Insight: Common factors of two numbers are exactly the factors of their GCD - this transforms an O(n) enumeration problem into an O(log n + √GCD) mathematical solution!

Time & Space Complexity

Time Complexity

⏱️

O(log(min(a,b)) + sqrt(GCD))

GCD computation takes O(log(min(a,b))) and factor counting takes O(sqrt(GCD))

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ a, b ≤ 1000
Both a and b are positive integers
Note: 1 is always a common factor of any two positive integers

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach leverages the mathematical insight that common factors of two numbers are exactly the factors of their Greatest Common Divisor (GCD). Instead of checking every number up to min(a,b), we first compute GCD using the Euclidean algorithm in O(log n) time, then count factors of the GCD in O(√GCD) time, resulting in much better performance than the brute force O(min(a,b)) approach.

Common Approaches

Approach	Time	Space	Notes
✓ GCD + Factor Counting (Optimal)	O(log(min(a,b)) + sqrt(GCD))	O(1)	Find GCD first, then count its factors efficiently
Brute Force (Check Every Possible Factor)	O(min(a,b))	O(1)	Check every integer from 1 to min(a,b) to see if it divides both numbers

GCD + Factor Counting (Optimal) — Algorithm Steps

Calculate GCD of a and b using Euclidean algorithm
Initialize counter to 0
Loop from 1 to sqrt(GCD)
For each divisor i of GCD, increment counter
If i != GCD/i, increment counter again (for the paired factor)
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate GCD(12,6)

Using Euclidean algorithm: GCD(12,6) = 6

Find factors of GCD=6

Check divisors from 1 to sqrt(6) ≈ 2.45

Count factor pairs

1 divides 6 → factors (1,6), 2 divides 6 → factors (2,3)

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int commonFactors(int a, int b) {
    int g = gcd(a, b);
    int count = 0;
    
    // Count factors of GCD
    int limit = (int)sqrt(g);
    for (int i = 1; i <= limit; i++) {
        if (g % i == 0) {
            count++;
            if (i != g / i) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d\n", commonFactors(a, b));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(min(a,b)) + sqrt(GCD))

GCD computation takes O(log(min(a,b))) and factor counting takes O(sqrt(GCD))

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ a, b ≤ 1000
Both a and b are positive integers
Note: 1 is always a common factor of any two positive integers

24.7K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

GCD + Factor Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler