C Program To Print Sum Of Individual Square Of Numbers Upto N Terms

Calculating the sum of squares is a fundamental task in mathematics and programming, frequently appearing in various computational challenges. In this article, you will learn how to compute the sum of the squares of individual numbers up to 'n' terms using C programming, exploring both iterative and formula-based methods.

Problem Statement

The problem requires calculating the sum of the squares of the first 'n' natural numbers. Mathematically, this is represented as the series: $1^2 + 2^2 + 3^2 + \dots + n^2$

This calculation is important in fields like statistics for computing variance, in physics for certain kinematic equations, and in numerical analysis for series approximation. Efficiently solving this can optimize algorithms that rely on such sums.

Example

Consider finding the sum of the squares of numbers up to $n=3$. The sum would be: $1^2 + 2^2 + 3^2 = 1 + 4 + 9 = 14$

Background & Knowledge Prerequisites

To understand and implement the solutions effectively, you should have a basic understanding of:

• C Programming Basics: Variables, data types (especially int and long long).
• Input/Output: Using printf for output and scanf for input.
• Control Flow: Specifically, for loops for iteration.
• Arithmetic Operators: Addition, multiplication.

No special libraries or complex data structures are required beyond the standard input/output (stdio.h).

Use Cases or Case Studies

Calculating the sum of squares has several practical applications:

• Statistical Analysis: Used in formulas for variance and standard deviation, which measure data dispersion.
• Physics: Can appear in problems involving moments of inertia or certain energy calculations where square terms are involved.
• Numerical Methods: Essential in approximating integrals or solving differential equations using series expansions.
• Combinatorics and Number Theory: Forms a basic building block for more complex series and number patterns.
• Algorithmic Challenges: Often a sub-problem in competitive programming tasks or algorithm design.

Solution Approaches

We will explore two primary methods to calculate the sum of squares: an iterative approach using a loop and a more efficient formula-based approach.

Approach 1: Iterative Method (Loop-based)

This approach involves iterating from 1 to 'n', squaring each number, and adding it to a running total.

One-line summary: Iterate through numbers from 1 to 'n', calculate the square of each, and accumulate the sum.

Code Example:

// Sum of Squares using Iteration
#include <stdio.h>

int main() {
    int n;
    long long sum_of_squares = 0; // Use long long for sum to prevent overflow for larger n
    int i;

    // Step 1: Prompt user for input
    printf("Enter a positive integer (n): ");
    
    // Step 2: Read the value of n
    if (scanf("%d", &n) != 1 || n < 1) {
        printf("Invalid input. Please enter a positive integer.\\n");
        return 1; // Indicate an error
    }

    // Step 3: Iterate from 1 to n, square each number, and add to sum
    for (i = 1; i <= n; i++) {
        sum_of_squares += (long long)i * i; // Cast to long long before multiplication to prevent overflow
    }

    // Step 4: Print the result
    printf("The sum of squares up to %d is: %lld\\n", n, sum_of_squares);

    return 0;
}

Run

Sample Output:

Enter a positive integer (n): 3
The sum of squares up to 3 is: 14

 

Stepwise Explanation:

1. Initialization: Declare an integer n to store the user's input and a long long variable sum_of_squares initialized to 0. long long is used for the sum to handle potentially large results that might exceed the capacity of an int.
2. Input: The program prompts the user to enter a positive integer for 'n' and reads it using scanf. Input validation ensures n is positive.
3. Iteration: A for loop runs from i = 1 up to n.
4. Calculation: Inside the loop, i * i calculates the square of the current number. This result is then added to sum_of_squares. We explicitly cast i * i to long long before addition to prevent overflow if i * i itself exceeds INT_MAX before being assigned to sum_of_squares.
5. Output: After the loop completes, the final sum_of_squares is printed to the console.

 

Approach 2: Formula-based Method

There is a well-known mathematical formula for the sum of the first 'n' squares: $S_n = \frac{n(n+1)(2n+1)}{6}$

This formula provides a constant-time solution, which is significantly more efficient for large 'n' compared to the iterative approach.

One-line summary: Directly apply the mathematical formula $\frac{n(n+1)(2n+1)}{6}$ to compute the sum.

Code Example:

// Sum of Squares using Formula
#include <stdio.h>

int main() {
    int n;
    long long sum_of_squares = 0; // Use long long for the sum

    // Step 1: Prompt user for input
    printf("Enter a positive integer (n): ");

    // Step 2: Read the value of n
    if (scanf("%d", &n) != 1 || n < 1) {
        printf("Invalid input. Please enter a positive integer.\\n");
        return 1; // Indicate an error
    }

    // Step 3: Apply the formula
    // (long long)n is used to ensure the multiplication is done using long long arithmetic
    // to prevent intermediate overflow before division.
    sum_of_squares = (long long)n * (n + 1) * (2 * n + 1) / 6;

    // Step 4: Print the result
    printf("The sum of squares up to %d is: %lld\\n", n, sum_of_squares);

    return 0;
}

Run

Sample Output:

Enter a positive integer (n): 5
The sum of squares up to 5 is: 55

 

Stepwise Explanation:

1. Initialization: Declare an integer n and a long long variable sum_of_squares initialized to 0.
2. Input: The program prompts for and reads the value of 'n', including input validation.
3. Formula Application: The core of this method is directly applying the formula. We cast n to long long before the multiplication chain n * (n + 1) * (2 * n + 1) to ensure that the intermediate product does not overflow if n is large (e.g., n=100000 would cause n*(n+1) to overflow a 32-bit int). Since the product n(n+1)(2n+1) is always divisible by 6 for any integer n, the integer division will yield the correct result.
4. Output: The calculated sum_of_squares is printed.

 

Conclusion

We have explored two distinct methods for calculating the sum of individual squares up to 'n' terms in C. The iterative approach, while straightforward to understand and implement, becomes less efficient as 'n' grows due to its linear time complexity. The formula-based method, leveraging a mathematical identity, offers a constant-time solution, making it significantly more performant for larger values of 'n'. Choosing the right approach depends on the scale of 'n' and the performance requirements of your application.

Summary

• Problem: Calculate $1^2 + 2^2 + \dots + n^2$.
• Iterative Method: Uses a for loop to sum squares sequentially. Simple, but $O(n)$ time complexity.
• Formula Method: Uses the direct mathematical formula $\frac{n(n+1)(2n+1)}{6}$. Highly efficient with $O(1)$ time complexity.
• Data Types: Use long long for the sum variable to prevent integer overflow, especially for larger values of 'n'.
• Efficiency: The formula-based approach is generally preferred for its speed and efficiency for any 'n'.