Sum of Perfect Square Elements in Array: C, C++, Java, Python

For the array {1, 2, 3, 4, 5, 9}, the sum of its perfect square elements is 14.

The three qualifying elements are 1, 4, and 9. Numbers like 2, 3, and 5 are skipped. This filter-and-accumulate pattern is one of the most consistently tested array problems in placement coding rounds: TCS NQT, AMCAT Automata, and technical screening rounds at mid-size IT firms all use variants of it. One pass through the array is all you need.

What Is a Perfect Square?

A square number is a non-negative integer that equals the product of some integer multiplied by itself. The first several: 0 (0 × 0), 1 (1 × 1), 4 (2 × 2), 9 (3 × 3), 16 (4 × 4), 25 (5 × 5), 36, 49, 64, 81, 100.

Two edge cases matter for code correctness:

• Zero: 0 = 0 × 0, so 0 is a valid perfect square. A guard written as if (n <= 0) return false incorrectly excludes it. Write if (n < 0) return false instead.
• Negatives: No negative integer is a perfect square. Any real number squared is non-negative, so a negative input should exit the check immediately.

Algorithm Step-by-Step

• Read the array and its length.
• Initialise sum = 0.
• For each element num in the array:
  • Compute sq = (int)sqrt(num).
  • If sq * sq == num or (sq + 1) * (sq + 1) == num, add num to sum.
• Return sum.

The (sq + 1) guard in Step 3 is not redundant. On certain compilers, sqrt(9) returns 2.9999... rather than exactly 3.0. Casting to int gives 2, and 2 * 2 = 4 does not equal 9. The guard catches this floating-point truncation with one extra multiplication and no branching.

Worked Example

Input: {1, 2, 3, 4, 5, 9}

• Element 1: sq = 1. 1 * 1 = 1 equals 1. Perfect square. sum = 1.
• Element 2: sq = 1. 1 * 1 = 1, 2 * 2 = 4. Neither equals 2. Skip. sum = 1.
• Element 3: sq = 1. 1 * 1 = 1, 2 * 2 = 4. Neither equals 3. Skip. sum = 1.
• Element 4: sq = 2. 2 * 2 = 4 equals 4. Perfect square. sum = 5.
• Element 5: sq = 2. 2 * 2 = 4, 3 * 3 = 9. Neither equals 5. Skip. sum = 5.
• Element 9: sq = 3 (or 2 if float-truncated). Guard: (2+1) * (2+1) = 9. Perfect square. sum = 14.
• Output: 14

How to Test Whether a Number Is a Perfect Square

Two approaches appear in placement solutions. Both produce identical results; they differ in whether you use the standard math library.

Method 1: sqrt and square-back

int isPerfectSquare(int n) {
    if (n < 0) return 0;
    int sq = (int)sqrt((double)n);
    return sq * sq == n || (sq + 1) * (sq + 1) == n;
}

This runs in O(1) time per element. The (double) cast prevents integer overflow inside sqrt for large inputs. The (sq + 1) guard handles the floating-point rounding described in the algorithm section above.

Method 2: brute-force loop (no math library)

int isPerfectSquare(int n) {
    if (n < 0) return 0;
    for (int i = 0; (long long)i * i <= n; i++) {
        if (i * i == n) return 1;
    }
    return 0;
}

This runs in O(√n) time per element but requires no math.h. For array elements up to a few million, the brute-force version is fast enough on any placement judge. Both approaches pass the same test cases.

The GeeksforGeeks walkthrough on checking perfect squares in C++ covers both variants with additional notes on integer overflow for large inputs.

Complete Programs

C

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

int isPerfectSquare(int n) {
    if (n < 0) return 0;
    int sq = (int)sqrt((double)n);
    return sq * sq == n || (sq + 1) * (sq + 1) == n;
}

int sumPerfectSquares(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        if (isPerfectSquare(arr[i]))
            sum += arr[i];
    }
    return sum;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 9};
    int size = sizeof(arr) / sizeof(arr[0]);
    printf("Sum of perfect square elements: %d\n", sumPerfectSquares(arr, size));
    return 0;
}

Output: Sum of perfect square elements: 14

C++

#include <iostream>
#include <cmath>
#include <vector>
using namespace std;

bool isPerfectSquare(int n) {
    if (n < 0) return false;
    int sq = (int)sqrt((double)n);
    return sq * sq == n || (sq + 1) * (sq + 1) == n;
}

int sumPerfectSquares(const vector<int>& arr) {
    int sum = 0;
    for (int x : arr) {
        if (isPerfectSquare(x))
            sum += x;
    }
    return sum;
}

int main() {
    vector<int> arr = {1, 2, 3, 4, 5, 9};
    cout << "Sum of perfect square elements: " << sumPerfectSquares(arr) << endl;
    return 0;
}

Output: Sum of perfect square elements: 14

Java

public class PerfectSquareSum {

    static boolean isPerfectSquare(int n) {
        if (n < 0) return false;
        int sq = (int) Math.sqrt(n);
        return sq * sq == n || (sq + 1) * (sq + 1) == n;
    }

    static int sumPerfectSquares(int[] arr) {
        int sum = 0;
        for (int x : arr) {
            if (isPerfectSquare(x))
                sum += x;
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 9};
        System.out.println("Sum of perfect square elements: " + sumPerfectSquares(arr));
    }
}

Output: Sum of perfect square elements: 14

Python

import math

def is_perfect_square(n):
    if n < 0:
        return False
    sq = int(math.sqrt(n))
    return sq * sq == n or (sq + 1) * (sq + 1) == n

def sum_perfect_squares(arr):
    return sum(x for x in arr if is_perfect_square(x))

arr = [1, 2, 3, 4, 5, 9]
print("Sum of perfect square elements:", sum_perfect_squares(arr))

Output: Sum of perfect square elements: 14

Python’s int(math.sqrt(n)) truncates toward zero, same as C. The (sq + 1) guard becomes more relevant for large integers where float precision degrades.

Complexity Analysis

Metric	Method 1 (sqrt)	Method 2 (brute-force)
Time per element	O(1)	O(√M), M = max element
Time for full array	O(n)	O(n × √M)
Auxiliary space	O(1)	O(1)

Both methods use O(1) auxiliary space: just one integer variable (sum) that does not grow with input size. No additional array or structure is allocated.

The loop structure here is the same pattern described in sum of digits of a number: initialise an accumulator, test a property of each element with arithmetic, add or skip. The symmetric pairs problem adds a HashMap layer on top of the same traversal skeleton when the test requires looking across elements rather than at a single element.

The (sq + 1) guard catches the case where sqrt(9) returns 2.999 at the cost of one extra multiplication. That same category of silent precision error appears in ML pipelines, where off-by-epsilon gaps in feature computation produce wrong predictions without a crash. TinkerLLM is a hands-on platform for exploring LLM integration and data pipeline experiments through real API calls, starting at ₹299.