Codestin Search App

Perfect Number - Problem

Math Easy

A perfect number is a fascinating mathematical concept - it's a positive integer that equals the sum of all its positive divisors, excluding the number itself. Think of it as a number that is perfectly balanced with its factors!

For example, 6 is perfect because its divisors are 1, 2, and 3, and 1 + 2 + 3 = 6. Similarly, 28 is perfect because 1 + 2 + 4 + 7 + 14 = 28.

Your task: Given an integer n, determine if it's a perfect number. Return true if it is, false otherwise.

Note: A divisor of an integer x is any integer that divides x evenly (with no remainder).

Input & Output

example_1.py — Basic Perfect Number

$ Input: 6

› Output: true

💡 Note: 6 is a perfect number because its proper divisors are 1, 2, and 3, and 1 + 2 + 3 = 6.

example_2.py — Larger Perfect Number

$ Input: 28

› Output: true

💡 Note: 28 is a perfect number because its proper divisors are 1, 2, 4, 7, and 14, and 1 + 2 + 4 + 7 + 14 = 28.

example_3.py — Not Perfect Number

$ Input: 12

› Output: false

💡 Note: 12 is not perfect because its proper divisors are 1, 2, 3, 4, and 6, and 1 + 2 + 3 + 4 + 6 = 16 ≠ 12.

Constraints

1 ≤ num ≤ 10⁸
Note: Perfect numbers are extremely rare
The first few perfect numbers are: 6, 28, 496, 8128...

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Perfect numbers equal the sum of their proper divisors

Find Divisor Pairs

Every divisor i has a pair n/i (except when i = √n)

Optimize Search

Only check numbers up to √n to find all divisors

Sum and Compare

Add all divisors and check if sum equals the original number

Key Takeaway

🎯 Key Insight: By recognizing that divisors come in pairs, we can reduce our search space from O(n) to O(√n), making the algorithm efficient enough to handle large numbers while maintaining correctness.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses the mathematical insight that divisors come in pairs. Instead of checking all numbers from 1 to n-1, we only check up to √n and count both divisors in each pair. This reduces time complexity from O(n) to O(√n), making it efficient even for large numbers.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Square Root Approach	O(√n)	O(1)	Only check divisors up to √n, count pairs efficiently
Brute Force - Check All Divisors	O(n)	O(1)	Check every number from 1 to n-1 to find all divisors

Optimized Square Root Approach — Algorithm Steps

Handle edge cases: if n ≤ 1, return false
Initialize sum to 1 (since 1 is always a divisor)
Loop from i = 2 to √n
If n % i == 0, add i to sum
If i ≠ n/i, also add n/i to sum (avoid double counting perfect squares)
Return true if sum equals n

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 1

1 is always a proper divisor

Check up to √n

For each i, if n%i==0, add both i and n/i

Avoid Double Count

If i² = n, only count i once

Compare Sum

Check if total equals n

Code -

solution.c — C

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

bool checkPerfectNumber(int num) {
    if (num <= 1) {
        return false;
    }
    
    int divisorSum = 1; // 1 is always a divisor
    
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) {
            divisorSum += i;
            // Add the paired divisor if it's different
            if (i * i != num) {
                divisorSum += num / i;
            }
        }
    }
    
    return divisorSum == num;
}

int main() {
    int num;
    scanf("%d", &num);
    printf("%s\n", checkPerfectNumber(num) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We only check divisors up to the square root of n

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space

✓ Linear Space

28.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Square Root Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler