c
exercises
exercises.c🔧c
/**
* @file exercises.c
* @brief Nested Loops Exercises
*
* Practice nested loops with patterns and matrices.
*
* Compile: gcc -Wall exercises.c -o exercises
* Run: ./exercises
*/
#include <stdio.h>
/* ============================================================
* EXERCISE 1: SIMPLE RECTANGLE
* ============================================================
* Difficulty: Easy
*
* Task: Print a rectangle of 'X' with given rows and cols.
*
* Example for 3 rows, 5 cols:
* X X X X X
* X X X X X
* X X X X X
*/
void printRectangle(int rows, int cols) {
// TODO: Print rectangle of X
// Your code here
}
void exercise_1() {
printf("\n=== Exercise 1: Rectangle ===\n");
printRectangle(3, 5);
}
/* ============================================================
* EXERCISE 2: RIGHT TRIANGLE
* ============================================================
* Difficulty: Easy
*
* Task: Print a right triangle with n rows.
*
* Example for n=5:
* *
* * *
* * * *
* * * * *
* * * * * *
*/
void printRightTriangle(int n) {
// TODO: Print right triangle
// Your code here
}
void exercise_2() {
printf("\n=== Exercise 2: Right Triangle ===\n");
printRightTriangle(5);
}
/* ============================================================
* EXERCISE 3: NUMBER PATTERN
* ============================================================
* Difficulty: Easy
*
* Task: Print number pattern.
*
* Example for n=5:
* 1
* 1 2
* 1 2 3
* 1 2 3 4
* 1 2 3 4 5
*/
void printNumberPattern(int n) {
// TODO: Print number pattern
// Your code here
}
void exercise_3() {
printf("\n=== Exercise 3: Number Pattern ===\n");
printNumberPattern(5);
}
/* ============================================================
* EXERCISE 4: INVERTED TRIANGLE
* ============================================================
* Difficulty: Easy
*
* Task: Print an inverted right triangle.
*
* Example for n=5:
* * * * * *
* * * * *
* * * *
* * *
* *
*/
void printInvertedTriangle(int n) {
// TODO: Print inverted triangle
// Your code here
}
void exercise_4() {
printf("\n=== Exercise 4: Inverted Triangle ===\n");
printInvertedTriangle(5);
}
/* ============================================================
* EXERCISE 5: PYRAMID
* ============================================================
* Difficulty: Medium
*
* Task: Print a centered pyramid.
*
* Example for n=5:
* *
* ***
* *****
* *******
* *********
*/
void printPyramid(int n) {
// TODO: Print pyramid with proper spacing
// Your code here
}
void exercise_5() {
printf("\n=== Exercise 5: Pyramid ===\n");
printPyramid(5);
}
/* ============================================================
* EXERCISE 6: HOLLOW RECTANGLE
* ============================================================
* Difficulty: Medium
*
* Task: Print a hollow rectangle.
*
* Example for 5x7:
* * * * * * * *
* * *
* * *
* * *
* * * * * * * *
*/
void printHollowRectangle(int rows, int cols) {
// TODO: Print hollow rectangle
// Your code here
}
void exercise_6() {
printf("\n=== Exercise 6: Hollow Rectangle ===\n");
printHollowRectangle(5, 7);
}
/* ============================================================
* EXERCISE 7: MATRIX SUM
* ============================================================
* Difficulty: Medium
*
* Task: Calculate and return sum of all elements in matrix.
*/
int matrixSum(int matrix[][3], int rows, int cols) {
// TODO: Return sum of all elements
// Your code here
return 0; // Replace this
}
void exercise_7() {
printf("\n=== Exercise 7: Matrix Sum ===\n");
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
printf("Sum of matrix: %d (should be 45)\n", matrixSum(matrix, 3, 3));
}
/* ============================================================
* EXERCISE 8: MATRIX MAX
* ============================================================
* Difficulty: Medium
*
* Task: Find and return the maximum element in matrix.
*/
int matrixMax(int matrix[][3], int rows, int cols) {
// TODO: Return maximum element
// Your code here
return 0; // Replace this
}
void exercise_8() {
printf("\n=== Exercise 8: Matrix Max ===\n");
int matrix[3][3] = {
{12, 25, 8},
{45, 16, 33},
{7, 19, 28}
};
printf("Maximum element: %d (should be 45)\n", matrixMax(matrix, 3, 3));
}
/* ============================================================
* EXERCISE 9: ROW SUMS
* ============================================================
* Difficulty: Medium
*
* Task: Print the sum of each row.
*
* Example:
* Row 0: 6
* Row 1: 15
* Row 2: 24
*/
void printRowSums(int matrix[][3], int rows, int cols) {
// TODO: Print sum of each row
// Your code here
}
void exercise_9() {
printf("\n=== Exercise 9: Row Sums ===\n");
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
printRowSums(matrix, 3, 3);
}
/* ============================================================
* EXERCISE 10: DIAMOND PATTERN
* ============================================================
* Difficulty: Hard
*
* Task: Print a diamond pattern.
*
* Example for n=5:
* *
* ***
* *****
* *******
* *********
* *******
* *****
* ***
* *
*/
void printDiamond(int n) {
// TODO: Print diamond pattern
// Your code here
}
void exercise_10() {
printf("\n=== Exercise 10: Diamond Pattern ===\n");
printDiamond(5);
}
/* ============================================================
* EXERCISE 11: LETTER TRIANGLE
* ============================================================
* Difficulty: Medium
*
* Task: Print letter triangle.
*
* Example for n=5:
* A
* B B
* C C C
* D D D D
* E E E E E
*/
void printLetterTriangle(int n) {
// TODO: Print letter triangle
// Your code here
}
void exercise_11() {
printf("\n=== Exercise 11: Letter Triangle ===\n");
printLetterTriangle(5);
}
/* ============================================================
* EXERCISE 12: MULTIPLICATION TABLE
* ============================================================
* Difficulty: Medium
*
* Task: Print a multiplication table up to n x n.
*/
void printMultTable(int n) {
// TODO: Print multiplication table with headers
// Your code here
}
void exercise_12() {
printf("\n=== Exercise 12: Multiplication Table ===\n");
printMultTable(5);
}
/* ============================================================
* EXERCISE 13: DIAGONAL SUM
* ============================================================
* Difficulty: Medium
*
* Task: Calculate sum of main diagonal elements.
*/
int diagonalSum(int matrix[][3], int n) {
// TODO: Return sum of main diagonal (0,0), (1,1), (2,2)...
// Your code here
return 0; // Replace this
}
void exercise_13() {
printf("\n=== Exercise 13: Diagonal Sum ===\n");
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
printf("Diagonal sum: %d (should be 15)\n", diagonalSum(matrix, 3));
}
/* ============================================================
* EXERCISE 14: BORDER ELEMENTS
* ============================================================
* Difficulty: Medium
*
* Task: Print only the border elements of a matrix.
*
* For a 3x3 matrix:
* 1 2 3
* 4 6
* 7 8 9
*/
void printBorder(int matrix[][4], int rows, int cols) {
// TODO: Print border elements of matrix
// Your code here
}
void exercise_14() {
printf("\n=== Exercise 14: Border Elements ===\n");
int matrix[4][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16}
};
printBorder(matrix, 4, 4);
}
/* ============================================================
* EXERCISE 15: HOURGLASS PATTERN
* ============================================================
* Difficulty: Hard
*
* Task: Print an hourglass pattern.
*
* Example for n=5:
* *********
* *******
* *****
* ***
* *
* ***
* *****
* *******
* *********
*/
void printHourglass(int n) {
// TODO: Print hourglass pattern
// Your code here
}
void exercise_15() {
printf("\n=== Exercise 15: Hourglass Pattern ===\n");
printHourglass(5);
}
/* ============================================================
* MAIN FUNCTION
* ============================================================ */
int main() {
printf("╔════════════════════════════════════════════════╗\n");
printf("║ NESTED LOOPS - EXERCISES ║\n");
printf("║ Practice patterns and matrices ║\n");
printf("╚════════════════════════════════════════════════╝\n");
// Uncomment exercises as you complete them:
// exercise_1();
// exercise_2();
// exercise_3();
// exercise_4();
// exercise_5();
// exercise_6();
// exercise_7();
// exercise_8();
// exercise_9();
// exercise_10();
// exercise_11();
// exercise_12();
// exercise_13();
// exercise_14();
// exercise_15();
printf("\n=== Uncomment exercises in main() to run them ===\n");
return 0;
}
/* ============================================================
* ANSWER KEY
* ============================================================
*
* EXERCISE 1:
* void printRectangle(int rows, int cols) {
* for (int i = 0; i < rows; i++) {
* for (int j = 0; j < cols; j++) {
* printf("X ");
* }
* printf("\n");
* }
* }
*
* EXERCISE 2:
* void printRightTriangle(int n) {
* for (int i = 1; i <= n; i++) {
* for (int j = 1; j <= i; j++) {
* printf("* ");
* }
* printf("\n");
* }
* }
*
* EXERCISE 3:
* void printNumberPattern(int n) {
* for (int i = 1; i <= n; i++) {
* for (int j = 1; j <= i; j++) {
* printf("%d ", j);
* }
* printf("\n");
* }
* }
*
* EXERCISE 4:
* void printInvertedTriangle(int n) {
* for (int i = n; i >= 1; i--) {
* for (int j = 1; j <= i; j++) {
* printf("* ");
* }
* printf("\n");
* }
* }
*
* EXERCISE 5:
* void printPyramid(int n) {
* for (int i = 1; i <= n; i++) {
* for (int s = 1; s <= n - i; s++) printf(" ");
* for (int j = 1; j <= 2*i - 1; j++) printf("*");
* printf("\n");
* }
* }
*
* EXERCISE 6:
* void printHollowRectangle(int rows, int cols) {
* for (int i = 0; i < rows; i++) {
* for (int j = 0; j < cols; j++) {
* if (i == 0 || i == rows-1 || j == 0 || j == cols-1)
* printf("* ");
* else
* printf(" ");
* }
* printf("\n");
* }
* }
*
* EXERCISE 7:
* int matrixSum(int matrix[][3], int rows, int cols) {
* int sum = 0;
* for (int i = 0; i < rows; i++) {
* for (int j = 0; j < cols; j++) {
* sum += matrix[i][j];
* }
* }
* return sum;
* }
*
* EXERCISE 8:
* int matrixMax(int matrix[][3], int rows, int cols) {
* int max = matrix[0][0];
* for (int i = 0; i < rows; i++) {
* for (int j = 0; j < cols; j++) {
* if (matrix[i][j] > max) max = matrix[i][j];
* }
* }
* return max;
* }
*
* EXERCISE 9:
* void printRowSums(int matrix[][3], int rows, int cols) {
* for (int i = 0; i < rows; i++) {
* int sum = 0;
* for (int j = 0; j < cols; j++) sum += matrix[i][j];
* printf("Row %d: %d\n", i, sum);
* }
* }
*
* EXERCISE 10:
* void printDiamond(int n) {
* // Upper half
* for (int i = 1; i <= n; i++) {
* for (int s = 1; s <= n-i; s++) printf(" ");
* for (int j = 1; j <= 2*i-1; j++) printf("*");
* printf("\n");
* }
* // Lower half
* for (int i = n-1; i >= 1; i--) {
* for (int s = 1; s <= n-i; s++) printf(" ");
* for (int j = 1; j <= 2*i-1; j++) printf("*");
* printf("\n");
* }
* }
*
* EXERCISE 11:
* void printLetterTriangle(int n) {
* for (int i = 0; i < n; i++) {
* for (int j = 0; j <= i; j++) {
* printf("%c ", 'A' + i);
* }
* printf("\n");
* }
* }
*
* EXERCISE 12:
* void printMultTable(int n) {
* printf(" |");
* for (int j = 1; j <= n; j++) printf("%4d", j);
* printf("\n---+");
* for (int j = 1; j <= n; j++) printf("----");
* printf("\n");
* for (int i = 1; i <= n; i++) {
* printf("%2d |", i);
* for (int j = 1; j <= n; j++) printf("%4d", i*j);
* printf("\n");
* }
* }
*
* EXERCISE 13:
* int diagonalSum(int matrix[][3], int n) {
* int sum = 0;
* for (int i = 0; i < n; i++) {
* sum += matrix[i][i];
* }
* return sum;
* }
*
* EXERCISE 14:
* void printBorder(int matrix[][4], int rows, int cols) {
* for (int i = 0; i < rows; i++) {
* for (int j = 0; j < cols; j++) {
* if (i == 0 || i == rows-1 || j == 0 || j == cols-1)
* printf("%2d ", matrix[i][j]);
* else
* printf(" ");
* }
* printf("\n");
* }
* }
*
* EXERCISE 15:
* void printHourglass(int n) {
* // Upper half (including middle)
* for (int i = n; i >= 1; i--) {
* for (int s = 0; s < n - i; s++) printf(" ");
* for (int j = 0; j < 2*i - 1; j++) printf("*");
* printf("\n");
* }
* // Lower half
* for (int i = 2; i <= n; i++) {
* for (int s = 0; s < n - i; s++) printf(" ");
* for (int j = 0; j < 2*i - 1; j++) printf("*");
* printf("\n");
* }
* }
*
* ============================================================
*/