C Program to Solve the Magic Squares Puzzle

The Magic Squares puzzle is an intriguing mathematical problem that involves arranging numbers in a square grid such that the sum of each row, each column, and both diagonals is the same. In this puzzle, the goal is to determine whether a given square grid forms a valid magic square or not.

To solve this puzzle, we can develop a C program that prompts the user to enter the elements of the square grid, validates the input, and checks if the grid satisfies the conditions of a magic square. By performing the necessary calculations and comparisons, the program can provide the user with the solution.

Problem Statement

You are required to write a C program that solves the Magic Squares puzzle. A magic square is an arrangement of numbers in a square grid, where the numbers in each row, each column, and both diagonals have the same sum.

Your program should prompt the user to enter the elements of a square grid and determine whether it forms a valid magic square or not. The program should output either “Magic square found!” or “Not a magic square!” accordingly.

Your program should have the following specifications:

1. The size of the square grid should be 3×3.
2. The program should read the elements of the grid from the user.
3. The program should validate the input to ensure that valid integer values are entered for the elements.
4. The program should check if the input grid forms a valid magic square.
5. If the input grid is a valid magic square, the program should print “Magic square found!”.
6. If the input grid is not a valid magic square, the program should print “Not a magic square!”.

C Program to Solve the Magic Squares Puzzle

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

#define SIZE 3 // Size of the square (3x3 in this example)

void solveMagicSquare(int magicSquare[SIZE][SIZE]) {
    int rowSum = 0, colSum = 0, diagSum1 = 0, diagSum2 = 0;

    // Calculate the sum of the first row
    for (int j = 0; j < SIZE; j++) {
        rowSum += magicSquare[0][j];
    }

    // Check if all rows, columns, and diagonals have the same sum
    for (int i = 0; i < SIZE; i++) {
        // Calculate the sum of the current row
        int currentRowSum = 0;
        for (int j = 0; j < SIZE; j++) {
            currentRowSum += magicSquare[i][j];
        }
        if (currentRowSum != rowSum) {
            printf("Not a magic square!\n");
            return;
        }

        // Calculate the sum of the current column
        int currentColSum = 0;
        for (int j = 0; j < SIZE; j++) {
            currentColSum += magicSquare[j][i];
        }
        if (currentColSum != rowSum) {
            printf("Not a magic square!\n");
            return;
        }

        // Calculate the sum of the main diagonal (top-left to bottom-right)
        diagSum1 += magicSquare[i][i];

        // Calculate the sum of the secondary diagonal (top-right to bottom-left)
        diagSum2 += magicSquare[i][SIZE - 1 - i];
    }

    if (diagSum1 != rowSum || diagSum2 != rowSum) {
        printf("Not a magic square!\n");
        return;
    }

    printf("Magic square found!\n");
}

int main() {
    int magicSquare[SIZE][SIZE];

    printf("Enter the elements of the magic square:\n");

    // Read the elements of the magic square
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            scanf("%d", &magicSquare[i][j]);
        }
    }

    solveMagicSquare(magicSquare);

    return 0;
}

How it Works?

1. The program starts by defining the necessary libraries, including stdio.h for input/output operations and stdbool.h for using the bool data type.
2. A constant SIZE is defined to represent the size of the square grid. In this case, it is set to 3 since the puzzle specifies a 3×3 grid.
3. The program declares a function solveMagicSquare that takes a 2D array magicSquare as a parameter. This function will check if the input grid forms a valid magic square.
4. Inside the solveMagicSquare function, several variables are declared to keep track of the sums of rows, columns, and diagonals. rowSum is initialized to 0, and colSum, diagSum1, and diagSum2 are initially set to 0 as well.
5. A loop is used to calculate the sum of the first row by iterating over the columns of the grid.
6. Another loop is used to check if the sums of each row and column are equal to the sum of the first row. If any of the sums are different, the function prints “Not a magic square!” and returns.
7. Inside the same loop, the sums of the main diagonal (diagSum1) and the secondary diagonal (diagSum2) are calculated.
8. After the loop, a check is performed to verify if the sums of both diagonals are equal to the sum of the rows/columns. If not, the function prints “Not a magic square!” and returns.
9. If all the checks pass, the function prints “Magic square found!” indicating that the input grid is a valid magic square.
10. The main function is defined, where the program execution begins. It declares a 2D array magicSquare of size SIZE x SIZE to store the user’s input.
11. The program prompts the user to enter the elements of the magic square using nested loops that iterate over the rows and columns.
12. The input values are read using the scanf function and stored in the magicSquare array.
13. The solveMagicSquare function is called, passing the magicSquare array as an argument.
14. Finally, the program returns 0 to indicate successful execution.

This program takes user input for the elements of a 3×3 grid, checks if it forms a valid magic square, and provides the appropriate output.

Input / Output

The input does not represent a magic square because the sum of the last row is 16, which is different from the expected sum of 15.