Basic C Programming Exercises for Beginners: 50+ Coding Problems with Solutions

#include <stdio.h>

int main() {
    float pi_value;

    printf("Enter a floating-point number (e.g., 3.14): ");
    
    // Read the float value
    scanf("%f", &pi_value);

    // Print the value formatted to two decimal places
    printf("\nThe number rounded to two decimal places is: %.2f\n", pi_value);

    return 0;
}Code language: C++ (cpp)

Explanation:

• float pi_value;: Declares a variable to store the decimal value.
• scanf("%f", &pi_value);: Reads a floating-point number from input.
• printf("... %.2f\n", pi_value);: This is the key line for formatting. The format specifier %.2f tells the printf() function to display the corresponding float argument (pi_value) with exactly two digits after the decimal point.

#include <stdio.h>

int main() {
    int num1, num2, sum;

    printf("Enter the first integer: ");
    scanf("%d", &num1);
    
    printf("\nEnter the second integer: ");
    scanf("%d", &num2);
    
    // Calculate the sum
    sum = num1 + num2;
    
    // Print the result
    printf("\nThe sum of %d and %d is: %d\n", num1, num2, sum);

    return 0;
}Code language: C++ (cpp)

Explanation:

• int num1, num2, sum;: Three integer variables are declared.
• The program uses two separate scanf() calls to read the values into num1 and num2.
• sum = num1 + num2;: The addition operator (+) calculates the sum, and the result is stored in the sum variable.
• The final printf() uses three %d format specifiers, substituting them in order with the values of num1, num2, and sum.

#include <stdio.h>

int main() {
    int a, b;
    a = 20;
    b = 10;
    
    // Perform operations
    printf("\nSum: %d + %d = %d\n", a, b, a + b);
    printf("\nDifference: %d - %d = %d\n", a, b, a - b);
    printf("\nProduct: %d * %d = %d\n", a, b, a * b);
    
    // Division with float casting for accuracy
    if (b != 0) {
        printf("\nQuotient: %d / %d = %.2f\n", a, b, (float)a / b);
    } else {
        printf("\nQuotient: Cannot divide by zero.\n");
    }
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• The first three operations (+, -, *) are straightforward integer arithmetic.
• The Division: Integer division (a / b) in C truncates the decimal part (e.g., 5/2 would be 2). To get a precise result, one of the operands is temporarily converted to a float using type casting: (float)a. This forces the entire division operation to be performed in floating-point arithmetic, and the result is printed using %.2f.
• An if statement is used to prevent the program from crashing or giving an error if the user attempts to divide by zero.

#include <stdio.h>

#define PI 3.14159

int main() {
    float radius, area, circumference;
    radius = 5;

    // Calculate Area: PI * r * r
    area = PI * radius * radius;
    
    // Calculate Circumference: 2 * PI * r
    circumference = 2 * PI * radius;

    printf("\nArea of the circle: %.3f\n", area);
    printf("\nCircumference of the circle: %.3f\n", circumference);

    return 0;
}Code language: C++ (cpp)

Explanation:

• #define PI 3.14159: This defines a symbolic constant. The preprocessor replaces every instance of PI in the code with 3.14159 before compilation.
• The program reads the radius as a float.
• The formulas for area and circumference are implemented directly using the * operator and the PI constant.
• The output uses %.3f to display the results with three decimal places.

#include <stdio.h>

int main() {
    float principal, rate, time, simple_interest;
    principal = 1000;
    rate = 8;
    time = 3;
    
    // Calculate Simple Interest
    simple_interest = (principal * rate * time) / 100;
    
    printf("\nSimple Interest is: %.2f\n", simple_interest);

    return 0;
}Code language: C++ (cpp)

Explanation:

• All variables are declared as float to accommodate monetary values and decimal interest rates.
• The program reads the three input values (P,R,T).
• simple_interest = (principal * rate * time) / 100;: This line directly implements the simple interest formula. Parentheses are used around the numerator to ensure multiplication happens before division, although standard operator precedence (multiplication and division have equal precedence and are evaluated left-to-right) would handle it correctly here too.
• The final result is printed with two decimal places (%.2f), which is conventional for currency.

#include <stdio.h>

int main() {
    int A, B, temp;
    A = 10;
    B = 20;

    printf("\n--- Before Swap ---\n");
    printf("A = %d, B = %d\n", A, B);
    
    // The three-step swap logic
    temp = A;  // Step 1: Store original A
    A = B;     // Step 2: Overwrite A with B's value
    B = temp;  // Step 3: Overwrite B with the original A (stored in temp)

    printf("\n--- After Swap ---\n");
    printf("A = %d, B = %d\n", A, B);

    return 0;
}Code language: C++ (cpp)

Explanation:

• int A, B, temp;: Three integer variables are declared. temp acts as a necessary intermediary storage location.
• Step 1: temp = A;: The original value of A is saved in temp. If we didn’t do this, the original value of A would be lost in the next step.
• Step 2: A = B;: The value of B is copied into A. A now holds B’s original value.
• Step 3: B = temp;: The value stored in temp (the original value of A) is copied into B. B now holds A’s original value. The swap is complete

#include <stdio.h>

int main() {
    int A, B;
    A = 10;
    B = 20;
    printf("\n--- Before Swap ---\n");
    printf("A = %d, B = %d\n", A, B);
    
    // The arithmetic swap logic
    A = A + B; // A now holds the sum of original A and B
    B = A - B; // B now holds (A + B) - B, which is original A
    A = A - B; // A now holds (A + B) - (original A), which is original B

    printf("\n--- After Swap ---\n");
    printf("A = %d, B = %d\n", A, B);

    return 0;
}Code language: C++ (cpp)

Explanation:

This method relies purely on arithmetic:

• A=A−B: We subtract the new A (the sum) by the new B (the original A). The result is the original value of B. (Example: A=15−5=10. Now A=10,B=5). The swap is complete.
• A=A+B: We store the sum in A. (Example: if A=5,B=10, now A=15,B=10)
• B=A−B: We subtract the new A (the sum) by B. The result is the original value of A. (Example: B=15−10=5. Now A=15,B=5)

#include <stdio.h>

int main() {
    char ch;

    printf("\nEnter a character: ");
    scanf(" %c", &ch); // Note the space to handle whitespace

    // Print the character itself
    printf("\nThe character entered is: %c\n", ch);
    
    // Print the ASCII value by using %d
    printf("\nThe ASCII value of '%c' is: %d\n", ch, ch);

    return 0;
}Code language: C++ (cpp)

Explanation:

In C, the char data type is actually an integer type that typically stores the 8-bit numerical ASCII code of a character.

• When we read the character with scanf(" %c", &ch), the variable ch stores the integer code (e.g., 65 for ‘A’, 97 for ‘a’).
• When we use printf("...%c...", ch), the program interprets the number in ch as a character and prints ‘A’.
• When we use printf("...%d...", ch), the program interprets the number in ch as an integer and prints 65.

#include <stdio.h>

int main() {
    int num;
    num = 12;

    // Use the modulo operator for the check
    if (num % 2 == 0) {
        printf("%d is an EVEN number.\n", num);
    } else {
        printf("%d is an ODD number.\n", num);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• num % 2 calculates the remainder when num is divided by 2.
• The if statement checks the condition num % 2 == 0.
• If the remainder is 0 (the condition is true), the number is even, and the code inside the if block executes.
• If the remainder is not 0 (it will be 1 for any odd integer), the condition is false, and the code inside the else block executes, concluding the number is odd.

#include <stdio.h>

int main() {
    int A, B, C;
    A = 10;
    B = 30;
    C = 20;

    if (A >= B && A >= C) {
        printf("A (%d) is the largest number.\n", A);
    } 
    else if (B >= A && B >= C) {
        printf("B (%d) is the largest number.\n", B);
    } 
    else {
        // If A and B aren't the largest, C must be (or all are equal)
        printf("C (%d) is the largest number.\n", C);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The first condition A >= B && A >= C checks if A is greater than or equal to both B AND C. The logical AND operator (&&) requires both sub-conditions to be true. If true, A is the maximum.
• If A wasn’t the maximum, the program proceeds to the else if block. The condition B >= A && B >= C checks if B is greater than or equal to both A AND C.
• If neither of the first two conditions is met, it means C must be the largest (or equal to the others, in which case any would be a correct answer), so the final else block executes.

#include <stdio.h>

int main() {
    int year;
    year = 2024;

    // Leap year conditions:
    // (Divisible by 400) OR (Divisible by 4 AND Not divisible by 100)
    if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
        printf("%d is a LEAP YEAR.\n", year);
    } else {
        printf("%d is NOT a leap year.\n", year);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The expression contains the full logic for a leap year:

• year % 400 == 0: True for years like 2000 and 2400.
• year % 4 == 0 && year % 100 != 0: True for years like 2004,2008,2012, but false for century years like 1900,2100.

The || (OR) operator connects these two main conditions. If either condition is true, the overall condition is true, and the year is declared a leap year.

#include <stdio.h>

int main() {
    char op;
    float num1, num2;

    printf("Enter operator (+, -, *, /): ");
    scanf(" %c", &op); // Read operator first
    
    printf("\nEnter two operands: ");
    scanf("%f %f", &num1, &num2);

    switch (op) {
        case '+':
            printf("%.2f + %.2f = %.2f\n", num1, num2, num1 + num2);
            break;
        case '-':
            printf("%.2f - %.2f = %.2f\n", num1, num2, num1 - num2);
            break;
        case '*':
            printf("%.2f * %.2f = %.2f\n", num1, num2, num1 * num2);
            break;
        case '/':
            if (num2 != 0) {
                printf("%.2f / %.2f = %.2f\n", num1, num2, num1 / num2);
            } else {
                printf("Error: Division by zero is not allowed.\n");
            }
            break;
        default:
            printf("Error: Invalid operator entered.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The switch statement evaluates the op variable.
• Execution jumps to the case label that matches the value of op (e.g., case '+').
• Inside the case '/', an additional if check is included to prevent division by zero.
• The break statement is essential in each case; it immediately exits the switch block. Without it, the code would “fall through” and execute the subsequent case blocks.
• The default case handles any operator that doesn’t match the defined cases.

#include <stdio.h>

int main() {
    int i;
    
    printf("The first 10 natural numbers are:\n");
    
    // Loop from 1 up to 10, inclusive
    for (i = 1; i <= 10; i++) {
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization (i = 1): The loop counter i starts at 1.
• Condition (i <= 10): The loop continues as long as i is less than or equal to 10.
• Update (i++): After each iteration, the value of i is incremented by 1.
• The printf statement inside the loop executes 10 times, printing the current value of i in each iteration.

#include <stdio.h>

int main() {
    int i = 10; // Initialize counter to 10

    printf("Numbers in reverse order:\n");
    
    // Loop continues as long as i is 1 or greater
    while (i >= 1) {
        printf("%d ", i);
        i--; // Decrement the counter
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization: i is set to 10.
• Condition (i >= 1): The loop body executes repeatedly as long as i is 1 or greater.
• Body: printf prints the current value of i.
• Update (i--): The decrement operator reduces i by 1 in each pass (10,9,8,…). This step is crucial; without it, the condition would always be true, creating an infinite loop.

#include <stdio.h>

int main() {
    int N, i, sum = 0;
    N = 10;
    
    // Loop from 1 to N
    for (i = 1; i <= N; i++) {
        sum = sum + i; // Accumulate the sum
    }

    printf("The sum of the first %d natural numbers is: %d\n", N, sum);

    return 0;
}Code language: C++ (cpp)

Explanation:

• sum = 0: The accumulator variable sum must be initialized to 0 to ensure the starting point is correct.
• for (i = 1; i <= N; i++): This loop iterates N times.
• sum = sum + i;: This is the accumulation step. In the first iteration, sum=0+1. In the second, sum=1+2=3, and so on, until all numbers up to N are added.

#include <stdio.h>
int main() {
    int i = 1;
    do {
        printf("%d ", i);
        i += 2;
    } while (i <= 100);
    return 0;
}Code language: C++ (cpp)

Explanation:

Unlike for and while, this do while loop runs the body first before checking the condition. Here, i begins at 1, and after each print, it is incremented by 2 to move to the next odd number. The loop continues until i becomes greater than 100.

#include <stdio.h>

int main() {
    int N, i;
    N = 2;

    printf("\nMultiplication Table for %d:\n", N);
    
    // Loop from 1 to 10
    for (i = 1; i <= 10; i++) {
        // Print: N x i = (N * i)
        printf("%d x %d = %d\n", N, i, N * i);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The printf statement formats the output to show the full equation (e.g., 5×3=15) for clarity.
• The program takes the input number N.
• The for loop uses i to represent the multiplier (1,2,3,…,10).
• Inside the loop, the expression N * i performs the calculation.

#include <stdio.h>

int main() {
    int choice;

    do {
        printf("\n--- Menu ---\n");
        printf("1. Greet\n");
        printf("2. Say Goodbye\n");
        printf("3. Exit\n");
        printf("Enter your choice (1-3): ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("Hello! Welcome to the program.\n");
                break;
            case 2:
                printf("Goodbye! Have a nice day.\n");
                break;
            case 3:
                printf("Exiting program. Thank you!\n");
                break; // Required to exit switch, not do-while
            default:
                printf("Invalid choice. Please enter 1, 2, or 3.\n");
        }
    } while (choice != 3); // Loop continues UNTIL choice is 3

    return 0;
}Code language: C++ (cpp)

Explanation:

This combines control flow structures for interactive programs.

• do { ... } while (condition): The code inside the do block executes first. The condition (choice != 3) is checked after the first run.
• The switch statement inside the loop handles the different menu options.
• The loop continues as long as choice is not equal to 3. Once the user enters 3, the switch handles the exit message, and the while condition becomes false, terminating the entire loop and ending the program.

#include <stdio.h>

int main() {
    int N, i;
    N = 5;
    // Factorials grow very fast, so we use long long
    long long factorial = 1; 
    
    if (N < 0) {
        printf("Error: Factorial is not defined for negative numbers.\n");
    } else {
        for (i = 1; i <= N; i++) {
            factorial *= i; // Equivalent to: factorial = factorial * i;
        }
        printf("The factorial of %d is: %lld\n", N, factorial);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization: factorial is set to 1, because 0!=1 and multiplying by 1 won’t change the product.
• Loop: The loop runs from i=1 to N.
• Calculation: The line factorial *= i; is the multiplication step. For N=5, it calculates: 5*4*3*2*1 = 120

#include <stdio.h>

int main() {
    long long num = 3456;
    int count = 0;
    long long original_num = num; // Save the original number for printing

    // Handle the case of 0 separately
    if (num == 0) {
        count = 1;
    } else {
        // Loop until the number becomes 0
        while (num > 0) {
            num /= 10; // Integer division removes the last digit
            count++;   // Increment digit count
        }
    }

    printf("The number %lld has %d digits.\n", original_num, count);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Process: The core of the logic is the loop: num /= 10; (e.g., 1234→123→12→1→0).
• Iteration: For every iteration, one digit is “removed” by the integer division, and the count is incremented.
• Termination: The loop stops when num is no longer greater than 0. The total number of iterations equals the number of digits. The special case for num=0 is handled separately, as the loop condition num > 0 would fail immediately.

#include <stdio.h>

int main() {
    int num = 123, reversed_num = 0, remainder;
    
    int original_num = num;

    while (num != 0) {
        remainder = num % 10; // 1. Extract the last digit
        reversed_num = reversed_num * 10 + remainder; // 2. Build the reversed number
        num /= 10; // 3. Remove the last digit
    }

    printf("The reverse of %d is: %d\n", original_num, reversed_num);

    return 0;
}Code language: C++ (cpp)

Explanation: If num=123:

• Loop ends. This pattern successfully extracts digits from the right and prepends them to the new reversed number.
• Iter 1: remainder = 3. reversed_num = 0*10 + 3 = 3. num = 12.
• Iter 2: remainder = 2. reversed_num = 3*10 + 2 = 32. num = 1.
• Iter 3: remainder = 1. reversed_num = 32*10 + 1 = 321. num = 0.

#include <stdio.h>

int main() {
    int num = 121, original_num, reversed_num = 0, remainder;
    
    original_num = num; // Crucial: save the original value

    // Logic to reverse the number
    while (num != 0) {
        remainder = num % 10;
        reversed_num = reversed_num * 10 + remainder;
        num /= 10;
    }

    // Check if the original and reversed numbers are the same
    if (original_num == reversed_num) {
        printf("%d is a PALINDROME.\n", original_num);
    } else {
        printf("%d is NOT a palindrome.\n", original_num);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Saving Original: Before entering the while loop, the value of num is copied to original_num. This is essential because the loop modifies and eventually reduces num to 0.
• Reversal: The while loop calculates the reversed_num exactly as in Exercise 19.
• Comparison: The final if statement compares the intact original_num against the computed reversed_num to determine if the number is a palindrome.

#include <stdio.h>

int main() {
    int N = 20, i;

    printf("Odd numbers from 1 to %d:\n", N);

    for (i = 1; i <= N; i++) {
        // Control flow check for even numbers
        if (i % 2 == 0) {
            continue; // Skips the rest of the loop body for even numbers
        }

        // This line only executes if 'i' is ODD
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

The continue keyword alters control flow within a loop by skipping the current iteration and immediately moving to the next one (i.e., the loop update expression).

• The loop iterates through all numbers.
• When an even number is encountered (i % 2 == 0), continue is executed. This causes the program to jump directly to i++, skipping the printf statement for that even number.
• The printf statement is only reached when i is an odd number.

#include <stdio.h>

int main() {
    int N=8, i;
    int t1 = 0, t2 = 1;
    int nextTerm = t1 + t2;

    printf("Fibonacci Series up to %d terms:\n%d, %d, ", N, t1, t2);

    // Start loop from i=3 since the first two terms are printed already
    for (i = 3; i <= N; ++i) {
        printf("%d, ", nextTerm);
        t1 = t2;
        t2 = nextTerm;
        nextTerm = t1 + t2;
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

Base Case: The first two terms (0 and 1) are initialized and printed outside the loop.

Loop Logic: The for loop iterates for the remaining terms. In each iteration:

• A new nextTerm is calculated. This three-step update shifts the window of the last two terms forward.
• The nextTerm is printed.
• The “old” second term (t2) becomes the new first term (t1).
• The nextTerm becomes the new second term (t2).

#include <stdio.h>

int main() {
    int rows=3, cols=3, i, j;

    // Outer loop for rows
    for (i = 1; i <= rows; i++) {
        // Inner loop for columns (prints stars in a single row)
        for (j = 1; j <= cols; j++) {
            printf("*");
        }
        printf("\n"); // Move to the next line after a row is complete
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

Nested loops are essential for 2D patterns.

• Outer loop (i): Iterates R times, representing each row.
• Inner loop (j): Iterates C times. In each iteration, it prints one * without a newline, building a single row horizontally.
• Newline: printf("\n"); is placed outside the inner loop but inside the outer loop. This ensures that after a complete row of C stars is printed, the cursor moves to the beginning of the next line.

#include <stdio.h>

int main() {
    const int SIZE = 5;
    int arr[SIZE];
    int i;

    // 1. Input Loop
    printf("Enter 5 integers:\n");
    for (i = 0; i < SIZE; i++) {
        printf("Enter element %d: ", i + 1);
        scanf("%d", &arr[i]); // Read into the address of the array element
    }

    // 2. Output Loop
    printf("\nElements stored in the array: ");
    for (i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• Input: In the first loop, scanf("%d", &arr[i]); reads the integer and stores it at the memory address of the array element at index i.
• Output: The second loop retrieves the stored value at arr[i] and prints it. Separating input and output loops is standard practice for clear array handling.

#include <stdio.h>

int main() {
    int arr[5] = {10, 5, 20, 15, 30};
    int i;
    int sum = 0; // Accumulator variable

    for (i = 0; i < 5; i++) {
        sum = sum + arr[i]; // Add current element to the sum
    }

    printf("The elements are: 10, 5, 20, 15, 30\n");
    printf("The sum of all array elements is: %d\n", sum);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization: sum starts at 0.
• for (i = 0; i < 5; i++): Rum loop 5 times to loop through the array
• Accumulation: Inside each iteration use the accumulation technique (sum = sum + array[i]). It adds current element to the sum.

#include <stdio.h>

int main() {
    int arr[6] = {55, 12, 89, 7, 42, 60};
    int i;
    
    // Initialize max and min with the first element
    int max = arr[0];
    int min = arr[0];

    // Loop starts from the second element (index 1)
    for (i = 1; i < 6; i++) {
        if (arr[i] > max) {
            max = arr[i]; // New maximum found
        }
        if (arr[i] < min) {
            min = arr[i]; // New minimum found
        }
    }

    printf("Array elements: {55, 12, 89, 7, 42, 60}\n");
    printf("Maximum element: %d\n", max);
    printf("Minimum element: %d\n", min);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Initialization: By setting max and min to arr[0], we ensure they have valid starting points from the array.
• Comparison: The loop starts at index 1 because the element at index 0 has already been accounted for. Two separate if statements check for the maximum and minimum in every iteration. This efficient technique avoids unnecessary nested logic.

#include <stdio.h>

int main() {
    int arr[5] = {10, 25, 30, 45, 50};
    int key, i;
    int found_index = -1; // -1 indicates not found

    printf("Enter the element to search: ");
    scanf("%d", &key);

    for (i = 0; i < 5; i++) {
        if (arr[i] == key) {
            found_index = i; // Store the index where it was found
            break;           // Element found, exit loop immediately
        }
    }

    if (found_index != -1) {
        printf("Element %d found at index %d.\n", key, found_index);
    } else {
        printf("Element %d not found in the array.\n", key);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Flag/Index: The variable found_index is used to track the search result. Initializing it to −1 is a common way to denote “not found” since array indices are always non-negative.
• Search: The for loop performs a linear search. The if (arr[i] == key) condition checks for a match.
• Efficiency: Once a match is found, break terminates the loop, preventing unnecessary comparisons for the remaining elements.
• Result: The final if-else statement checks the value of found_index to report the result.

#include <stdio.h>

// Function signature is void, meaning it returns nothing
void check_even_odd(int num) {
    if (num % 2 == 0) {
        printf("%d is EVEN.\n", num);
    } else {
        printf("%d is ODD.\n", num);
    }
}

int main() {
    int A = 42;
    int B = 17;

    printf("Checking numbers...\n");
    
    // Call the function for A
    check_even_odd(A); 
    
    // Call the function for B
    check_even_odd(B);

    return 0;
}Code language: C++ (cpp)

Explanation:

• void Return Type: void check_even_odd(int num) signifies that the function accepts an integer but does not return any data. Its purpose is solely to execute the code within its body (the printing).
• Functionality: The logic inside the function is the same as in Exercise 13 (Even/Odd check).
• Call: The function is called with check_even_odd(A);. This simply transfers control and the value of A to the function. When the function finishes, control returns to main().

#include <stdio.h>

// Function definition
int find_max(int arr[], int size) {
    int max = arr[0]; // Initialize max with the first element
    int i;
    
    for (i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max; // Return the final maximum value
}

int main() {
    int data[] = {8, 15, 2, 70, 9, 33};
    int size = 6;
    int result;

    // Call the function
    result = find_max(data, size);

    printf("The array elements are: {8, 15, 2, 70, 9, 33}\n");
    printf("The largest element found by the function is: %d\n", result);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Function Parameters: int arr[] tells the function it’s receiving an array of integers. The int size is passed separately because C arrays, when passed to a function, decay into pointers and lose their size information.
• Logic: The function uses the comparison logic to iteratively update max.
• Return: Once the loop completes, return max; sends the single maximum value back to main(), which stores it in the result variable.

#include <stdio.h>

int main() {
    char str[100];
    int length = 0;

    printf("Enter a string:\n ");
    // Read string input (up to 99 characters)
    scanf("%s", str); 

    // Loop through the array until the null terminator is found
    while (str[length] != '\0') {
        length++;
    }

    printf("The length of the string is: %d\n", length);

    return 0;
}Code language: C++ (cpp)

Explanation:

• char str[100];: Declares a character array to store the string.
• scanf("%s", str);: Reads the string. Note that scanf with %s automatically appends the null terminator (\0) and does not need the address-of operator (&) for the array name.
• while (str[length] != '\0'): The loop increments the length counter until the null terminator is reached. Since the null terminator itself is not counted as part of the string’s length, the loop correctly exits after counting the last valid character.

#include <stdio.h>

int main() {
    char source[] = "Copy Me!";
    // Destination must be large enough to hold the source string + '\0'
    char destination[20]; 
    int i = 0;

    // Loop until the null terminator of the source string is reached
    while (source[i] != '\0') {
        destination[i] = source[i];
        i++;
    }

    // Essential: Add the null terminator to the destination string
    destination[i] = '\0'; 

    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The code uses a while loop to traverse the source string. In each iteration, destination[i] = source[i]; copies the character from the source to the destination.
• The loop stops when source[i] is the null terminator.
• After the loop, the index i is pointing to the position right after the last copied character. The line destination[i] = '\0'; manually places the null terminator, ensuring the destination array is treated as a valid C string.

#include <stdio.h>
#include <ctype.h> // For tolower() to simplify the vowel check

int main() {
    char str[] = "Programming In C is fun.";
    int vowels = 0;
    int consonants = 0;
    int i = 0;

    while (str[i] != '\0') {
        char ch = tolower(str[i]); // Convert to lowercase for simplified check

        // Check if the character is an alphabet
        if (ch >= 'a' && ch <= 'z') {
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
                vowels++;
            } else {
                consonants++;
            }
        }
        i++;
    }

    printf("String: %s\n", str);
    printf("Total Vowels: %d\n", vowels);
    printf("Total Consonants: %d\n", consonants);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The code iterates through the string. It first uses tolower() from <ctype.h> to convert the character to lowercase, simplifying the vowel check. The outer if condition ensures that the character is an alphabet.
• The inner if condition explicitly checks if the character matches any of the five lowercase vowels using the logical OR operator (||). If it is an alphabet and not a vowel, the else block increments the consonants count. Non-alphabetic characters (spaces, periods, digits) are correctly ignored.

#include <stdio.h>
#include <ctype.h> // For isspace()

int main() {
    // String starts/ends with spaces and has multiple spaces between words
    char str[] = "This is a test string"; 
    int word_count = 0;
    // 0: outside a word, 1: inside a word
    int is_word = 0; 
    int i = 0;

    while (str[i] != '\0') {
        if (isspace(str[i])) {
            // Character is a space (or other whitespace)
            is_word = 0;
        } else if (is_word == 0) {
            // Character is NOT a space AND we were previously outside a word
            is_word = 1; // Now inside a word
            word_count++; // Increment count (start of a new word)
        }
        i++;
    }

    printf("The string is: \"%s\"\n", str);
    printf("Total number of words: %d\n", word_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

The code uses a state-machine approach with the is_word flag. The isspace() function (from <ctype.h>) reliably checks for any whitespace character (space, tab, newline).

• If a space is found, the is_word flag is reset to 0 (the program is “outside a word”).
• If a non-space character is found and is_word was 0 (meaning the previous character was a space or it’s the start of the string), it means a new word has begun. The is_word flag is set to 1, and word_count is incremented. This logic correctly handles leading/trailing spaces and multiple spaces between words by only counting the transition from a space/non-word state to a non-space/word state.

#include <stdio.h>

int main() {
    int length = 0;
    int i;

   char str[] = "Elon"; 

    // 1. Calculate length
    while (str[length] != '\0') {
        length++;
    }

    printf("Reversed string: ");
    // 2. Print characters from last to first
    for (i = length - 1; i >= 0; i--) {
        printf("%c", str[i]);
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

Length Calculation: The while loop calculates the length, necessary for knowing where the string ends.

Reverse Loop: The for loop is structured to iterate backward:

• Initialization: i = length - 1 (The last valid character index).
• Condition: i >= 0 (Continue until the first index).
• Update: i-- (Move backward one character).

In each iteration, str[i] prints the character starting from the end, effectively reversing the output.

#include <stdio.h>
#include <ctype.h>

int main() {
    char str[] = "Jessa";
    int frequency[26] = {0}; // Initialize all 26 counters to zero
    int i, index;

    for (i = 0; str[i] != '\0'; i++) {
        char ch = tolower(str[i]);

        if (ch >= 'a' && ch <= 'z') {
            // Calculate index (a=0, b=1, c=2, ...)
            index = ch - 'a'; 
            frequency[index]++;
        }
    }

    printf("\nCharacter Frequencies:\n");
    for (i = 0; i < 26; i++) {
        if (frequency[i] > 0) {
            // Convert index back to character: 'a' + 0 = 'a'
            printf("%c: %d\n", 'a' + i, frequency[i]);
        }
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Frequency Array: An array of size 26 is used, where index 0 stores the count for ‘a’, index 1 for ‘b’, and so on.
• Indexing: The expression index = ch - 'a'; utilizes the fact that characters are stored as sequential ASCII values. For example, if ch is ‘c’, 'c' - 'a' is 2, which is the correct index for ‘c’.
• Counting: frequency[index]++; increments the counter for the corresponding letter.
• Output: The final loop iterates through the 26 counters. Only if a count is greater than 0 is the character ('a' + i) and its count printed.

#include <stdio.h>

// 1. Structure Definition
struct Student {
    char name[50];
    int roll_number;
    float percentage;
};

int main() {
    // 2. Declare a structure variable
    struct Student s1;

    // 3. Input details
    printf("Enter Student Name: \n");
    scanf("%s", s1.name); // Note: scanf stops reading at the first whitespace

    printf("Enter Roll Number: \n");
    scanf("%d", &s1.roll_number);

    printf("Enter Percentage: \n");
    scanf("%f", &s1.percentage);

    // 4. Display details
    printf("\n--- Student Details ---\n");
    printf("Name: %s\n", s1.name);
    printf("Roll Number: %d\n", s1.roll_number);
    printf("Percentage: %.2f%%\n", s1.percentage);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program first defines the Student structure template. In main(), a variable s1 of this structure type is created, reserving memory for all three members contiguously.
• The input process uses the dot operator (s1.name, s1.roll_number, etc.) to directly access and assign values to the individual fields of the s1 variable. The output simply retrieves and prints these stored values.

#include <stdio.h>

struct Student {
    char name[50];
    int roll_number;
    float marks;
};

int main() {
    // Array of 3 Student structures
    struct Student students[3]; 
    int i;

    // Input loop
    for (i = 0; i < 3; i++) {
        printf("\n--- Enter Data for Student %d ---\n", i + 1);
        printf("Name: ");
        scanf("%s", students[i].name);
        printf("Roll Number: ");
        scanf("%d", &students[i].roll_number);
        printf("Marks: ");
        scanf("%f", &students[i].marks);
    }

    // Output loop
    printf("\n--- All Student Records ---\n");
    for (i = 0; i < 3; i++) {
        printf("Student %d: Name=%s, Roll=%d, Marks=%.2f\n", 
               i + 1, students[i].name, students[i].roll_number, students[i].marks);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Array Declaration: struct Student students[3]; creates an array where each element (students[0], students[1], students[2]) is a complete Student structure.
• Looping: The for loop makes it easy to process multiple records. Inside the loop, students[i] accesses the i-th student’s record, and the dot operator (.name, .roll_number, etc.) accesses the fields within that record.

#include <stdio.h>

// 1. Inner Structure
struct Date {
    int day;
    int month;
    int year;
};

// 2. Outer Structure, containing an instance of Date
struct Employee {
    int id;
    char name[50];
    struct Date date_of_joining; // Nested Structure
};

int main() {
    struct Employee e1;

    printf("Enter Employee ID: \n");
    scanf("%d", &e1.id);
    printf("Enter Employee Name: \n");
    scanf("%s", e1.name);
    printf("Enter Date of Joining (day month year): \n");
    // Chained access for nested members
    scanf("%d %d %d", &e1.date_of_joining.day, 
                      &e1.date_of_joining.month, 
                      &e1.date_of_joining.year);

    // Displaying the data
    printf("\n--- Employee Record ---\n");
    printf("ID: %d\n", e1.id);
    printf("Name: %s\n", e1.name);
    printf("Joining Date: %d/%d/%d\n", 
           e1.date_of_joining.day, 
           e1.date_of_joining.month, 
           e1.date_of_joining.year);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Nesting: struct Date date_of_joining; within struct Employee makes date_of_joining a member of type Date.
• Chained Access: To reach the year member, you must first access the employee variable (e1), then the nested structure member (.date_of_joining), and finally the desired field (.year), resulting in e1.date_of_joining.year. This demonstrates how to navigate layers of structures.

#include <stdio.h>

// 1. Structure Definition
struct Car {
    int model_year;
    char color[20];
};

int main() {
    // 2. Declare a structure variable
    struct Car my_car;
    // 3. Declare a pointer to the structure
    struct Car *car_ptr;

    // 4. Point the pointer to the structure variable
    car_ptr = &my_car;

    // 5. Access and assign values using the arrow operator (->)
    printf("Enter Car Model Year: \n");
    scanf("%d", &car_ptr->model_year);
    printf("Enter Car Color: ");
    scanf("%s", car_ptr->color);

    // 6. Access and display values using the arrow operator
    printf("\n--- Car Details (via Pointer) ---\n");
    printf("Model Year: %d\n", car_ptr->model_year);
    printf("Color: %s\n", car_ptr->color);

    return 0;
}Code language: C++ (cpp)

Explanation:

• car_ptr is a pointer designed to hold the memory address of a struct Car.
• By assigning car_ptr = &my_car;, it points to the my_car variable.
• The arrow operator (->) is syntactical shorthand for dereferencing the pointer and then accessing a member. For example, car_ptr->model_year is equivalent to (*car_ptr).model_year. This is the standard way to interact with structures via pointers.

#include <stdio.h>

int main() {
    int num = 42;
    // Declare a pointer to an integer
    int *ptr; 

    // Assign the address of num to ptr
    ptr = &num; 

    printf("Value of num: %d\n", num);
    printf("Address of num (&num): %p\n", &num);
    printf("Value stored in ptr (address): %p\n", ptr);
    
    // Dereference ptr to get the value at that address
    printf("Value retrieved by *ptr: %d\n", *ptr); 

    return 0;
}Code language: C++ (cpp)

Explanation:

• int *ptr;: This declares ptr as a variable that holds the memory address of an integer.
• ptr = #: The address-of operator (&) retrieves the memory address where num is stored, and this address is assigned to the pointer ptr.
• *ptr: The dereference operator (*) tells the program to access the value stored at the memory location currently held by ptr. Since ptr holds the address of num, *ptr gives us the value 42.

#include <stdio.h>

int main() {
    int data = 100;
    int *data_ptr = &data; // Initialization and assignment in one step

    printf("Initial value of data: %d\n", data);
    
    // Use the pointer to modify the value stored at its address
    *data_ptr = 250; 

    printf("New value of data (modified via pointer): %d\n", data);
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• int *data_ptr = &data;: The pointer is initialized to hold the address of data.
• *data_ptr = 250;: This is the core pointer operation. It is equivalent to saying: “Go to the memory address held by data_ptr (which is the address of data), and put the value 250 there.” This directly overwrites the original value of data.

#include <stdio.h>

// Function takes a pointer to an integer (pass by reference)
void square_value(int *n) {
    // Read the value, calculate the square, and write the result back
    *n = (*n) * (*n); 
}

int main() {
    int x = 5;

    printf("Original value of x: %d\n", x);
    
    // Pass the address of x to the function
    square_value(&x); 

    printf("Value of x after function call: %d\n", x);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Pass by Reference: By passing the address (&x), the function does not work on a copy of x but on the original variable’s memory. This is called pass by reference.
• *n = (*n) * (*n);: The function first dereferences the pointer to get the value 5. It squares it to get 25. It then uses the dereference operator on the left side to write 25 back into the memory location pointed to by n (which is x). The original variable x is permanently modified.

#include <stdio.h>

int main() {
    int arr[3] = {10, 20, 30};
    int *p;

    // The array name acts as a pointer to the first element (arr[0])
    p = arr; 

    printf("Value of the first element (arr[0]): %d\n", *p);
    
    // Pointer arithmetic: p + 1 points to the next integer element (arr[1])
    // The asterisk (*) dereferences the new address
    printf("Value of the second element (arr[1] via pointer arithmetic): %d\n", *(p + 1));
    
    // We can also increment the pointer itself:
    p++; // p now points to arr[1]
    printf("Value of the second element (*p after increment): %d\n", *p);

    return 0;
}Code language: C++ (cpp)

Explanation:

• p = arr;: The array name arr evaluates to the address of its first element (&arr[0]).
• *(p + 1): When you add an integer N to a pointer, the pointer doesn’t just increase by N bytes; it increases by N times the size of the data type it points to. Since p is an int *, p + 1 automatically moves the address forward by sizeof(int) bytes, making it point directly to arr[1]. The dereference operator then retrieves the value 20.

#include <stdio.h>

int main() {
    int A = 75;
    int B = 92;
    int *ptrA = &A;
    int *ptrB = &B;

    printf("Variable A holds: %d\n", *ptrA);
    printf("Variable B holds: %d\n", *ptrB);

    // Compare the values pointed to by the pointers
    if (*ptrA > *ptrB) {
        printf("A is larger (Value: %d).\n", *ptrA);
    } else if (*ptrB > *ptrA) {
        printf("B is larger (Value: %d).\n", *ptrB);
    } else {
        printf("The values are equal (Value: %d).\n", *ptrA);
    }

    // Example of comparing addresses (for conceptual clarity, though not the main requirement)
    if (ptrA > ptrB) {
        printf("\n(Address of A is higher than address of B)\n");
    } else {
        printf("\n(Address of B is higher than address of A)\n");
    }


    return 0;
}Code language: C++ (cpp)

Explanation:

• Pointer Assignment: ptrA = &A and ptrB = &B assign the addresses of the two variables.
• Value Comparison: The crucial part is *ptrA > *ptrB. This compares the content of the memory locations (the values 75 and 92), not the addresses themselves. The program correctly identifies B as having the larger value.
• Address Comparison: The second if statement shows that you can also compare the pointers directly (ptrA > ptrB), which compares the numerical memory addresses, but this is usually only meaningful when pointers point to the same array or structure.

#include <stdio.h>

// Recursive function for factorial
long long factorial(int n) {
    // Base Case: Stops the recursion
    if (n == 0) {
        return 1;
    }

    // Recursive Step: Calls itself with n-1
    return n * factorial(n - 1); 
}

int main() {
    int num = 5;
    long long result = factorial(num);

    printf("Factorial of %d is: %lld\n", num, result); // 5! = 120

    return 0;
}Code language: C++ (cpp)

Explanation:

Recursion is the process where a function calls itself.

• Base Case (n=0): When the function hits the base case, it returns 1, preventing infinite calls.
• Stacking Calls: For factorial(5), the calls stack up: 5×fact(4)→5×(4×fact(3))→⋯→5×4×3×2×1×fact(0).
• Unwinding: Once fact(0) returns 1, the multiplication results are returned back up the stack (unwinding) until the final result is returned to main. This process uses the program’s call stack to store intermediate results.

#include <stdio.h>

int main() {
    int size = 5;
    int source_arr[5] = {1, 2, 3, 4, 5};
    int dest_arr[5]; // Destination array
    int i;

    printf("Source array elements: ");
    for (i = 0; i < size; i++) {
        printf("%d ", source_arr[i]);
    }
    printf("\n");

    // Loop to copy elements
    for (i = 0; i < size; i++) {
        dest_arr[i] = source_arr[i];
    }

    printf("Destination array elements (after copy): ");
    for (i = 0; i < size; i++) {
        printf("%d ", dest_arr[i]);
    }
    printf("\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

This is the most straightforward array manipulation technique.

• The program uses a for loop that iterates from the first index (0) to the last index (size−1).
• Inside the loop, the assignment statement dest_arr[i] = source_arr[i]; explicitly copies the value stored at index i of the source array into the same index i of the destination array. This ensures an exact, element-by-element replication of the source array’s content.

#include <stdio.h>
#include <stdlib.h> // Needed for exit()

int main() {
    // Declare a file pointer
    FILE *fp;
    char name[] = "Alice Johnson";
    int age = 30;

    // Open the file in write mode ("w")
    fp = fopen("data.txt", "w");

    // Check for file opening error
    if (fp == NULL) {
        printf("Error opening file!\n");
        // Exit the program if file cannot be opened
        exit(1); 
    }

    // Write data to the file
    fprintf(fp, "Name: %s\n", name);
    fprintf(fp, "Age: %d years\n", age);

    // Close the file
    fclose(fp);

    printf("Data successfully written to data.txt.\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program first declares a FILE pointer, fp. It attempts to open data.txt in write mode ("w"). If the file doesn’t exist, it’s created; if it exists, its content is truncated (deleted). The program checks if fp is NULL, which indicates a failure to open the file.
• If successful, fprintf() is used exactly like printf(), but its first argument is the file pointer, directing the output to the file instead of the console. Finally, fclose(fp) is called to close the file, flushing any remaining buffers and releasing the file resource.

#include <stdio.h>
#include <stdlib.h> 

int main() {
    FILE *fp;
    char buffer[100]; // Buffer to hold each line of data

    // Open the file in read mode ("r")
    fp = fopen("data.txt", "r");

    if (fp == NULL) {
        printf("Error opening file or file not found!\n");
        exit(1);
    }

    printf("Content of data.txt:\n");
    printf("---------------------\n");

    // Read content line by line using fgets()
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        // Print the line read from the file to the console
        printf("%s", buffer);
    }

    // Close the file
    fclose(fp);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is opened in read mode ("r"). A character array, buffer, is used as a temporary storage space for each line read.
• The fgets() function reads a line from the file stream (fp) and stores it into buffer, reading at most sizeof(buffer) - 1 characters, or until a newline character or EOF is encountered.
• The loop continues as long as fgets() returns a non-NULL value. The content of the buffer is then printed to the standard output using printf().

#include <stdio.h>
#include <stdlib.h> 

int main() {
    FILE *fp;

    // Use a simple date string for demonstration
    char date[] = "2025-10-15"; 

    // Open the file in append mode ("a")
    fp = fopen("data.txt", "a");

    if (fp == NULL) {
        printf("Error opening file!\n");
        exit(1);
    }

    // Write the new data (appended to the end)
    fprintf(fp, "Date Appended: %s\n", date);
    fprintf(fp, "Status: Successfully appended.\n");

    // Close the file
    fclose(fp);

    printf("New data successfully appended to data.txt.\n");

    return 0;
}Code language: C++ (cpp)

Explanation:

The core difference here is the use of the append mode ("a") in fopen(). When a file is opened in this mode, the file pointer is automatically positioned at the end of the file. Subsequent write operations using fprintf() or other output functions will simply add the new data after the existing content, preserving the original data.

#include <stdio.h>
#include <stdlib.h> 

int main() {
    FILE *fp;
    int character;
    long char_count = 0; // Use long for potentially large files

    fp = fopen("data.txt", "r");

    if (fp == NULL) {
        printf("Error: Could not open data.txt\n");
        exit(1);
    }

    // Read the file character by character
    while ((character = fgetc(fp)) != EOF) {
        char_count++;
    }

    fclose(fp);

    printf("Total number of characters in the file: %ld\n", char_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The file is read using the fgetc() function, which returns the next character from the file stream as an int. We use an int to store the return value because it must be able to hold the EOF value (which is outside the range of a standard char).
• Inside the while loop, as long as the returned value is not equal to EOF, the character counter (char_count) is incremented.

#include <stdio.h>
#include <stdlib.h> 

int main() {
    FILE *fp;
    int character;
    int line_count = 0;

    fp = fopen("data.txt", "r");

    if (fp == NULL) {
        printf("Error: Could not open data.txt\n");
        exit(1);
    }

    // Read character by character
    while ((character = fgetc(fp)) != EOF) {
        // Check for the newline character
        if (character == '\n') {
            line_count++;
        }
    }

    // A common convention: If the file is not empty and doesn't end with a newline, 
    // the last line won't have been counted yet. We check the file size to see if it's empty.
    if (line_count == 0) {
         // Reset pointer to beginning to check if file is empty
         fseek(fp, 0, SEEK_END); 
         if (ftell(fp) > 0) { 
             line_count = 1; // It's not empty, so it has at least one line
         }
    } else {
         // If there was content and the last character wasn't a newline, increment count
         // Simpler approach: Check if the last character read was NOT a newline
         fseek(fp, -1, SEEK_END);
         if (fgetc(fp) != '\n') {
             line_count++;
         }
    }

    // Simpler, more robust approach:
    // if (line_count > 0 || (fseek(fp, 0, SEEK_END) != -1 && ftell(fp) > 0) ) {
    //     // Logic to handle the last line without a newline
    // }


    fclose(fp);

    printf("Total number of lines in the file: %d\n", line_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise uses fgetc() to iterate through the file.

• The program specifically looks for the newline character ('\n'); every time this character is found, the line_count is incremented.
• A key complexity in line counting is handling the last line of the file. If a file ends with actual content but without a final newline character, the last line won’t be counted.
• The robust solution often involves a conditional check after the loop to see if the file contained any characters at all and if the last character read was not a newline.