Count Square Sum Triples - Practice Coding Problems

Count Square Sum Triples - Problem

Math Enumeration Easy

Square Sum Triples - The Classic Pythagorean Problem

A square triple (a, b, c) is a set of three integers where a² + b² = c². These are also known as Pythagorean triples, named after the famous theorem about right triangles!

Given an integer n, your task is to count how many square triples exist where all three numbers a, b, and c are between 1 and n (inclusive).

Examples:
• For n=5: The triple (3, 4, 5) works because 3² + 4² = 9 + 16 = 25 = 5²
• For n=10: We can find triples like (3, 4, 5), (4, 3, 5), (6, 8, 10), (8, 6, 10)

Note: Order matters! (3, 4, 5) and (4, 3, 5) are considered different triples.

Input & Output

example_1.py — Basic Case

$ Input: n = 5

› Output: 2

💡 Note: There are 2 square triples: (3,4,5) because 3² + 4² = 9 + 16 = 25 = 5², and (4,3,5) because 4² + 3² = 16 + 9 = 25 = 5². Note that (3,4,5) and (4,3,5) are counted as different triples.

example_2.py — Larger Range

$ Input: n = 10

› Output: 4

💡 Note: There are 4 square triples: (3,4,5), (4,3,5), (6,8,10), and (8,6,10). The first two come from the 3-4-5 Pythagorean triple, and the last two come from the 6-8-10 triple (which is 2 times the 3-4-5 triple).

example_3.py — Edge Case

$ Input: n = 2

› Output: 0

💡 Note: No square triples exist with all values ≤ 2. The smallest Pythagorean triple is (3,4,5), which requires n ≥ 5.

Visualization

Tap to expand

Understanding the Visualization

Setup Perfect Squares

Pre-compute all squares 1², 2², 3², ..., n² for quick lookup

Test All Pairs

For each possible pair (a,b), calculate what the hypotenuse c would need to be

Verify Triangle

Check if c² = a² + b² exists in our set of perfect squares and c ≤ n

Key Takeaway

🎯 Key Insight: Pre-computing perfect squares and using hash lookup transforms an O(n³) brute force into an elegant O(n²) solution with O(1) verification per pair.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops with O(1) hash set lookup for each pair

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores up to n perfect squares

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 250
All values a, b, c must be in range [1, n]
Order matters: (3,4,5) and (4,3,5) are different triples

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses a hash set to pre-compute all perfect squares from 1 to n², then checks each pair (a,b) to see if a² + b² exists in the set. This achieves O(n²) time complexity with O(1) lookups, avoiding expensive square root calculations and floating point precision issues. The key insight is that instead of calculating √(a² + b²) and checking if it's an integer, we can directly check if the sum exists in our pre-computed set of perfect squares.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Optimization (Optimal)	O(n²)	O(n)	Pre-compute all perfect squares and use hash lookup for instant verification
Optimized Nested Loops (Two Pointers Concept)	O(n²)	O(1)	Fix two values and calculate the third, then check if it's valid and within range
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible combinations of (a, b, c) and verify the Pythagorean relationship

Hash Set Optimization (Optimal) — Algorithm Steps

Pre-compute all perfect squares from 1² to n² and store in a hash set
Loop through all possible values of a from 1 to n
For each a, loop through all possible values of b from 1 to n
Calculate sum = a² + b² and check if it exists in the hash set
If sum exists and √sum ≤ n, increment the counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Pre-compute Squares

Store all perfect squares 1² to n² in hash set

Check Each Pair

For each (a,b), calculate a² + b²

Hash Lookup

Instant O(1) check if sum exists in set

Code -

solution.c — C

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

int countTriples(int n) {
    // Create array to mark perfect squares (simple hash approach)
    bool* squares = (bool*)calloc(n * n + 1, sizeof(bool));
    
    // Pre-compute all perfect squares up to n^2
    for (int i = 1; i <= n; i++) {
        int square = i * i;
        if (square <= n * n) {
            squares[square] = true;
        }
    }
    
    int count = 0;
    for (int a = 1; a <= n; a++) {
        for (int b = 1; b <= n; b++) {
            int cSquared = a * a + b * b;
            // Check if cSquared is a perfect square in our range
            if (cSquared <= n * n && squares[cSquared]) {
                count++;
            }
        }
    }
    
    free(squares);
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops with O(1) hash set lookup for each pair

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores up to n perfect squares

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 250
All values a, b, c must be in range [1, n]
Order matters: (3,4,5) and (4,3,5) are different triples

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

Hash Set Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler