Closest Divisors - Practice Coding Problems

Closest Divisors - Problem

Math Medium

Finding the Perfect Factor Pair

Given an integer num, you need to find two divisors that are as close to each other as possible. However, there's a twist! You can choose to find divisors for either num + 1 or num + 2 - whichever gives you the closest pair.

Goal: Return the two integers whose product equals either num + 1 or num + 2 and have the smallest absolute difference between them.

Example: For num = 8, you can choose between:
• 9 = 1 × 9 (difference: 8) or 9 = 3 × 3 (difference: 0)
• 10 = 1 × 10 (difference: 9) or 10 = 2 × 5 (difference: 3)

The answer is [3, 3] since they have the smallest difference of 0.

Input & Output

example_1.py — Basic Case

$ Input: num = 8

› Output: [3, 3]

💡 Note: For num=8, we check num+1=9 and num+2=10. For 9: divisors are (1,9) with diff=8, (3,3) with diff=0. For 10: divisors are (1,10) with diff=9, (2,5) with diff=3. The smallest difference is 0 from [3,3].

example_2.py — Another Case

$ Input: num = 123

› Output: [5, 25]

💡 Note: For num=123, we check 124 and 125. For 124: closest divisors near √124≈11.1 are found by checking down from 11. For 125: 125=5×25, and √125≈11.2, so checking from 11 down we find 5×25 with difference |5-25|=20. After comparing both, [5,25] gives the minimum difference.

example_3.py — Edge Case

$ Input: num = 999

› Output: [25, 40]

💡 Note: For num=999, we check 1000 and 1001. 1000=25×40 (diff=15), while 1001=7×143 (diff=136). The optimal pair is [25,40] with difference 15.

Visualization

Tap to expand

Understanding the Visualization

Two Sheets Available

You have sheets of size num+1 and num+2 square units

Find Square Root

Calculate √(sheet_size) to find the ideal square dimensions

Search Downward

Starting from √n, find the first valid divisor going down

Compare Results

Pick the rectangle closest to square from both sheets

Key Takeaway

🎯 Key Insight: The closest divisors are always found near the square root! This transforms an O(n) brute force into an elegant O(√n) solution.

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We only check divisors from sqrt(n) down to 1, and stop at the first match

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store results

✓ Linear Space

Constraints

1 ≤ num ≤ 10⁹
Output format: Return any valid pair as [a, b] where a×b = num+1 or num+2
The returned pair should have the minimum absolute difference |a-b|

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 21

The optimal solution uses the mathematical insight that the closest divisors are always near the square root. Instead of checking all divisors O(n), we start from √(num+1) and √(num+2) and work downward, achieving O(√n) time complexity. The first divisor we find will automatically give us the closest pair!

Common Approaches

Approach	Time	Space	Notes
✓ Square Root Optimization	O(√n)	O(1)	Start from square root and work outward to find closest divisors efficiently
Brute Force (Check All Divisors)	O(n)	O(1)	Find all divisor pairs for both num+1 and num+2, then pick the closest pair

Square Root Optimization — Algorithm Steps

For both target = num+1 and target = num+2:
Calculate the square root of target
Start from floor(sqrt(target)) and work downward
Find the first divisor i where target % i == 0
The pair will be (i, target/i) - automatically closest!
Compare results from both targets and return the better pair

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate √(num+1)

Start searching from the square root downward

First divisor found

The first divisor we find will give us the closest pair

Calculate √(num+2)

Repeat the same process for num+2

Compare differences

Return the pair with smaller difference

Code -

solution.c — C

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

int* findClosestDivisors(int n) {
    int* result = (int*)malloc(2 * sizeof(int));
    
    // Start from square root and work down
    for (int i = (int) sqrt(n); i >= 1; i--) {
        if (n % i == 0) {
            result[0] = i;
            result[1] = n / i;
            return result;
        }
    }
    
    result[0] = 1;
    result[1] = n;
    return result;
}

int* closestDivisors(int num) {
    int* divisors1 = findClosestDivisors(num + 1);
    int* divisors2 = findClosestDivisors(num + 2);
    
    int diff1 = abs(divisors1[0] - divisors1[1]);
    int diff2 = abs(divisors2[0] - divisors2[1]);
    
    int* result = (int*)malloc(2 * sizeof(int));
    
    if (diff1 <= diff2) {
        result[0] = divisors1[0];
        result[1] = divisors1[1];
    } else {
        result[0] = divisors2[0];
        result[1] = divisors2[1];
    }
    
    free(divisors1);
    free(divisors2);
    return result;
}

int main() {
    int num;
    scanf("%d", &num);
    int* result = closestDivisors(num);
    printf("[%d, %d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We only check divisors from sqrt(n) down to 1, and stop at the first match

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store results

✓ Linear Space

Constraints

1 ≤ num ≤ 10⁹
Output format: Return any valid pair as [a, b] where a×b = num+1 or num+2
The returned pair should have the minimum absolute difference |a-b|

23.6K Views

Medium Frequency

~12 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

Square Root Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler