Control Structures and Functions

Control Structures and Functions

Contents

Describe Decision Making Structures 1

Define and apply if-else statement 3

Define and apply if-else Ladder 9

Describe switch statement with proper syntax in ā€˜Cā€™ 9

Apply switch statement 9

Describe and apply for Loop with proper syntax of ‘C’ Language 9

Describe and apply nested for Loop with proper syntax of ‘C’ Language 9

Define while Loop and do-while Loop 9

Differentiate between while loop and do-while loop 9

Apply while loop and do-while loop 9

Describe the use of Jumping Control statements 9

Differentiate between break and continue 9

Describe goto statement 9

Define Function and its benefits 9

Differentiate between User-defined Functions and Library Functions 9

Classify the user-defined Functions 9

Differentiate between Formal Arguments and Actual Arguments 9

Describe Parameters Passing Techniques used in Functions 9

Differentiate between call-by-value and call-by-reference 9

Describe Recursive Function 9

Write Programs using Recursive Functions 9

Describe Tower of Hanoi problem 9

Write a Recursive Program to implement Tower of Hanoi problem 9

Describe Decision Making Structures

Decision making structures in the C programming language refer to the various constructs and statements that enable programmers to make choices and control the flow of execution based on specific conditions. The primary decision-making structures in C are the if statement, the if-else statement, the nested if-else statement, and the switch statement.

  1. If statement:

The if statement is the simplest decision-making structure in C. It allows a program to execute a block of code if a given condition is true. The syntax of the if statement is as follows:

if (condition)

{

// Code to be executed if the condition is true

}

  1. If-else statement:

The if-else statement extends the functionality of the if statement by providing an alternative block of code to execute when the condition is false. The syntax of the if-else statement is as follows:

if (condition)

{

// Code to be executed if the condition is true

}

else

{

// Code to be executed if the condition is false

}

  1. Nested if-else statement:

The nested if-else statement allows multiple conditions to be evaluated sequentially. It consists of an if statement inside another if or else block. This structure is useful when multiple conditions need to be checked. The syntax of the nested if-else statement is as follows:

if (condition1)

{

// Code to be executed if condition1 is true

if (condition2)

{

// Code to be executed if both condition1 and condition2 are true

}

else

{

// Code to be executed if condition1 is true and condition2 is false

}

}

else

{

// Code to be executed if condition1 is false

}

  1. Switch statement:

The switch statement provides an efficient way to select one of several alternatives based on the value of an expression. It allows programmers to compare a single variable against multiple constant values and execute the corresponding block of code. The syntax of the switch statement is as follows:

switch (expression)

{

case constant1:

// Code to be executed if expression equals constant1

break;

case constant2:

// Code to be executed if expression equals constant2

break;

// …

default:

// Code to be executed if expression does not match any constant

break;

}

These decision-making structures in C provide programmers with the flexibility to control program flow and execute specific code blocks based on different conditions, making the language suitable for implementing complex decision logic.

Define and apply if-else statement

The if-else statement is a decision-making structure in C that allows a program to execute different blocks of code based on a condition. It provides an alternative block of code to execute when the condition specified in the if statement evaluates to false.

The syntax of the if-else statement is as follows:

if (condition)

{

// Code to be executed if the condition is true

}

else

{

// Code to be executed if the condition is false

}

Here’s an example that demonstrates the usage of the if-else statement:

  1. Positive or Negative number check:

#include <stdio.h>

int main()

{

int number;

printf(“Enter a number: “);

scanf(“%d”, &number);

if (number > 0)

{

printf(“The number is positive.\n”);

}

else

{

printf(“The number is non-positive.\n”);

}

return 0;

}

In this example, the user is prompted to enter a number. The value of the number is then checked using the if-else statement. If the number is greater than 0, the message “The number is positive.” is printed. Otherwise, if the number is less than or equal to 0, the message “The number is non-positive.” is printed.

  1. Leap Year Check:

#include <stdio.h>

int main()

{

int year;

printf(“Enter a year: “);

scanf(“%d”, &year);

if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))

{

printf(“%d is a leap year.\n”, year);

}

else

{

printf(“%d is not a leap year.\n”, year);

}

return 0;

}

This program checks if a given year is a leap year using the if-else statement. Leap years are divisible by 4 but not divisible by 100 unless they are divisible by 400.

  1. Absolute Value Calculation:

#include <stdio.h>

int main()

{

int number;

printf(“Enter a number: “);

scanf(“%d”, &number);

if (number < 0)

{

number = -number;

}

printf(“The absolute value is: %d\n”, number);

return 0;

}

In this program, the user inputs a number, and the if-else statement is used to calculate the absolute value of the number. If the number is negative, it is multiplied by -1 to make it positive.

  1. Prime Number Check:

#include <stdio.h>

int main()

{

int number, i, isPrime = 1;

printf(“Enter a positive integer: “);

scanf(“%d”, &number);

if (number <= 1)

{

isPrime = 0; // Numbers less than or equal to 1 are not prime

}

else

{

for (i = 2; i <= number / 2; i++)

{

if (number % i == 0)

{

isPrime = 0; // Number is divisible by i, not prime

break;

}

}

}

if (isPrime == 1)

{

printf(“%d is a prime number.\n”, number);

}

else

{

printf(“%d is not a prime number.\n”, number);

}

return 0;

}

In this program, the user enters a positive integer. The program checks whether the number is greater than 1. If it is less than or equal to 1, it sets the isPrime variable to 0, indicating that it is not a prime number.

Otherwise, the program uses a for loop to check divisibility of the number by integers from 2 to number/2. If the number is divisible by any of these integers, the isPrime variable is set to 0 and the loop is terminated using the break statement.

After the loop, the program checks the value of isPrime. If it is 1, the number is considered prime, and the program displays the appropriate message. Otherwise, if isPrime is 0, the number is not prime.

This program efficiently determines whether a given number is prime or not by checking its divisibility up to the square root of the number.

  1. Even-odd Check Program:

#include <stdio.h>

int main()

{

int number;

printf(“Enter a number: “);

scanf(“%d”, &number);

if (number % 2 == 0)

{

printf(“%d is an even number.\n”, number);

}

else

{

printf(“%d is an odd number.\n”, number);

}

return 0;

}

In this program, the user is prompted to enter a number. The program then uses the if-else statement to check whether the number is divisible by 2 (even) or not. If the number is divisible by 2, the program prints that it is an even number. Otherwise, it prints that it is an odd number.

The modulo operator % is used to determine the remainder when the number is divided by 2. If the remainder is 0, it means the number is divisible by 2 and hence even. If the remainder is not 0, it means the number is not divisible by 2 and hence odd.

This program demonstrates how the if-else statement can be used to perform a basic check and classify a number as even or odd based on the condition evaluated.

The if-else statement provides a way to handle multiple scenarios and execute different blocks of code accordingly, based on the evaluation of the condition. It is a fundamental construct in programming and is widely used to implement decision logic in C programs.

These examples demonstrate how the if-else statement can be used to implement different decision-making scenarios in C programs. By evaluating conditions and executing appropriate blocks of code, you can create programs that perform different actions based on specific conditions or user input.

Define and apply if-else Ladder

The if-else ladder is an extension of the if-else statement in C, where multiple conditions are checked sequentially using a series of if and else-if statements. It allows you to handle multiple scenarios and execute different blocks of code based on different conditions. The conditions are evaluated in the order they appear, and the block of code associated with the first true condition is executed.

Here’s the general syntax of the if-else ladder:

if (condition1)

{

// Code to be executed if condition1 is true

}

else if (condition2)

{

// Code to be executed if condition1 is false and condition2 is true

}

else if (condition3)

{

// Code to be executed if condition1 and condition2 are false and condition3 is true

}

// …

else

{

// Code to be executed if none of the conditions are true

}

Now let’s look at five examples of programs that utilize the if-else ladder:

  1. BMI Classification:

#include <stdio.h>

int main()

{

float weight, height, bmi;

printf(“Enter weight (in kg): “);

scanf(“%f”, &weight);

printf(“Enter height (in meters): “);

scanf(“%f”, &height);

bmi = weight / (height * height);

if (bmi < 18.5)

{

printf(“Underweight\n”);

}

else if (bmi < 25)

{

printf(“Normal weight\n”);

}

else if (bmi < 30)

{

printf(“Overweight\n”);

}

else

{

printf(“Obese\n”);

}

return 0;

}

This program calculates the Body Mass Index (BMI) using the weight and height provided by the user. Based on the calculated BMI, it classifies the person into one of the categories: Underweight, Normal weight, Overweight, or Obese.

  1. Time Classification:

#include <stdio.h>

int main()

{

int hours;

printf(“Enter the number of hours: “);

scanf(“%d”, &hours);

if (hours >= 0 && hours < 12)

{

printf(“Good morning!\n”);

}

else if (hours >= 12 && hours < 18)

{

printf(“Good afternoon!\n”);

}

else if (hours >= 18 && hours < 24)

{

printf(“Good evening!\n”);

}

else

{

printf(“Invalid input!\n”);

}

return 0;

}

This program takes the number of hours as input and uses an if-else ladder to greet the user based on the time of the day: Good morning for hours 0-11, Good afternoon for hours 12-17, and Good evening for hours 18-23. If the input is not within the valid range, an “Invalid input!” message is displayed.

  1. Ticket Price Calculation:

#include <stdio.h>

int main()

{

int age;

float ticketPrice;

printf(“Enter your age: “);

scanf(“%d”, &age);

if (age <= 5 || age >= 60)

{

ticketPrice = 0.0;

}

else if (age <= 12)

{

ticketPrice = 10.0;

}

else if (age <= 18)

{

ticketPrice = 15.0;

}

else

{

ticketPrice = 20.0;

}

printf(“Ticket price: $%.2f\n”, ticketPrice);

return 0;

}

This program asks the user for their age and calculates the ticket price based on the age. If the age is 5 or below, or 60 and above, the ticket price is $0. For ages 6-12, the ticket price is $10. For ages 13-18, the ticket price is $15. For ages above 18, the ticket price is $20.

  1. Character Type Classification:

#include <stdio.h>

int main()

{

char ch;

printf(“Enter a character: “);

scanf(” %c”, &ch);

if ((ch >= ‘a’ && ch <= ‘z’) || (ch >= ‘A’ && ch <= ‘Z’))

{

printf(“Alphabet\n”);

}

else if (ch >= ‘0’ && ch <= ‘9’)

{

printf(“Digit\n”);

}

else

{

printf(“Special character\n”);

}

return 0;

}

This program takes a character as input and classifies it into one of three types: Alphabet, Digit, or Special character. If the character is a lowercase or uppercase letter, it is classified as an Alphabet. If it is a digit (0-9), it is classified as a Digit. Otherwise, it is classified as a Special character.

  1. Grading System:

#include <stdio.h>

int main()

{

int marks;

printf(“Enter your marks: “);

scanf(“%d”, &marks);

if (marks >= 90)

{

printf(“Grade: A\n”);

}

else if (marks >= 80)

{

printf(“Grade: B\n”);

}

else if (marks >= 70)

{

printf(“Grade: C\n”);

}

else if (marks >= 60)

{

printf(“Grade: D\n”);

}

else if (marks >= 50)

{

printf(“Grade: E\n”);

}

else

{

printf(“Grade: F\n”);

}

return 0;

}

This program takes the marks obtained by a student and uses an if-else ladder to assign a grade based on the marks. Grades are assigned as follows: A for marks 90 and above, B for marks 80-89, C for marks 70-79, D for marks 60-69, E for marks 50-59, and F for marks below 50.

These examples demonstrate the usage of the if-else ladder to handle multiple conditions and execute different blocks of code based on those conditions. It provides a powerful way to implement complex decision-making logic in C programs.

Describe switch statement with proper syntax in ā€˜Cā€™

The switch statement is another decision-making structure in C that allows you to choose one of several execution paths based on the value of a variable or an expression. It provides a more concise alternative to a series of if-else statements when multiple conditions need to be evaluated.

The syntax of the switch statement in C is as follows:

switch (expression)

{

case constant1:

// Code to be executed if expression matches constant1

break;

case constant2:

// Code to be executed if expression matches constant2

break;

case constant3:

// Code to be executed if expression matches constant3

break;

// …

default:

// Code to be executed if expression does not match any constant

}

Here’s an example that demonstrates the usage of the switch statement:

#include <stdio.h>

int main()

{

int choice;

printf(“Select an option (1-3): “);

scanf(“%d”, &choice);

switch (choice)

{

case 1:

printf(“Option 1 selected.\n”);

break;

case 2:

printf(“Option 2 selected.\n”);

break;

case 3:

printf(“Option 3 selected.\n”);

break;

default:

printf(“Invalid option selected.\n”);

}

return 0;

}

In this example, the user is prompted to select an option by entering a number (1-3). The program uses the switch statement to match the value of the choice variable with the specified constants (1, 2, 3). If the value of choice matches one of the constants, the corresponding code block is executed. If the value does not match any of the constants, the code block associated with the default label is executed.

The break statement is used after each code block to exit the switch statement and prevent fall-through to the next case. Without the break statement, the execution would continue to the next case, resulting in unintended behavior.

The switch statement provides an efficient way to handle multiple cases based on the value of an expression. It is especially useful when dealing with a large number of cases or when multiple conditions need to be evaluated against the same expression.

Apply switch statement

Here are five examples of programs that utilize the switch statement in C:

  1. Day of the Week:

#include <stdio.h>

int main()

{

int day;

printf(“Enter a number (1-7) representing the day of the week: “);

scanf(“%d”, &day);

switch (day)

{

case 1:

printf(“Sunday\n”);

break;

case 2:

printf(“Monday\n”);

break;

case 3:

printf(“Tuesday\n”);

break;

case 4:

printf(“Wednesday\n”);

break;

case 5:

printf(“Thursday\n”);

break;

case 6:

printf(“Friday\n”);

break;

case 7:

printf(“Saturday\n”);

break;

default:

printf(“Invalid day\n”);

}

return 0;

}

This program takes a number representing the day of the week as input and uses a switch statement to print the corresponding day.

  1. Grade Calculation:

#include <stdio.h>

int main()

{

int score;

printf(“Enter your score (0-100): “);

scanf(“%d”, &score);

switch (score / 10)

{

case 10:

case 9:

printf(“Grade: A\n”);

break;

case 8:

printf(“Grade: B\n”);

break;

case 7:

printf(“Grade: C\n”);

break;

case 6:

printf(“Grade: D\n”);

break;

default:

printf(“Grade: F\n”);

}

return 0;

}

This program takes a score as input and uses a switch statement to calculate the corresponding grade based on the score range.

  1. Calculator:

#include <stdio.h>

int main()

{

float num1, num2;

char operator;

printf(“Enter two numbers: “);

scanf(“%f %f”, &num1, &num2);

printf(“Enter an operator (+, -, *, /): “);

scanf(” %c”, &operator);

switch (operator)

{

case ‘+’:

printf(“%.2f + %.2f = %.2f\n”, num1, num2, num1 + num2);

break;

case ‘-‘:

printf(“%.2f – %.2f = %.2f\n”, num1, num2, num1 – num2);

break;

case ‘*’:

printf(“%.2f * %.2f = %.2f\n”, num1, num2, num1 * num2);

break;

case ‘/’:

if (num2 != 0)

{

printf(“%.2f / %.2f = %.2f\n”, num1, num2, num1 / num2);

}

else

{

printf(“Division by zero is not allowed.\n”);

}

break;

default:

printf(“Invalid operator\n”);

}

return 0;

}

This program takes two numbers and an operator as input and uses a switch statement to perform the corresponding arithmetic operation.

  1. Month Name:

#include <stdio.h>

int main()

{

int month;

printf(“Enter a number (1-12) representing the month: “);

scanf(“%d”, &month);

switch (month)

{

case 1:

printf(“January\n”);

break;

case 2:

printf(“February\n”);

break;

case 3:

printf(“March\n”);

break;

case 4:

printf(“April\n”);

break;

case 5:

printf(“May\n”);

break;

case 6:

printf(“June\n”);

break;

case 7:

printf(“July\n”);

break;

case 8:

printf(“August\n”);

break;

case 9:

printf(“September\n”);

break;

case 10:

printf(“October\n”);

break;

case 11:

printf(“November\n”);

break;

case 12:

printf(“December\n”);

break;

default:

printf(“Invalid month\n”);

}

return 0;

}

This program takes a number representing the month as input and uses a switch statement to print the corresponding month name.

  1. Menu Selection:

#include <stdio.h>

int main()

{

char choice;

printf(“Select an option:\n”);

printf(“A. Option 1\n”);

printf(“B. Option 2\n”);

printf(“C. Option 3\n”);

printf(“Enter your choice: “);

scanf(” %c”, &choice);

switch (choice)

{

case ‘A’:

case ‘a’:

printf(“Option 1 selected.\n”);

break;

case ‘B’:

case ‘b’:

printf(“Option 2 selected.\n”);

break;

case ‘C’:

case ‘c’:

printf(“Option 3 selected.\n”);

break;

default:

printf(“Invalid choice\n”);

}

return 0;

}

This program presents a menu with options A, B, and C. The user selects an option by entering the corresponding character, and the switch statement matches the choice to execute the associated code block.

These examples demonstrate the usage of the switch statement in C to handle different cases based on the value of a variable or an expression. The switch statement provides a clean and structured way to implement multiple condition checks and execute the appropriate code block.

Describe and apply for Loop with proper syntax of ‘C’ Language

In C, loops are used to repeatedly execute a block of code until a specific condition is met. There are three types of loops in C: the for loop, the while loop, and the do-while loop. Each type of loop has a different syntax and is used in different situations.

  1. for Loop:

The for loop is used when the number of iterations is known or when you want to loop through a sequence of values. It consists of three parts: initialization, condition, and increment/decrement.

Syntax:

for (initialization; condition; increment/decrement)

{

// Code to be executed

}

Example:

#include <stdio.h>

int main()

{

int i;

for (i = 1; i <= 5; i++)

{

printf(“%d\n”, i);

}

return 0;

}

This example demonstrates a for loop that prints the numbers 1 to 5. The loop initializes i to 1, executes the code block as long as i is less than or equal to 5, and increments i by 1 in each iteration.

Here are 10 C programs that utilize the for loop:

  1. Program to print numbers from 1 to 10:

#include <stdio.h>

int main()

{

int i;

for (i = 1; i <= 10; i++)

{

printf(“%d “, i);

}

return 0;

}

  1. Program to calculate the sum of numbers from 1 to 100:

#include <stdio.h>

int main()

{

int i, sum = 0;

for (i = 1; i <= 100; i++)

{

sum += i;

}

printf(“Sum: %d\n”, sum);

return 0;

}

  1. Program to print even numbers from 1 to 20:

#include <stdio.h>

int main()

{

int i;

for (i = 2; i <= 20; i += 2)

{

printf(“%d “, i);

}

return 0;

}

  1. Program to print the multiplication table of a number:

#include <stdio.h>

int main()

{

int number, i;

printf(“Enter a number: “);

scanf(“%d”, &number);

for (i = 1; i <= 10; i++)

{

printf(“%d x %d = %d\n”, number, i, number * i);

}

return 0;

}

  1. Program to calculate the factorial of a number:

#include <stdio.h>

int main()

{

int number, i, factorial = 1;

printf(“Enter a number: “);

scanf(“%d”, &number);

for (i = 1; i <= number; i++)

{

factorial *= i;

}

printf(“Factorial: %d\n”, factorial);

return 0;

}

  1. Program to check if a number is prime or not:

#include <stdio.h>

int main()

{

int number, i, isPrime = 1;

printf(“Enter a number: “);

scanf(“%d”, &number);

for (i = 2; i <= number / 2; i++)

{

if (number % i == 0)

{

isPrime = 0;

break;

}

}

if (isPrime)

{

printf(“%d is a prime number.\n”, number);

}

else

{

printf(“%d is not a prime number.\n”, number);

}

return 0;

}

  1. Program to calculate the sum of even numbers from 1 to 50:

#include <stdio.h>

int main()

{

int i, sum = 0;

for (i = 2; i <= 50; i += 2)

{

sum += i;

}

printf(“Sum of even numbers: %d\n”, sum);

return 0;

}

  1. Program to print the ASCII values of lowercase alphabets:

#include <stdio.h>

int main()

{

char ch;

for (ch = ‘a’; ch <= ‘z’; ch++)

{

printf(“Character: %c\tASCII Value: %d\n”, ch, ch);

}

return 0;

}

9. Program to reverse a given number:

#include <stdio.h>

int main()

{

int number, reversedNumber = 0, remainder;

printf(“Enter a number: “);

scanf(“%d”, &number);

for (; number != 0; number /= 10)

{

remainder = number % 10;

reversedNumber = reversedNumber * 10 + remainder;

}

printf(“Reversed number: %d\n”, reversedNumber);

return 0;

}

10. Sum of squares of even numbers up to a given even number ‘n’:

#include <stdio.h>

int main()

{

int n, i, sum = 0;

printf(“Enter an even number: “);

scanf(“%d”, &n);

for (i = 2; i <= n; i += 2)

{

sum += i * i;

}

printf(“Sum of squares: %d\n”, sum);

return 0;

}

In this program, we first take an even number ‘n’ as input from the user. The for loop is used to iterate through even numbers starting from 2 up to ‘n’. In each iteration, we calculate the square of the current even number (i * i) and add it to the ‘sum’ variable. Finally, we print the sum of the squares of even numbers.

For example, if the user enters 10, the program will calculate the sum as 220 (2^2 + 4^2 + 6^2 + 8^2 + 10^2) and display the result.

Describe and apply nested for Loop with proper syntax of ‘C’ Language

In C, a nested for loop is a loop inside another loop. It is used when you need to perform iterations within iterations. The syntax of a nested for loop is as follows:

for (initialization; condition; increment/decrement)

{

// Code to be executed

for (initialization; condition; increment/decrement)

{

// Code to be executed

}

}

The nested for loop consists of an outer loop and an inner loop. The outer loop controls the number of iterations, while the inner loop performs iterations for each iteration of the outer loop.

Here’s an example that demonstrates the usage of a nested for loop to print a pattern of asterisks:

#include <stdio.h>

int main()

{

int rows, columns;

printf(“Enter the number of rows: “);

scanf(“%d”, &rows);

printf(“Enter the number of columns: “);

scanf(“%d”, &columns);

for (int i = 1; i <= rows; i++)

{

for (int j = 1; j <= columns; j++)

{

printf(“* “);

}

printf(“\n”);

}

return 0;

}

In this example, the user is prompted to enter the number of rows and columns for the pattern. The outer for loop controls the iteration for each row, and the inner for loop controls the iteration for each column within a row. The inner loop prints an asterisk (*) followed by a space, and the outer loop adds a newline character after each row.

For instance, if the user enters 3 for rows and 5 for columns, the program will output the following pattern:

* * * * *

* * * * *

* * * * *

Nested for loops are commonly used in scenarios where you need to iterate over two-dimensional arrays, generate patterns, or perform matrix operations.

Here are 5 C programs that use nested for loops to print different patterns:

  1. Program to print a right triangle pattern:

#include <stdio.h>

int main()

{

int rows;

printf(“Enter the number of rows: “);

scanf(“%d”, &rows);

for (int i = 1; i <= rows; i++)

{

for (int j = 1; j <= i; j++)

{

printf(“* “);

}

printf(“\n”);

}

return 0;

}

This program prompts the user to enter the number of rows and prints a right triangle pattern using asterisks.

  1. Program to print a square pattern:

#include <stdio.h>

int main()

{

int side;

printf(“Enter the side length: “);

scanf(“%d”, &side);

for (int i = 1; i <= side; i++)

{

for (int j = 1; j <= side; j++)

{

printf(“* “);

}

printf(“\n”);

}

return 0;

}

This program prompts the user to enter the side length and prints a square pattern using asterisks.

  1. Program to print a pyramid pattern:

#include <stdio.h>

int main()

{

int rows;

printf(“Enter the number of rows: “);

scanf(“%d”, &rows);

for (int i = 1; i <= rows; i++)

{

for (int j = 1; j <= rows – i; j++)

{

printf(” “);

}

for (int k = 1; k <= 2 * i – 1; k++)

{

printf(“*”);

}

printf(“\n”);

}

return 0;

}

This program prompts the user to enter the number of rows and prints a pyramid pattern using asterisks.

  1. Program to print a diamond pattern:

#include <stdio.h>

int main()

{

int rows, i, j, space;

printf(“Enter the number of rows: “);

scanf(“%d”, &rows);

space = rows – 1;

for (i = 1; i <= rows; i++)

{

for (j = 1; j <= space; j++)

{

printf(” “);

}

space–;

for (j = 1; j <= 2 * i – 1; j++)

{

printf(“*”);

}

printf(“\n”);

}

space = 1;

for (i = 1; i <= rows – 1; i++)

{

for (j = 1; j <= space; j++)

{

printf(” “);

}

space++;

for (j = 1; j <= 2 * (rows – i) – 1; j++)

{

printf(“*”);

}

printf(“\n”);

}

return 0;

}

This program prompts the user to enter the number of rows and prints a diamond pattern using asterisks.

  1. Program to print a pattern of numbers:

#include <stdio.h>

int main()

{

int rows;

printf(“Enter the number of rows: “);

scanf(“%d”, &rows);

for (int i = 1; i <= rows; i++)

{

for (int j = 1; j <= i; j++)

{

printf(“%d “, j);

}

printf(“\n”);

}

return 0;

}

This program prompts the user to enter the number of rows and prints a pattern of numbers.

These programs demonstrate the use of nested for loops to generate different patterns. Feel free to experiment with them and modify the code to create your own patterns.

Define while Loop and do-while Loop

In C, the while loop and do-while loop are used to repeat a block of code multiple times until a certain condition is met. Here’s a description of each loop along with their syntax:

  1. while Loop:

The while loop is a control flow statement that executes a block of code repeatedly as long as a specified condition is true. It checks the condition before executing the code block.

Syntax:

while (condition)

{

// Code to be executed

// Statements to be repeated

}

The condition is evaluated before each iteration. If the condition is true, the code block is executed. After executing the code block, the condition is checked again, and the process continues until the condition becomes false. If the condition is initially false, the code block is never executed.

  1. do-while Loop:

The do-while loop is similar to the while loop but with a slight difference. It executes the code block first and then checks the condition. This ensures that the code block is executed at least once, even if the condition is false.

Syntax:

do

{

// Code to be executed

// Statements to be repeated

}

while (condition);

The code block is executed first, and then the condition is checked. If the condition is true, the loop continues and the code block is executed again. The process repeats until the condition becomes false. Since the condition is checked at the end of the loop, the code block is guaranteed to execute at least once.

Here’s an example that demonstrates the usage of while and do-while loops:

#include <stdio.h>

int main()

{

int count = 0;

// while loop

while (count < 5)

{

printf(“Count: %d\n”, count);

count++;

}

printf(“\n”);

count = 0;

// do-while loop

do

{

printf(“Count: %d\n”, count);

count++;

} while (count < 5);

return 0;

}

In this example, both the while loop and do-while loop are used to print the value of the count variable. The while loop executes the code block as long as count is less than 5, while the do-while loop executes the code block first and then checks the condition.

The output of this program will be:

Count: 0

Count: 1

Count: 2

Count: 3

Count: 4

Count: 0

Count: 1

Count: 2

Count: 3

Count: 4

Both loops are powerful constructs for implementing repetitive logic in a program, and the choice between them depends on the specific requirements of the problem at hand.

Differentiate between while loop and do-while loop

Here’s a tabular comparison between the while loop and do-while loop in C:

while Loop do-while Loop
Syntax “`c “`c
while (condition) do
{ {
// Code to be executed // Code to be executed
// Statements to be repeated // Statements to be repeated
} } while (condition);
Execution Checks the condition first before executing the code block. Executes the code block first and then checks the condition.
If the condition is false initially, the code block is never executed. The code block is guaranteed to execute at least once.
If the condition is false, the code block is skipped entirely. If the condition is false, the loop terminates.
The code block may never be executed if the condition is false from the start. The code block is executed at least once.

Key Differences:

  • In the while loop, the condition is checked first before executing the code block, while in the do-while loop, the code block is executed first and then the condition is checked.
  • The while loop may never execute the code block if the condition is false from the start, whereas the do-while loop guarantees that the code block will execute at least once.
  • If the condition is false in the while loop, the code block is skipped entirely. In contrast, if the condition is false in the do-while loop, the loop terminates and the program continues to the next statement.

It’s important to choose the appropriate loop depending on the specific requirements of the program. The while loop is typically used when the number of iterations is not known in advance, while the do-while loop is useful when you want to execute a block of code at least once and then continue based on a condition.

Apply while loop and do-while loop

Here are six C programs that demonstrate the usage of the while loop and do-while loop:

  1. Program to print numbers from 1 to 5 using a while loop:

#include <stdio.h>

int main()

{

int num = 1;

while (num <= 5)

{

printf(“%d “, num);

num++;

}

return 0;

}

  1. Program to calculate the factorial of a number using a while loop:

#include <stdio.h>

int main()

{

int number, fact = 1;

printf(“Enter a positive integer: “);

scanf(“%d”, &number);

while (number > 0)

{

fact *= number;

number–;

}

printf(“Factorial: %d\n”, fact);

return 0;

}

  1. Program to print a countdown from 10 to 1 using a do-while loop:

#include <stdio.h>

int main()

{

int count = 10;

do

{

printf(“%d “, count);

count–;

} while (count >= 1);

return 0;

}

  1. Program to calculate the sum of digits of a positive integer using a do-while loop:

#include <stdio.h>

int main()

{

int number, sum = 0, digit;

printf(“Enter a positive integer: “);

scanf(“%d”, &number);

do

{

digit = number % 10;

sum += digit;

number /= 10;

} while (number > 0);

printf(“Sum of digits: %d\n”, sum);

return 0;

}

  1. Program to find the average of numbers entered by the user using a while loop and terminating on a specific condition:

#include <stdio.h>

int main()

{

int num, sum = 0, count = 0;

float average;

printf(“Enter numbers (enter -1 to terminate): “);

while (1)

{

scanf(“%d”, &num);

if (num == -1)

break;

sum += num;

count++;

}

average = (float)sum / count;

printf(“Average: %.2f\n”, average);

return 0;

}

  1. Program to reverse a number using a do-while loop:

#include <stdio.h>

int main()

{

int number, reversedNumber = 0, remainder;

printf(“Enter a positive integer: “);

scanf(“%d”, &number);

do

{

remainder = number % 10;

reversedNumber = reversedNumber * 10 + remainder;

number /= 10;

} while (number != 0);

printf(“Reversed number: %d\n”, reversedNumber);

return 0;

}

These programs demonstrate different use cases of the while loop and do-while loop in C. Feel free to run and modify them to explore further.

Describe the use of Jumping Control statements

Jumping control statements in C are used to alter the normal flow of program execution. They allow you to transfer control from one part of the program to another, skipping certain statements or repeating specific blocks of code. There are three jumping control statements in C: break, continue, and goto. Here’s a description of each:

  1. break statement:

The break statement is used to exit or terminate a loop or switch statement. When encountered, it immediately terminates the nearest enclosing loop or switch statement and transfers control to the statement following the terminated loop or switch.

for (int i = 1; i <= 10; i++)

{

if (i == 5)

{

break; // Terminate the loop when i equals 5

}

printf(“%d “, i);

}

Output: 1 2 3 4

In the above example, the break statement is used to exit the for loop when i is equal to 5. As a result, the loop terminates, and the remaining iterations are skipped.

  1. continue statement:

The continue statement is used to skip the current iteration of a loop and move to the next iteration. When encountered, it jumps to the next iteration without executing the remaining code in the loop block.

for (int i = 1; i <= 10; i++)

{

if (i % 2 == 0)

{

continue; // Skip even numbers

}

printf(“%d “, i);

}

Output: 1 3 5 7 9

In this example, the continue statement is used to skip even numbers. When i is divisible by 2, the continue statement is executed, and the remaining code in the loop block is skipped. The loop proceeds to the next iteration.

  1. goto statement:

The goto statement is used to transfer control to a labeled statement in the same function. It allows you to jump to a specific point in the program, skipping any code in between.

int number = 5;

if (number < 10)

{

goto lessThanTen;

}

else

{

goto greaterThanTen;

}

lessThanTen:

printf(“Number is less than 10.\n”);

goto end;

greaterThanTen:

printf(“Number is greater than 10.\n”);

goto end;

end:

printf(“Program ended.\n”);

Output: Number is less than 10. Program ended.

In this example, the goto statement is used to transfer control to a specific labeled statement based on the value of number. It allows you to directly jump to the desired section of code.

It’s important to note that the use of goto statements should be done sparingly and carefully, as improper usage can make code difficult to read and maintain.

These jumping control statements provide flexibility in controlling the flow of a program by altering the execution sequence. However, it is recommended to use them judiciously and ensure they are used to enhance code readability and maintainability.

Differentiate between break and continue

Here’s a tabular comparison between the break and continue statements in C:

break Statement continue Statement
Usage Terminates the nearest enclosing loop or switch statement. Skips the current iteration of a loop and moves to the next one.
Immediately transfers control to the statement following the terminated loop or switch. Jumps to the next iteration without executing the remaining code in the loop block.
Applicable Loop Types for, while, do-while, switch for, while, do-while
Can be used with any loop or switch statement. Can be used with any loop statement.
Works with nested loops and switches. Works with nested loops.
Usage Example “`c “`c
for (int i = 1; i <= 10; i++) for (int i = 1; i <= 10; i++)
{ {
if (i == 5) if (i % 2 == 0)
{ {
break; // Terminate the loop when i equals 5 continue; // Skip even numbers
} }
printf(“%d “, i); printf(“%d “, i);
} }
Output 1 2 3 4 1 3 5 7 9

Key Differences:

  • The break statement terminates the loop or switch statement it is enclosed in and transfers control to the statement following the terminated loop or switch. In contrast, the continue statement skips the current iteration of a loop and moves to the next iteration.
  • break is used to exit a loop or switch statement entirely, while continue is used to skip the remaining code in the loop block for the current iteration and proceed to the next iteration.
  • break can be used with any loop or switch statement, including nested loops and switches. On the other hand, continue can be used with any loop statement but not with a switch statement.
  • The break statement affects the entire loop or switch, while the continue statement affects only the current iteration of a loop.

It’s important to understand the differences between break and continue to use them appropriately in your programs based on the desired control flow.

Difference between break and exit():

Here’s a tabular comparison between the break statement and the exit() function in C:

break Statement exit() Function
Usage Used to terminate a loop or switch statement. Used to terminate the entire program.
Transfers control to the statement immediately following the loop or switch. Terminates the program and returns control to the operating system.
Applicable Scopes Works within loops and switch statements. Can be used in any part of the program.
Can be used only within the same function where it is defined. Can be used in any function, including main().
Error Handling Typically used for control flow within the program. Primarily used for abnormal program termination or error handling.
Does not necessarily indicate an error or exceptional condition. Typically indicates an abnormal program termination due to an error.
Usage Example “`c “`c
for (int i = 0; i < 10; i++) { #include <stdlib.h>
if (i == 5) {
break; // Terminate the loop when i equals 5 int main() {
} // Code execution
printf(“%d “, i); // Error or abnormal condition detected
} exit(1); // Terminate the program with error code 1
Output 0 1 2 3 4

Key Differences:

  • The break statement is used to terminate a loop or switch statement, transferring control to the statement immediately following the terminated loop or switch. In contrast, the exit() function is used to terminate the entire program and return control to the operating system.
  • The break statement is limited to the scope of the loop or switch where it is defined and can only be used within the same function. On the other hand, the exit() function can be used in any part of the program, including different functions and even the main() function.
  • The break statement is typically used for control flow within the program, allowing you to control the iteration or branching logic. Conversely, the exit() function is primarily used for abnormal program termination, such as error handling or terminating the program when an exceptional condition occurs.
  • The break statement does not necessarily indicate an error or exceptional condition; it is a normal control flow construct. In contrast, the exit() function is often used to indicate an abnormal program termination due to an error or critical condition.
  • The break statement is used within the program code itself to control the flow, while the exit() function is called explicitly to terminate the program at any point.

It’s important to use the appropriate control flow mechanism based on the desired behavior and the specific requirements of your program.

Describe goto statement

The goto statement in C is a control flow statement that allows you to transfer control unconditionally from one part of the code to another. It provides a way to jump to a labeled statement within the same function, effectively bypassing any code in between. The goto statement is often considered a controversial feature of the C language due to its potential to create complex and hard-to-maintain code. It is generally recommended to use goto sparingly and only when there are no cleaner alternatives.

The syntax of the goto statement is as follows:

goto label;

Here, label refers to a unique identifier followed by a colon :. The label can be placed anywhere within the same function, but it cannot be placed inside a block or nested within another control statement.

To illustrate the usage of the goto statement, consider the following example:

#include <stdio.h>

int main()

{

int number;

printf(“Enter a positive integer: “);

scanf(“%d”, &number);

if (number <= 0)

{

goto error;

}

printf(“The number is: %d\n”, number);

return 0;

error:

printf(“Invalid input. Please enter a positive integer.\n”);

return 1;

}

In this program, the user is prompted to enter a positive integer. If the number entered is less than or equal to zero, the program transfers control to the error label using the goto statement. It then displays an error message and terminates the program with a non-zero exit code.

The goto statement, if used improperly, can make the code difficult to read, understand, and maintain. It can create spaghetti code and hinder code comprehension. Therefore, it is generally recommended to avoid using goto and instead use structured control flow constructs like if-else, loops, and functions to achieve the desired program logic.

Define Function and its benefits

In C, a function is a named block of code that performs a specific task. It is a self-contained unit of code that can be called and executed whenever needed. Functions provide a way to modularize and organize code, making it more manageable, reusable, and efficient.

Here are some key aspects and benefits of functions in C:

  1. Modularity: Functions enable modular programming by breaking down complex programs into smaller, logical units. Each function focuses on a specific task, making the code easier to understand, debug, and maintain. Functions can be developed and tested independently, promoting code reusability.
  2. Code Reusability: Once defined, functions can be called from multiple parts of a program, reducing code duplication. This reusability eliminates the need to rewrite the same code in multiple places, improving code efficiency and reducing the likelihood of errors.
  3. Abstraction: Functions allow you to hide the implementation details and provide a higher-level abstraction of the functionality. By exposing only the necessary interface (function signature), you can use functions as building blocks, making it easier to reason about the program and reducing dependencies between different parts of the code.
  4. Code Organization: Functions help organize code into smaller, manageable units, improving code readability and maintainability. With well-defined functions, it becomes easier to locate and modify specific parts of the program, enhancing code comprehension and reducing the chances of introducing bugs.
  5. Code Efficiency: By encapsulating specific functionality in functions, you can optimize and reuse code segments, resulting in more efficient programs. Functions can be called multiple times with different input parameters, enabling code flexibility and avoiding code redundancy.
  6. Parameter Passing: Functions can accept parameters or arguments, allowing data to be passed into the function for processing. This enables functions to be more versatile and adaptable, as they can work with different data values without the need to rewrite the entire function.
  7. Code Testing: Functions can be tested independently, making it easier to identify and isolate bugs or issues. By providing well-defined inputs and examining the output, you can verify the correctness of individual functions before integrating them into the larger program.

In summary, functions in C promote code organization, reusability, and maintainability. They allow for the creation of modular, well-structured programs that are easier to understand, debug, and enhance. By encapsulating code within functions, developers can build scalable and efficient software systems.

Differentiate between User-defined Functions and Library Functions

User-defined Functions and Library Functions in C serve different purposes and have distinct characteristics. Here’s a comparison between the two:

  1. Definition:
    • User-defined Functions: These functions are created by the user or programmer within the program code to perform specific tasks.
    • Library Functions: Also known as built-in or pre-defined functions, these functions are already provided in C libraries and can be used directly in programs.
  2. Creation:
    • User-defined Functions: Users define and implement these functions themselves according to their requirements.
    • Library Functions: These functions are already implemented and provided by the C standard library or additional libraries. They are typically written in C or assembly language by experienced programmers.
  3. Availability:
    • User-defined Functions: These functions are specific to the program in which they are defined. They are available only within the scope of the program unless explicitly shared with other parts of the code.
    • Library Functions: These functions are widely available and accessible across different programs. They are provided as part of the C standard library or additional libraries and can be used in any C program by including the appropriate library header.
  4. Usage:
    • User-defined Functions: Users define these functions to tailor the program’s behavior to their specific needs. They can implement custom algorithms, perform specific computations, or provide specialized functionality.
    • Library Functions: These functions offer a wide range of commonly used functionality, such as mathematical operations, string manipulation, file handling, input/output operations, and more. They provide ready-made solutions for common programming tasks.
  5. Implementation:
    • User-defined Functions: Users write the implementation of user-defined functions according to their specific requirements. The implementation is typically included within the program’s source code.
    • Library Functions: The implementation of library functions is pre-written and bundled within library files. Users can access and utilize these functions by including the appropriate library header and linking the library during the compilation process.
  6. Extension:
    • User-defined Functions: Users can modify and extend the functionality of user-defined functions as per their needs. They have control over the implementation and can customize the behavior of these functions within their program.
    • Library Functions: Library functions are fixed in their implementation and cannot be directly modified. However, users can utilize these functions in their programs and build upon them using user-defined functions.

In summary, user-defined functions are created by users to meet specific requirements within their program, while library functions are pre-existing functions provided by the C standard library or additional libraries. User-defined functions are tailored to the user’s specific needs, while library functions provide commonly used functionality and solutions for various programming tasks.

Here’s a tabular comparison between User-defined Functions and Library Functions in C:

User-defined Functions Library Functions
Definition Created by the user or programmer within the program code. Already implemented and provided by C libraries.
Creation Users define and implement these functions themselves. Functions are pre-defined and provided by the libraries.
Availability Specific to the program in which they are defined. Widely available and accessible across different programs.
Usage Tailored to meet specific requirements of the program. Provide ready-made solutions for common programming tasks.
Implementation Users write the implementation as part of their program. Pre-written implementation bundled within library files.
Extension Users have control over the implementation and can modify them. Fixed implementation and cannot be directly modified.
Examples “`c “`c
int add(int a, int b) #include <stdio.h>
{
return a + b; int main() {
} printf(“Square root of 16: %f\n”, sqrt(16));
return 0;
int result = add(5, 3); }
“`
Benefits – Customized functionality to meet specific needs. – Provides commonly used functionality and solutions.
– Increases code modularity and reusability. – Saves development time and effort.
– Allows flexibility in implementation and extension. – Well-tested and optimized code.
– Provides better code organization and readability. – Standardized and widely used across different programs.

Note: The examples provided in the table demonstrate a simple user-defined function and a library function. The user-defined function add() adds two integers, while the library function sqrt() calculates the square root of a number.

Classify the user-defined Functions

User-defined functions in C can be classified into several categories based on their behavior and purpose. Some of the most common categories are:

  1. Function with no argument and no return value: These functions perform a specific task and do not take any input nor return any output.
  2. Function with argument but no return value: These functions take one or more inputs as arguments and perform a specific task, but do not return any output.
  3. Function with no argument but with return value: These functions perform a specific task and return a value, but do not take any input as arguments.
  4. Function with argument and return value: These functions take one or more inputs as arguments, perform a specific task, and return a value as output.
  5. Recursive function: A function that calls itself is known as a recursive function. Recursive functions are useful for solving problems that can be broken down into smaller, repetitive sub-problems.

These categories provide a general idea of the different types of user-defined functions in C and the various ways they can be used. However, it is important to note that functions in C can be written in many different ways to achieve various goals, and these categories are not strict or mutually exclusive.

User-defined functions in C can be classified based on their purpose and usage within a program. Here are some common classifications of user-defined functions:

  1. Utility Functions: These functions provide general-purpose functionality that can be used across different parts of a program. Examples include functions for input/output, mathematical calculations, string manipulation, and conversion between data types.
  2. Helper Functions: Helper functions are used to assist in performing specific tasks within a program. They often encapsulate common operations or algorithms that are reused multiple times. Examples include functions for sorting arrays, searching for elements, or validating input data.
  3. Procedural Functions: Procedural functions perform a specific procedure or process within a program. They may involve a series of steps or operations to accomplish a particular task. Examples include functions for reading and processing data from a file, performing calculations based on user input, or executing a complex algorithm.
  4. Modular Functions: Modular functions are designed to promote code modularity and organization. They break down complex tasks into smaller, more manageable units. These functions can improve code readability, maintenance, and reusability. Examples include functions for handling different aspects of a larger system or program, such as functions for user authentication, database operations, or user interface interactions.
  5. Callback Functions: Callback functions are passed as arguments to other functions and are invoked by those functions at specific times or events. They allow for customization and dynamic behavior in a program. Examples include event handlers in graphical user interfaces or functions used in sorting algorithms to define custom comparison logic.
  6. Initialization/Setup Functions: These functions are responsible for initializing variables, setting up data structures, and preparing the program for execution. They are typically called at the beginning of a program or when specific conditions are met.
  7. Termination/Cleanup Functions: These functions handle the cleanup and release of resources before the program exits. They may be used to free allocated memory, close open files, or perform other cleanup operations. They are typically called at the end of a program or when specific conditions for termination are met.

It’s important to note that these classifications are not mutually exclusive, and a user-defined function may fall into multiple categories based on its purpose and usage within a program. The specific classification of a user-defined function depends on the context and requirements of the program being developed.

Differentiate between Formal Arguments and Actual Arguments

Here’s a tabular comparison between Formal Arguments and Actual Arguments in C:

Formal Arguments Actual Arguments
Definition Parameters defined in the function declaration. Values or variables passed to a function during function invocation.
Purpose Placeholder names used within the function. Provide values to be used by the function during execution.
Syntax Defined in the function prototype or declaration. Passed as values or variables when calling the function.
Data Types Can be of any valid C data type. Must match the data type expected by the formal arguments.
Number of Arguments Can have zero or more formal arguments. Must match the number of formal arguments defined by the function.
Relationship to Actuals Represents the expected data in the function. Contains the actual values or variables passed to the function.
Storage and Scope Exists within the function’s scope. Do not have storage or scope; they are temporary values.
Examples “`c “`c
void calculateSum(int a, int b) int x = 5;
{ int y = 3;
int sum = a + b; calculateSum(x, y);
printf(“Sum: %d\n”, sum); “`

In summary, formal arguments are parameters defined in the function declaration and serve as placeholder names within the function. They represent the expected data that will be used by the function during execution. Actual arguments, on the other hand, are the values or variables passed to a function during function invocation. They must match the data type and number of formal arguments defined by the function. Actual arguments provide the actual values to be used by the function during execution.

Describe Parameters Passing Techniques used in Functions

In C, there are different parameter passing techniques used when passing arguments to functions. These techniques determine how the values of arguments are transferred between the calling function and the called function.

Here are the commonly used parameter passing techniques:

  1. Pass by Value: This is the default parameter passing technique in C. When arguments are passed by value, a copy of the argument’s value is made and passed to the function. Any changes made to the formal parameter within the function do not affect the original argument in the calling function. This technique is simple and efficient but does not allow for direct modification of the original argument.
  2. Pass by Reference: With pass by reference, the address (reference) of the argument is passed to the function. This allows the function to directly access and modify the original argument. In C, pass by reference is achieved by using pointers. By dereferencing the pointer, the function can access and modify the value stored at the memory location pointed to by the argument. This technique is useful when you need to modify the original value and avoid making copies of large data structures.
  3. Pass by Pointer: Similar to pass by reference, pass by pointer involves passing the address of the argument to the function. It allows the function to modify the original argument indirectly through the pointer. However, unlike pass by reference, the function needs to explicitly dereference the pointer to access and modify the value. This technique offers flexibility and can be used when you want to modify the original value or when the argument’s value can be NULL.
  4. Pass by Array: In C, arrays are passed to functions by reference, meaning that the function receives a pointer to the array’s first element. This allows the function to access and modify the elements of the array directly. Since arrays decay into pointers when passed as arguments, modifications made to the array within the function will affect the original array in the calling function.

It’s important to note that the choice of parameter passing technique depends on the requirements and constraints of the program. Each technique has its advantages and considerations, such as efficiency, memory usage, and the need to modify the original argument. By understanding these parameter passing techniques, you can effectively choose the appropriate technique for your specific scenario.

Differentiate between call-by-value and call-by-reference

Call-by-value and call-by-reference are two different parameter passing techniques used when passing arguments to functions. Here’s a comparison between the two:

Call-by-Value:

  • In call-by-value, a copy of the value of the argument is passed to the function.
  • Any changes made to the formal parameter within the function do not affect the original argument in the calling function.
  • The original value of the argument remains unchanged after the function call.
  • The formal parameter acts as a local variable within the function, and any modifications made to it are limited to the scope of the function.
  • It is the default parameter passing technique in C.
  • Primitive data types (int, float, char, etc.) are typically passed by value.
  • Pass-by-value is simple and efficient since only the value is passed.
  • Examples of call-by-value:

void increment(int num) {

num = num + 1;

}

int main() {

int x = 5;

increment(x);

printf(“Value of x: %d\n”, x); // Output: Value of x: 5

return 0;

}

Call-by-Reference:

  • In call-by-reference, the address (reference) of the argument is passed to the function.
  • The function can directly access and modify the original argument.
  • Any changes made to the formal parameter within the function will affect the original argument in the calling function.
  • The formal parameter acts as an alias or an alternate name for the original argument.
  • Pointers are typically used to achieve call-by-reference in C.
  • Call-by-reference allows for efficient modification of large data structures since only the memory address is passed.
  • Examples of call-by-reference:

void incrementByRef(int* num) {

(*num)++; // Dereference the pointer to modify the value

}

int main() {

int x = 5;

incrementByRef(&x); // Pass the address of x

printf(“Value of x: %d\n”, x); // Output: Value of x: 6

return 0;

}

In summary, call-by-value makes a copy of the value of the argument, while call-by-reference passes the address of the argument. Call-by-value does not modify the original argument, while call-by-reference allows for direct modification. The choice between the two techniques depends on the specific requirements and constraints of the program.

Describe Recursive Function

A recursive function is a function that calls itself directly or indirectly during its execution. It is a powerful programming technique that allows a function to solve complex problems by breaking them down into smaller, more manageable subproblems. Recursive functions typically have a base case and a recursive case.

Here are the key components and characteristics of recursive functions:

  1. Base Case: A base case is the condition or criteria that determines when the recursive function should stop calling itself and return a result. It acts as the termination condition and prevents infinite recursion. The base case usually represents the simplest form of the problem that can be solved directly without further recursion.
  2. Recursive Case: The recursive case defines the steps to solve the problem by calling the function itself with a modified input. It reduces the problem size or complexity and brings it closer to the base case. The recursive case usually involves breaking down the problem into smaller subproblems and combining the results to solve the original problem.
  3. Function Call: Inside the recursive function, there is a function call to itself. This recursive call allows the function to repeat the same set of steps on a smaller or simpler version of the problem. The recursive function may pass modified arguments or parameters to the subsequent recursive calls.
  4. Progress Towards Base Case: For the recursive function to converge towards the base case, it should make progress towards the termination condition with each recursive call. This ensures that the recursive function eventually reaches the base case and stops the recursion.
  5. Stack Usage: Recursive functions typically use the system stack to keep track of function calls. Each recursive call pushes a new stack frame onto the stack, which contains the function’s local variables, return address, and other necessary information. As the recursive calls complete, the stack frames are popped off the stack, allowing the program to return to the previous point of execution.

Recursive functions are commonly used to solve problems that can be divided into smaller, identical subproblems. Examples of such problems include factorial calculation, Fibonacci sequence generation, tree traversal, and searching algorithms like binary search. However, it’s essential to design recursive functions carefully to ensure they have a valid base case and proper termination conditions to avoid infinite recursion.

Here’s an example of a 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! = n * (n-1)!

else {

return n * factorial(n – 1);

}

}

int main() {

int num = 5;

int result = factorial(num);

printf(“Factorial of %d is %d\n”, num, result); // Output: Factorial of 5 is 120

return 0;

}

In the above example, the factorial function calculates the factorial of a number n by recursively calling itself with n-1 until it reaches the base case (n == 0 or n == 1).

Write Programs using Recursive Functions

Here are five C programs that utilize recursive functions:

1. Program to Calculate the Sum of Natural Numbers

This program calculates the sum of the first n natural numbers using recursion.

#include <stdio.h>

int calculateSum(int n) {

// Base case: sum of 0 or 1 is the number itself

if (n == 0 || n == 1) {

return n;

}

// Recursive case: sum of n numbers = n + sum of (n-1) numbers

else {

return n + calculateSum(n – 1);

}

}

int main() {

int num = 5;

int sum = calculateSum(num);

printf(“Sum of the first %d natural numbers: %d\n”, num, sum); // Output: Sum of the first 5 natural numbers: 15

return 0;

}

2. Program to Find the Factorial of a Number

This program calculates the factorial of a number using recursion.

#include <stdio.h>

int factorial(int n) {

// Base case: factorial of 0 or 1 is 1

if (n == 0 || n == 1) {

return 1;

}

// Recursive case: n! = n * (n-1)!

else {

return n * factorial(n – 1);

}

}

int main() {

int num = 5;

int result = factorial(num);

printf(“Factorial of %d: %d\n”, num, result); // Output: Factorial of 5: 120

return 0;

}

3. Program to Calculate the Fibonacci Series

This program generates the Fibonacci series using recursion.

#include <stdio.h>

int fibonacci(int n) {

// Base case: first two Fibonacci numbers are 0 and 1

if (n == 0 || n == 1) {

return n;

}

// Recursive case: Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)

else {

return fibonacci(n – 1) + fibonacci(n – 2);

}

}

int main() {

int num = 6;

printf(“Fibonacci series up to %d:\n”, num);

for (int i = 0; i <= num; i++) {

printf(“%d “, fibonacci(i));

}

printf(“\n”);

// Output: Fibonacci series up to 6: 0 1 1 2 3 5 8

return 0;

}

4. Program to Find the GCD (Greatest Common Divisor) of Two Numbers

This program calculates the greatest common divisor (GCD) of two numbers using recursion and Euclid’s algorithm.

#include <stdio.h>

int gcd(int a, int b) {

// Base case: GCD(a, 0) = a

if (b == 0) {

return a;

}

// Recursive case: GCD(a, b) = GCD(b, a % b)

else {

return gcd(b, a % b);

}

}

int main() {

int num1 = 24;

int num2 = 36;

int result = gcd(num1, num2);

printf(“GCD of %d and %d: %d\n”, num1, num2, result); // Output: GCD of 24 and 36: 12

return 0;

}

5. Program to Reverse a String

This program reverses a string using recursion.

#include <stdio.h>

void reverseString(char* str) {

// Base case: empty string or single character

if (*str == ‘\0’ || *(str + 1) == ‘\0’) {

return;

}

// Recursive case: reverse the remaining substring and swap characters

else {

reverseString(str + 1);

printf(“%c”, *str);

}

}

int main() {

char str[] = “Hello, World!”;

printf(“Original String: %s\n”, str); // Output: Original String: Hello, World!

printf(“Reversed String: “);

reverseString(str);

printf(“\n”); // Output: Reversed String: !dlroW ,olleH

return 0;

}

These programs demonstrate the use of recursion to solve various problems. Remember that when using recursion, it’s important to have proper base cases to ensure termination and handle the simplest form of the problem.

Describe Tower of Hanoi problem

The Tower of Hanoi problem is a classic puzzle or mathematical game that involves three rods and a set of disks of different sizes. The objective of the puzzle is to move all the disks from one rod to another, following specific rules, using the third rod as an auxiliary.

Here are the key components and rules of the Tower of Hanoi problem:

  1. Setup: The puzzle consists of three rods, usually named “source,” “destination,” and “auxiliary.” The source rod initially holds a stack of disks arranged in decreasing order of size, with the largest disk at the bottom and the smallest disk at the top.
  2. Objective: The objective is to move all the disks from the source rod to the destination rod, one disk at a time, using the auxiliary rod as a temporary holding place. At the end of the puzzle, the disks should be arranged on the destination rod in the same order as the source rod.
  3. Rules: The Tower of Hanoi puzzle follows the following rules:
    • Only one disk can be moved at a time.
    • A larger disk cannot be placed on top of a smaller disk.
    • It is allowed to move the top disk from one rod to another rod or to place it on an empty rod.
  4. Recursive Solution: The Tower of Hanoi problem can be efficiently solved using recursion. The recursive algorithm follows these steps:
    • Move n-1 disks from the source rod to the auxiliary rod, using the destination rod as an auxiliary.
    • Move the largest disk from the source rod to the destination rod directly.
    • Move the n-1 disks from the auxiliary rod to the destination rod, using the source rod as an auxiliary.

By recursively applying these steps, the puzzle can be solved for any number of disks.

The Tower of Hanoi problem is not only a recreational puzzle but also has real-world applications in computer science and algorithm design. It illustrates the concept of recursive problem-solving and is often used to explain and analyze recursion in introductory programming courses.

Write a Recursive Program to implement Tower of Hanoi problem

#include <stdio.h>

void towerOfHanoi(int n, char source, char auxiliary, char destination) {

if (n == 1) {

printf(“Move disk 1 from %c to %c\n”, source, destination);

return;

}

towerOfHanoi(n – 1, source, destination, auxiliary);

printf(“Move disk %d from %c to %c\n”, n, source, destination);

towerOfHanoi(n – 1, auxiliary, source, destination);

}

int main() {

int numDisks = 3;

char sourceRod = ‘A’;

char auxiliaryRod = ‘B’;

char destinationRod = ‘C’;

printf(“Tower of Hanoi Solution:\n”);

towerOfHanoi(numDisks, sourceRod, auxiliaryRod, destinationRod);

return 0;

}

In the above program, the towerOfHanoi function takes four parameters:

  • n: the number of disks to be moved
  • source: the rod from which the disks are initially placed
  • auxiliary: the auxiliary rod used for intermediate steps
  • destination: the rod where the disks should be moved to

The function uses recursion to solve the Tower of Hanoi problem. The base case (n == 1) is when there is only one disk to be moved. In this case, it directly moves the disk from the source rod to the destination rod.

For n > 1, the function follows the recursive steps:

  1. Move n-1 disks from the source rod to the auxiliary rod, using the destination rod as an auxiliary.
  2. Move the largest disk from the source rod to the destination rod directly.
  3. Move the n-1 disks from the auxiliary rod to the destination rod, using the source rod as an auxiliary.

The program demonstrates the recursive solution by solving the Tower of Hanoi problem for 3 disks. You can change the numDisks variable to solve the problem for a different number of disks.