C Program To Find Sum Of Squares Of Digits Of A Number

Understanding the individual digits of a number is a fundamental programming task, useful in various numerical algorithms. In this article, you will learn how to write a C program to calculate the sum of the squares of the digits of any given integer.

Problem Statement

The core problem is to process an integer by breaking it down into its constituent digits, then performing an operation (squaring) on each digit, and finally aggregating those results (summing them up). This task is a common exercise for beginners to grasp digit manipulation techniques and loop control structures in programming. For instance, for the number 123, the goal is to calculate (1*1) + (2*2) + (3*3).

Example

Consider the number 123.

• Its digits are 1, 2, and 3.
• Squaring each digit gives 1*1=1, 2*2=4, and 3*3=9.
• The sum of these squares is 1 + 4 + 9 = 14.

Background & Knowledge Prerequisites

To understand and implement the solutions in this article, you should be familiar with the following C programming concepts:

• Basic C Syntax: Understanding how to declare variables, write functions (like main), and use input/output operations (printf, scanf).
• Arithmetic Operators: Specifically, the modulo operator (%) to extract the last digit of a number, and the division operator (/) to remove the last digit.
• Loops: The while loop is crucial for iterating through all digits of a number until no digits are left.

Use Cases or Case Studies

Calculating the sum of squares of digits, or digit manipulation in general, appears in several contexts:

• Number Theory Problems: Many mathematical puzzles and theorems involve analyzing the properties of numbers based on their digits (e.g., happy numbers, narcissistic numbers).
• Data Validation and Checksums: While not directly for sum of squares, the underlying technique of digit extraction is used in algorithms like the Luhn algorithm for validating credit card numbers or in creating checksums.
• Educational Exercises: It's a classic problem used to teach fundamental programming concepts like iterative processing, arithmetic operations, and conditional logic.
• Basic Encryption/Hashing (Conceptual): In very simplified contexts, digit-based transformations could form part of a hashing function or a simple encoding scheme, although real-world systems are far more complex.
• Algorithmic Challenges: Often encountered in coding competitions or interviews to test a candidate's grasp of basic algorithms.

Solution Approaches

Iterative Digit Extraction

This approach uses a while loop to repeatedly extract the last digit of the number, square it, add it to a running sum, and then remove that digit from the original number until the number becomes zero.

• One-line summary: Uses a while loop, modulo, and division operations to process each digit and accumulate their squared sum.

• Code Example:

// Sum of Squares of Digits
    #include <stdio.h>

    int main() {
        // Step 1: Declare variables
        int number;
        int sum_of_squares = 0;
        int digit;

        // Step 2: Prompt user for input
        printf("Enter an integer: ");
        scanf("%d", &number);

        // Store the original number for display later
        int original_number = number;

        // Step 3: Handle negative numbers by converting to positive for digit processing
        if (number < 0) {
            number = -number;
        }

        // Step 4: Loop to extract digits and calculate sum of squares
        while (number > 0) {
            // Extract the last digit
            digit = number % 10;

            // Square the digit and add to the sum
            sum_of_squares += digit * digit;

            // Remove the last digit from the number
            number /= 10;
        }

        // Step 5: Display the result
        printf("The sum of the squares of the digits of %d is: %d\\n", original_number, sum_of_squares);

        return 0;
    }

Run

• Sample Output:

Enter an integer: 123
    The sum of the squares of the digits of 123 is: 14

Enter an integer: 456
    The sum of the squares of the digits of 456 is: 77

(Explanation for 456: 4*4 + 5*5 + 6*6 = 16 + 25 + 36 = 77)

• Stepwise Explanation for Clarity:

1. Initialization: Variables number (to store input), sum_of_squares (initialized to 0 to accumulate results), and digit (to hold each extracted digit) are declared. original_number stores the initial input for display.
2. Input: The program prompts the user to enter an integer and reads it into the number variable.
3. Handle Negatives: If the input number is negative, it's converted to its positive equivalent using number = -number. This ensures the digit extraction logic works consistently, as the sum of squares of digits is the same for a number and its negative counterpart (e.g., 123 and -123 both yield 14).
4. Looping through Digits: A while (number > 0) loop continues as long as there are digits left in number.

• digit = number % 10;: The modulo operator (%) gives the remainder when number is divided by 10, which is always its last digit.
• sum_of_squares += digit * digit;: The extracted digit is squared and added to sum_of_squares.
• number /= 10;: The integer division operator (/) removes the last digit from number. For example, if number was 123, it becomes 12.

1. Output: Once the loop finishes (when number becomes 0), the program prints the original_number and the final sum_of_squares.

Conclusion

This article demonstrated a clear and efficient way to calculate the sum of the squares of the digits of an integer using C programming. The iterative approach, leveraging the modulo and division operators within a while loop, is a fundamental technique for digit manipulation that is both easy to understand and implement.

Summary

• The problem involves extracting each digit of a number, squaring it, and then summing these squared values.
• Key operators: Modulo (% 10) extracts the last digit, and integer division (/ 10) removes the last digit.
• A while loop is used to process digits iteratively until the number becomes zero.
• Initialization of the sum variable to zero is crucial for accurate accumulation.
• The approach handles both positive and negative integers gracefully.