Q -1 write a program to print pattern
23
456
7 8 9 10
11 12 13 14 15
Ans :
#include<stdio.h> // Header file for i/o.
int main(){ // entry point of a program.
int r,c,cnt=1; // variable declaration + initialization
for (r=1;r<=5;r++){
for(c=4;c>=r;c--) // for loop to print space
printf(" ");
for(c=1;c<=r;c++) // for loop to print numbers
printf("%d ",cnt++);
printf("\n");
return 0;
}
Q-2 write a program to swap two number without using third
variable.
Ans :
#include<stdio.h> // Header file for i/o.
int main(){ // entry point of a program.
int a,b; // variable declartion
// input
printf("Enter value of a and b : ");
scanf("%d%d",&a,&b);
// calculation
a^=b;
b^=a;
a^=b;
// output
printf("value of a : %d\n value of b : %d\n",a,b);
return 0;
}
Q-3 Explain C data types in detail ?
Ans : Data Types
Data types in C determine the type and size of data associated with
variables.
Types of Data Types in C
1. Primary / Primitive / Base / Fundamental Data types :
I. int: For whole numbers (e.g., 0, -5, 10).
II. float : For real numbers (with decimal points).(e.g., 3.14)
III. double : For real number (with decimal point).
IV. char: For individual characters (e.g., ‘h’, ‘A’, ‘$’).
V. void: An incomplete type (used for functions that don’t return
anything).
Float Double
1. It has 7 decimal 1. It has 15 decimal
digits precision. digits precision.
2. We have to define a 2. All values with
float value by using f decimal points are
suffix. considered as double
in c by default.
3. For float data type, 3. For double data type,
the format specifier the format specifier
is %f. is %lf.
4. It uses 4 bytes 4. It uses 8 bytes of
memory. memory.
Modifiers
Modifiers in C are keywords that alter the behavior of variables,
functions, or data types.
1. signed Modifier
Signed variables can store positive, negative integers, and zero.
2. unsigned Modifier
Unsigned variables can store only non-negative integer values.
3. short Modifier
The short keyword modifies the minimum values that a data type can
hold. It is used for small integers that lie in the range of −32,767 to
+32,767.
4. long Modifier
The long keyword modifies the maximum values that a data type can
hold.
2. Secondary / Derived data type
Array - An array is a linear data structure that holds a group of
elements having the same data types.
or
An array in C is a fixed-size collection of similar data items stored
in contiguous memory locations. It can be used to store the
collection of primitive data types such as int, char, float, etc., and
also derived and user-defined data types such as pointers,
structures, etc
Strings - It's a group of zero or more characters must be
represented within double quotation mark.
In c programming it is represented by character array.
Character array is nothing but a null terminating array where string
end identified by null.
Null -> '\0'
Declaration of character array
char nameOfString [ Size + 1 ]
3. User Defined Data Types
Enum , Struct , Union
Q-4 Explain nested if with practical example.
Ans : Nested If
Nested if statements refer to the placement of one or more if
statements within another if statement. This allows for more
complex decision-making processes within your C programs.
Example : WAP to find the biggest number among 3 numbers.
#include<stdio.h> // Header file for i/o.
int main(){ // entry point of a program.
int n1,n2,n3; // variable declartion
// input
printf("Enter three numbers : ");
scanf("%d%d%d",&n1,&n2,&n3);
// comparison and output
if(n1>n2){
if(n1>n3)
printf("%d is the largest number.",n1);
else
printf("%d is the largest number.",n3);
else if(n2>n3){
if(n2>n1)
printf("%d is the largest number",n2);
else
printf("%d is the largest number.",n3);
else
printf("%d is the largest number.",n3);
return 0;
Q-5 Explain operator and its precedence in detail.
Operators
Operators in C are symbols that perform mathematical, relational,
bitwise, conditional, or logical operations on operands in a program
Arithmetic operators
Used to perform mathematical operations on operands, such as
addition, subtraction, multiplication, division, and modulus.
Relational operators
Also known as conditional operators, these operators are used to
compare values and return a true or false value based on the
comparison.
Logical operators
Boolean operators that combine two expressions to produce a true
or false output.
Bitwise operators
The bitwise operators are the operators used to perform the
operations on the data at the bit-level.
Increment / Decrement Operator
The increment operator ( ++ ) is used to increment the value of a
variable in an expression by 1. It can be used on variables of the
numeric type such as integer, float, character, pointers, etc.
The decrement operator ( -- ) is used to decrement the value of the
variable in an expression by 1.
Associativity and Precedence
Associativity and Precedence of Operators are fundamental
concepts in programming that determine how expressions with
multiple operators are evaluated.
1. Operator Precedence:
• Defines the order in which operators are evaluated in an
expression.
• Operators with higher precedence are evaluated before
operators with lower precedence.
o Example: In 3 + 4 * 2, the multiplication (*) has higher
precedence than addition (+), so the result is 3 + (4 * 2) =
11.
2. Operator Associativity:
• Determines the direction in which operators of the same
precedence are evaluated.
• Types of Associativity:
o Left-to-Right (Left Associative): Operators are
evaluated from left to right.
• Example: In 5 - 3 - 2, subtraction is left associative,
so it's ((5 - 3) - 2) = 0.
o Right-to-Left (Right Associative): Operators are
evaluated from right to left.
• Example: In 2 ** 3 ** 2 (exponentiation in Python),
it's 2 ** (3 ** 2) = 2 ** 9 = 512.
Key Points to Remember
• Operators with higher precedence are evaluated first.
• When operators have the same precedence, associativity
determines the evaluation order.
• Parentheses can override precedence and associativity to
explicitly specify the desired evaluation order.
Q-6 Explain functions and its types ? Write a program
demonstrating user defined function in detail.
A function is a set of statements that when called perform some
specific tasks. It is the basic building block of a program that
provides organization and code reusability. The programming
statements of a function are enclosed within { } braces, having
certain meanings and performing certain operations.
Types of Functions
There are two types of functions in C:
1. Library Functions
2. User Defined Functions
Library Functions
A library function is also referred to as a “built-in function”. A
compiler package already exists that contains these functions, each
of which has a specific meaning and is included in the package. Built-
in functions have the advantage of being directly usable without
being defined.
Examples :
pow() -> math.h
strlen() -> string.h
printf() , scanf() -> stdio.h
User Defined functions
Functions that the programmer creates are known as User-Defined
functions or “tailor-made functions”. User-defined functions can be
improved and modified according to the need of the programmer.
Whenever we write a function that is case-specific and is not
defined in any header file, we need to declare and define our own
functions according to the syntax.
Syntax
return_type name_of_the_function (parameter_1, parameter_2,….);
example :
Conditions of Return Types and Arguments
In C programming language, functions can be called either with or
without arguments and might return values. They may or might not
return values to the calling functions.
1. Function with no arguments and no return value
void greet()
2. Function with no arguments and with return value
int get_random_number()
3. Function with argument and with no return value
void printBigNum(int a, int b)
4. Function with arguments and with return value
int add(int a, int b)
// write a program to demonstrate user defined function
#include <stdio.h> // header file for i/o
// user defined function to add two numbers.
int add(int a, int b) {
return a + b;
int main() { // entry point of program
int sum = add(5, 3); // call add function and store result in
// sum
printf("Sum: %d\n", sum); // output
return 0;
Q-7 Write a program to check whether a number is a prime or not
using a function ?
Ans :
#include <stdio.h> // header file for i/o
#include <math.h> // header file for math functions
// function to check whether a number is prime or not
void checkPrime(int n)
if (n <= 1) // checking for negetive numbers
printf("number is not prime.");
return;
int i, flag = 0; // variable declaration + initialization
// working
for (i = 2; i <= sqrt(n); i++)
if (n % i == 0)
flag = 1;
break;
//output
if (flag == 0)
printf("number is prime.");
else
printf("number is not prime.");
int main()
int n = 1;
checkPrime(n);
return 0;
Q-8 what is recursion ? explain stack overflow ?
Ans :
Recursion :
A function is said to be recursively defined if the function definition
refers to itself.
Or
Recursion is the process by which a function calls itself.
Recursion has some important properties. Some of which are
mentioned below:
• The primary property of recursion is the ability to solve a
problem by breaking it down into smaller sub-problems, each of
which can be solved in the same way.
• A recursive function must have a base case or stopping criteria
to avoid infinite recursion.
• Recursion involves calling the same function within itself, which
leads to a call stack.
• Recursive functions may be less efficient than iterative
solutions in terms of memory and performance.
#include <stdio.h> // header file for i/o
// function to find factorial of a number using function
long long int fact(int n){
if(n<=1) // base case
return 1;
else
return fact(n-1)*n; // recursive call
int main() // entry point of program
int n = 7; // variable declartion + initialization
long long int res = fact(n); // call fact function
printf("%ld",res); // output
return 0;
Stack Overflow:
Stack is a special region of our process’s memory which is used to
store local variables used inside the function, parameters passed
through a function and their return addresses. Whenever a new local
variable is declared it is pushed onto the stack. All the variables
associated with a function are deleted and memory they use is freed
up, after the function finishes running. The user does not have any
need to free up stack space manually. Stack is Last-In-First-Out
data structure. In our computer’s memory, stack size is limited. If a
program uses more memory space than the stack size then stack
overflow will occur and can result in a program crash. There are two
cases in which stack overflow can occur:
1. If we declare large number of local variables or declare an
array or matrix or any higher dimensional array of large size
can result in overflow of stack.
2. If function recursively call itself infinite times then the stack
is unable to store large number of local variables used by every
function call and will result in overflow of stack.
Q-9 Write a program to print values of array in ascending and
descending order.
// program to print array in ascending order.
#include<stdio.h> // Header file for i/o.
int main(){ // entry point of a program.
int a[8] = {34,22,56,42,67,88,43,11},i,j;
// sorting array in ascedning order
for(i=0;i<8;i++){
for(j=i+1;j<8;j++){
if(a[i]>a[j]){
int t = a[i];
a[i] = a[j];
a[j] = t;
// output
for(i=0;i<8;i++)
printf("%d ",a[i]);
return 0;
// program to print array in descending order
#include<stdio.h> // Header file for i/o.
int main(){ // entry point of a program.
int a[8] = {34,22,56,42,67,88,43,11},i,j;
// Descending Order
for(i=0;i<8;i++){
for(j=i+1;j<8;j++){
if(a[i]<a[j]){
int t = a[i];
a[i] = a[j];
a[j] = t;
}
// output
for(i=0;i<8;i++)
printf("%d ",a[i]);
return 0;
Q-10 what is the difference between call by value and call by
address with suitable example?
Ans :
Call By Value in C
In call by value method of parameter passing, the values of actual
parameters are copied to the function’s formal parameters.
• There are two copies of parameters stored in different
memory locations.
• One is the original copy and the other is the function copy.
• Any changes made inside functions are not reflected in the
actual parameters of the caller.
Call by Reference in C
In call by reference method of parameter passing, the address of
the actual parameters is passed to the function as the formal
parameters. In C, we use pointers to achieve call-by-reference.
• Both the actual and formal parameters refer to the same
locations.
• Any changes made inside the function are actually reflected in
the actual parameters of the caller.
Difference between call by value and call by address
Call By Value Call By Reference
While calling a function, instead
While calling a function, we of passing the values of variables,
pass the values of variables we pass the address of
to it. Such functions are variables(location of variables) to
known as “Call By Values”. the function known as “Call By
References.
In this method, the value of
each variable in the calling In this method, the address of
function is copied into actual variables in the calling
corresponding dummy function is copied into the dummy
variables of the called variables of the called function.
function.
With this method, using
With this method, the addresses we would have access
changes made to the dummy to the actual variables and hence
variables in the called we would be able to manipulate
function have no effect on them.
Call By Value Call By Reference
the values of actual variables
in the calling function.
In call-by-values, we cannot
In call by reference, we can alter
alter the values of actual
the values of variables through
variables through function
function calls.
calls.
Values of variables are Pointer variables are necessary to
passed by the Simple define to store the address values
technique. of variables.
This method is preferred
This method is preferred when we
when we have to pass some
have to pass a large amount of
small values that should not
data to the function.
change.
Call by value is considered Call by reference is risky as it
safer as original data is allows direct modification in
preserved original data
Example:
#include <stdio.h>
// Function prototypes
void callByValue(int a);
void callByAddress(int *b);
int main() {
int x = 10, y = 20;
// Call by Value
printf("Before callByValue: x = %d\n", x);
callByValue(x);
printf("After callByValue: x = %d\n", x);
// Call by Address
printf("Before callByAddress: y = %d\n", y);
callByAddress(&y);
printf("After callByAddress: y = %d\n", y);
return 0;
// Function to demonstrate Call by Value
void callByValue(int a) {
a = a + 10; // Changes local to the function
printf("Inside callByValue: a = %d\n", a);
}
// Function to demonstrate Call by Address
void callByAddress(int *b) {
*b = *b + 10; // Changes reflected outside the function
printf("Inside callByAddress: *b = %d\n", *b);
