Q1) Distinguish between while and do-while loops:

Feature While Loop Do-While Loop

Condition check Before executing the After executing the statements at
statements least once
Minimum 0 times (if condition is initially 1 time (guaranteed execution)
execution false)
Syntax while (condition) { statements; do { statements; } while (condition);
}
Semicolon No semicolon after while Semicolon after while in the
do...while statement
Brackets Optional for single statement Always required
Variable Before loop execution Before or within the loop
initialization
Control type Entry-controlled (checks Exit-controlled (checks condition
condition before entering) after executing the statements)

Q2) Differences between break and continue statements:

Feature Break Statement Continue Statement

Context Switch and loops (for, while, do) Loops (for, while, do) only
Effect Terminates the entire switch or Skips the remaining code in the current
loop immediately iteration and moves to the next
Syntax break; continue;
Termination Ends the loop or switch entirely Doesn't end the loop, just moves to the next
iteration
Nesting Affects the innermost enclosing Affects the innermost loop it's within
loop or switch

Q3) What is recursion?

1. Recursion: A function that calls itself is called as recursive function and this
technique is called as recursion.
2. A recursive function must definitely have a condition that exits from calling
the function again.
3. Hence there must be a condition that calls the function itself if that
condition is true.
4. If the condition is false then it will exit from the loop of calling itself again.
Q4) Distinguish between if-else and switch statements:
Feature If-Else Statement Switch Statement
Number of Handles a single condition Handles multiple conditions based on the
conditions same variable or expression
Structure Sequential checks of conditions using Jumps directly to the matching case
if, else if, and else blocks using a value comparison
Data types Works with any data type Typically limited to integers and
characters (languages vary)
Readability Can become less readable with many More concise and readable for multiple
nested conditions conditions on the same variable
Efficiency Can be less efficient for multiple Often more efficient for multiple
comparisons due to sequential comparisons due to direct jumps
checks
Fall-through No default fall-through behavior (only May have fall-through behavior (executes
executes the matching block) subsequent cases unless break is used)

Q5) Distinguish between structures and unions:

Feature Structure Union
Memory Allocates separate memory for Allocates shared memory, size of the
allocation each member largest member
Data storage Stores multiple values Stores only one value at a time,
simultaneously overwriting others
Data security More secure (members have Less secure (members share
distinct memory) memory, potential for corruption)
Ease of use Generally easier to use and Can be more complex to manage
understand
Memory Less efficient in terms of More efficient when only one
efficiency memory usage member needs to be active
Use cases Storing multiple related values Storing alternative values or saving
together memory in specific cases

Q6) what is significance of storage classes? Explain it with

relevant examples.
:- The different locations in the computer where we can store data
and their accessibility,initial values etc. very based on the way they
are declared. These different ways are termed as different storage
classes.
In C there are for storage classes, namely
1. Automatic
2. Register
3. Static
4. External or global

1. Automatic storage class

In this case data is stored in memory The initial value ofsuch
a variable is garbageThe scope of the variable is local i.e.
limited to the function in which it is defined.The life of such
variables is till the control remains in the particular function
where it is defined.
For e.g.:
Int i; or auto int i;
2. Register storage class
In this case data is stored in CPU register The initial value of
such a variable is garbage. The scope of the variable is local
i.e. limited to the function in which it is defined

Q7) Define Algorithm.

Algorithm :-
An Algorithm is a sequence of steps to solve a problem.Algorithm is
a step-by-step procedure, which defines a set of instructions to be
executed in a certain order to get the desired output
Algorithm to check whether given number is Armstrong or not :-
Step I : Start.
Step II : Input n, sum, rem, temp.
Step III : sum = 0, rem=0.
Step IV : Print “Enter an integer number : ”
Step V : Read n.
Step VI : temp = n.
Step VII : If temp is less than equal to zero Then,
Go to Step IX.
Else
rem = temp mod 10
sum = sum + ( rem X rem X rem )
temp = temp / 10
Step VIII : Go to Step VII.
Step IX : If sum is equal to n Then,
Print “Number n is an Armstrong number.”
Else
Print “Number n is not an Armstrong number.”
Step X : Stop
Q8) What are advantages and disadvantages of recursion?
:- Recursion: A function that calls itself is called as recursive function
and this technique is called as recursion.
Advantages:
1. Reduce unnecessary calling of functions.
2. Through Recursion one can solve problems in easy way while its
iterative solution is very big and complex.
3. Extremely useful when applying the same solution.
Disadvantages:
1. Recursive solution is always logical and it is very difficult to trace.
2. In recursive we must have an if statement somewhere to force the
function to return without the recursive call being executed,
otherwise the function will never return.
3. Recursion uses more processor time.
i. A recursive function must definitely have a condition that exits
from calling a function again.
ii. Hence there must be condition that calls the function itselfif that
condition is true.
iii. If the condition is false then it will exit from the loop of calling
itself again.
Q9) . Explain what is flowchart? Explain different symbols in
flowchart.
A flowchart is graphical representation of the algorithm of a
program. The flowchart gives a nice idea of the flow of the algorithm
in sequence as well as the condition changes in the sequence
Q10) Explain different data type modifiers available in C language.

In the C programming language, data type modifiers are used to modify

the properties or characteristics of basic data types. These modifiers allow you
to fine-tune the behavior and storage of variables. Here are some of the
common data type modifiers available in C:
1. Signed / unsigned:
The `signed` modifier is used to declare a variable as capable of
representing both positive and negative values. It is often used
implicitly when you declare variables without any modifier.The
`unsigned` modifier is used to declare a variable as capable of
representing only non-negative values, effectively doubling the
positive range but eliminating the representation of negative
numbers.
2. Short / long:

The `short` modifier is used to declare a variable with a smaller

storage size than its default data type. For example, `short int` uses
less memory than a regular `int`, but the range of representable
values is reduced.The `long` modifier is used to declare a variable
with a larger storage size than its default data type. For example,
`long int` uses more memory than a regular `int`, allowing you to
represent larger values.
3. long long:
The `long long` modifier is used to declare a variable with an even
larger storage size than the regular `long` modifier. This is often used
to represent very large integers.
4. const:
The `const` modifier is used to declare a variable as constant,
meaning its value cannot be changed after initialization. It is often
used to define constants or to ensure that a variable remains
unchanged in a function.
5. volatile:
The `volatile` modifier is used to indicate that a variable's value can
be changed at any time by external factors that the compiler may
not be aware of. This prevents the compiler from optimizing out
certain accesses to the variable.
6. Bool:
The `Bool` data type modifier is used to declare variables that can
hold only two values: `0` (false) or `1` (true). It is typically used in
boolean expressions and is often used in conjunction with the
<stdbool.h> header.
7. Complex:
The Complex modifier is used to declare variables that hold
complex numbers. It is used in conjunction with the <complex.h>
header and allows you to work with complex arithmetic.
8. Imaginary:
The imaginary modifier is used to declare variables that represent
the maginary part of a complex number. Like Complex, it is used
with the
<complex.h>header.
Q11) Explain with example left and right shift bitwise operator.

Bitwise shift operators in C are used to shift the bits of a value left or
right by a specified number of positions. These operators are `<<`
for left shift and `>>` for right shift. Bitwise shifts can be used for
quick multiplication or division by powers of 2, as well as
manipulating individual bits in a value.
1. Left Shift (`<<`):
The left shift operator shifts the bits of a number to the left by the
specified number of positions. It's equivalent to multiplying the
number by 2 raised to the power of the shift count.
2. Right Shift (`>>`):
The right shift operator shifts the bits of a number to the right by the
specified number of positions. It's equivalent to integer division of
the number by 2 raised to the power of the shift count.
Q12) Distinguish entry and exit control loops:

Feature Entry Control Loop Exit Control

Loop
Condition Before entering loop body After executing
check loop body
Execution May not execute at all Executes at least
once
Examples For loop, While loop Do-While loop
Syntax for (initialization; condition; do { ... } while
increment/decrement) { ... } <br> while (condition);
(condition) { ... }
Best used Number of iterations is known or Loop body must
when condition might be false initially execute at least
once
Q13). Explain need of function prototype with example.
A function prototype in C serves as forward declaration of a function before its
actual implementation or definition. It informs the compiler about the
function’s name, return type, and parameter type, allowing the compiler to
perform type checking and validation during

C Language:
#include <stdio.h>

// Function prototype:
int calculateArea(int length, int width); // Declares the
function's signature

int main() {
// Function calls (can be made before the definition):
int area1 = calculateArea(10, 5);
int area2 = calculateArea(20, 15);

printf("Area 1: %d\n", area1);

printf("Area 2: %d\n", area2);

return 0;
}
// Function definition (can be placed later in the file or in a
separate file):
int calculateArea(int length, int width) { // Defines the
function's implementation
return length * width;
}
Q14) Explain conditional operator with example.
An operator that requires three operands is called as ternary
or conditional operator.

C Language:
#include <stdio.h>

// Function to calculate the sum of elements in

an array
int calculate_sum(int numbers[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += numbers[i];
}
return sum;
}
int main() {
int numbers[] = {10, 20, 30, 40, 50};
int size = sizeof(numbers) /
sizeof(numbers[0]);

int total_sum = calculate_sum(numbers, size);

printf("The sum of the list is: %d\n",
total_sum);
return 0;}
Q17) List and explain different components of Computer
System.

1. Input Devices:

• Function: Allow users to enter data and

instructions into the computer.

• Examples: Keyboard, mouse, touchpad,

scanner, microphone, webcam,
2. Output Devices:

• Function: Present information and results to

the user.
• Examples: Monitor, printer, speakers,
headphones, projector.
3. Central Processing Unit (CPU):

• Function: The "brain" of the computer, responsible

for processing data and instructions.
• Components:

o Arithmetic Logic Unit (ALU): Performs

arithmetic and logical operations.

o Control Unit (CU): Fetches, decodes, and

executes instructions.

4. Motherboard:
• Function: The main circuit board that connects all
components of the computer.

• Key components: CPU socket, RAM slots, expansion

slots, storage connectors, ports for peripherals.

5. Memory:
• Function: Stores data and instructions temporarily or
permanently.

• Types:
o Random Access Memory (RAM): Temporary

storage for active programs and data.

o Read-Only Memory (ROM): Permanent storage

for essential instructions.

o Storage Devices: Long-term storage for files and

programs (e.g., hard drives, solid-state drives,

external drives).

6. Power Supply Unit (PSU):

• Function: Converts AC power from the outlet to DC

power that the computer components need.
7. Expansion Cards:
• Function: Add additional functionality to the computer

(e.g., graphics cards, sound cards, network adapters).

7. Communication Devices:

• Function: Enable the computer to connect to other

devices and networks.
 • Examples: Modems, network cards, wireless
adapters.

8. Software:

• Function: Instructs the hardware on how to

operate and perform tasks.
• Types:
o Operating System (OS): Manages the

computer's resources and provides a user

interface.
o Application Software: Programs that perform

specific tasks, such as word processing, web

browsing, or gaming.

10. Firmware:
• Function: Permanent software embedded in

hardware components, providing low-level control

and instructions.
• Examples: BIOS, UEFI.

Q18) What is a function prototype?

• It's a declaration of a function that specifies its

name, return type, and parameters.

• It acts as a blueprint for the function, informing

the compiler about its interface before the actual

function definition is encountered.
 • It doesn't contain the function's body (code).

Syntax:

C Language:
returnType functionName(parameterType1 parameter1,
parameterType2 parameter2, ...);

Example:

C Language:

// Function prototype
int addNumbers(int a, int b); // Declares a function named
addNumbers that takes two integers and returns an integer

int main() {
int result = addNumbers(5, 3); // Calls the addNumbers
function
printf("Sum: %d", result);
return 0;
}

// Function definition (with body)

int addNumbers(int a, int b) {
return a + b; // Actual implementation of the function
}

Importance of Function Prototypes:

 1. Type Checking: The compiler uses prototypes to
ensure correct data types are used in function calls,
preventing potential errors.

2. Separate Compilation: Prototypes allow functions to

be defined in separate files and compiled
independently, promoting modularity and code
organization.

3. Self-Documentation: Prototypes serve as concise

documentation, making code more readable and
understandable.

4. Function Overloading: Prototypes enable multiple

functions with the same name but different parameter
lists, enhancing code flexibility.

Key Points:

• Place prototypes before using a function in your code,

typically in header files.
• Parameter names in prototypes are optional, but
providing them improves readability.
• Prototypes are not mandatory for functions defined
before their use, but they are strongly recommended
for code clarity and maintainability.
Q19) Explain conditional operator with proper
example.

• It's a concise way to express a simple if-else

statement within a single line of code.
• It takes three operands: a condition, an expression to
evaluate if the condition is true, and an expression to
evaluate if the condition is false.

Syntax:

C Language :

condition ? expression1 : expression2;

How it works:

1. The condition is evaluated first.

2. If the condition is true, expression1 is evaluated and its
value becomes the result of the entire expression.
3. If the condition is false, expression2 is evaluated and its
value becomes the result.
Examples:

1. Assigning a value based on a condition:

C
int age = 25;
char *status = (age >= 18) ? "Adult" : "Minor"; // status
will be "Adult"

2. Finding the maximum of two numbers:

C
int x = 10, y = 20;
int max = (x > y) ? x : y; // max will be 20

3. Printing a message based on a condition:

C
double score = 85.5;
printf("%s\n", (score >= 90) ? "Excellent!" : "Good
job!"); // Prints "Good job!"

Key Points:

• Use parentheses to clarify the condition and

expressions, especially when dealing with complex
logic.

• It's often used for assignments and short conditional

expressions.
 • For more complex logic or multiple statements, use
traditional if-else blocks for better readability and
maintainability.

• It's a convenient tool for concise conditional

expressions, but use it judiciously to avoid overly
compact code that can be harder to understand.

Q20) Explain following standard library functions i)

Floor() ii) ceil() iii) sqrt () iii)pow()

1. floor():
• Purpose: Returns the largest integer that is less than or
equal to the given number. It rounds down to the
nearest integer.

• Example:
o floor(4.9) = 4
o floor(-3.2) = -4

• Common uses:
o Rounding down numbers for calculations

o Truncating decimals

o Finding integer boundaries

2. ceil():
• Purpose: Returns the smallest integer that is greater
than or equal to the given number. It rounds up to the
nearest integer.
• Example:
o ceil(4.1) = 5
o ceil(-2.8) = -2
• Common uses:

o Rounding up numbers for calculations

o Determining minimum values for quantities
o Converting floating-point numbers to integers for
specific purposes

3.sqrt():
• Purpose: Calculates the square root of a given number,
which is the number that, when multiplied by itself,
gives the original number.

• Example:
o sqrt(25) = 5
o sqrt(9) = 3

• Common uses:
o Finding the lengths of sides in geometry

o Calculating distances

o Solving equations involving squares

4. pow():

• Purpose: Raises a given number (base) to a specified

power (exponent). It performs exponentiation.
• Example:
o pow(2, 3) = 8 (meaning 2 raised to the power of 3,

or 2 multiplied by itself 3 times)

o pow(4, 0.5) = 2 (equivalent to finding the square

root of 4)

• Common uses:
o Calculating exponential growth or decay

o Handling scientific notation

o Performing complex mathematical operations

involving powers

This function is available in the header file “math.h”. This

function calculates and returns the value of xy The
parameters x and y are to be passed to it. The parameters
as well the answer returned are double data type. But it
can also accept parameters of different data type.

Q21) Explain the following functions with proper example.

a ) strlen( ) b) strcmp( ) c) strcat( )a) strlen()
 • Purpose: Calculates the length of a string, excluding the
null terminator character ('\0').
• Syntax: size_t strlen(const char *str);
• Returns: The length of the string as an unsigned integer
(size_t).

Example:

C Language:-

char name[] = "Alice";

int length = strlen(name); // length will be 5

b) strcmp()

• Purpose: Compares two strings lexicographically

(alphabetically).
• Syntax: int strcmp(const char *str1, const char *str2);
• Returns:
o 0 if the strings are equal

o A negative value if str1 is less than str2

o A positive value if str1 is greater than str2

Example:
C Language:
char name1[] = "Alice";
char name2[] = "Bob";
int result = strcmp(name1, name2); // result will be
negative
c) strcat()

• Purpose: Concatenates (joins) two strings, appending

the second string to the end of the first string.
• Syntax: char *strcat(char *dest, const char *src);
• Returns: A pointer to the concatenated string (dest).
• Important note: Ensure that the destination string (dest)
has enough space to accommodate the concatenated
result, including the null terminator.

Example:

C
char greeting[] = "Hello";
char name[] = "World";
strcat(greeting, name); // greeting becomes
"HelloWorld"

Q23) Definition of Structure and an explanation of its

declaration syntax with an example:

Structure (in C programming):

• A user-defined composite data type that groups

variables of different data types under a single name.

 • It allows you to organize and manage related data
together, making code more readable and
maintainable.
• It's similar to a record in database terminology.

Syntax for declaring a Structure:

C Language :

struct structure_name {
data_type member_1;
data_type member_2;
// ... more members
};

Explanation:
• struct: Keyword indicating a structure declaration.

• structure_name: Name you choose for the structure

(optional, but recommended).

• { ... }: Braces enclosing the structure's members.

• data_type member_1;: Declaration of a member with its

data type and name.

Example:

C Language

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

Declaring Structure Variables:

C Language :

struct Student student1, student2; // Declares two variables

of type struct Student
Accessing Structure Members:
C
student1.roll_no = 10;
strcpy(student1.name, "Alice");
student1.marks = 85.5;

Key Points:

• Structure members can be of any valid data type,

including other structures.
• Structure declaration only creates a template; it
doesn't allocate memory.
• Memory is allocated when you declare structure
variables.
• Access structure members using the dot (.) operator.
 • Structures are commonly used to represent real-world
entities in code (e.g., students, employees, books).
Q24) Explain function prototype with proper
example.
Function Prototype:
• A declaration of a function that specifies its name,

return type, and parameters (without its actual body).

• It acts as a blueprint or signature for the function,

informing the compiler about its interface before its

definition.

Purpose of Function Prototypes:

1. Type Checking: Ensures that functions are called with

the correct number and types of arguments, preventing
errors during compilation.

2. Compiler Optimization: Allows the compiler to

optimize code more effectively by knowing function
details beforehand.

3. Separate Compilation: Enables functions to be

defined in separate files and linked together, promoting
code modularity and reusability.

4. Header Files: Used in header files to make function

declarations available across multiple source files.
Syntax:

C Language:

return_type function_name(parameter_list);

Example:
C Language:

// Function prototype
int add(int a, int b); // Declares a function
named add that takes two ints and returns
an int

int main() {
int result = add(5, 3); // Calls the add
function before its definition
printf("Sum: %d", result);
return 0;
}

// Function definition (can be placed later

in the code or in a separate file)
int add(int x, int y) { // Function body with
matching signature
return x + y;
}

Key Points:

• Function prototypes only declare the function's

interface, not its implementation.

• The actual code of the function is defined in the

function definition.

• Function prototypes can appear multiple times, but the

definition must be unique.

• Using function prototypes is considered good

programming practice for clarity, type safety, and
efficient code organization.

Q25) Explain the multi-way branching statement

available in C language with example.

Multi-way branching in C refers to the ability to choose

among multiple code blocks based on the value of an
expression. It's achieved using the switch statement.
Syntax of the switch statement:
C
switch (expression) {
case value1:
// code to execute if expression equals value1
break;
case value2:
// code to execute if expression equals value2
break;
// ... more cases
default:
// code to execute if expression doesn't match any case
}

Explanation:
1. Switch (expression): Evaluates the expression and
compares its value to the values in the case labels.
2. Case value1:: If expression matches value1, the code
within this case block executes.
3. Break;: Terminates the switch statement and
prevents execution from falling through to
subsequent cases.
4. Default:: Optional block that executes if expression
doesn't match any of the case values.
Example:

C Language:

int day = 3;
switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
default:
printf("Another day\n");
}
Output:
Wednesday
Key Points:

• The expression in switch must evaluate to an integer

or character type.
• case values must be literal constants or constant
expressions.
• break statements are crucial to prevent unintended
fall-through.
• The default block is optional but handles unmatched
cases.
• switch is often more readable than long if-else if
chains for multiple choices.

Q26) Explain how problem is defined with the

help of example .

Problem Definition:

• The process of clearly and concisely articulating a

specific issue or challenge that needs to be addressed.
• A crucial first step in problem-solving, as it sets the
direction for finding solutions.
Key Elements of a Problem Definition:

• Identifying the Problem:

o Pinpointing the exact issue or difficulty being

faced.
 o Describing the symptoms or undesirable
outcomes.
o Example: "Sales have been declining for the past
three months."

• Specifying the Boundaries:

o Defining the scope of the problem, including

what's included and excluded.
o Establishing the context and relevant factors.
o Example: "The decline is limited to online sales,
while in-store sales remain stable."
• Understanding the Goals:

o Clarifying what needs to be achieved to resolve

the problem.
o Specifying desired outcomes or improvements.
o Example: "The goal is to increase online sales by
15% within the next quarter."
• Considering Constraints:

o Identifying any limitations, restrictions, or

requirements that must be considered.
o Recognizing factors that could influence solutions.
 o Example: "The marketing budget is limited, and
we must adhere to brand guidelines."
Example of a Well-Defined Problem:

Problem: "The company's website is experiencing high

bounce rates, with 60% of visitors leaving after viewing
only one page. This is negatively impacting lead generation
and sales."

Boundaries: "The issue is specific to the company's main

website and does not affect other digital properties."

Goals: "Reduce bounce rates to 40% or lower within 3

months and increase website conversions by 10%."

Constraints: "Solutions must align with the company's

brand identity and limited development resources."

Benefits of Clear Problem Definition:

• Guides focused problem-solving efforts.

• Facilitates effective communication among

stakeholders.
• Helps identify appropriate solutions and evaluate their
potential impact.
• Prevents addressing symptoms rather than the root
cause.
• Enhances decision-making and resource allocation.
27) . Write a short note on a) Turing model b) Von
Neumann model

a) Turing model:
• Concept: A theoretical model of computation

conceived by Alan Turing in 1936.

• Structure: It consists of a tape with symbols, a head
that reads and writes on the tape, and a set of
instructions.
• Operation: The head moves along the tape, reading
its symbols and changing them based on the current
state and read symbol.
• Significance: Provides a mathematical framework for
defining computability and proving the Church-Turing
Thesis, establishing that any effectively computable
function can be computed by a Turing machine.
• Limitations: Abstract and theoretical, not directly
applicable to building real-world computers.
b) Von Neumann model:
• Concept: An architectural design for computers laid

out by John von Neumann in 1945.

• Structure: Based on a stored-program paradigm with
separate data and instruction memory, a control unit,
and an arithmetic logic unit.
• Operation: Instructions and data are stored in
memory, fetched by the control unit, decoded, and
executed by the arithmetic logic unit.
• Significance: Defines the basic architecture of
modern computers and paved the way for their
practical development.
• Limitations: Finite memory and sequential execution
of instructions impose limitations on computational
power.
Similarities:
• Both models address theoretical computing

capabilities.
• Both involve a system that manipulates symbols based
on defined rules.
• Both are influential in understanding the nature of
computation.
Differences:
• Focus: Turing model is theoretical and focuses on

defining computability, while Von Neumann model is

practical and guides the design of actual computers.
 • Structure: Turing model is tape-based with simple
operations, while Von Neumann model has distinct
memory units and complex processing capabilities.
• Application: Turing model is used for theoretical
analyses and proofs, while Von Neumann model is
directly implemented in real-world computers.

28). What is numbering system and types of

number systems

Numbering Systems: Representing and Manipulating

Quantity

A numbering system is a way of representing and

manipulating quantities using symbols and rules. It's the
foundation for counting, measuring, and performing
calculations. There are various types of numbering
systems, each with its own structure and characteristics.

Types of Numbering Systems:

• Natural Numbers:

o Used for counting whole objects (1, 2, 3, ...).

o Doesn't include zero or negative numbers.

• Whole Numbers:
o Includes natural numbers and zero (0, 1, 2, 3, ...).
 o Still non-negative.
• Integers:
o Whole numbers plus negative numbers (... -3, -2, -

1, 0, 1, 2, 3, ...).
o Represent both positive and negative quantities.
• Rational Numbers:
o Numbers that can be expressed as a fraction (e.g.,

1/2, 3/4, -5/7).

o Represent all numbers that can be obtained by
dividing integers.
• Real Numbers:
o Rational numbers plus irrational numbers (e.g., π,

√2).
o Represent all numbers that can be measured on a
continuous scale.
• Complex Numbers:
o Numbers of the form a + bi, where a and b are

real numbers and i is the imaginary unit (√-1).

o Used in advanced mathematics and engineering.
• Positional Systems:
o Value of a digit depends on its position within the

number (e.g., decimal, binary, hexadecimal).

o Most commonly used in everyday life and
computers.
Additional Aspects:
 • Each system has its own set of operations (addition,
subtraction, multiplication, etc.) with defined rules.
• Some systems can represent a wider range of numbers
than others.
• Choice of system depends on the context and
application.

29). Write an algorithm and draw flowchart to

calculate roots of quadratic equation

1. Input coefficients:
• Get the values of a, b, and c from the user.

2. Calculate discriminant:
• discriminant = b^2 - 4ac

3. Determine root type:

• If discriminant > 0:

o Calculate real and distinct roots:

▪ root1 = (-b + sqrt(discriminant)) / (2a)
▪ root2 = (-b - sqrt(discriminant)) / (2a)
• Else if discriminant == 0:
o Calculate real and equal roots:
▪ root1 = root2 = -b / (2a)
• Else (discriminant < 0):
 o Calculate complex roots:
▪ realPart = -b / (2a)
▪ imaginaryPart = sqrt(-discriminant) / (2a)
o Display roots in the form: root1 = realPart +
imaginaryParti root2 = realPart - imaginaryParti
4. Display roots:
• Print the calculated roots based on the case.

Flowchart:
Explanation:
• The flowchart starts with an input symbol to get

coefficients a, b, and c.
• A process symbol calculates the discriminant.
• A decision symbol checks the discriminant's value.
• If discriminant > 0, a process symbol calculates real
and distinct roots.
• If discriminant == 0, a process symbol calculates real
and equal roots.
• If discriminant < 0, a process symbol calculates
complex roots.
• Output symbols display the calculated roots in each
case.
Key Points:
• The quadratic formula is used to calculate the roots: x

= (-b ± √(b^2 - 4ac)) / (2a)

• The discriminant determines the nature of roots (real,
equal, or complex).
• Complex roots involve the imaginary unit 'i'.

Q30) Explain time complexity of an algorithm .

Time Complexity:
• It measures how the execution time of an algorithm

grows as the input size increases.

• It's essential for understanding algorithm efficiency

and predicting performance for different input sizes.

• It's typically expressed using Big O notation, which

focuses on the dominant term in the algorithm's

growth rate.

Analyzing Time Complexity in C:

1. Identify Input Size:

o Determine the variable that represents the input

size (e.g., n for an array of n elements).

2. Count Basic Operations:
o Analyze the algorithm's code and count the

number of basic operations (assignments,

comparisons, function calls, etc.) that are
executed for a given input size.
o Focus on operations within loops and nested

loops, as they often contribute significantly to the

overall complexity.
3. Express in Big O Notation:
o Discard constant factors and lower-order terms,

focusing on the term that grows the fastest as the

input size increases.
o Common Big O notations for time

complexity:
 ▪ O(1): Constant time (no change with input
size)
▪ O(n): Linear time (grows proportionally to
input size)
▪ O(n^2): Quadratic time (grows as the square
of input size)
▪ O(log n): Logarithmic time (grows
logarithmically with input size)
Example :

C Language :

int sum_of_array(int arr[], int n) {

int sum = 0;
for (int i = 0; i < n; i++) {
sum += arr[i]; // Basic operation
(addition) inside a loop
}
return sum;
}

•Time complexity: O(n) (linear time)

o The loop executes n times, and for each iteration,

there's a single addition operation.

Key Points:
 • Time complexity is a theoretical measure, not actual
execution time.
• It's about growth rate as input size increases, not
specific input values.
• Nested loops can significantly impact complexity (e.g.,
two nested loops with n iterations each would be
O(n^2)).
• Understanding time complexity is crucial for choosing
efficient algorithms and predicting performance for
large inputs

Q31). Explain space complexity of an algorithm

Explain logical operators. Write a c program to
demonstrate the same.
Space Complexity

Explanation:
• Space complexity measures the amount of

memory (RAM) an algorithm uses as a function of

the input size.
• It's crucial for understanding memory
requirements and potential resource constraints.
• It's also expressed using Big O notation, focusing
on the dominant term in memory usage growth.
Analyzing Space Complexity in C:
• Identify Memory Allocations:
o Examine variables, arrays, data structures, and

function calls that occupy memory.

o Consider memory used for inputs, outputs,
temporary variables, and recursion stacks.

• Measure Memory Growth:

o Determine how memory usage changes with

varying input sizes.

o Focus on memory-intensive operations like
creating large arrays or data structures.

• Express in Big O Notation:

o Discard constant factors and lower-order

terms, similar to time complexity.
o Common Big O notations for space
complexity:
▪ O(1): Constant space (no change with
input size)
▪ O(n): Linear space (grows proportionally
to input size)
▪ O(n^2): Quadratic space (grows as the
square of input size)
 ▪ O(log n): Logarithmic space (grows
logarithmically with input size)

Example

C Language :
void copy_array(int arr1[], int arr2[], int n) {
for (int i = 0; i < n; i++) {
arr2[i] = arr1[i]; // Copies elements to
a new array
}
}
• Space complexity: O(n) (linear space)
o Creates a new array arr2 of size n, using
additional memory proportional to input size.
Logical Operators in C
Explanation:
• Logical operators perform logical operations on

boolean values (true or false).

 • They're used for decision-making and conditional
execution in C programs.
Operators:
• && (AND): True if both operands are true.

• || (OR): True if at least one operand is true.

• ! (NOT): Inverts the truth value of the operand.

C Program Demonstrating Logical Operators:

C Language
#include <stdio.h>

int main() {
int a = 10, b = 5, c = 20;

// AND operator
if (a > b && a > c) {
printf("a is the largest number.\n");
}

// OR operator
if (b > a || b > c) {
printf("b is greater than either a or c.\n");
}
 // NOT operator
if (!(a == b)) { // Equivalent to "if (a != b)"
printf("a is not equal to b.\n");
}

return 0;
}

Q32) . Explain Ternary or Conditional operators

in c. write a program to determine maximum of
three number

Ternary or Conditional Operators in C:

Explanation:
• It's a shorthand way to write if-else statements

within a single expression.

• It has three operands:
o Condition (true or false)
o Expression1 (executed if condition is true)
o Expression2 (executed if condition is false)
• Syntax: condition ? expression1 : expression
Example:

C language :
int max = (a > b) ? a : b; // Assigns the larger of
a and b to max
C Program to Determine Maximum of Three
Numbers Using Ternary Operator:

C Language:
#include <stdio.h>

int main() {
int a, b, c;

printf("Enter three numbers: ");

scanf("%d %d %d", &a, &b, &c);

int max = a > b ? (a > c ? a : c) : (b > c ? b : c);

// Nested ternary for three comparisons

printf("The maximum number is: %d\n",

max);

return 0;
}
Explanation:
• The program prompts for three numbers and

stores them in a, b, and c.

• The ternary operator is used to find the maximum:

o a > b ? ... : ...: Checks if a is greater than b.
▪ If true, it evaluates the left expression (a >
c ? a : c) to compare a with c.
▪ If false, it evaluates the right expression (b
> c ? b : c) to compare b with c.
• The nested ternary ensures all three numbers are
compared and the maximum is assigned to max.
• The result is printed.

Q33) What is error, explain different types of

error occurred in program?

• Syntax Errors:
o Violations of the grammar rules of the

programming language.
 o Examples: missing semicolons, incorrect
keywords, misspelled variable names.
o Caught by the compiler, preventing program
execution.
• Runtime Errors:
o Occur during program execution, often due to

unexpected inputs or operations.

o Examples: division by zero, accessing invalid
memory locations, infinite loops.
o Terminate the program abnormally.
• Logical Errors:
o Flaws in the program's logic, leading to

incorrect results despite running without

crashing.
o Examples: incorrect calculations, flawed
algorithms, misunderstanding of
requirements.
o Not detected by the compiler or runtime
system; require careful debugging and testing.
• Semantic Errors:
o Violations of the language's meaning or intent,

even if the code is syntactically correct.

o Examples: using a variable of the wrong type,
mismatched function arguments.
 o May not be caught immediately, but can lead
to unexpected behavior.

• Linker Errors:
o Issues during the linking process, when

multiple files are combined into an executable.

o Examples: missing or unresolved functions,
mismatched libraries.
o Prevent program execution.
• Compilation Errors:
o Problems encountered by the compiler during

code translation.
o Examples: syntax errors, type mismatches,
undefined variables.
o Must be fixed before execution.
Prevention and Debugging:
• Practice good coding habits: consistent formatting,

meaningful variable names, comments.

• Use tools like compilers, linters, and debuggers to
identify errors early.
• Implement thorough testing to catch errors before
deployment.
 • Write clear and concise code to minimize the
likelihood of errors.

Q34).Explain with example any two bitwise

operator in c language :
1. Bitwise AND Operator (&)
• Purpose: Performs a logical AND operation on

each corresponding bit of two integer operands.

• Result: A new integer where each bit is 1 only if
both corresponding bits in the operands are 1;
otherwise, the bit is 0.
Example:
C Language:
int x = 12; // Binary representation: 00001100
int y = 25; // Binary representation: 00011001
int result = x & y; // Binary representation of
result: 00001000 (decimal 8)

Explanation:

• The bits of x and y are compared pair-wise:

o The first bit of x (0) AND the first bit of y (0)
results in 0.
 o The second bit of x (0) AND the second bit of
y (1) results in 0.
o And so on, resulting in the binary value
00001000, which is 8 in decimal.
Common Uses:
• Checking if a specific bit is set in a number (e.g., if

(x & 2) { ... } to check if the second bit is 1)

• Isolating specific bits (e.g., int lower_4_bits = x &
0xF; to get the lower 4 bits of x)
• Clearing specific bits (e.g., x &= ~(1 << 5); to clear
the 5th bit of x)
2. Bitwise XOR Operator (^)
• Purpose: Performs a logical exclusive OR (XOR)

operation on each corresponding bit of two

integer operands.
• Result: A new integer where each bit is 1 if the
corresponding bits in the operands are different,
and 0 if they are the same.
Example:
C Language:
int x = 10; // Binary representation: 00001010
int y = 15; // Binary representation: 00001111
int result = x ^ y; // Binary representation of
result: 00000101 (decimal 5)
Explanation:

• The bits of x and y are compared pair-wise:

o The first bit of x (0) XOR the first bit of y (0)
results in 0.
o The second bit of x (0) XOR the second bit of
y (1) results in 1.
o And so on, resulting in the binary value
00000101, which is 5 in decimal.
Common Uses:

• Toggling bits (e.g., x ^= 4; to toggle the 3rd bit of

x)
• Swapping values without using a temporary
variable (e.g., x ^= y; y ^= x; x ^= y;)
• Encryption and decryption algorithms

Q35) Explain bitwise right shift operator, bitwise x-or

operator with example .

1. Bitwise Right Shift Operator (>>)

• Purpose: Shifts all bits of a binary number to the

right by a specified number of positions.

 • Syntax: value >> number_of_positions
• Behavior:
o Shifts each bit to the right, filling vacated bits
on the left with:
▪ 0 for unsigned integers
▪ The sign bit (usually the most significant
bit) for signed integers
o Effectively divides the unsigned integer by 2
raised to the power of the shift count.
Example:
C Language:
unsigned int x = 24; // Binary representation:
00011000
unsigned int result = x >> 2; // Shift right by 2
positions
// Binary representation of result: 00000110
(decimal 6)

int y = -15; // Binary representation (assuming

8-bit signed): 11110001
int result2 = y >> 1; // Shift right by 1 position
// Binary representation of result2: 11111000
(decimal -8)
Common Uses:

• Dividing unsigned integers by powers of 2

efficiently
• Isolating specific bits or groups of bits
• Implementing arithmetic operations like division
and modulo
2. Bitwise XOR Operator (^)
• Purpose: Performs a logical exclusive OR

operation on each corresponding bit of two

integer operands.
• Result: A new integer where each bit is 1 if the
corresponding bits in the operands are different,
and 0 if they are the same.
Example:

C Language
int x = 10; // Binary representation: 00001010
int y = 15; // Binary representation: 00001111
int result = x ^ y; // Binary representation of
result: 00000101 (decimal 5)
Common Uses:

• Toggling bits (e.g., x ^= 4; to toggle the 3rd bit of

x)
• Swapping values without using a temporary
variable (e.g., x ^= y; y ^= x; x ^= y;)
• Encryption and decryption algorithms
• Generating parity bits for error detection
• Detecting changes in data (e.g., comparing a value
before and after modification)

Q36) Write an explain unformatted IO functions

Unformatted I/O functions are a category of

input/output functions in C that read or write data as a
stream of bytes without applying any formatting or
interpretation. This means they work directly with the
raw binary representation of data, without considering
data types or specific formatting rules.
Key characteristics:

• No format specifiers: Unlike formatted functions

like printf and scanf, unformatted functions don't
use format specifiers (e.g., %d, %f) to control the
output or input format.
• Limited data types: They typically work with
character data types (char, char*) and arrays of
characters (strings), but not with other data types
like integers or floats.
• Faster performance: They can be more efficient
than formatted I/O functions, especially for large
amounts of data, as they don't incur overhead for
formatting and parsing.
• Lower-level operations: They provide more
direct control over the underlying I/O operations,
which can be useful for specific tasks like binary
file manipulation or hardware interaction.
Common unformatted I/O functions in C:
Input functions:

• getchar(): Reads a single character from standard

input (usually the keyboard).
• getc(FILE stream): Reads a single character from
a specified file stream.
 • fgetc(FILE stream): Similar to getc, but also
returns an error indicator.
• fread(void ptr, size_t size, size_t count, FILE
stream): Reads a block of data from a file stream.
Output functions:

• putchar(char c): Writes a single character to

standard output (usually the console).
• Putc(char c, FILE stream): Writes a single
character to a specified file stream.
• fputc(char c, FILE stream): Similar to putc, but
also returns an error indicator.
• fwrite(const void ptr, size_t size, size_t
count, FILE stream): Writes a block of data to a
file stream.
When to use unformatted I/O:

• Reading or writing binary data (e.g., images, audio

files, raw sensor data).
• Transferring data between files or devices without
any translation needed.
• Optimizing performance for large data transfers
where formatting is not required.
 • Working with custom data structures that need
direct control over their binary representation.

Q37) Explain different tokens of C.

The Different Tokens of C: Building Blocks of a C

Program
In C, the smallest meaningful units of code are called
tokens. These tokens are recognized by the compiler
and form the building blocks of your program.
Understanding them is crucial for writing valid and
efficient C code.

1.Keywords:

• These are reserved words with pre-defined

meanings in the C language. They cannot be used
as variable names or identifiers.
• Examples: int, float, while, if, for, return, etc.
2. Identifiers:

• These are user-defined names given to variables,

functions, constants, and other program elements.
• They follow naming conventions: must start with a
letter, underscore, or <span class="math-
inline">\, and can contain subsequent letters,
underscores, digits, and ``.
• Examples: myVariable, sumFunction, PI, etc.
4.Constants:

• These are fixed values that cannot be changed

during program execution. They can be of
different types like:
o Integer constants: 10, -5, 0xFF, etc.
o Floating-point constants: 3.14, 1.2e-6, etc.
o Character constants: 'a', '\n', etc.
o String literals: "Hello, World!", etc.
5.Operators:

• These are symbols used to perform various

operations on operands (data). They can be
categorized as:
o Arithmetic operators: +, -, *, /, etc.
o Relational operators: ==, !=, <, >, etc.
o Logical operators: &&, ||, !, etc.
o Assignment operators: =, +=, -=, etc.
 o Bitwise operators: &, |, ~, ^, etc.

6.Special Characters:

• These are symbols with specific meanings and

functions within the C syntax. Examples include:
o Punctuation marks: (), {}, [, ], ,, ;, etc.
o White space characters: spaces, tabs, newlines
(used for readability but not part of tokens).
o Other symbols: #, @, ?, etc.
Understanding the types and roles of these
tokens is essential for:

• Writing syntactically correct C code.

• Identifying errors and debugging your program.
• Analyzing and optimizing your code performance.
• Effectively communicating your code to other
 Q38) What is precedence and associativity of
operators

Precedence:
• Specifies the relative priority or "ranking" of

operators. Operators with higher precedence are

evaluated before those with lower precedence.
• Example: In 2 + 3 * 4, multiplication (*) has
higher precedence than addition (+), so 3 * 4 is
evaluated first, resulting in 14, and then 2 + 14 is
evaluated, giving the final result of 16.
Associativity:
• Determines the order of evaluation when multiple

operators of the same precedence appear in an

expression.
• Can be either left-to-right or right-to-left.
Common Operator Precedence and Associativity in C:

Precedence Operators Associativity

(Highest to
Lowest)
1 () (function calls, Left-to-right
parentheses)
2 [] (array subscript) Left-to-right
3 . (member access), -> Left-to-right
(pointer to member
access)
4 ++ (postfix increment), Left-to-right
-- (postfix decrement)
5 ++ (prefix increment), - Right-to-left
- (prefix decrement), +,
- (unary), !, ~
6 *, /, % Left-to-right
7 +, - (binary) Left-to-right
8 <<, >> Left-to-right
9 <, <=, >, >= Left-to-right
10 ==, != Left-to-right
11 & (bitwise AND) Left-to-right
12 ^ (bitwise XOR) Left-to-right
13 ` ` (bitwise OR)
14 && (logical AND) Left-to-right
15 ` ` (logical OR)
16 ?: (ternary conditional) Right-to-left
17 =, +=, -=, *=, /=, %=, =`
<<=, >>=, &=, ^=, `
Key Points

• Use parentheses to explicitly control the order of

evaluation when needed, even if precedence and
associativity rules would already produce the
desired result. This enhances code readability and
clarity.
• Unary operators (those that operate on a single
operand) generally have higher precedence than
binary operators.
• Most operators in C have left-to-right associativity,
meaning operations are performed from left to
right when multiple operators of the same
precedence are present.
• Understanding these rules is crucial for writing
accurate and predictable C code.

Q39) Explain the following with example 1) goto,

2) continue 3) break

1. goto Statement:
Purpose: Unconditionally transfers control to a
labeled statement within the same function.
Syntax:
C
goto label;

// ... (code can be here)

label:
// code to be executed after the jump
Example:
C
#include <stdio.h>

int main() {
int i = 0;

loop: // Label for the loop

printf("%d ", i);
i++;
if (i < 5) {
goto loop; // Jump back to the loop label
}

printf("\nLoop finished.\n");

return 0;
}
2. continue Statement:

Purpose: Skips the remaining statements in the

current iteration of a loop and jumps to the beginning
of the next iteration.

Syntax:

C Language
continue;
Example:
C Language
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // Skip even numbers
}
printf("%d ", i);
}

Visual Representation:

3. break Statement:
Purpose: Terminates the current loop or switch
statement immediately, and control flow jumps to the
statement following the loop or switch.
Syntax:
C
break;
Example:
C
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // Exit the loop when i reaches 5
}
printf("%d ", i);
}

Q40) Explain switch case and if-else ladder with

example

Switch-Case:

Purpose: Used for multi-way branching based on the

value of a single expression. It compares the
expression's value with multiple cases and executes
the code block associated with the matching case.
Syntax:

C Language
switch (expression) {
case value1:
// code to execute if expression equals
value1
break;
case value2:
// code to execute if expression equals
value2
break;
// ... more cases
default:
// code to execute if no case matches
}
Example:

C Language
#include
<stdio.h>
int
main()
{
int day = 3;
switch (day) {
case
1:
printf("Monday\n");
break;
case
2:
printf("Tuesday\n");
break;
case
3:
printf("Wednesday\n");
break;
// ... more cases for other days
default:
printf("Invalid day\n");
}

return 0;
}
If-Else Ladder:

Purpose: Used for conditional execution of code

blocks based on multiple conditions. It checks
conditions sequentially and executes the
corresponding code block if the condition is true.

Syntax:

C Language:

if (condition1) {
// code to execute if condition1 is true
} else

if (condition2) {
// code to execute if condition1 is false and
condition2 is true
} else if (condition3) {
// ... more else if statements
} else {
// code to execute if none of the above
conditions are true
}
Example:

C Language
#include <stdio.h>

int main() {
int grade = 85;

if (grade >= 90) {

printf("Excellent\n");
} else if (grade >= 80) {
printf("Very Good\n");
} else if (grade >= 70) {
printf("Good\n");
} else {
printf("Needs Improvement\n");
}

return 0;
}
Q41) Explain difference between call by value
and call by reference

Call by Value:

• Concept: When a function is called by value, a

copy of the actual argument's value is passed to
the function. Any changes made to the argument
within the function only affect the copy, not the
original variable in the calling function.
• Mechanism:
o The compiler creates a copy of the argument's
value in a separate memory location.
o The function receives and works with this
copy.
o The original variable remains unaffected.
Example:
C Language
#include <stdio.h>

void swap_by_value(int x, int y) {

int temp = x;
x = y;
y = temp;
}

int main() {
int a = 10, b = 20;
printf("Before swap: a = %d, b = %d\n", a, b);
swap_by_value(a, b); // Call by value
printf("After swap: a = %d, b = %d\n", a, b);
// Values remain unchanged
return 0;
}

Output:
Before swap: a = 10, b = 20
After swap: a = 10, b = 20
Call by Reference:

• Concept: When a function is called by reference,

the address (memory location) of the actual
argument is passed to the function. Any changes
made to the argument within the function directly
affect the original variable in the calling function.
• Mechanism:
o The address of the argument is passed to the
function.
o The function operates on the original variable
using this address.
Any changes made within the function are
reflected in the original variable
Examplee:
C Language :
#include <stdio.h>

void swap_by_reference(int *x, int *y) {

int temp = *x;
*x = *y;
*y = temp;
}

int main() {
int a = 10, b = 20;
printf("Before swap: a = %d, b = %d\n", a, b);
swap_by_reference(&a, &b); // Call by
reference
printf("After swap: a = %d, b = %d\n", a, b);
// Values are swapped
return 0;
}

Output:
Before swap: a = 10, b = 20
After swap: a = 20, b = 10
Key Differences:

Feature Call by Value Call by Reference

Argument Copy of value Address of variable
passing
Original Unaffected Directly modified
variable
Memory More Less
usage
Efficiency Less efficient More efficient
Use cases When you want When you want to
to protect modify original data
original data or work with large
data structures

Q42). Explain any 2 library functions in math.h

along with its uses

1. sqrt(x):
• Purpose: Calculates the square root of a non-

negative number x.
 • Return value: Returns a double-precision
floating-point value representing the square root
of x.
Example:
C Language:
#include <stdio.h>
#include <math.h>

int main() {
double number = 25.0;
double square_root = sqrt(number);
printf("The square root of %.2f is %.2f\n",
number, square_root);
return 0;
}
• Output: The square root of 25.00 is 5.00

• Use cases:

o Finding the length of the hypotenuse of a right

triangle given the lengths of the other two

sides.
o Calculating standard deviation in statistics.
o Solving equations involving square roots.
2. sin(x):
• Purpose: Calculates the sine of an angle x,

expressed in radians.
 • Return value: Returns a double-precision
floating-point value representing the sine of x.
Example:
C Language:
#include <stdio.h>
#include <math.h>

int main() {
double angle = 30.0 * M_PI / 180.0; //
Convert degrees to radians
double sine_value = sin(angle);
printf("The sine of %.2f radians is %.2f\n",
angle, sine_value);
return 0;
}
• Output: The sine of 0.52 radians is 0.50

• Use cases:
o Modeling periodic phenomena like sound

waves, light waves, and planetary motion.

o Calculating trigonometric values for angles in
geometry and physics.
o Generating waveforms for audio synthesis and
signal processing.
Important notes:

• To use these functions, you need to include the

math.h header file in your C program.
• The angle argument for trigonometric functions
like sin must be in radians, not degrees. Use the
M_PI constant from math.h for conversion if
needed.
• The math.h library offers a wide range of other
mathematical functions, including:
o Exponential and logarithmic functions (e.g.,
exp, log, pow)
o Trigonometric functions (e.g., cos, tan, asin,
acos, atan)
o Rounding and remainder functions (e.g., ceil,
floor, round, fmod)
o Absolute value function (fabs)
Q43). Explain any two storage class with
example

1. Automatic Storage Class (auto):

• Scope: Variables declared within a block (e.g., a

function or a loop) have automatic storage class.

 • Lifetime: They exist only within the block where
they are declared. Once the block ends, they are
destroyed and their memory is released.
• Declaration: Declared using the auto keyword
(optional, as it's the default).

Examples :

C Language:
void myFunction() {
int x = 10; // Automatic variable
// x can be used only within this function
}

2. Static Storage Class (static):

• Scope: Variables declared with the static keyword

have static storage class.

• Lifetime: They retain their value even after the
block where they are declared ends, and their
memory is not released until the program
terminates.
• Declaration: Declared using the static keyword.
 Example:
C Language:
void myFunction() {
static int count = 0; // Static variable
count++;
printf("Function called %d times\n", count);
}

Key Differences and Use Cases:

Feature Automatic Static

Scope Block File
Lifetime Temporary Persistent
Default Uninitialized 0
value
Memory Stack Data segment
allocation
Use cases Temporary Maintaining state
variables, across function
function calls, counting,
arguments counters
Storage Classes:

• Register: Suggests the compiler to store the

variable in a CPU register for faster access
(implementation-dependent).

• Extern: Declares a variable that is defined in

another file, allowing access to it from multiple
files.

Q44) What do you mean by static and extern

storage class with example:
Static Storage Class:
Scope:
• Limited to the file where they are declared.

• Can be global or local within a function.

Lifetime:
• Retain their value throughout the entire program

execution.
• Initialized only once, usually to 0 by default.
Declaration:
• Use the static keyword.

Examples:

• Static Global Variable:

C Language
static int global_count = 0; // Accessible
only within this file

void myFunction() {
global_count++;
printf("Global count: %d\n",
global_count);
}
• Static Local Variable:

C Language
void myFunction() {
static int local_count = 0; // Retains
value between calls
local_count++;
printf("Local count: %d\n", local_count);
}
Common Uses:
• Maintaining state across function calls.

• Hiding variables from other files.

• Limiting the scope of global variables.
Extern Storage Class:
Scope:
• Refers to variables declared in another file.

Lifetime:
• Depends on where the variable is actually defined.

Declaration:
• Use the extern keyword.

Example:
C
// File1.c
int global_value = 10;

// File2.c
extern int global_value; // Declares access to
global_value from File1.c

void myFunction() {
printf("Global value: %d\n", global_value);
}
Common Use:
• Sharing variables across multiple files.

Q45) Explain call by value and call by reference with

example

Call by Value:

• Concept: When a function is called by value, a

copy of the actual argument's value is passed to
the function. Any changes made to the argument
within the function only affect the copy, not the
original variable in the calling function.
• Mechanism:

o The compiler creates a copy of the argument's

value in a separate memory location.
o The function receives and works with this
copy.
o The original variable remains unaffected.
Example:
C Language:
#include <stdio.h>

void swap_by_value(int x, int y) {

int temp = x;
x = y;
y = temp;
}

int main() {
int a = 10, b = 20;
printf("Before swap: a = %d, b = %d\n", a, b);
swap_by_value(a, b); // Call by value
printf("After swap: a = %d, b = %d\n", a, b);
// Values remain unchanged
return 0;
}

Output:
Before swap: a = 10, b = 20
After swap: a = 10, b = 20
Call by Reference:

• Concept: When a function is called by reference,

the address (memory location) of the actual
argument is passed to the function. Any changes
made to the argument within the function directly
affect the original variable in the calling function.
• Mechanism:
o The address of the argument is passed to the
function.
o The function operates on the original variable
using this address.
o Any changes made within the function are
reflected in the original variable.
Example:
C Language:
#include <stdio.h>

void swap_by_reference(int *x, int *y) {

int temp = *x;
*x = *y;
*y = temp;
}

int main() {
int a = 10, b = 20;
printf("Before swap: a = %d, b = %d\n",
a, b);
swap_by_reference(&a, &b); // Call by
reference
printf("After swap: a = %d, b = %d\n", a,
b); // Values are swapped
return 0;
}
Output:
Before swap: a = 10, b = 20
After swap: a = 20, b = 10
Key Differences:

Feature Call by Value Call by Reference

Argument passing Copy of value Address of variable
Original variable Unaffected Directly modified
Memory usage More Less
Efficiency Less efficient More efficient

Q46) Explain array and what is need of an array

Array:
• Definition: A collection of elements of the same

data type, stored in contiguous memory locations

under a common name.
• Accessing elements: Each element is accessed
using an index, which starts from 0.
• Declaration:
C Language :
data_type array_name[size];
• Example:
C Language:
int numbers[5]; // Array to store 5 integers
char vowels[5] = {'a', 'e', 'i', 'o', 'u'}; // Array
with initial values
Need for Arrays:

• Organizing Data:
o Store and manage large sets of related data
efficiently.
o Group elements of the same type for easier
handling and processing.
• Efficient Access and Manipulation:
o Access individual elements directly using their
indices, enabling fast operations.
o Perform operations on entire collections of
data using loops and array-based algorithms.
• Memory Efficiency:
o Require less memory compared to declaring
many individual variables.
• Structured Data Representation:
o Represent multi-dimensional data structures
like matrices, tables, and lists.
o Model real-world entities and relationships.
• Programming Foundation:
o Fundamental building blocks for advanced
data structures like linked lists, stacks, queues,
and trees.
 • Algorithm Implementation:
o Essential for implementing various algorithms
in sorting, searching, numerical computations,
and data analysis.
Common Use Cases:

• Storing lists of items (e.g., student names, product

prices)
• Representing matrices and tables
• Implementing stacks and queues
• Sorting and searching algorithms
• Text processing and string manipulation
• Numerical computations and scientific simulations

Q47) State any 2 library function in string.h

along with its uses.
1. strlen(str):
• Purpose: Calculates the length of a string (the

number of characters excluding the null

terminator).
• Return value: Returns an unsigned integer
representing the length of the string.
 • Example:
C Language :
#include <stdio.h>
#include <string.h>

int main() {
char string[] = "Hello, world!";
int length = strlen(string);
printf("The length of the string is: %d\n",
length); // Output: 13
return 0;
}
• Common uses:

o Determining the size of a string for memory

allocation.
o Creating substrings or extracting parts of a
string.
o Performing string comparison operations.
2. strcpy(dest, src):

• Purpose: Copies the contents of one string (src)

to another string (dest), including the null
terminator.
 • Return value: Returns a pointer to the
destination string (dest).
• Example:
C Language :
#include <stdio.h>
#include <string.h>

int main() {
char source[] = "Copy this string";
char destination[50];
strcpy(destination, source);
printf("Destination string: %s\n",
destination); // Output: Copy this string
return 0;
}
• Important note: Use strcpy with caution as it can

lead to buffer overflows if the destination string is

not large enough to hold the copied string.
Consider using strncpy for safer string copying.
• Common uses:

o Duplicating strings for various purposes.

o Initializing string variables with specific

values.
o Combining strings to create new strings.
Q48) . Explain any three string standard library
functions
:-
1. strlen(str):
• Purpose: Calculates the length of a string

(excluding the null terminator).

• Return value: Returns an unsigned integer
representing the string's length.
• Example:
C Language:
char str[] = "Hello";
int len = strlen(str); // len will be 5

2. strcat(dest, src):
• Purpose: Concatenates two strings (appends src

to the end of dest).

• Return value: Returns a pointer to the
destination string (dest).
Example:
C Language:
char dest[] = "Hello ";
char src[] = "world!";strcat(dest, src); // dest
will be "Hello world!"
3. strcmp(str1, str2):
• Purpose: Compares two strings lexicographically

(character by character).
• Return value:
o Returns 0 if the strings are equal.
o Returns a negative value if str1 is
lexicographically less than str2.
o Returns a positive value if str1 is
lexicographically greater than str2.
Example:
C Language:
char str1[] = "apple";
char str2[] = "banana";
int result = strcmp(str1, str2); // result will be
negative

Other useful string functions:

• strcpy(dest, src): Copies a string (src) to another

string (dest).
• strncpy(dest, src, n): Copies a specified number
of characters from src to dest.
• strchr(str, ch): Finds the first occurrence of a
characte
Q49). Write a program to calculate sum of list by
passing array to function.
C Language:
#include <stdio.h>

// Function to calculate the sum of elements in

an array
int calculate_sum(int numbers[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += numbers[i];
}
return sum;
}
int main() {
int numbers[] = {10, 20, 30, 40, 50};
int size = sizeof(numbers) /
sizeof(numbers[0]);

int total_sum = calculate_sum(numbers, size);

printf("The sum of the list is: %d\n",

total_sum);

return 0;
}
Q50). Explain reference and dereference
operators with example

• Purpose: Obtains the memory address of a

variable.
• Example:
C Language:
int x = 10;
int *ptr = &x; // ptr stores the address of x
printf("Address of x: %p\n", &x); // Output:
memory address of x
printf("Value of ptr: %p\n", ptr); // Output:
same as the address of x

Dereference Operator (*):

• Purpose: Accesses the value stored at the

memory address pointed to by a pointer.
Example:
C Language :
int y = 20;
int *ptr2 = &y; // ptr2 points to y
printf("Value of y: %d\n", *ptr2); // Output: 20
(value of y)

Key Points:

• Pointers: Variables that store memory addresses.

They are declared using the * symbol.
• Reference operator (&): Used to get the address
of a variable.
• Dereference operator (*): Used to access the
value at the address pointed to by a pointer.
• Relationship: The dereference operator
effectively "undoes" the reference operator.
Common Use Cases:
• Dynamically allocating memory (using malloc,

calloc, etc.)
• Passing variables by reference to functions (for
modification)
• Working with arrays and pointers interchangeably
 • Implementing data structures like linked lists and
trees

Q51) What do you mean by structure

Reference Operator (&):

• Purpose: Obtains the memory address of a

variable.
• Syntax: &variable_name
• Example:
C Language:
int x = 10;
int *ptr = &x; // ptr stores the address of x
printf("Address of x: %p\n", &x); // Output:
memory address of x
printf("Value of ptr: %p\n", ptr); // Output:
same as the address of x

Dereference Operator (*):

• Purpose: Accesses the value stored at the

memory address pointed to by a pointer.

 • Example:
C Language:
int y = 20;
int *ptr2 = &y; // ptr2 points to y
printf("Value of y: %d\n", *ptr2); // Output: 20
(value of y)

Key Points:

• Reference operator (&): Used to get the address

of a variable.
• Dereference operator (*): Used to access the
value at the address pointed to by a pointer.
• Relationship: The dereference operator
effectively "undoes" the reference operator.
Common Use Cases:
• Dynamically allocating memory (using malloc,

calloc, etc.)
• Passing variables by reference to functions (for
modification)
• Working with arrays and pointers interchangeably
• Implementing data structures like linked lists and
trees
Q52). Define Union, differentiate structure and
union.
Both structures and unions in C are user-defined
data types used to group data of different types but
with distinct functionalities and memory allocation
practices.

Structure:
• Definition: A collection of named members of

different data types stored in consecutive memory

locations.
• Memory allocation: Each member gets its own
dedicated memory space within the structure.
• Accessing members: Each member can be
accessed using the dot operator (.) with the
structure name and member name.
• Use cases: Used for grouping related data that
needs to be accessed independently, like student
records (name, age, marks), employee info (id,
name, department), etc.
Union:
• Definition: A collection of named members of

different data types, but only one member can

hold a value at any given time. They share the
same memory location.
• Memory allocation: The size of the union is
determined by the largest member, and all other
members share this space. Only one member can
be actively "live" at a time.
• Accessing members: Members are accessed
using the dot operator, similar to structures.
However, changing the value of one member
affects all other members as they share the same
location.
• Use cases: Used for situations where different
data types might be used at different times, but
storing all of them simultaneously is not cost-
effective or necessary (e.g., a variable that might
store either an integer or a character depending on
the situation)
Differences:

Feature Structure Union

Memory Separate space for Shared space for all
allocation each member members
Live All members can hold Only one member
members values simultaneously can hold a value at
a time
Accessing Independent access Shared access
members using dot operator using dot operator
Use cases Related data with Dynamic data
independent access types with limited
usage at once

Q53). Explain nested structure with example

In programming:

A nested structure is a data structure that

contains another structure within it, creating a
hierarchical organization of related data.
C language :

struct address {
char street[50];
char city[50];
char state[20];
int zipcode;
};

struct employee {
int id;
char name[50];
float salary;
struct address address; // Nested structure
};

Key points:

• Nesting: The address structure is nested within

the employee structure.
• Accessing members: To access members of the
nested structure: employee.address.street
• Organization: Nested structures group related
data, enhancing readability and maintainability.
Real-world examples:
 • Book: A book has chapters (nested structures)
that contain pages (nested within chapters).
• Company: A company has departments (nested
structures) that consist of employees (nested
within departments).
• Family tree: A family tree has parents
(structures) who have children (nested within
parents).
• File system: A file system has folders (structures)
that contain files and subfolders (nested within
folders).

Benefits of nested structures:

• Improved organization: Break down complex

data into logical, manageable units.

• Enhanced readability: Code becomes easier to
understand and navigate.
• Better maintainability: Changes can be made
more easily to specific parts of the data.
• Code reusability: Nested structures can be
reused in different parts of a program.
Q54).Explain how to read contents from file and
write on to the file with syntax

Key step
1.Include necessary header:
C Language:

#include <stdio.h>

2.Open the file:

C Language:

FILE *fp = fopen("filename.txt", "mode");

o fp: File pointer to manage the file

o filename.txt: Name of the file to open
o mode: Specifies the operation (common
modes):
▪ "r": Read mode

▪ "w": Write mode (creates a new file

or overwrites an existing one)

▪ "a": Append mode (adds content to

the end of an existing file)

3.Read contents (for reading):

o Reading characters:

C.Language :

char ch;
while ((ch = fgetc(fp)) != EOF) {
// Process the character
}

o Reading strings:

C Language:

char line[100];
fgets(line, sizeof(line), fp);
o Reading formatted data:

C Language:

int age;
char name[50];
fscanf(fp, "%d %s", &age, name);
4. Write contents (for writing):

o Writing characters:
C
char ch = 'A';
fputc(ch, fp);
o Writing strings:
C
char message[] = "Hello, world!";
fputs(message, fp);
o Writing formatted data:
C
int value = 10;
fprintf(fp, "Value: %d", value);

5.Close the file:

C Language :

fclose(fp);
Essential points:

• Error checking: Always check if fopen

returns NULL to handle file opening
errors.

• Binary files: Use fread and fwrite for

binary data.

• File modes: Choose the appropriate

mode based on your intended operations.

• File position: Use fseek to move within a

file
for reading or writing at specific
positions.

Q55) What is the need of computer programming

And What do you mean by structured
programming?
Develop an ALGORITHM and FLOWCHART to find
reverse of a number.

1. Programming is to give the machine a list of steps to

perform a particular task.
2. If the system to which programming is done is a
computer than it is called as
Computer programming.
3. A programming of any system has to be done in the
language understood by that system.
4. Programming languages are an interface between
humans and computer, they allow us to communicate
with computers in order to do awesome things.
5. Structured programming (SP) is a technique devised
to improve the reliability and clarity of programs
6. In SP, control of program flow is restricted to three
structures, sequence,

• IF THEN ELSE, and DO WHILE, or to a structure

derivable
• combination of the basic three. Thus, a structured
program does not
 • need to use GO TOs or branches (unless it is
written in a language that
• does not have statement forms corresponding to
the SP structures, in
• which case, GO TOs may be used to simulate the
structures).
• The result is a program built of modules that are
highly independent of
• each other.
• In turn, this allows a programmer to be more
confident that the code
• contains fewer logic errors and will be easier to
debug and change in the future.

9. However, SP may be less efficient than an

unstructured counterpart.
Algorithm:
1. START
2. PRINT “Enter a number”
3. INPUT n.
4. d1 = n mod 10
5. d2 = n/10
6. PRINT d1, d2.
7. STOP.
Flowchart: