Sum of Square Numbers - Practice Coding Problems

Sum of Square Numbers - Problem

You're given a non-negative integer c, and your task is to determine whether there exist two integers a and b such that a² + b² = c.

In other words, you need to find if the given number c can be expressed as the sum of two perfect squares.

Note: The integers a and b can be zero, negative, or positive, but since we're dealing with squares, we only need to consider non-negative values (as (-x)² = x²).

Examples:

c = 5 → true (because 1² + 2² = 1 + 4 = 5)
c = 3 → false (no two squares sum to 3)
c = 0 → true (because 0² + 0² = 0)

Input & Output

example_1.py — Basic positive case

$ Input: c = 5

› Output: true

💡 Note: 5 can be expressed as 1² + 2² = 1 + 4 = 5, so the answer is true.

example_2.py — No solution case

$ Input: c = 3

› Output: false

💡 Note: There are no two integers a and b such that a² + b² = 3. We can verify: 0²+0²=0, 0²+1²=1, 1²+1²=2, 0²+2²=4. None equal 3.

example_3.py — Edge case with zero

$ Input: c = 0

› Output: true

💡 Note: 0 can be expressed as 0² + 0² = 0 + 0 = 0, so the answer is true.

Constraints

0 ≤ c ≤ 2³¹ - 1
Both a and b can be zero, positive, or negative
Since we're dealing with squares, we only need to consider non-negative values

Visualization

Tap to expand

Understanding the Visualization

Setup

Place left pointer at 0, right pointer at √c

Calculate

Compute left² + right² and compare with target c

Adjust

Move left forward if sum too small, move right backward if sum too large

Converge

Continue until found or pointers meet

Key Takeaway

🎯 Key Insight: The two pointers approach works because as we increase 'a', the sum increases, and as we increase 'b', the sum also increases. This monotonic property allows us to eliminate impossible combinations efficiently.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

The optimal solution uses the two pointers technique with O(√c) time complexity. Start with pointers at 0 and √c, then move them based on whether their squares' sum is less than, equal to, or greater than the target value c.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search Approach	O(√c log c)	O(1)	For each value a, binary search for b where b² = c - a²
Two Pointers (Optimal)	O(√c)	O(1)	Use two pointers from 0 and √c, move based on sum comparison
Brute Force (Nested Loops)	O(c)	O(1)	Try all possible pairs (a, b) where a, b ≤ √c

Binary Search Approach — Algorithm Steps

For each value a from 0 to √c:
Calculate required b_squared = c - a²
Check if b_squared is a perfect square
If yes, return true
Return false if no valid pair found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose value a

Iterate through possible values of a

Calculate b²

Compute required b² = c - a²

Check perfect square

Use square root to verify if b² is perfect

Return result

True if perfect square found, continue otherwise

Code -

solution.c — C

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

bool isSquare(long long n) {
    if (n < 0) return false;
    long long root = (long long) sqrt(n);
    return root * root == n;
}

bool judgeSquareSum(int c) {
    int limit = (int) sqrt(c);
    for (int a = 0; a <= limit; a++) {
        long long bSquared = (long long) c - (long long) a * a;
        if (isSquare(bSquared)) {
            return true;
        }
    }
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(√c log c)

We iterate through √c values, and for each we perform a binary search or square root operation

⚡ Linearithmic

Space Complexity

O(1)

Only using temporary variables for calculations

✓ Linear Space

87.4K Views

Medium Frequency

~15 min Avg. Time

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

Binary Search Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler