Abundant and Deficient Classifier - Problem

Given a positive integer, classify it as abundant, deficient, or perfect based on the sum of its proper divisors.

Definitions:

Proper divisors: All positive divisors of a number except the number itself
Abundant: Sum of proper divisors > number
Deficient: Sum of proper divisors < number
Perfect: Sum of proper divisors = number

Additionally, find and list the first 20 numbers of each type.

For a single number classification, return the classification as a string. For finding the first 20 of each type, return an object with arrays for each classification.

Input & Output

Example 1 — Perfect Number

$ Input: n = 6

› Output: perfect

💡 Note: Proper divisors of 6 are [1, 2, 3]. Sum = 1 + 2 + 3 = 6, which equals the number itself, so 6 is perfect.

Example 2 — Abundant Number

$ Input: n = 12

› Output: abundant

💡 Note: Proper divisors of 12 are [1, 2, 3, 4, 6]. Sum = 1 + 2 + 3 + 4 + 6 = 16, which is greater than 12, so 12 is abundant.

Example 3 — Deficient Number

$ Input: n = 8

› Output: deficient

💡 Note: Proper divisors of 8 are [1, 2, 4]. Sum = 1 + 2 + 4 = 7, which is less than 8, so 8 is deficient.

Constraints

1 ≤ n ≤ 10⁶
n is a positive integer

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to find all proper divisors efficiently and sum them up. The optimal approach uses square root optimization, checking divisors up to √n and finding pairs simultaneously. Time: O(√n), Space: O(1).

Common Approaches

✓ Brute Force Divisor Check

⏱️ Time: O(n) Space: O(1)

Iterate through all numbers from 1 to n-1, check if each divides n evenly, and sum up all the divisors found. Then compare the sum with n to determine the classification.

Square Root Optimization

⏱️ Time: O(√n) Space: O(1)

Instead of checking every number up to n-1, only check up to √n. When we find a divisor i, we also get n/i as a divisor (except when i = √n). This dramatically reduces the number of checks needed.

Brute Force Divisor Check — Algorithm Steps

Loop through all numbers from 1 to n-1
For each number, check if it divides n evenly using modulo
Sum all the proper divisors found
Compare sum with n to classify as abundant, deficient, or perfect

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Loop

Check numbers 1, 2, 3... up to n-1

Test Divisibility

Use modulo to see if number divides evenly

Sum Divisors

Add up all numbers that divide evenly

Classify

Compare sum with original number

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

char* solution(int n) {
    int divisorSum = 0;
    for (int i = 1; i < n; i++) {
        if (n % i == 0) {
            divisorSum += i;
        }
    }
    
    if (divisorSum > n) {
        return "abundant";
    } else if (divisorSum < n) {
        return "deficient";
    } else {
        return "perfect";
    }
}

int main() {
    int n;
    scanf("%d", &n);
    char* result = solution(n);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop from 1 to n-1 checking each potential divisor

✓ Linear Growth

Space Complexity

O(1)

Only storing the running sum, no extra data structures

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

842 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

Abundant and Deficient Classifier - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Divisor Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler