Problem Statement 1:

You are tasked with creating a simple program in C that takes two numbers as input from the user and allows them to perform basic arithmetic operations such as addition, subtraction, multiplication, and division on these numbers. The program should use if-else statements and arithmetic operators to carry out the chosen operation. It should also handle the case of division by zero and provide appropriate error messages for invalid operations.

Code:

#include <stdio.h>

int main()
{
    double num1, num2;
    char operation;

    // Prompt the user to enter two numbers
    printf("Enter two numbers: ");
    scanf("%lf %lf", &num1, &num2);

    // Ask the user to choose an operation (+, -, *, /)
    printf("Enter an operation (+, -, *, /): ");
    scanf(" %c", &operation);

    // Use if-else statements to perform the selected operation
    if (operation == '+')
    {
        // Addition
        printf("%.2lf + %.2lf = %.2lf\n", num1, num2, num1 + num2);
    }
    else if (operation == '-')
    {
        // Subtraction
        printf("%.2lf - %.2lf = %.2lf\n", num1, num2, num1 - num2);
    }
    else if (operation == '*')
    {
        // Multiplication
        printf("%.2lf * %.2lf = %.2lf\n", num1, num2, num1 * num2);
    }
    else if (operation == '/')
    {
        // Division
        // Check if the second number is not zero to avoid division by zero
        if (num2 != 0.0)
        {
            printf("%.2lf / %.2lf = %.2lf\n", num1, num2, num1 / num2);
        }
        else
        {
            printf("Cannot divide by zero.\n");
        }
    }
    else
    {
        // If the operation is not recognized
        printf("Invalid operation.\n");
    }

    return 0;
}

Explanation:

1. The code starts by including the standard input/output library (<stdio.h>).

2. In the main() function, we declare the following variables:

   • double num1, num2; to store the two numbers entered by the user.

   • char operation; to store the selected arithmetic operation.

3. We prompt the user to enter two numbers using printf, and then we use scanf to read and store these numbers in num1 and num2.

4. Next, we ask the user to choose an operation (+, -, *, /) using printf and read their choice into the operation variable using scanf. Note that there is a space before %c in scanf to consume any leading whitespace characters or newline characters left in the input buffer.

5. We use a series of if-else statements to check the value of operation and perform the corresponding arithmetic operation:

   • If operation is +, we perform addition and print the result.

   • If operation is -, we perform subtraction and print the result.

   • If operation is *, we perform multiplication and print the result.

   • If operation is /, we perform division, but we also check if num2 is not zero to avoid division by zero. If it's not zero, we print the result; otherwise, we print an error message.

6. If none of the recognized operations is chosen, we print "Invalid operation."

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 2:

You are tasked with creating a program in C that converts temperatures between Fahrenheit and Celsius. The program should allow the user to choose the conversion direction using if-else statements and use arithmetic operators for the conversions. It should handle conversions from Celsius to Fahrenheit and from Fahrenheit to Celsius based on the unit provided by the user (C for Celsius, F for Fahrenheit).

Code:

#include <stdio.h>

int main()
{
    double temperature;
    char unit;

    // Prompt the user to enter the temperature and its unit (C or F)
    printf("Enter temperature followed by its unit (C or F): ");
    scanf("%lf %c", &temperature, &unit);

    // Using if-else statements to determine the conversion direction
    if (unit == 'C' || unit == 'c')
    {
        // Convert from Celsius to Fahrenheit
        double fahrenheit = (temperature * 9 / 5) + 32;
        printf("%.2lf°C is equal to %.2lf°F\n", temperature, fahrenheit);
    }
    else if (unit == 'F' || unit == 'f')
    {
        // Convert from Fahrenheit to Celsius
        double celsius = (temperature - 32) * 5 / 9;
        printf("%.2lf°F is equal to %.2lf°C\n", temperature, celsius);
    }
    else
    {
        // If the unit is not recognized
        printf("Invalid unit. Please enter C for Celsius or F for Fahrenheit.\n");
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, two variables are declared:

   • double temperature; to store the temperature value entered by the user.

   • char unit; to store the unit of the temperature (C for Celsius, F for Fahrenheit).

3. The program prompts the user to enter the temperature followed by its unit, such as "25 C" or "78 F." It uses printf to display the prompt and scanf to read the input values, storing the temperature in temperature and the unit in unit.

4. The program uses if-else statements to determine the conversion direction based on the value of unit:

   • If unit is 'C' or 'c', it converts from Celsius to Fahrenheit using the formula (Celsius * 9/5) + 32 and prints the result in both Celsius and Fahrenheit.

   • If unit is 'F' or 'f', it converts from Fahrenheit to Celsius using the formula (Fahrenheit - 32) * 5/9 and prints the result in both Fahrenheit and Celsius.

   • If unit is neither 'C'/'c' nor 'F'/'f', it prints an error message indicating that the unit is invalid.

5. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 3:

You are tasked with creating a program in C that calculates the factorial of a non-negative integer entered by the user. The program should use a loop to perform the calculation and display the result. It should handle the case of a negative input by informing the user that the factorial of a negative number doesn't exist.

Code:

#include <stdio.h>

int main()
{
    int n, i;
    unsigned long long factorial = 1; // long long is used to handle larger numbers

    // Prompt the user to enter a non-negative integer
    printf("Enter a non-negative integer: ");
    scanf("%d", &n);

    // Check if the user entered a negative number
    if (n < 0)
    {
        printf("Factorial of a negative number doesn't exist.\n");
    }
    else
    {
        // Calculate the factorial using a loop
        for (i = 1; i <= n; ++i)
        {
            factorial *= i; // factorial = factorial * i
        }
        printf("Factorial of %d = %llu\n", n, factorial);
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, the following variables are declared:

   • int n to store the non-negative integer entered by the user.

   • int i to use as a loop counter.

   • unsigned long long factorial to store the factorial result. unsigned long long is used to handle larger numbers since factorials can become very large.

3. The program prompts the user to enter a non-negative integer using printf and reads the input into the variable n using scanf.

4. The program checks if the entered value of n is negative using an if statement. If n is negative, it prints an error message indicating that the factorial of a negative number doesn't exist.

5. If n is non-negative, the program proceeds to calculate the factorial using a for loop:

   • It initializes factorial to 1.

   • It then uses a loop to calculate the factorial by multiplying factorial with consecutive integers from 1 to n.

6. After the loop completes, the program prints the result, displaying the value of n and the calculated factorial.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 4:

You are tasked with creating a program in C that calculates the result of raising a number to a certain power entered by the user. The program should use loops and arithmetic operators to perform the calculation. It should also handle negative exponents appropriately.

Code:

#include <stdio.h>

int main()
{
    double base, result = 1.0;
    int exponent, i;

    // Prompt the user to enter the base and exponent
    printf("Enter a base number: ");
    scanf("%lf", &base);
    printf("Enter an exponent (integer): ");
    scanf("%d", &exponent);

    // Saving the original exponent value for display purposes
    int originalExponent = exponent;

    // Handling negative exponents
    if (exponent < 0)
    {
        base = 1 / base;
        exponent = -exponent;
    }

    // Calculate the power using a loop
    for (i = 1; i <= exponent; ++i)
    {
        result *= base;
    }

    // Display the result
    printf("%.2lf raised to the power of %d is %.2lf\n", base, originalExponent, result);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, the following variables are declared:

   • double base to store the base number entered by the user.

   • double result initialized to 1.0 to store the result of the calculation.

   • int exponent to store the integer exponent entered by the user.

   • int i to use as a loop counter.

3. The program prompts the user to enter a base number and an exponent (integer) using printf and reads these values into base and exponent using scanf.

4. To handle negative exponents, the program checks if exponent is less than 0. If it is, it calculates the reciprocal of the base and makes exponent positive.

5. The program then proceeds to calculate the power using a for loop:

   • It initializes result to 1.0.

   • It uses a loop that runs from 1 to exponent to repeatedly multiply result by base.

6. After the loop completes, the program prints the result, displaying the value of base, the original value of exponent, and the calculated result.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 5:

You are tasked with creating a program in C that checks whether a given year entered by the user is a leap year or not. The program should use if-else statements and conditions to determine if the year meets the leap year criteria.

Code:

#include <stdio.h>

int main()
{
    int year;

    // Prompt the user to enter a year
    printf("Enter a year: ");
    scanf("%d", &year);

    // Check if the year is a leap year
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
    {
        // If the year is divisible by 4 but not divisible by 100, or divisible by 400, it is a leap year
        printf("%d is a leap year.\n", year);
    }
    else
    {
        // If the above conditions are not met, it is not a leap year
        printf("%d is not a leap year.\n", year);
    }

    return 0;
}

Explanation:

1. The code starts with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, one variable is declared:

   • int year to store the year entered by the user.

3. The program prompts the user to enter a year using printf and reads the input into the variable year using scanf.

4. The program checks if the year is a leap year using an if-else statement and a series of conditions:

   • If year is divisible by 4 (year % 4 == 0) and not divisible by 100 (year % 100 != 0), or if it is divisible by 400 (year % 400 == 0), then it is a leap year.

5. If the above conditions are met, the program prints that the year is a leap year; otherwise, it prints that the year is not a leap year.

6. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 6:

You are tasked with creating a program in C that calculates the area of a circle. The radius of the circle should be entered by the user. The formula to calculate the area is: Area = π * radius * radius.

Code:

#include <stdio.h>

#define PI 3.14159

int main()
{
    double radius, area;

    // Prompt the user to enter the radius of the circle
    printf("Enter the radius of the circle: ");
    scanf("%lf", &radius);

    // Calculate the area of the circle
    area = PI * radius * radius;

    // Display the result
    printf("The area of the circle with radius %.2lf is %.2lf\n", radius, area);

    return 0;
}

Explanation:

1. The code starts by including the standard input/output library (<stdio.h>).

2. It defines a constant PI with the value 3.14159 using a preprocessor directive (#define). This constant represents the mathematical value of π (pi).

3. In the main() function, two variables are declared:

   • double radius to store the radius of the circle entered by the user.

   • double area to store the calculated area of the circle.

4. The program prompts the user to enter the radius of the circle using printf and reads the input into the variable radius using scanf.

5. The program calculates the area of the circle using the formula Area = PI * radius * radius and stores the result in the variable area.

6. Finally, the program displays the result to the user using printf, showing the value of the radius and the calculated area with two decimal places.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 7:

You are tasked with creating a program in C that swaps the values of two integer variables without using a third variable. The goal is to exchange the values of a and b using arithmetic operations, addition, and subtraction, in order to achieve the swap.

Code:

#include <stdio.h>

int main()
{
    int a, b;

    // Prompt the user to enter two integers
    printf("Enter two integers: ");
    scanf("%d %d", &a, &b);

    // Displaying original values
    printf("Original values: a = %d, b = %d\n", a, b);

    // Swapping the values without a third variable using arithmetic operations
    a = a + b;    // Step 1: Add both values and store the sum in 'a'
    b = a - b;    // Step 2: Subtract the original 'b' value from the new 'a' value and store it in 'b' (resulting in the original 'a' value in 'b')
    a = a - b;    // Step 3: Subtract the original 'b' value (now in 'a') from the new 'a' value (now in 'b') and store it in 'a' (resulting in the original 'b' value in 'a')

    // Displaying swapped values
    printf("Swapped values: a = %d, b = %d\n", a, b);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, two integer variables, a and b, are declared. These variables will store the values entered by the user.

3. The program prompts the user to enter two integers using printf and reads these input values into a and b using scanf.

4. The original values of a and b are displayed to the user using printf.

5. To swap the values of a and b without using a third variable, we employ a sequence of arithmetic operations:

   • a = a + b;: In this step, we add the values of a and b and store the result in a. Now, a holds the sum of the original values of a and b.

   • b = a - b;: Next, we subtract the original value of b (before the addition in the previous step) from the new value of a. This operation effectively assigns the original value of a to b.

   • a = a - b;: Finally, we subtract the original value of b (now in a) from the new value of a (now in b). This operation assigns the original value of b to a.

6. After the swap, the program displays the swapped values of a and b using printf.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 8:

You are tasked with creating a program in C that reverses the digits of a number entered by the user. The program should take an integer as input, reverse its digits, and display the reversed number.

Code:

#include <stdio.h>

int main()
{
    int num, reversedNum = 0;

    // Prompt the user to enter an integer
    printf("Enter an integer: ");
    scanf("%d", &num);

    // Process to reverse the digits of the number
    while (num != 0)
    {
        int digit = num % 10;                   // Extract the last digit of num
        reversedNum = reversedNum * 10 + digit; // Append the digit to reversedNum
        num /= 10;                              // Remove the last digit from num
    }

    // Display the reversed number
    printf("Reversed number: %d\n", reversedNum);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, two integer variables are declared:

   • int num to store the integer entered by the user.

   • int reversedNum initialized to 0 to store the reversed number.

3. The program prompts the user to enter an integer using printf and reads the input into the variable num using scanf.

4. To reverse the digits of the number, the program uses a while loop that continues until num becomes 0. Within the loop:

   • int digit = num % 10;: This line extracts the last digit of num and stores it in the variable digit.

   • reversedNum = reversedNum * 10 + digit;: It appends the extracted digit to the reversedNum by multiplying the existing reversed number by 10 (shifting digits to the left) and then adding the digit to the result.

   • num /= 10;: This line removes the last digit from num by integer division, effectively shifting digits to the right.

5. After the loop completes, the program displays the reversed number using printf.

6. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 9:

You are tasked with creating a program in C that calculates the sum of the first N natural numbers, where N is entered by the user. The program should ensure that N is a positive integer and then calculate and display the sum.

Code:

#include <stdio.h>

int main()
{
    int N, sum = 0;

    // Prompt the user to enter the value of N
    printf("Enter a positive integer N: ");
    scanf("%d", &N);

    // Check if N is positive
    if (N <= 0)
    {
        printf("Please enter a positive integer.\n");
    }
    else
    {
        // Calculate the sum of the first N natural numbers
        for (int i = 1; i <= N; i++)
        {
            sum += i; // Add each number to sum
        }

        // Display the result
        printf("Sum of the first %d natural numbers is: %d\n", N, sum);
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, two integer variables are declared:

   • int N to store the positive integer entered by the user (N).

   • int sum initialized to 0 to store the sum of the first N natural numbers.

3. The program prompts the user to enter a positive integer N using printf and reads the input into the variable N using scanf.

4. It checks if N is positive by using an if statement. If N is not positive (less than or equal to 0), it prints an error message asking the user to enter a positive integer.

5. If N is positive, the program proceeds to calculate the sum of the first N natural numbers using a for loop:

   • The loop runs from 1 to N, and in each iteration, it adds the value of i to the sum variable, where i represents the current natural number.

6. After the loop completes, the program displays the result by printing the sum of the first N natural numbers along with the value of N.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 10:

You are tasked with creating a program in C that checks whether a number is prime or not. The program should take a positive integer as input, determine if it is prime, and display the result.

Code:

#include <stdio.h>

int main()
{
    int num, i, isPrime = 1; // isPrime is set to 1 (true)

    // Prompt the user to enter a number
    printf("Enter a positive integer: ");
    scanf("%d", &num);

    // Check if the number is less than or equal to 1
    if (num <= 1)
    {
        isPrime = 0; // 0 represents false
    }
    else
    {
        // Check for factors other than 1 and the number itself
        for (i = 2; i <= num / 2; i++)
        {
            if (num % i == 0)
            {
                isPrime = 0; // 0 represents false
                break;
            }
        }
    }

    // Display if the number is prime or not
    if (isPrime)
    {
        printf("%d is a prime number.\n", num);
    }
    else
    {
        printf("%d is not a prime number.\n", num);
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, three integer variables are declared:

   • int num to store the positive integer entered by the user.

   • int i for use in the loop to check for factors.

   • int isPrime initialized to 1 (true) to indicate that the number is assumed to be prime initially.

3. The program prompts the user to enter a positive integer using printf and reads the input into the variable num using scanf.

4. It checks if the entered number is less than or equal to 1. If num is less than or equal to 1, it sets isPrime to 0 (false), indicating that the number is not prime.

5. If num is greater than 1, the program proceeds to check for factors other than 1 and the number itself in the range from 2 to num / 2. It does this using a for loop:

   • In each iteration, it checks if num is divisible by i (i.e., num % i == 0). If it is, it sets isPrime to 0 (false) and breaks out of the loop.

6. After the loop completes, the program checks the value of isPrime to determine if the number is prime or not. If isPrime is 1, it prints that the number is prime; otherwise, it prints that the number is not prime.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 11:

You are tasked with creating a program in C that finds the greatest common divisor (GCD) of two numbers entered by the user. The program should take two integers as input, calculate their GCD using the Euclidean algorithm, and display the result.

Code:

#include <stdio.h>

int main()
{
    int num1, num2, gcd, temp, remainder;

    // Prompt the user to enter two integers
    printf("Enter two integers: ");
    scanf("%d %d", &num1, &num2);

    // Making sure num1 is the larger number
    if (num2 > num1)
    {
        temp = num1;
        num1 = num2;
        num2 = temp;
    }

    // Euclidean algorithm to find the GCD
    while (num2 != 0)
    {
        remainder = num1 % num2;
        num1 = num2;
        num2 = remainder;
    }

    gcd = num1;

    // Display the GCD
    printf("GCD of the entered numbers is: %d\n", gcd);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, five integer variables are declared:

   • int num1 and int num2 to store the two integers entered by the user.

   • int gcd to store the GCD of the two numbers.

   • int temp to temporarily store the value of num1 during swapping if needed.

   • int remainder to store the remainder during the Euclidean algorithm.

3. The program prompts the user to enter two integers using printf and reads these inputs into num1 and num2 using scanf.

4. To ensure that num1 holds the larger number and num2 holds the smaller number, the program checks if num2 is greater than num1. If it is, a temporary variable temp is used to swap the values of num1 and num2.

5. The Euclidean algorithm is used to find the GCD of the two numbers in a while loop:

   • The loop continues as long as num2 is not equal to 0.

   • In each iteration, the program calculates the remainder of num1 divided by num2 and stores it in remainder.

   • num2 is updated to remainder, and num1 retains its original value.

   • This process continues until num2 becomes 0, at which point num1 holds the GCD.

6. The GCD is stored in the variable gcd.

7. The program displays the calculated GCD using printf.

8. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 12:

You are tasked with creating a program in C that reads an integer and prints the sum of its digits. The program should take an integer as input, calculate the sum of its digits, and display the result.

Code:

#include <stdio.h>

int main()
{
    int num, sum = 0;

    // Prompt the user to enter an integer
    printf("Enter an integer: ");
    scanf("%d", &num);

    // Process to sum the digits of the number
    while (num != 0)
    {
        sum += num % 10; // Add the last digit to sum
        num /= 10;       // Remove the last digit from num
    }

    // Display the sum of the digits
    printf("Sum of the digits is: %d\n", sum);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, two integer variables are declared:

   • int num to store the integer entered by the user.

   • int sum initialized to 0 to store the sum of the digits.

3. The program prompts the user to enter an integer using printf and reads the input into the variable num using scanf.

4. To sum the digits of the number, the program uses a while loop that continues until num becomes 0. Within the loop:

   • sum += num % 10;: In each iteration, it extracts the last digit of num using the modulo operator (num % 10) and adds it to the sum variable.

   • num /= 10;: It then removes the last digit from num by integer division, effectively shifting digits to the right.

5. After the loop completes, the program displays the sum of the digits using printf.

6. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 13:

You are tasked with creating a program in C that prints the first N numbers of the Fibonacci sequence. The program should take an integer N as input, calculate and display the first N terms of the Fibonacci sequence.

Code:

#include <stdio.h>

int main()
{
    int n, first = 0, second = 1, next, i;

    // Prompt the user to enter the number of terms N
    printf("Enter the number of terms: ");
    scanf("%d", &n);

    printf("First %d terms of Fibonacci sequence are: ", n);

    for (i = 0; i < n; i++)
    {
        if (i <= 1)
            next = i; // The first two numbers are 0 and 1
        else
        {
            next = first + second; // Calculate the next Fibonacci number
            first = second;        // Update first with the value of the second
            second = next;         // Update second with the value of the next
        }
        printf("%d ", next); // Print the current Fibonacci number
    }

    printf("\n");

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, several integer variables are declared:

   • int n to store the number of terms in the Fibonacci sequence requested by the user.

   • int first initialized to 0, representing the first number in the sequence.

   • int second initialized to 1, representing the second number in the sequence.

   • int next to store the next number in the sequence.

   • int i to control the loop counter.

3. The program prompts the user to enter the number of terms (n) they want to generate in the Fibonacci sequence using printf, and reads the input into the variable n using scanf.

4. It initializes the first and second variables with the values 0 and 1 respectively, which are the first two terms of the Fibonacci sequence.

5. The program enters a for loop that iterates from 0 to n-1, printing the first n terms of the Fibonacci sequence. Inside the loop:

   • For the first two terms (when i is 0 or 1), it sets next to i since the Fibonacci sequence starts with 0 and 1.

   • For subsequent terms, it calculates the next Fibonacci number by adding first and second and stores it in next.

   • It then updates first with the value of second, effectively shifting the values for the next iteration.

   • It also updates second with the value of next to prepare for the next iteration.

   • Finally, it prints the current value of next.

6. After printing all n terms, the program prints a newline character to separate the output.

7. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 14:

You are tasked with creating a program in C that checks whether a number is a palindrome or not. A palindrome number is one that remains the same when its digits are reversed. The program should take an integer as input, reverse its digits, and determine if it is a palindrome or not.

Code:

#include <stdio.h>

int main()
{
    int num, originalNum, reversedNum = 0, remainder;

    // Prompt the user to enter an integer
    printf("Enter an integer: ");
    scanf("%d", &num);

    originalNum = num; // Store the original number

    // Process to reverse the digits of the number
    while (num != 0)
    {
        remainder = num % 10;                       // Get the last digit
        reversedNum = reversedNum * 10 + remainder; // Add it to the reversed number
        num /= 10;                                  // Remove the last digit
    }

    // Check if the number is a palindrome
    if (originalNum == reversedNum)
    {
        printf("%d is a palindrome.\n", originalNum);
    }
    else
    {
        printf("%d is not a palindrome.\n", originalNum);
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, four integer variables are declared:

   • int num to store the integer entered by the user.

   • int originalNum to store the original number before reversal.

   • int reversedNum initialized to 0 to store the reversed number.

   • int remainder to store the remainder when extracting digits.

3. The program prompts the user to enter an integer using printf and reads the input into the variable num using scanf.

4. It stores the original value of num in the originalNum variable to compare it with the reversed number later.

5. To reverse the digits of the number, the program uses a while loop that continues until num becomes 0. Inside the loop:

   • remainder = num % 10;: In each iteration, it extracts the last digit of num using the modulo operator (num % 10) and stores it in the remainder variable.

   • reversedNum = reversedNum * 10 + remainder;: It then adds the extracted digit to the reversedNum, effectively reversing the digits.

   • num /= 10;: It removes the last digit from num by integer division, effectively shifting digits to the right.

6. After the loop completes, the program checks if the original number (originalNum) is equal to the reversed number (reversedNum) to determine if it is a palindrome.

7. Depending on the result of the comparison, the program prints whether the number is a palindrome or not using printf.

8. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 15:

You are tasked with creating a program in C that converts a decimal number (entered as an integer) to its binary equivalent. The program should take a decimal integer as input, perform the conversion, and display the binary equivalent.

Code:

#include <stdio.h>

int main()
{
    int decimal, binary = 0, base = 1, remainder, originalDecimal;

    // Prompt the user to enter a decimal number
    printf("Enter a decimal number: ");
    scanf("%d", &decimal);

    originalDecimal = decimal; // Store the original decimal number

    // Process to convert decimal to binary
    while (decimal > 0)
    {
        remainder = decimal % 2;
        binary = binary + remainder * base;
        decimal = decimal / 2;
        base = base * 10;
    }

    // Display the binary equivalent
    printf("Binary equivalent of %d is %d\n", originalDecimal, binary);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, five integer variables are declared:

   • int decimal to store the decimal number entered by the user.

   • int binary initialized to 0 to store the binary equivalent.

   • int base initialized to 1 to keep track of the positional value during binary conversion.

   • int remainder to store the remainder when dividing by 2.

   • int originalDecimal to store the original decimal number before conversion.

3. The program prompts the user to enter a decimal number using printf and reads the input into the variable decimal using scanf.

4. It stores the original value of decimal in the originalDecimal variable to display it later in the output.

5. To convert the decimal number to its binary equivalent, the program uses a while loop that continues as long as decimal is greater than 0. Inside the loop:

   • remainder = decimal % 2;: In each iteration, it calculates the remainder when decimal is divided by 2 and stores it in the remainder variable. This remainder will be a binary digit (either 0 or 1).

   • binary = binary + remainder * base;: It updates the binary variable by adding the calculated binary digit (remainder) multiplied by the current positional value (base). This effectively builds the binary number.

   • decimal = decimal / 2;: It updates the decimal by performing integer division by 2, effectively shifting digits to the right.

   • base = base * 10;: It updates the base by multiplying it by 10 to move to the next positional value.

6. After the loop completes, the program has constructed the binary equivalent in the binary variable.

7. The program displays the binary equivalent along with the original decimal number using printf.

8. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 16:

You are tasked with creating a program in C that finds the largest digit in a given integer. The program should take an integer as input, find the largest digit in it, and display the result.

Code:

#include <stdio.h>

int main()
{
    int num, maxDigit = 0, digit;

    // Prompt the user to enter an integer
    printf("Enter an integer: ");
    scanf("%d", &num);

    // Check if the number is negative, make it positive
    if (num < 0)
    {
        num = -num;
    }

    // Process to find the largest digit in the number
    while (num > 0)
    {
        digit = num % 10; // Get the last digit
        if (digit > maxDigit)
        {
            maxDigit = digit; // Update maxDigit if the current digit is larger
        }
        num /= 10; // Remove the last digit
    }

    // Display the largest digit
    printf("The largest digit is: %d\n", maxDigit);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, three integer variables are declared:

   • int num to store the integer entered by the user.

   • int maxDigit initialized to 0 to store the largest digit found.

   • int digit to temporarily store each digit during processing.

3. The program prompts the user to enter an integer using printf and reads the input into the variable num using scanf.

4. It checks if the entered number is negative (less than 0) and if so, makes it positive by applying the unary - operator. This ensures that the program finds the largest digit regardless of the sign of the input.

5. To find the largest digit in the number, the program uses a while loop that continues as long as num is greater than 0. Inside the loop:

   • digit = num % 10;: In each iteration, it calculates the last digit of num using the modulo operator (num % 10) and stores it in the digit variable.

   • It then compares digit with maxDigit to check if the current digit is larger. If it is, it updates maxDigit to the value of digit.

   • num /= 10;: It removes the last digit from num by performing integer division by 10, effectively shifting digits to the right.

6. After the loop completes, the program has found the largest digit in the number, stored in the maxDigit variable.

7. The program displays the largest digit using printf.

8. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 17:

You are tasked with creating a program in C that checks if a number is an Armstrong number or not. An Armstrong number, also known as a narcissistic number, is a three-digit integer such that the sum of the cubes of its digits is equal to the number itself. The program should take a three-digit integer as input, check if it is an Armstrong number, and display the result.

Code:

#include <stdio.h>

int main()
{
    int num, originalNum, remainder, result = 0;

    // Prompt the user to enter a three-digit integer
    printf("Enter a three-digit integer: ");
    scanf("%d", &num);

    originalNum = num; // Store the original number

    // Process to check if the number is an Armstrong number
    while (originalNum != 0)
    {
        remainder = originalNum % 10;
        result += remainder * remainder * remainder; // Add the cube of the digit to result
        originalNum /= 10;                           // Remove the last digit
    }

    // Check if the number is an Armstrong number
    if (result == num)
    {
        printf("%d is an Armstrong number.\n", num);
    }
    else
    {
        printf("%d is not an Armstrong number.\n", num);
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, four integer variables are declared:

   • int num to store the three-digit integer entered by the user.

   • int originalNum to store the original number before processing.

   • int remainder to temporarily store the remainder when extracting digits.

   • int result initialized to 0 to store the sum of the cubes of the digits.

3. The program prompts the user to enter a three-digit integer using printf and reads the input into the variable num using scanf.

4. It stores the original value of num in the originalNum variable to check if it is an Armstrong number later.

5. To check if the number is an Armstrong number, the program uses a while loop that continues as long as originalNum is not equal to 0. Inside the loop:

   • remainder = originalNum % 10;: In each iteration, it calculates the last digit of originalNum using the modulo operator (originalNum % 10) and stores it in the remainder variable.

   • result += remainder * remainder * remainder;: It adds the cube of the digit (remainder) to the result, effectively calculating the sum of the cubes of its digits.

   • originalNum /= 10;: It removes the last digit from originalNum by performing integer division by 10, effectively shifting digits to the right.

6. After the loop completes, the program has calculated the sum of the cubes of the digits in the variable result.

7. The program checks if result is equal to the original number num. If they are equal, it means that the number is an Armstrong number, and it prints a corresponding message. Otherwise, it prints a message indicating that it is not an Armstrong number.

8. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 18:

You are tasked with creating a program in C that adds the digits of a number until the sum becomes a single digit. The program should take an integer as input, repeatedly sum its digits, and continue until the sum is a single digit. Then, it should display the final single-digit sum.

Code:

#include <stdio.h>

int main()
{
    int num, sum = 0, temp;

    // Prompt the user to enter an integer
    printf("Enter an integer: ");
    scanf("%d", &num);

    while (num > 9)
    {               // Continue until the number is a single digit
        sum = 0;    // Reset sum for each iteration of the outer loop
        temp = num; // Work with a temporary variable

        // Sum the digits of the number
        while (temp != 0)
        {
            sum += temp % 10; // Add the last digit to sum
            temp /= 10;       // Remove the last digit
        }

        num = sum; // Update num with the sum of its digits
    }

    // Display the single digit sum
    printf("Single digit sum: %d\n", num);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. In the main() function, three integer variables are declared:

   • int num to store the integer entered by the user.

   • int sum initialized to 0 to store the sum of the digits.

   • int temp to temporarily store the number during processing.

3. The program prompts the user to enter an integer using printf and reads the input into the variable num using scanf.

4. The program enters a while loop that continues as long as num is greater than 9, which means it has more than one digit. The purpose of this loop is to continue adding the digits until a single digit result is achieved.

5. Inside the loop:

   • sum = 0;: At the beginning of each iteration, it resets the sum to 0 to calculate the sum of the digits for the current value of num.

   • temp = num;: It stores the current value of num in the temp variable to work with a temporary copy of the number.

6. It enters a nested while loop to sum the digits of temp until there are no more digits left:

   • sum += temp % 10;: In each iteration, it calculates the last digit of temp using the modulo operator (temp % 10) and adds it to the sum.

   • temp /= 10;: It removes the last digit from temp by performing integer division by 10, effectively shifting digits to the right.

7. After the inner loop completes, sum contains the sum of the digits of the original num.

8. It updates the value of num with the sum calculated in the inner loop. This is done to repeat the process with the new num value, which may still have multiple digits.

9. The outer loop continues to iterate until num becomes a single digit.

10. Once num becomes a single digit (i.e., it is less than or equal to 9), the program exits the loop.

11. It displays the single-digit sum using printf.

12. The program returns 0 at the end of the main() function, indicating successful execution.

Problem Statement 19:

You are tasked with creating a C program that includes a function named calculateCircleArea to calculate the area of a circle based on the radius. The program's main function should prompt the user to enter the radius, call the calculateCircleArea function to compute the area, and then display the calculated area.

Code:

#include <stdio.h>

// Define a constant for pi
#define PI 3.14159265359

// Function to calculate the area of a circle
double calculateCircleArea(double radius)
{
    double area;

    // Calculate the area using the formula: area = pi * radius * radius
    area = PI * radius * radius;

    return area;
}

int main()
{
    double radius, area;

    // Prompt the user to enter the radius of the circle
    printf("Enter the radius of the circle: ");
    scanf("%lf", &radius);

    // Call the function to calculate the area
    area = calculateCircleArea(radius);

    // Display the calculated area
    printf("The area of the circle with radius %.2lf is %.2lf\n", radius, area);

    return 0;
}

Explanation:

1. The code starts with the inclusion of the standard input/output library (<stdio.h>).

2. It defines a constant PI with the value of pi (approximately 3.14159265359) to be used in the area calculation formula.

3. The program defines a function named calculateCircleArea that takes a double parameter radius and returns a double value, which is the calculated area of the circle.

4. Inside the calculateCircleArea function:

   • It declares a local double variable area to store the computed area.

   • The area is calculated using the formula: area = PI * radius * radius.

   • The calculated area is then returned as the function's result.

5. In the main function:

   • Two double variables are declared: radius to store the radius entered by the user and area to store the calculated area.

   • The program prompts the user to enter the radius of the circle using printf.

   • The user's input is read and stored in the radius variable using scanf.

6. The program calls the calculateCircleArea function and passes the radius as an argument. The returned value (the area) is stored in the area variable.

7. Finally, the program displays the calculated area using printf, rounding it to two decimal places for a more readable result.

8. The program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 20:

You are tasked with creating a C program that includes a function named findGreatest. This function should take three integer arguments and return the greatest among them. The program's main function should prompt the user to enter three numbers, call the findGreatest function to determine the greatest number, and then display the greatest number.

Code:

#include <stdio.h>

// Function to find the greatest among three integers
int findGreatest(int num1, int num2, int num3)
{
    int greatest = num1;

    // Compare num2 with greatest
    if (num2 > greatest)
    {
        greatest = num2;
    }

    // Compare num3 with greatest
    if (num3 > greatest)
    {
        greatest = num3;
    }

    return greatest;
}

int main()
{
    int num1, num2, num3, greatest;

    // Prompt the user to enter three numbers
    printf("Enter three numbers: ");
    scanf("%d %d %d", &num1, &num2, &num3);

    // Call the function to find the greatest number
    greatest = findGreatest(num1, num2, num3);

    // Display the greatest number
    printf("The greatest number is: %d\n", greatest);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. It defines a function named findGreatest that takes three integer parameters (num1, num2, and num3) and returns an integer value, which is the greatest among the three numbers.

3. Inside the findGreatest function:

   • It declares a local integer variable greatest and initializes it with the value of num1. This variable will store the greatest number among the three.

   • It compares num2 with greatest and updates greatest if num2 is greater.

   • It also compares num3 with greatest and updates greatest if num3 is greater.

   • Finally, it returns the value of greatest.

4. In the main function:

   • Four integer variables are declared: num1, num2, num3, and greatest.

   • The program prompts the user to enter three numbers using printf.

   • The user's input is read and stored in the variables num1, num2, and num3 using scanf.

5. The program calls the findGreatest function, passing num1, num2, and num3 as arguments. The returned value (the greatest number) is stored in the variable greatest.

6. Finally, the program displays the greatest number using printf.

7. The program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 21:

You are tasked with creating a C program that takes an array of integers and calculates the sum of its elements.

Code:

#include <stdio.h>

int main()
{
    int size, i, sum = 0;

    // Prompt the user to enter the size of the array
    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size]; // Declare an array of the specified size

    // Prompt the user to enter the array elements
    printf("Enter the elements of the array:\n");
    for (i = 0; i < size; i++)
    {
        printf("Element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    // Calculate the sum of array elements
    for (i = 0; i < size; i++)
    {
        sum += arr[i];
    }

    // Display the sum of array elements
    printf("The sum of array elements is: %d\n", sum);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. It declares integer variables size, i, and sum. size will store the size of the array, i is used as a loop counter, and sum will store the sum of the array elements.

3. The program prompts the user to enter the size of the array using printf.

4. The user's input for the array size is read and stored in the size variable using scanf.

5. An integer array arr of the specified size is declared.

6. The program prompts the user to enter the elements of the array one by one using a loop. It displays a prompt for each element, and the user's input is stored in the corresponding position of the array arr.

7. After collecting all the array elements, the program enters a loop to calculate the sum of the array elements. It iterates through each element of the array, adds it to the sum variable, and accumulates the sum.

8. Finally, the program displays the calculated sum of the array elements using printf.

9. The program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 22:

You are tasked with creating a C program that reads an array of numbers and finds the largest and smallest numbers among them.

Code:

#include <stdio.h>

int main()
{
    int size, i;
    int largest, smallest; // Variables to store the largest and smallest numbers

    // Prompt the user to enter the size of the array
    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size]; // Declare an array of the specified size

    // Prompt the user to enter the array elements
    printf("Enter the elements of the array:\n");
    for (i = 0; i < size; i++)
    {
        printf("Element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    // Initialize largest and smallest with the first element
    largest = arr[0];
    smallest = arr[0];

    // Find the largest and smallest numbers in the array
    for (i = 1; i < size; i++)
    {
        if (arr[i] > largest)
        {
            largest = arr[i];
        }
        if (arr[i] < smallest)
        {
            smallest = arr[i];
        }
    }

    // Display the largest and smallest numbers
    printf("The largest number is: %d\n", largest);
    printf("The smallest number is: %d\n", smallest);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. It declares integer variables size, i, largest, and smallest. size will store the size of the array, i is used as a loop counter, and largest and smallest will store the largest and smallest numbers, respectively, among the array elements.

3. The program prompts the user to enter the size of the array using printf.

4. The user's input for the array size is read and stored in the size variable using scanf.

5. An integer array arr of the specified size is declared.

6. The program prompts the user to enter the elements of the array one by one using a loop. It displays a prompt for each element, and the user's input is stored in the corresponding position of the array arr.

7. After collecting all the array elements, the program initializes largest and smallest with the value of the first element of the array (arr[0]).

8. The program enters a loop starting from the second element of the array (arr[1]) and iterates through each element. Inside the loop, it checks whether the current element is larger than largest or smaller than smallest and updates these variables accordingly.

9. After the loop, the program has determined the largest and smallest numbers among the array elements.

10. Finally, the program displays the largest and smallest numbers using printf.

11. The program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 23:

You are tasked with creating a C program that takes a string input and reverses it using a loop.

Code:

#include <stdio.h>

int main()
{
    char input[100]; // Assuming a maximum input length of 100 characters
    char reversed[100];
    int i, length = 0;

    // Prompt the user to enter a string
    printf("Enter a string: ");
    scanf("%s", input); // Read the string without spaces

    // Find the length of the input string
    while (input[length] != '\0')
    {
        length++;
    }

    // Reverse the string character by character
    for (i = length - 1; i >= 0; i--)
    {
        reversed[length - 1 - i] = input[i];
    }

    reversed[length] = '\0'; // Add the null character to terminate the reversed string

    // Display the reversed string
    printf("Reversed string: %s\n", reversed);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>).

2. It declares character arrays input and reversed, an integer variable i, and an integer variable length initialized to 0. input will store the user's input string, reversed will store the reversed string, i is used as a loop counter, and length will store the length of the input string.

3. The program prompts the user to enter a string using printf.

4. The user's input for the string is read and stored in the input array using scanf. Note that scanf("%s", input) reads a string without spaces.

5. The program calculates the length of the input string by iterating through each character until it encounters the null character '\0' which marks the end of the string.

6. After finding the length of the input string, the program enters a loop to reverse the string character by character. It starts from the last character of the input string and copies it to the first position of the reversed array, then moves to the second last character and copies it to the second position of reversed, and so on. This loop effectively reverses the string.

7. The program adds the null character '\0' to the end of the reversed string to terminate it.

8. Finally, the program displays the reversed string using printf.

9. The program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 24:

You are tasked with creating a C program that checks if a given string is a palindrome (reads the same backward as forward).

Code:

#include <stdio.h>
#include <string.h>

int main()
{
    char input[100];            // Assuming a maximum input length of 100 characters
    int i, j, isPalindrome = 1; // Initialize isPalindrome to 1 (true)

    // Prompt the user to enter a string
    printf("Enter a string: ");
    scanf("%s", input); // Read the string without spaces

    int length = strlen(input);

    // Check if the string is a palindrome
    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        if (input[i] != input[j])
        {
            isPalindrome = 0; // Set isPalindrome to 0 (false) if characters don't match
            break;            // Exit the loop early if a mismatch is found
        }
    }

    // Display the result
    if (isPalindrome)
    {
        printf("The string is a palindrome.\n");
    }
    else
    {
        printf("The string is not a palindrome.\n");
    }

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>) and the string manipulation library (<string.h>).

2. It declares a character array input to store the user's input string, integer variables i and j for loop counters, and an integer variable isPalindrome initialized to 1. isPalindrome is used to track whether the string is a palindrome or not.

3. The program prompts the user to enter a string using printf.

4. The user's input for the string is read and stored in the input array using scanf. Note that scanf("%s", input) reads a string without spaces.

5. The program calculates the length of the input string using strlen function and stores it in the length variable.

6. A loop is used to check if the string is a palindrome. The loop runs from i = 0 to j = length - 1 (from the beginning to the end of the string).

7. Inside the loop, it compares characters at position i and j in the input array. If they don't match, it sets isPalindrome to 0 (false) and exits the loop using break.

8. After the loop, it checks the value of isPalindrome. If it is 1, it prints "The string is a palindrome," indicating that the string is a palindrome. If it is 0, it prints "The string is not a palindrome," indicating that the string is not a palindrome.

9. Finally, the program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 25:

You are tasked with creating a C program that takes a string and counts the number of vowels and consonants in it.

Code:

#include <stdio.h>
#include <ctype.h> // Include the ctype.h header for character functions

int main()
{
    char input[100]; // Assuming a maximum input length of 100 characters
    int vowels = 0, consonants = 0;
    int i;

    // Prompt the user to enter a string
    printf("Enter a string: ");
    scanf("%s", input); // Read the string without spaces

    // Convert the input string to lowercase for easier vowel checking
    for (i = 0; input[i]; i++)
    {
        input[i] = tolower(input[i]);
    }

    // Count vowels and consonants
    for (i = 0; input[i]; i++)
    {
        char ch = input[i];

        if (ch >= 'a' && ch <= 'z')
        {
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
            {
                vowels++;
            }
            else
            {
                consonants++;
            }
        }
    }

    // Display the counts of vowels and consonants
    printf("Number of vowels: %d\n", vowels);
    printf("Number of consonants: %d\n", consonants);

    return 0;
}

Explanation:

1. The code begins with the inclusion of the standard input/output library (<stdio.h>) and the character handling library (<ctype.h>) for character functions.

2. It declares a character array input to store the user's input string, integer variables vowels and consonants to keep count of vowels and consonants, and an integer variable i for loop control.

3. The program prompts the user to enter a string using printf.

4. The user's input for the string is read and stored in the input array using scanf. Note that scanf("%s", input) reads a string without spaces.

5. To simplify vowel checking, the program converts the characters in the input array to lowercase using a loop. This ensures that both uppercase and lowercase vowels are counted correctly.

6. Two loops are used to count vowels and consonants in the input string. The first loop iterates through each character of the input string.

7. Inside the loop, it checks if the character ch is a lowercase letter ('a' to 'z') using the islower function from ctype.h. If it's a lowercase letter, it further checks if it is a vowel ('a', 'e', 'i', 'o', or 'u'). If it is, it increments the vowels count; otherwise, it increments the consonants count.

8. After both loops, it displays the counts of vowels and consonants using printf.

9. Finally, the program returns 0 at the end of the main function, indicating successful execution.

Problem Statement 26:

You are tasked with creating a C program that simulates a digital clock. The program should utilize a structure named Time with fields for hours, minutes, and seconds to represent the current time. Additionally, you need to write a function named incrementSeconds that takes a Time structure as input and increments the time by one second, properly adjusting the minutes and hours while considering the 24-hour time format. In the main function, the program should start from a user-input time and continuously print the time after each second. It is crucial that the program handles the transition from 23:59:59 to 00:00:00 correctly.

Code:

#include <stdio.h>

// Define a structure to represent time
struct Time
{
    int hours;
    int minutes;
    int seconds;
};

// Function to increment time by one second
void incrementSeconds(struct Time *time)
{
    time->seconds++;

    if (time->seconds == 60)
    {
        time->seconds = 0;
        time->minutes++;

        if (time->minutes == 60)
        {
            time->minutes = 0;
            time->hours++;

            if (time->hours == 24)
            {
                time->hours = 0; // Wrap around to 00:00:00 at midnight
            }
        }
    }
}

int main()
{
    struct Time currentTime;

    // Prompt the user to enter the initial time
    printf("Enter the initial time in format hh:mm:ss: ");
    scanf("%d:%d:%d", &currentTime.hours, &currentTime.minutes, &currentTime.seconds);

    // Validate the input
    if (currentTime.hours < 0 || currentTime.hours >= 24 ||
        currentTime.minutes < 0 || currentTime.minutes >= 60 ||
        currentTime.seconds < 0 || currentTime.seconds >= 60)
    {
        printf("Invalid input. Please enter a valid time.\n");
        return 1; // Exit with an error code
    }

    // Infinite loop to continuously increment and print the time
    while (1)
    {
        // Print the current time
        printf("%02d:%02d:%02d\n", currentTime.hours, currentTime.minutes, currentTime.seconds);

        // Increment the time by one second
        incrementSeconds(&currentTime);

        // Add a delay to simulate one second
        // Sleep function or delay function can be used here (platform-dependent)
        // For simplicity, we'll add a simple loop to waste time
        for (int i = 0; i < 10000000; i++)
        {
            // Wasting time
        }
    }

    return 0;
}

Explanation:

1. We start by defining a structure named Time to represent time. This structure has three fields: hours, minutes, and seconds.

2. The incrementSeconds function takes a pointer to a Time structure as an argument and increments the time by one second while adjusting the minutes and hours accordingly. It ensures that the time remains in the 24-hour format.

3. In the main function:

   a. We declare a variable currentTime of type Time to store the current time.

   b. We prompt the user to enter the initial time in the format "hh:mm:ss" (hours, minutes, and seconds) and use scanf to read and store these values in the currentTime structure.

   c. We validate the user input to ensure that the entered values for hours, minutes, and seconds are within valid ranges (hours: 0-23, minutes: 0-59, seconds: 0-59). If the input is invalid, we display an error message and exit the program with an error code (return 1;).

   d. Next, we enter an infinite loop (while (1)) to continuously update and print the time.

   e. Inside the loop, we:

   • Print the current time using printf, formatting it as "hh:mm:ss" with leading zeros for single-digit values.

   • Call the incrementSeconds function to increment the time by one second, taking care of minutes and hours rollover.

   • Add a delay (a simple loop that does nothing) to simulate one second. In a real application, a sleep function or a timer interrupt would be used for more accurate timing.

4. The program will continue running indefinitely, incrementing and displaying the time in a simulated clock fashion.

Problem Statement 27:

You are tasked with writing a C program that efficiently finds the maximum and minimum values within an array of integers. The program should define a structure to hold the results (both maximum and minimum values) and implement a function that takes an integer array (along with its size) as input, then returns the maximum and minimum values. The solution should demonstrate usage of this function by finding and printing the maximum and minimum values from a provided array.

Code:

#include <stdio.h>

// Define a structure to store the maximum and minimum values
struct MaxMinResult
{
    int max;
    int min;
};

// Function to find the maximum and minimum values in an integer array
struct MaxMinResult findMaxMin(int arr[], int size)
{
    struct MaxMinResult result;

    // Initialize max and min with the first element of the array
    result.max = arr[0];
    result.min = arr[0];

    // Iterate through the array to find max and min
    for (int i = 1; i < size; i++)
    {
        if (arr[i] > result.max)
        {
            result.max = arr[i];
        }
        if (arr[i] < result.min)
        {
            result.min = arr[i];
        }
    }

    return result;
}

int main()
{
    int arr[] = {12, 45, 6, 78, 32, 9, 53, 62, 17};
    int size = sizeof(arr) / sizeof(arr[0]);

    struct MaxMinResult result = findMaxMin(arr, size);

    printf("Maximum value: %d\n", result.max);
    printf("Minimum value: %d\n", result.min);

    return 0;
}

Explanation:

1. The #include <stdio.h> line includes the Standard Input Output header file, allowing the program to use the printf function for output.

2. The struct MaxMinResult is defined to store two integers, max and min, which represent the maximum and minimum values found in an array.

3. The findMaxMin function is declared to take two parameters: an integer array arr[] and its size size. It returns a struct MaxMinResult containing the maximum and minimum values found in the array.

4. Inside the findMaxMin function, the result variable is initialized with the first element of the array for both max and min. This is a common approach to ensure that max and min are valid elements of the array.

5. The function iterates through the array starting from the second element (since the first is already used for initialization). It compares each element with result.max and result.min to find the maximum and minimum values, respectively.

6. The main function defines an array arr with a set of integers and calculates its size using sizeof(arr) / sizeof(arr[0]). This size is necessary because the findMaxMin function requires the array size to iterate correctly through the array.

7. The main function calls findMaxMin, passing the array and its size. The returned structure contains the maximum and minimum values, which are then printed using printf.

8. Finally, the program outputs the maximum and minimum values found in the array to the standard output.

Problem Statement 28:

You are tasked with creating a function that concatenates two strings without using the built-in strcat function from the C Standard Library. Additionally, you need to demonstrate how to use this function in a simple C program.

Code:

#include <stdio.h>

// Function to concatenate two strings
void concatenateStrings(char dest[], const char source[])
{
    int i, j;

    // Find the length of the destination string
    for (i = 0; dest[i] != '\0'; i++)
    {
    }

    // Copy the source string to the end of the destination string
    for (j = 0; source[j] != '\0'; j++)
    {
        dest[i + j] = source[j];
    }

    // Add a null terminator to the end of the concatenated string
    dest[i + j] = '\0';
}

int main()
{
    char str1[100] = "Hello, ";
    const char str2[] = "world!";

    // Call the concatenateStrings function to concatenate str2 to str1
    concatenateStrings(str1, str2);

    // Print the concatenated string
    printf("Concatenated string: %s\n", str1);

    return 0;
}

Explanation:

1. The #include <stdio.h> directive includes the Standard Input Output Library for basic input/output operations, such as printf.

2. void concatenateStrings(char dest[], const char source[]) defines a function that takes two strings: dest (the destination string where the result will be stored) and source (the string to be appended to dest). It does not return any value (void).

3. Inside concatenateStrings, a for-loop iterates over the dest array until it finds the null terminator ('\0'), which signifies the end of the string. This determines where to start appending the source string.

4. Another for-loop iterates over the source string. Each character of source is appended to dest starting at the index immediately after dest's last character. This effectively concatenates source to the end of dest.

5. After appending all characters from source, a null terminator ('\0') is added to the end of dest to mark the new end of the concatenated string.

6. In main(), two strings str1 and str2 are defined, with str1 having enough space to hold the concatenated result. concatenateStrings is called with str1 and str2 as arguments.

7. Finally, the concatenated string stored in str1 is printed to the console using printf.

Problem Statement 29:

You are tasked with creating a C program that defines structures for various shapes: a circle, a rectangle, and a triangle. For each shape, you need to write functions that calculate their areas. The program should allow the user to select a shape, input the necessary dimensions, and then display the area of the chosen shape.

Code:

#include <stdio.h>
#include <math.h>

// Define a structure for a circle
typedef struct
{
    double radius;
} Circle;

// Define a structure for a rectangle
typedef struct
{
    double length;
    double width;
} Rectangle;

// Define a structure for a triangle
typedef struct
{
    double base;
    double height;
} Triangle;

// Function to calculate the area of a circle
double calculateCircleArea(Circle circle)
{
    return 3.14159265359 * circle.radius * circle.radius; // Using the value of pi
}

// Function to calculate the area of a rectangle
double calculateRectangleArea(Rectangle rectangle)
{
    return rectangle.length * rectangle.width;
}

// Function to calculate the area of a triangle
double calculateTriangleArea(Triangle triangle)
{
    return 0.5 * triangle.base * triangle.height;
}

int main()
{
    int choice;

    printf("Choose a shape:\n");
    printf("1. Circle\n");
    printf("2. Rectangle\n");
    printf("3. Triangle\n");
    printf("Enter your choice (1/2/3): ");
    scanf("%d", &choice);

    switch (choice)
    {
    case 1:
        Circle circle;
        printf("Enter the radius of the circle: ");
        scanf("%lf", &circle.radius);
        double area = calculateCircleArea(circle);
        printf("Area of the circle: %lf\n", area);
        break;
    case 2:
        Rectangle rectangle;
        printf("Enter the length and width of the rectangle: ");
        scanf("%lf %lf", &rectangle.length, &rectangle.width);
        double area = calculateRectangleArea(rectangle);
        printf("Area of the rectangle: %lf\n", area);
        break;
    case 3:
        Triangle triangle;
        printf("Enter the base and height of the triangle: ");
        scanf("%lf %lf", &triangle.base, &triangle.height);
        double area = calculateTriangleArea(triangle);
        printf("Area of the triangle: %lf\n", area);
        break;
    default:
        printf("Invalid choice\n");
    }

    return 0;
}

Explanation:

1. The code begins by defining three structures: Circle, Rectangle, and Triangle, each containing the necessary fields to represent dimensions of the respective shapes.

2. For each shape, a function is defined to calculate its area. These functions use the respective shape's dimensions (passed as a structure) to calculate the area. The circle area calculation uses a predefined value for Pi.

3. The main function starts by asking the user to choose a shape by entering a number corresponding to the shape (1 for circle, 2 for rectangle, 3 for triangle).

4. Depending on the user's choice, the program prompts for the necessary dimensions (radius for circle, length and width for rectangle, base and height for triangle), reads these values from the user, and stores them in the appropriate structure.

5. After reading the input, the program calls the corresponding area calculation function and prints the area to the console.

6. If the user enters an invalid choice, the program prints an "Invalid choice" message.

Problem Statement 30:

You need to write a C program that takes an integer n from the user, representing the number of elements in an array. The program should then allow the user to input n values to fill the array. Additionally, you must implement a function that counts how many times a specific number, also provided by the user, appears in the array. Finally, the program should display this count to the user.

Code:

#include <stdio.h>

// Function to count the occurrences of a specific number in an array
int countOccurrences(int arr[], int n, int target)
{
    int count = 0;

    for (int i = 0; i < n; i++)
    {
        if (arr[i] == target)
        {
            count++;
        }
    }

    return count;
}

int main()
{
    int n; // Number of elements in the array
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    int arr[n]; // Declare an array of size n

    // Initialize the array with values provided by the user
    printf("Enter %d elements:\n", n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }

    int target; // Number to search for
    printf("Enter the number to count: ");
    scanf("%d", &target);

    // Call the countOccurrences function to count occurrences of the target number
    int count = countOccurrences(arr, n, target);

    // Display the count to the user
    printf("The number %d appears %d times in the array.\n", target, count);

    return 0;
}

Explanation:

1. The program begins by including the stdio.h header for input and output functions.

2. A function countOccurrences is defined to count how many times a specific number appears in an array. It takes an array arr, its size n, and the target number target as arguments.

3. The main function first asks the user for the number of elements n and then declares an array arr of size n.

4. The user is prompted to enter n elements, which are read into the array using a for-loop.

5. The user is then asked for a target number whose occurrences in the array are to be counted.

6. The countOccurrences function is called with the array, its size, and the target number as arguments. It iterates through the array, incrementing a count variable each time the target number is found.

7. Finally, the program prints the number of times the target number appears in the array.

Problem Statement 31:

Develop a C program that can reverse the contents of a user-defined array without utilizing a secondary array to store the reversed sequence. The program must prompt the user to input the size of the array followed by its elements. Once the array is reversed in place, the modified array should be displayed to the user. This task aims to assess your skills in manipulating arrays and implementing in-place algorithms in C.

Code:

#include <stdio.h>

// Function to reverse the array in-place
void reverseArray(int arr[], int size)
{
    int start = 0;      // Index of the first element
    int end = size - 1; // Index of the last element

    while (start < end)
    {
        // Swap elements at start and end indices
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        // Move indices towards the center
        start++;
        end--;
    }
}

int main()
{
    int size;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size]; // Variable-length array declaration

    printf("Enter %d elements:\n", size);
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    // Call the reverseArray function to reverse the array in-place
    reverseArray(arr, size);

    // Display the reversed array
    printf("Reversed array:\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

Explanation:

1. The program starts with including the standard input-output header file necessary for input/output operations.

2. A function named reverseArray is defined to reverse the array in place. It takes an integer array and its size as arguments.

3. Inside this function, two pointers start and end are initialized to point to the beginning and the end of the array, respectively.

4. A loop is used to swap the elements at the start and end positions until they meet in the middle, effectively reversing the array.

5. The main function begins by asking the user for the size of the array and reads this value.

6. Based on the size input by the user, an array of that size is declared.

7. The program then prompts the user to input the elements of the array, which are stored in the array using a loop.

8. After the array is populated, the reverseArray function is called with the array and its size as arguments to reverse it.

9. Finally, the reversed array is printed to the screen, demonstrating that the original array has been reversed in place.

Problem Statement 32:

Create a C program that determines whether a given array is a palindrome. A palindrome is a sequence that reads the same backward as forward, such as [1, 2, 3, 2, 1]. The program should prompt the user to enter the size of the array and its elements. After evaluating the array, the program should output whether the array is a palindrome or not. This challenge aims to test your ability to implement algorithms that involve array manipulation and comparison logic in C.

Code:

#include <stdio.h>

// Function to check if an array is a palindrome
int isPalindrome(int arr[], int size)
{
    int start = 0;      // Index of the first element
    int end = size - 1; // Index of the last element

    // Continue comparing elements until start is less than or equal to end
    while (start <= end)
    {
        // If elements at start and end are not equal, it's not a palindrome
        if (arr[start] != arr[end])
        {
            return 0; // Not a palindrome
        }

        // Move indices towards the center
        start++;
        end--;
    }

    // If we reach here, the array is a palindrome
    return 1; // It's a palindrome
}

int main()
{
    int size;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size]; // Variable-length array declaration

    printf("Enter %d elements:\n", size);
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    // Call the isPalindrome function to check if the array is a palindrome
    int result = isPalindrome(arr, size);

    if (result)
    {
        printf("The array is a palindrome.\n");
    }
    else
    {
        printf("The array is not a palindrome.\n");
    }

    return 0;
}

Explanation:

1. The program includes the standard input-output header file for input and output functions.

2. A function named isPalindrome is defined to check if the array is a palindrome. It accepts an integer array and its size as parameters.

3. Two variables, start and end, are initialized to mark the beginning and the end of the array.

4. A while loop is used to iterate through the array from both ends towards the center. During each iteration, it compares the elements at start and end.

5. If at any point the elements at start and end are not equal, the function returns 0, indicating the array is not a palindrome.

6. The loop continues until start and end meet or cross. If all mirrored elements are equal, the function returns 1, indicating the array is a palindrome.

7. In the main function, the user is prompted to input the size of the array and its elements.

8. After gathering the input, the isPalindrome function is called with the array and its size.

9. The result of the isPalindrome function is used to print whether the array is a palindrome or not.

10. This program efficiently checks for palindrome properties in arrays without using extra space for a reversed copy, demonstrating in-place comparison logic.

Problem Statement 33:

Develop a C program that transposes a matrix input by the user and displays both the original and the transposed matrix. The transpose of a matrix is achieved by flipping the matrix over its diagonal, which turns its rows into columns and vice versa. This program aims to assess your understanding of two-dimensional arrays in C and how to manipulate them to achieve matrix transposition.

Code:

#include <stdio.h>

int main()
{
    int rows, cols;

    // Input the number of rows and columns of the matrix
    printf("Enter the number of rows: ");
    scanf("%d", &rows);
    printf("Enter the number of columns: ");
    scanf("%d", &cols);

    int matrix[rows][cols];
    int transposedMatrix[cols][rows]; // Transposed matrix with rows and columns swapped

    // Input elements of the matrix
    printf("Enter elements of the matrix:\n");
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            scanf("%d", &matrix[i][j]);
        }
    }

    // Transpose the matrix
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            transposedMatrix[j][i] = matrix[i][j]; // Swap rows and columns
        }
    }

    // Display the original matrix
    printf("Original matrix:\n");
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }

    // Display the transposed matrix
    printf("Transposed matrix:\n");
    for (int i = 0; i < cols; i++)
    {
        for (int j = 0; j < rows; j++)
        {
            printf("%d\t", transposedMatrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation:

1. The program begins by including the standard input-output header file for input and output functions.

2. It then prompts the user to input the number of rows and columns for the matrix.

3. Two matrices are declared: matrix for the original matrix and transposedMatrix for storing the transposed version. The dimensions of transposedMatrix are reversed relative to matrix.

4. The program collects the elements of the matrix from the user through nested loops.

5. It transposes the matrix by assigning the element at matrix[i][j] to transposedMatrix[j][i]. This effectively swaps the rows and columns of the matrix.

6. The original matrix is displayed by iterating through matrix and printing its elements.

7. The transposed matrix is then displayed by iterating through transposedMatrix and printing its elements. The loops ensure that elements are printed in a matrix format with tabs separating the columns.

8. This program effectively demonstrates how to work with two-dimensional arrays and perform matrix transposition, showcasing array indexing and element swapping.

Problem Statement 34:

Construct a C program to perform the addition of two matrices (2D arrays) and display the resulting matrix. Matrix addition is a straightforward operation where each element of the first matrix is added to the corresponding element of the second matrix. This task is intended to evaluate your skills in handling two-dimensional arrays, iterating through array elements, and performing element-wise operations in C.

Code:

#include <stdio.h>

// Function to add two matrices
void addMatrices(int mat1[][100], int mat2[][100], int result[][100], int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

int main()
{
    int rows, cols;

    // Input the number of rows and columns for the matrices
    printf("Enter the number of rows: ");
    scanf("%d", &rows);
    printf("Enter the number of columns: ");
    scanf("%d", &cols);

    int matrix1[100][100], matrix2[100][100], result[100][100];

    // Input elements of the first matrix
    printf("Enter elements of the first matrix:\n");
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            scanf("%d", &matrix1[i][j]);
        }
    }

    // Input elements of the second matrix
    printf("Enter elements of the second matrix:\n");
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            scanf("%d", &matrix2[i][j]);
        }
    }

    // Check if the matrices are compatible for addition (same size)
    if (rows > 0 && cols > 0)
    {
        // Call the addMatrices function to add the matrices
        addMatrices(matrix1, matrix2, result, rows, cols);

        // Display the result matrix
        printf("Result matrix after addition:\n");
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                printf("%d\t", result[i][j]);
            }
            printf("\n");
        }
    }
    else
    {
        printf("Matrix sizes are not valid for addition.\n");
    }

    return 0;
}

Explanation:

1. The program starts by declaring a function addMatrices that will add two matrices. It takes two input matrices, a result matrix, and their dimensions (rows and columns) as parameters.

2. Inside this function, a nested loop iterates through each element of the matrices, adding corresponding elements and storing the sum in the result matrix.

3. In the main function, the user is prompted to input the dimensions of the matrices.

4. Three matrices are declared with a fixed size of 100x100: matrix1, matrix2, and result. These matrices will hold the input matrices and the result of their addition.

5. The program then collects the elements of the first and second matrices from the user.

6. Before proceeding with the addition, the program checks if the matrices have valid sizes (rows and columns must be greater than 0).

7. The addMatrices function is called with the input matrices and their dimensions to perform the addition.

8. Finally, the resulting matrix is displayed by iterating through its elements and printing them in a formatted manner, showing the outcome of the matrix addition operation.

9. This program showcases how to perform operations on two-dimensional arrays and manipulate them to achieve a specific computational goal in C.

Problem Statement 35:

Design a C program that identifies and displays any duplicate elements within a user-defined array. This task involves iterating over the array to compare each element with every other element for duplicates. The program should first ask the user to enter the size of the array, followed by its elements. After processing, it should output the duplicate elements found within the array. This challenge will test your ability to work with arrays, implement nested loops, and utilize basic conditional logic in C.

Code:

#include <stdio.h>

// Function to find and display duplicate elements in an array
void findDuplicates(int arr[], int size)
{
    int found[size]; // Array to keep track of found elements (initialized to 0)

    // Initialize the found array to 0
    for (int i = 0; i < size; i++)
    {
        found[i] = 0;
    }

    for (int i = 0; i < size; i++)
    {
        for (int j = i + 1; j < size; j++)
        {
            // If the current element is equal to any element ahead in the array
            if (arr[i] == arr[j] && found[j] != 1)
            {
                // Display the duplicate element (if not already displayed)
                printf("Duplicate element: %d\n", arr[i]);
                found[j] = 1; // Mark the element as found to avoid repeating
                break; // Once a duplicate is found, no need to check further for this element
            }
        }
    }
}

int main()
{
    int size;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size];

    printf("Enter %d elements:\n", size);
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    // Call the findDuplicates function to find and display duplicate elements
    findDuplicates(arr, size);

    return 0;
}

Explanation:

1. The program includes the standard input-output header file necessary for utilizing input and output functions.

2. A function named findDuplicates is defined for identifying and displaying duplicate elements within an array. It takes the array and its size as parameters.

3. Inside this function, an array named found is declared to track which elements have been checked for duplicates. This array is initialized to zero.

4. A nested loop structure is employed where each element of the array (outer loop) is compared with every subsequent element (inner loop) to find duplicates.

5. If a duplicate is found (i.e., two elements are equal), and the duplicate has not been previously identified (checked using the found array), the function prints the duplicate element.

6. The found array is updated to mark the element as identified to prevent the same duplicate from being reported multiple times.

7. In the main function, the user is prompted to input the size of the array and its elements.

8. After collecting the array elements, the findDuplicates function is called to detect and display any duplicates within the array.

9. This program demonstrates an effective method for duplicate detection in arrays, illustrating concepts such as array manipulation, nested iteration, and conditional logic in C programming.

Problem Statement 36:

Create a C program that rotates the elements of a given array to the right by 'n' positions. Rotating an array involves shifting its elements to the right such that the last elements wrap around to the front of the array. The program should prompt the user to input the size of the array, the elements of the array, and the number of positions ('n') by which the array should be rotated. This task aims to test your ability to manipulate array indices and implement modular arithmetic in C programming.

Code:

#include <stdio.h>

// Function to rotate an array to the right by 'n' positions without reversing
void rotateRight(int arr[], int size, int n)
{
    // Handle cases where 'n' is larger than the array size
    n = n % size;

    int temp1, temp2, current, next;

    for (int i = 0; i < n; i++)
    {
        temp1 = arr[size - 1]; // Store the last element
        current = size - 1;

        for (int j = 0; j < size; j++)
        {
            next = (current + 1) % size; // Find the new destination index
            temp2 = arr[next];           // Store the element at the new destination
            arr[next] = temp1;           // Insert the stored element
            temp1 = temp2;               // Update temp1 with the stored element
            current = next;              // Update current index
        }
    }
}

int main()
{
    int size, n;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size];

    printf("Enter %d elements:\n", size);
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    printf("Enter the number of positions to rotate to the right: ");
    scanf("%d", &n);

    // Call the rotateRight function to rotate the array to the right by 'n' positions
    rotateRight(arr, size, n);

    // Display the rotated array
    printf("Rotated array:\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

Explanation:

1. The program includes the standard input-output header for input and output functions.

2. A function named rotateRight is defined to rotate the array elements to the right by 'n' positions. It takes the array, its size, and the number of positions to rotate as parameters.

3. Inside the function, it first adjusts 'n' to handle cases where 'n' is larger than the array size using modular arithmetic (n = n % size).

4. It uses two temporary variables (temp1 and temp2) to store elements during the rotation process.

5. The function performs the rotation in a nested loop. The outer loop runs 'n' times, and the inner loop cycles through the array to shift each element to its new position.

6. The inner loop uses modular arithmetic to calculate the next index position, ensuring that elements wrap around the array correctly.

7. In the main function, the user is asked to enter the size of the array, its elements, and the number of positions 'n' to rotate the array.

8. After collecting the inputs, the rotateRight function is called to perform the rotation.

9. Finally, the rotated array is printed to showcase the result of the rotation operation.

10. This program effectively demonstrates array manipulation, specifically how to rotate elements within an array using index manipulation and modular arithmetic in C.

Problem Statement 37:

Create a C program that verifies whether a given array is sorted in ascending order. Ascending order means that each element in the array is less than or equal to the next element. The program should prompt the user to input the size of the array followed by its elements. After assessing the array, the program should then indicate whether the array is sorted in ascending order. This task is aimed at testing your ability to iterate through array elements and apply conditional logic to compare their values in C.

Code:

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

// Function to check if an array is sorted in ascending order
bool isSortedAscending(int arr[], int size)
{
    for (int i = 1; i < size; i++)
    {
        // If the current element is greater than the previous element, it's not sorted
        if (arr[i] < arr[i - 1])
        {
            return false;
        }
    }
    // If we reach here, the array is sorted in ascending order
    return true;
}

int main()
{
    int size;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size];

    printf("Enter %d elements:\n", size);
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    // Call the isSortedAscending function to check if the array is sorted
    bool result = isSortedAscending(arr, size);

    if (result)
    {
        printf("The array is sorted in ascending order.\n");
    }
    else
    {
        printf("The array is not sorted in ascending order.\n");
    }

    return 0;
}

Explanation:

1. The program begins with including the standard input-output header for input and output functions and the boolean header for using bool type.

2. A function named isSortedAscending is defined to check if the array is sorted in ascending order. It takes an array and its size as parameters.

3. The function iterates through the array starting from the second element (index 1). For each element, it compares it with the previous one. If any element is found to be smaller than its predecessor, the function immediately returns false, indicating the array is not sorted in ascending order.

4. If the loop completes without finding any out-of-order elements, the function returns true, indicating the array is sorted in ascending order.

5. In the main function, the user is prompted to input the size of the array and its elements.

6. After collecting the inputs, the isSortedAscending function is called with the array and its size as arguments.

7. The result of the function is used to print a message indicating whether the array is sorted in ascending order.

8. This program effectively demonstrates how to check for ascending order in an array, showcasing basic array manipulation, loop iteration, and conditional logic in C programming.

Problem Statement 38:

Develop a C program that inserts an element into a specified position within an array. The program should initially prompt the user to input the current size of the array, followed by the actual elements of the array. It should then ask for the element to be inserted and the position at which this element should be placed. The task aims to assess your ability to manipulate array indices, handle dynamic array sizes, and implement basic input and output operations in C.

Code:

#include <stdio.h>

// Function to insert an element at a specific position in an array
void insertElement(int arr[], int *size, int element, int position)
{
    // Check if the position is valid (within the array bounds)
    if (position >= 0 && position <= *size)
    {
        // Shift elements to the right to make space for the new element
        for (int i = *size; i > position; i--)
        {
            arr[i] = arr[i - 1];
        }

        // Insert the new element at the specified position
        arr[position] = element;

        // Increment the size of the array
        (*size)++;
    }
    else
    {
        printf("Invalid position for insertion.\n");
    }
}

int main()
{
    int size;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[100]; // Assuming a maximum size of 100 for the array

    printf("Enter %d elements:\n", size);
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    int element, position;

    printf("Enter the element to insert: ");
    scanf("%d", &element);
    printf("Enter the position to insert (0 to %d): ", size);
    scanf("%d", &position);

    // Call the insertElement function to insert the element at the specified position
    insertElement(arr, &size, element, position);

    // Display the updated array
    printf("Updated array:\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

Explanation:

1. The program starts by including the standard input-output header for utilizing input and output functions.

2. A function named insertElement is declared to insert an element into the array at a specified position. It accepts the array, a pointer to its size, the element to be inserted, and the position at which to insert the element as parameters.

3. The function first checks if the given position is within the valid range (0 to the current size of the array) to ensure the integrity of the operation.

4. If the position is valid, it shifts the elements from that position one place to the right, creating space for the new element. This is done in a for loop that iterates backward from the last element to the insertion position.

5. The new element is inserted into the array at the specified position.

6. The size of the array is incremented by 1 to reflect the addition of the new element.

7. If the position is invalid, the function prints an error message.

8. In the main function, the user is prompted to input the initial size of the array and its elements. The array has been assumed to have a maximum size of 100 elements.

9. The user is then asked to enter the element to be inserted and its insertion position.

10. The insertElement function is called with the provided inputs to perform the insertion operation.

11. Finally, the updated array, including the newly inserted element, is displayed.

12. This program demonstrates basic array manipulation techniques, such as element insertion and dynamic resizing, while handling user inputs in C.

Problem Statement 39:

Design a C program that includes a structure named Point which holds two members: x and y coordinates, both of integer type. Implement a function to calculate the Euclidean distance between two points represented by this structure. The Euclidean distance is the straight-line distance between two points in Euclidean space. The program should prompt the user to input the x and y coordinates for two points and then compute and display the Euclidean distance between these points. This task is aimed at testing your understanding of structures in C, mathematical computations, and handling user input/output.

Code:

#include <stdio.h>
#include <math.h> // Include math.h for the sqrt function

// Define the Point structure with x and y coordinates
typedef struct
{
    int x;
    int y;
} Point;

// Function to calculate the Euclidean distance between two Point structures
double calculateDistance(Point p1, Point p2)
{
    int deltaX = p2.x - p1.x;
    int deltaY = p2.y - p1.y;
    return sqrt(deltaX * deltaX + deltaY * deltaY);
}

int main()
{
    Point point1, point2;

    printf("Enter coordinates for Point 1 (x y): ");
    scanf("%d %d", &point1.x, &point1.y);

    printf("Enter coordinates for Point 2 (x y): ");
    scanf("%d %d", &point2.x, &point2.y);

    // Call the calculateDistance function to calculate the Euclidean distance
    double distance = calculateDistance(point1, point2);

    printf("Euclidean distance between Point 1 and Point 2: %.2lf\n", distance);

    return 0;
}

Explanation:

1. The program begins with including the standard input-output header for input and output functions and the math header to use the sqrt function for square root calculations.

2. A structure named Point is defined, which contains two integer members: x and y, representing the coordinates of a point in 2D space.

3. A function calculateDistance is declared to compute the Euclidean distance between two points. It accepts two Point structures as parameters.

4. Inside the function, it calculates the differences in the x and y coordinates between the two points (deltaX and deltaY), then applies the Euclidean distance formula: sqrt((deltaX)^2 + (deltaY)^2).

5. In the main function, two Point variables (point1 and point2) are declared, and the user is prompted to enter their coordinates.

6. The calculateDistance function is called with these two points, and the computed distance is stored in a double variable named distance.

7. Finally, the calculated Euclidean distance is displayed to the user with a precision of two decimal places.

8. This program demonstrates the use of structures to represent data, mathematical calculations in C, and basic input/output handling.

Problem Statement 40:

Create a C program that utilizes a structure named Student, which contains two members: studentId (an integer) and grade (a float). Your program should create an array of Student structures to store information for multiple students. The program should prompt the user to enter the number of students, and then for each student, it should accept the student ID and grade as input. After collecting the data, the program should use a loop to print out each student's ID and grade. This task is designed to assess your ability to work with arrays of structures, handle user input/output, and iterate through arrays in C.

Code:

#include <stdio.h>

// Define the Student structure with studentId and grade members
struct Student
{
    int studentId;
    float grade;
};

int main()
{
    int numStudents;

    printf("Enter the number of students: ");
    scanf("%d", &numStudents);

    // Create an array of Student structures based on user input
    struct Student students[numStudents];

    // Input student information
    for (int i = 0; i < numStudents; i++)
    {
        printf("Enter Student %d ID: ", i + 1);
        scanf("%d", &students[i].studentId);

        printf("Enter Student %d Grade: ", i + 1);
        scanf("%f", &students[i].grade);
    }

    // Print student information
    printf("Student Information:\n");
    for (int i = 0; i < numStudents; i++)
    {
        printf("Student %d ID: %d, Grade: %.2f\n", i + 1, students[i].studentId, students[i].grade);
    }

    return 0;
}

Explanation:

1. The program starts with including the standard input-output header for utilizing input and output functions.

2. A structure named Student is defined, which has two members: studentId (an integer) and grade (a floating-point number).

3. In the main function, the user is prompted to enter the total number of students, which determines the size of the Student array to be created.

4. An array named students of the Student structure is declared with the size based on the user's input.

5. A for loop is used to iterate through each student in the array, prompting the user to input the student ID and grade for each. These values are stored in the respective fields of the Student structure within the array.

6. After collecting the data, another for loop is used to iterate through the array and print out the ID and grade of each student, formatted to show the grade to two decimal places.

7. This program demonstrates the use of structures and arrays to store and manipulate a collection of related data, as well as basic input/output handling in C.

Problem Statement 41:

Develop a C program that swaps the values of two integers using pointers. The program should define a function that takes the addresses of two integer variables and swaps their values. This exercise is intended to demonstrate your understanding of pointer usage in C for direct memory manipulation.

Code:

#include <stdio.h>

// Function to swap two numbers using pointers
void swap(int *num1, int *num2)
{
    int temp = *num1; // Save the value at address num1 in temp
    *num1 = *num2;    // Assign the value at address num2 to address num1
    *num2 = temp;     // Assign the value in temp (original value at num1) to num2
}

int main()
{
    int a = 10;
    int b = 20;

    printf("Before swapping:\n");
    printf("a = %d, b = %d\n", a, b);

    // Call the swap function with the addresses of a and b
    swap(&a, &b);

    printf("After swapping:\n");
    printf("a = %d, b = %d\n", a, b);

    return 0;
}

Explanation:

1. The program starts by including the standard input-output header for utilizing input and output functions.

2. A function named swap is declared to swap the values of two integers. It accepts two arguments: pointers to the integers (int *num1 and int *num2).

3. Inside the swap function, a temporary variable temp is used to store the value pointed to by num1. Then, the value pointed to by num2 is assigned to the location pointed to by num1. Finally, the value stored in temp is assigned to the location pointed to by num2, completing the swap.

4. In the main function, two integer variables a and b are declared and initialized.

5. The program prints the values of a and b before the swap for demonstration purposes.

6. The swap function is then called with the addresses of a and b (&a and &b) as its arguments.

7. After the swap operation, the program prints the values of a and b again, showing that their values have been swapped.

8. This program demonstrates the basic concept of pointers in C by directly manipulating the memory locations of variables to swap their values.

Problem Statement 42:

Design a C program that manages a library system capable of adding books, checking them in and out, updating book details, and displaying the library inventory. Utilize a Book structure that includes title, author, ISBN, and availability status. The program should demonstrate functionality for adding a new book, checking out and returning a book, updating a book's details, and displaying all books in the library. Implement functions for each of these actions and test them within your program. This task aims to evaluate your ability to work with structures, arrays, and pointers in C, as well as your understanding of basic library operations.

Code:

#include <stdio.h>
#include <string.h>

// Define the maximum number of books in the library
#define MAX_BOOKS 100

// Define the Book structure
typedef struct {
    char title[100];
    char author[100];
    char ISBN[20];
    int available; // 1 for available, 0 for checked out
} Book;

// Function prototypes
void addBook(Book *library, int *numBooks, Book newBook);
void updateBookDetails(Book *book, const char *newTitle, const char *newAuthor, const char *newISBN);
void checkOutBook(Book *book);
void returnBook(Book *book);
void displayLibrary(Book *library, int numBooks);

int main() {
    // Initialize the library
    Book library[MAX_BOOKS];
    int numBooks = 0; // Current number of books in the library

    // Example book to add
    Book exampleBook = {"Example Title", "Example Author", "123-456-789", 1};
    addBook(library, &numBooks, exampleBook);

    // Check out the first book
    if (numBooks > 0) {
        printf("\nChecking out the first book...\n");
        checkOutBook(&library[0]);
    }

    // Return the first book
    printf("\nReturning the first book...\n");
    returnBook(&library[0]);

    // Update the first book's details
    printf("\nUpdating the first book's details...\n");
    updateBookDetails(&library[0], "New Title", "New Author", "987-654-321");

    // Display all books in the library
    printf("\nLibrary Inventory:\n");
    displayLibrary(library, numBooks);

    return 0;
}

// Add a new book to the library
void addBook(Book *library, int *numBooks, Book newBook) {
    if (*numBooks < MAX_BOOKS) {
        library[*numBooks] = newBook; // Add the new book to the array
        (*numBooks)++; // Increment the total number of books
        printf("New book added to the library.\n");
    } else {
        printf("Library is full. Cannot add more books.\n");
    }
}

// Update a book's details
void updateBookDetails(Book *book, const char *newTitle, const char *newAuthor, const char *newISBN) {
    strcpy(book->title, newTitle); // Update title
    strcpy(book->author, newAuthor); // Update author
    strcpy(book->ISBN, newISBN); // Update ISBN
    printf("Book details updated.\n");
}

// Check out a book
void checkOutBook(Book *book) {
    if (book->available) {
        book->available = 0; // Mark as checked out
        printf("Book checked out successfully.\n");
    } else {
        printf("Book is already checked out.\n");
    }
}

// Return a book
void returnBook(Book *book) {
    if (!book->available) {
        book->available = 1; // Mark as available
        printf("Book returned successfully.\n");
    } else {
        printf("Book is not checked out.\n");
    }
}

// Display all books in the library
void displayLibrary(Book *library, int numBooks) {
    for (int i = 0; i < numBooks; i++) {
        printf("Title: %s, Author: %s, ISBN: %s, Status: %s\n",
               library[i].title, library[i].author, library[i].ISBN,
               library[i].available ? "Available" : "Checked Out");
    }
}

Explanation:

1. The Book structure is defined with title, author, ISBN, and available as its members. This structure represents each book in the library.

2. The program includes prototypes for functions that add a book to the library, update a book's details, check out a book, return a book, and display all books in the library.

3. Main Function:

   • Initializes an array of Book structures named library with a maximum size defined by MAX_BOOKS.

   • Manages the current number of books with numBooks.

   • Demonstrates adding a book, checking out and returning a book, updating a book's details, and displaying the library's inventory.

4. Function Implementations:

   • addBook: Adds a new book to the library array and increments the numBooks counter.

   • updateBookDetails: Updates the title, author, and ISBN of a book.

   • checkOutBook: Marks a book as checked out (not available).

   • returnBook: Marks a book as returned (available).

   • displayLibrary: Loops through the library array and prints the details of each book, indicating whether each is available or checked out.

Problem Statement 43:

Develop a C program that calculates the factorial of a given number using recursion. The factorial of a number n is defined as the product of all positive integers less than or equal to n. For example, the factorial of 5 (denoted as 5!) is 5 * 4 * 3 * 2 * 1 = 120. The program should define a recursive function that takes an integer n as its argument and returns the factorial of n. The base case for the recursion should handle the fact that the factorial of 0 and 1 is 1. After computing the factorial, the program should display the result. This task aims to test your understanding of recursion in C programming, a powerful technique for solving problems that can be divided into smaller instances of the same problem.

Code:

#include <stdio.h>

// Recursive function to calculate the factorial of a number
int factorial(int n) {
    // Base case: factorial of 0 or 1 is 1
    if (n == 0 || n == 1) {
        return 1;
    }
    // Recursive case: n * factorial of (n-1)
    return n * factorial(n - 1);
}

int main() {
    int num = 5; // Example number
    // Calculate and print the factorial of the number
    printf("Factorial of %d is %d\n", num, factorial(num));
    return 0;
}

Explanation:

1. Factorial Function: The program includes a recursive function factorial that calculates the factorial of a given integer n. The function uses a simple recursive formula: n! = n * (n-1)!, with the base cases being 0! = 1 and 1! = 1.

2. Recursion: The key concept demonstrated in this program is recursion, where the function factorial calls itself with a decremented value of n until it reaches the base case.

3. Main Function: In the main function, an example number num is defined, and the factorial of this number is computed by calling the factorial function. The result is then printed to the console.

Problem Statement 44:

Write a C program to compute the nth number in the Fibonacci sequence using recursion. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, usually starting with 0 and 1. That is, the sequence begins 0, 1, 1, 2, 3, 5, 8, 13, ... and so on. Your program should define a recursive function that takes an integer n as its argument and returns the nth Fibonacci number. Make sure to handle the base cases where n is 0 or 1. The program should prompt the user to enter a number, calculate the corresponding Fibonacci number, and display the result.

Code:

#include <stdio.h>

// Recursive function to calculate the n-th Fibonacci number
int fibonacci(int n) {
    // Base cases: Fibonacci(0) = 0, Fibonacci(1) = 1
    if (n <= 1) {
        return n;
    }
    // Recursive case: Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int num; // Variable to store the number input by the user

    // Prompt the user for the number
    printf("Enter a number to find its Fibonacci value: ");
    scanf("%d", &num);

    // Calculate and display the n-th Fibonacci number
    printf("Fibonacci(%d) is %d\n", num, fibonacci(num));

    return 0;
}

Explanation:

1. Fibonacci Function: The program includes a recursive function named fibonacci that calculates the nth number in the Fibonacci sequence. This function has two base cases: when n is 0, it returns 0, and when n is 1, it returns 1. For all other values of n, it returns the sum of the two preceding numbers in the sequence, computed by recursively calling itself with n - 1 and n - 2.

2. Recursion: This program demonstrates the use of recursion, a technique where a function calls itself to solve smaller instances of the same problem. Recursion is particularly well-suited for solving problems like generating Fibonacci numbers, which are defined in terms of previous values in the sequence.

3. Main Function: The main function prompts the user to enter a number for which the Fibonacci value is to be calculated. It reads this number using scanf, calls the fibonacci function with the input number as the argument, and prints the result.

Problem Statement 45:

Develop a C program that checks if a given string is a palindrome using recursion. A palindrome is a word, phrase, number, or other sequence of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization). Your program should implement a recursive function that takes a string, along with starting and ending indices as arguments, and returns true if the string is a palindrome and false otherwise. The base case of the recursion should handle the scenario where the comparison has reached the middle of the string or if the characters being compared do not match. Test your function by determining if a predefined string is a palindrome and display the result.

Code:

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

// Recursive function to check if a string is a palindrome
bool isPalindrome(char str[], int start, int end) {
    // Base case: If the start index is greater than or equal to the end index
    if (start >= end) {
        return true;
    }
    // Check if the characters at the start and end are different
    if (str[start] != str[end]) {
        return false;
    }
    // Move towards the middle of the string
    return isPalindrome(str, start + 1, end - 1);
}

int main() {
    char str[] = "racecar"; // Example string to check
    // Check if the string is a palindrome
    if (isPalindrome(str, 0, strlen(str) - 1)) {
        printf("%s is a palindrome\n", str);
    } else {
        printf("%s is not a palindrome\n", str);
    }
    return 0;
}

Explanation:

1. Palindrome Function: The program includes a recursive function isPalindrome that checks if a given string is a palindrome. The function takes three arguments: the string str, and two integers, start and end, which represent the indices of the characters currently being compared.

2. Recursion Logic: The function compares the characters at the start and end indices. If these characters are not equal, it immediately returns false, indicating that the string is not a palindrome. If the characters are equal, the function calls itself with start incremented by 1 and end decremented by 1, moving the comparison inward towards the center of the string.

3. Base Case: The recursion has two base cases:

   • If start is greater than or equal to end, it means the entire string (or the relevant portion of it) has been checked without finding any mismatched characters, so the function returns true.

   • If the characters at the start and end indices are different, the function returns false.

4. Main Function: The main function defines a test string str and calls the isPalindrome function with the initial start index of 0 and an end index of strlen(str) - 1 (which is the last character of the string). It then prints whether the string is a palindrome based on the function's return value.

Problem Statement 46:

Write a C program that converts a decimal number to its binary representation using recursion. The program should define a recursive function that takes an integer n (the decimal number) as its argument and prints its binary representation. In computing the binary representation, remember that the binary form of a decimal number can be obtained by dividing the number by 2 and recording the remainder (0 or 1) for each division, working from the least significant bit to the most significant bit. The base case of the recursion occurs when n is reduced to 0. The program should test this function by converting a predefined decimal number to binary and displaying the result.

Code:

#include <stdio.h>

// Recursive function to convert a decimal number to binary
void decimalToBinary(int n) {
    // Base case: When n is reduced to 0, the recursion stops
    if (n > 0) {
        decimalToBinary(n / 2); // Recursive call with n divided by 2
        printf("%d", n % 2); // Print the remainder, which represents the binary digit
    }
}

int main() {
    int decimalNumber = 10; // Example decimal number to convert
    // Print the introduction to the binary representation
    printf("Binary representation of %d is: ", decimalNumber);
    // Call the recursive function to print the binary representation
    decimalToBinary(decimalNumber);
    // Print a newline character for neatness
    printf("\n");
    return 0;
}

Explanation:

1. Recursive Function (decimalToBinary): The function takes an integer n as input and prints its binary representation. It works by recursively dividing n by 2 (shifting right in binary terms) until n is 0. After each recursive call, it prints the remainder of the division by 2 (n % 2), which is either 0 or 1, representing a binary digit. The recursive calls build up on the call stack, and as they return, the remainders are printed in the correct order, from the most significant bit to the least significant bit.

2. Recursion Logic: The recursion begins with the most significant part of the binary number (due to the recursive call being placed before the printf statement). This ensures that the binary digits are printed in the correct order as the function unwinds from its recursion.

3. Main Function: The main function defines a test case with a decimal number, decimalNumber, and calls decimalToBinary to convert it to binary. It starts by printing a message indicating the decimal number being converted, calls the recursive function to print its binary representation, and ends with a newline for clarity.

Problem Statement 47:

Develop a C program that calculates the length of a string using recursion. The program should implement a recursive function that takes a string (character array) as its argument and returns the length of that string. The function should determine the length by counting characters until it reaches the null terminator ('\0'), which marks the end of the string.

Code:

#include <stdio.h>
#include <string.h>

// Recursive function to calculate the length of a string
int stringLength(char str[]) {
    // Base case: If the first character is the null terminator, return 0
    if (str[0] == '\0') {
        return 0;
    }
    // Recursive step: Move to the next character and add 1 to the length
    return 1 + stringLength(str + 1);
}

int main() {
    char str[] = "Hello, World!"; // Example string
    // Calculate and print the length of the string
    printf("Length of the string is %d\n", stringLength(str));
    return 0;
}

Explanation:

1. Recursive Function (stringLength): The function checks if the first character of the string is the null terminator ('\0'). If it is, the string's length is 0, which is the base case of the recursion. If not, the function calls itself with a pointer to the next character in the string (str + 1), effectively reducing the problem size by one character. It adds 1 to the result of this recursive call, counting each character until the base case is reached.

2. Recursion Logic: This approach exploits the fact that a string in C is an array of characters terminated by a null character. By recursively calling the function with the next substring (excluding the first character), and adding 1 for each call, the function accumulates the total number of characters before the null terminator.

3. Main Function: The main function defines an example string str and calls stringLength to find its length. It then prints the length of the string. This demonstrates how recursion can be used to iterate through a string and calculate its length without using traditional loop constructs or the built-in strlen function.

Problem Statement 48:

Write a C program that calculates the sum of the digits of a given integer using recursion. The program should define a recursive function that takes an integer n as its argument and returns the sum of its digits. The base case for the recursion occurs when n is reduced to 0, at which point the function should return 0. For any other value of n, the function should return the last digit of n plus the sum of the digits of the number obtained by removing the last digit from n (achieved by dividing n by 10).

Code:

#include <stdio.h>

// Recursive function to calculate the sum of digits of an integer
int sumOfDigits(int n) {
    // Base case: If n is 0, return 0
    if (n == 0) {
        return 0;
    }
    // Recursive step: Return the last digit plus the sum of the remaining digits
    return n % 10 + sumOfDigits(n / 10);
}

int main() {
    int num = 12345; // Example integer
    // Calculate and print the sum of the digits of num
    printf("Sum of digits of %d is %d\n", num, sumOfDigits(num));
    return 0;
}

Explanation:

1. Recursive Function (sumOfDigits): This function calculates the sum of the digits of an integer n recursively. It identifies the base case as n being 0, in which case it returns 0, signifying that there are no more digits to add.

2. Recursion Logic: For values of n greater than 0, the function separates the last digit of n using the modulus operator (n % 10) and adds it to the result of a recursive call to itself with the rest of the number (n / 10). This effectively peels off one digit at a time from n, adding each digit to the cumulative sum until n is reduced to 0.

3. Main Function: An example integer num is defined in the main function. The sumOfDigits function is then called with num as the argument to calculate the sum of its digits. The result is printed to demonstrate the functionality of the recursive solution.

Problem Statement 49:

Develop a C program that requests a string input from the user. This program should analyze the entered string and calculate the total number of words contained within it. For the purpose of this program, a word is defined as a sequence of characters that are separated by spaces. Assume that the input string will not start or end with spaces, and there will not be multiple consecutive spaces between words.

Code:

#include <stdio.h>
#include <string.h>

int main() {
    char str[1000]; // Array to hold user input
    int count = 0, i; // Variables for word count and loop control

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin); // Read string from user input
    str[strcspn(str, "\n")] = 0; // Remove trailing newline character

    // Initial check to see if the string starts with a non-space character
    if (str[0] != ' ') {
        count = 1; // If so, we have at least one word
    }

    // Loop through the string
    for (i = 0; str[i] != '\0'; i++) {
        // Check for space followed by a non-space character (indicating the start of a new word)
        if (str[i] == ' ' && str[i + 1] != ' ' && str[i + 1] != '\0') {
            count++;
        }
    }

    printf("Number of words in the string: %d\n", count);

    return 0;
}

Explanation:

• The program begins by declaring a character array str[1000] to store the input string and two integer variables: count to keep track of the number of words, and i for loop control.

• It then prompts the user to enter a string, which is read using fgets(). This function is chosen over scanf() to allow for spaces within the input. The newline character introduced by pressing enter is removed to prevent it from affecting the word count.

• An initial check is performed to see if the first character of the string is not a space. If it isn't, count is set to 1, assuming that the string starts with a word.

• The program then iterates over each character in the string using a for loop. Inside the loop, it checks for a pattern where a space character is followed by a non-space character (and that the next character is not the end of the string). This pattern indicates the start of a new word, and thus count is incremented.

• After the loop completes, the program prints the total word count. This approach effectively counts the number of transitions from a space to a non-space character across the string, which corresponds to counting words as defined in the problem statement.

Problem Statement 50:

Create a C program that prompts the user to input a string. The program should then calculate and display the frequency of each character within the string. It is important to treat uppercase and lowercase versions of a character as the same (i.e., 'A' and 'a' should be considered identical for counting purposes). The output should list characters and their frequencies.

Code:

#include <stdio.h>
#include <ctype.h> // For tolower function

int main() {
    char str[1000]; // Array to hold the input string
    int freq[26] = {0}; // Array to store frequency of each alphabet letter, initialized to 0
    int i;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin); // Read string from user input

    // Convert each character to lowercase and calculate frequency
    for (i = 0; str[i] != '\0'; i++) {
        if (str[i] >= 'A' && str[i] <= 'Z' || str[i] >= 'a' && str[i] <= 'z') {
            freq[tolower(str[i]) - 'a']++;
        }
    }

    // Display the frequency of each character
    printf("Frequency of each character in the string:\n");
    for (i = 0; i < 26; i++) {
        if (freq[i] != 0) {
            printf("%c: %d\n", i + 'a', freq[i]);
        }
    }

    return 0;
}

Explanation:

• The program starts by declaring a character array str[1000] to store the user's input and an integer array freq[26] to hold the frequency of each letter in the alphabet. The freq array is initialized with zeros.

• It prompts the user to input a string, which is read using fgets(). This approach allows spaces and punctuation in the string and ensures that the input doesn't overflow the buffer.

• The program then iterates over each character in the string with a for loop. If a character is an alphabet letter (either uppercase or lowercase), it converts the character to lowercase using tolower() and increments the corresponding index in the freq array. The index is determined by subtracting 'a' from the character value, which maps 'a' to 0, 'b' to 1, and so on, up to 'z'.

• After processing the entire string, the program iterates over the freq array and prints the frequency of each character that appears at least once. Characters are converted back to their alphabetical representations by adding 'a' to the index value.

• This program effectively counts and displays the frequency of each letter in the input string, ignoring case differences between uppercase and lowercase letters.

Problem Statement 51:

Design a C program that prompts the user to input a string. This program should process the input string by removing all extra spaces, ensuring that only a single space remains between words and no leading or trailing spaces are present. For instance, if the input string is "Hello World !", the program should modify it to "Hello World !".

Code:

#include <stdio.h>
#include <string.h>
#include <ctype.h> // For isspace function

void removeExtraSpaces(char* input) {
    int i, x = 0;
    for (i = 0; input[i]; ++i) {
        if (!isspace(input[i]) || (i > 0 && !isspace(input[i-1]))) {
            input[x++] = input[i];
        }
    }
    if (isspace(input[x-1])) x--; // Remove trailing space if exists
    input[x] = '\0'; // Null-terminate the modified string
}

int main() {
    char str[1000]; // Array to hold the input string

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin); // Read string from user input
    str[strcspn(str, "\n")] = 0; // Remove trailing newline character

    removeExtraSpaces(str); // Function call to remove extra spaces

    printf("String after removing extra spaces: '%s'\n", str);

    return 0;
}

Explanation:

• The program starts by defining a function removeExtraSpaces that takes a character array (string) as its input. This function is responsible for modifying the input string to remove extra spaces.

• Inside removeExtraSpaces, a for loop iterates through each character in the input string. The function uses the isspace function from ctype.h to check if a character is a space. It copies the character to a new position in the same string (input[x++]) if it is not a space or if it is the first space following a non-space character. This effectively collapses multiple spaces into a single space and preserves non-space characters.

• After the loop, the function checks if the last copied character is a space. If so, it decrements the index x to remove this trailing space.

• The main function reads a string from the user, removes the trailing newline character, calls removeExtraSpaces to modify the string in place, and then prints the modified string.

• This approach ensures that leading spaces, trailing spaces, and extra spaces between words are removed from the input string, leaving only single spaces between words.

Problem Statement 52:

Craft a C program that requests a string from the user and reverses each word within the string while maintaining the original order of the words. For example, if the input string is "Hello World", the program should output "olleH dlroW".

Code:

#include <stdio.h>
#include <string.h>
#include <ctype.h> // For isspace function

void reverseWord(char* start, char* end) {
    char temp;
    while (start < end) {
        temp = *start;
        *start++ = *end;
        *end-- = temp;
    }
}

int main() {
    char str[1000]; // Array to hold the input string
    char* start = str; // Pointer to track the start of a word
    char* temp = str; // Temporary pointer for iteration

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin); // Read string from user input
    str[strcspn(str, "\n")] = 0; // Remove trailing newline character

    // Loop through the string
    while (*temp) {
        // Find the start of a word
        start = temp;
        // Move temp to the end of the word
        while (*temp && !isspace(*temp)) {
            temp++;
        }
        // Reverse the word
        reverseWord(start, temp - 1);

        // If we've reached the end of the string, break
        if (!*temp) break;
        // Otherwise, skip the space
        temp++;
    }

    printf("String with each word reversed: '%s'\n", str);

    return 0;
}

Explanation:

• The program includes a helper function reverseWord that takes two pointers, start and end, as arguments. It reverses the characters between these pointers, effectively reversing a word.

• In the main function, the program reads a string from the user and removes the trailing newline character.

• It then uses two pointers, start and temp, to iterate through the string. start marks the beginning of a word, and temp is used to find the end of the word.

• The while loop iterates through the string. Inside the loop, temp advances until it finds a space or the end of the string, marking the end of a word.

• Once the end of a word is found, reverseWord is called with start and temp - 1 as arguments to reverse the word in place.

• After reversing the word, if the end of the string (*temp) is reached, the loop breaks. Otherwise, temp is incremented to skip the space, and the process repeats for the next word.

• Finally, the program prints the modified string, which now has each word reversed but maintains the original word order.

Problem Statement 53:

Develop a C program that takes a string input from the user, reverses the entire string, and then reverses each word within the reversed string. This process will ultimately reverse the order of the words in the original string. For instance, if the user inputs "Hello World", the program should first reverse the string to "dlroW olleH" and then reverse each word to achieve the final output "World Hello".

Code:

#include <stdio.h>
#include <string.h>
#include <ctype.h> // For isspace function

// Function to reverse any part of the string from start to end
void reverse(char* start, char* end) {
    char temp;
    while (start < end) {
        temp = *start;
        *start++ = *end;
        *end-- = temp;
    }
}

int main() {
    char str[1000]; // Array to hold the input string

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin); // Read string from user input
    str[strcspn(str, "\n")] = 0; // Remove trailing newline character

    // Reverse the entire string
    reverse(str, str + strlen(str) - 1);

    // Reverse each word in the reversed string
    char* word_begin = str;
    char* temp = str; // Temporary pointer for traversal
    while (*temp) {
        temp++;
        if (*temp == '\0' || isspace(*temp)) {
            reverse(word_begin, temp - 1);
            word_begin = temp + 1;
        }
    }

    printf("After reversing the string and then reversing each word: '%s'\n", str);

    return 0;
}

Explanation:

• The program defines a function reverse that takes two pointers, start and end, as arguments. This function reverses the portion of the string between these two pointers by swapping characters from the start and end until they meet in the middle.

• In the main function, the program reads a string from the user and removes the trailing newline character.

• It first reverses the entire string by calling reverse with pointers to the beginning and the end of the string. This action transforms the string as per the first step of the problem statement (e.g., "Hello World" becomes "dlroW olleH").

• Next, the program aims to reverse each word within this reversed string. It uses a temporary pointer temp to traverse the string and a pointer word_begin to mark the start of each word.

• As temp advances through the string, when it encounters a space or the end of the string (*temp == '\0'), it calls reverse for the word identified by word_begin and temp - 1. This reverses the individual word back to its original orientation but in the new reversed order.

• After reversing each word in the reversed string, the program prints the final result, which is the original string with the word order reversed (e.g., "World Hello").

Problem Statement 54:

Construct a C program that prompts the user to enter two strings: a main string and a substring. The program should then check whether the main string contains the given substring. If the substring is found within the main string, the program should output "True"; otherwise, it should output "False". For instance, if the main string is "Hello world" and the substring is "world", the program should return "True".

Code:

#include <stdio.h>
#include <string.h>

// Function to check if the main string contains the substring
int containsSubstring(char* str, char* substr) {
    char* pos = strstr(str, substr); // Use strstr to find the substring in the main string
    if (pos != NULL) {
        return 1; // Substring found
    } else {
        return 0; // Substring not found
    }
}

int main() {
    char mainStr[1000]; // Array to hold the main string
    char substr[1000]; // Array to hold the substring

    printf("Enter the main string: ");
    fgets(mainStr, sizeof(mainStr), stdin); // Read the main string
    mainStr[strcspn(mainStr, "\n")] = 0; // Remove trailing newline character

    printf("Enter the substring: ");
    fgets(substr, sizeof(substr), stdin); // Read the substring
    substr[strcspn(substr, "\n")] = 0; // Remove trailing newline character

    // Check if the main string contains the substring
    if (containsSubstring(mainStr, substr)) {
        printf("True\n"); // Substring found
    } else {
        printf("False\n"); // Substring not found
    }

    return 0;
}

Explanation:

• The program defines a function containsSubstring that takes two strings as arguments: the main string and the substring. It uses the strstr function from the C standard library, which returns a pointer to the first occurrence of the substring in the main string, or NULL if the substring is not found.

• In the main function, the program reads two strings from the user: the main string and the substring. It removes the trailing newline character from both inputs to ensure accurate comparison.

• The containsSubstring function is then called with the main string and the substring as arguments. If strstr returns a non-NULL value, indicating that the substring is present in the main string, containsSubstring returns 1 (True). Otherwise, it returns 0 (False).

• Based on the return value of containsSubstring, the program outputs "True" if the substring is found within the main string, and "False" if it is not.

• This approach allows the program to efficiently determine the presence of a substring within a main string, providing a simple method for substring search in C.