Study Strategy & Exam Tips

• Time Allocation: Spend about 90 minutes on the theory section below and 60 minutes
practicing and understanding the programs.
• Read Questions Carefully: In the exam, read the entire question paper first. Answer the
questions you are most confident about first.
• Structure Your Answers: For 5-mark descriptive questions, start with a definition,
explain the concept, provide the syntax if applicable, and write a small code example.
This structure covers all bases.
• Programming Section: Always include the necessary header file (#include
<stdio.h>). Write comments in your code to explain your logic. Even if your final
program has a bug, a well-structured and commented code shows your understanding and
can earn you partial marks.

Part 1: Detailed Theory Notes (for Parts A & B)

Unit 1: C Fundamentals

1.1 History and Features of C

The C language was developed at Bell Labs in

1972 by Dennis Ritchie. It evolved from earlier languages like ALGOL, BCPL, and B.

Key Features of C:

• Simple: It has a structured approach with a rich set of library functions and data types.
• Portable: C is highly portable, meaning code written for one system can run on another
with minimal changes.
• Mid-Level Language: It bridges the gap between machine-level (low-level) and high-
level languages, allowing for both system programming and application development.
• Structured Language: C programs are divided into modules called functions, which
makes the code easier to manage and reuse.
• Rich Library: Provides numerous built-in functions for various operations, saving
development time.
• Fast Speed: The compilation and execution time of C language is very fast due to the
availability of simpler, built-in functions and operators.
• Pointers: C supports the use of pointers, which allow for direct interaction with memory,
making tasks like dynamic memory allocation possible.

1.2 C Tokens: The Building Blocks

A token is the smallest individual unit in a C program. The compiler breaks a program down into
these tokens.

• Keywords: These are 32 reserved words with predefined meanings that cannot be used
as variable names.
o Examples: int, float, if, else, for, while, return, struct.
• Identifiers: These are the names given to variables, functions, and arrays.
o Rules for Naming:
1. Must begin with a letter (a-z, A-Z) or an underscore (

_).

2. Can contain letters, digits, and underscores, but no other special symbols (

@, $, etc.).

3. Cannot be a keyword.
4. Cannot contain spaces.
• Constants (Literals): Fixed values that do not change during program execution.
o Integer Constants: Whole numbers like 10, -22, 450.
o Floating-point Constants: Real numbers with decimal points like 10.3, 450.6.
o Character Constants: A single character enclosed in single quotes, like 'a',
'b'.
o String Constants: A sequence of characters enclosed in double quotes, like
"Hello World".
• Operators: Symbols that perform operations on operands (e.g., +, =, *).
• Special Symbols: Symbols with special meaning, like {} (curly braces for blocks), []
(square brackets for arrays), and ; (semicolon to terminate statements).

1.3 Structure of a C Program

A C program is organized into several sections.

C
/* 1. Documentation Section: Comments */
#include <stdio.h> /* 2. Link Section: Header files */

#define PI 3.14 /* 3. Definition Section: Constants */

int globalVar = 10; /* 4. Global Declaration Section */

void myFunction(); /* Function Prototype */

int main() { /* 5. Main Function: Entry point of the program */

// Declaration Part
int local_var;

// Executable Part
printf("Hello World");
 myFunction();
return 0;
}

void myFunction() { /* 6. Subprogram Section: User-defined functions */

printf("This is a user-defined function.");
}

1.4 Input/Output (I/O) Statements

These are used to interact with the user. The functions are defined in <stdio.h>.

• printf(): The formatted output function used to display text and values on the console.
o Syntax: printf("format string", arg1, arg2, ...);
• scanf(): The formatted input function used to read data from the user.
o Syntax: scanf("format string", &var1, &var2, ...);
o The & is the "address-of" operator, telling scanf where to store the input value.
• Format Specifiers: These tell printf and scanf what type of data to expect.
o %d or %i: Signed integer
o %f: Float
o %lf: Double
o %c: Character
o %s: String

Unit 2: Data Types, Operators, and Control Structures

2.1 Data Types

Data types define the type of data a variable can hold and the amount of memory it occupies.

• int: Stores whole numbers. Typically 4 bytes.

• char: Stores a single character. 1 byte.
• float: Stores single-precision floating-point numbers (numbers with decimals). 4 bytes,
up to 7 decimal digits of precision.
• double: Stores double-precision floating-point numbers. 8 bytes, up to 15 decimal digits
of precision.

2.2 Operators in Detail

• Arithmetic: +, -, *, /, % (Modulus - gives remainder).

• Relational: Used for comparison, they return 1 (true) or 0 (false). Examples:

5 > 3 returns 1. 5 == 3 returns 0.

• Logical: Used to combine conditions.

 o && (AND): True only if both conditions are true.
o || (OR): True if at least one condition is true.
o ! (NOT): Inverts the truth value (!true is false).
• Conditional (Ternary): A shorthand for an if-else statement.
o Syntax: condition ? expression_if_true : expression_if_false;
o Example: int max = (a > b) ? a : b; (sets max to a if a is greater, otherwise
sets it to b).

2.3 Control Flow Statements

These statements alter the sequential flow of program execution.

• Decision Making:
o if-else Ladder: Used to check multiple conditions.

if (condition1) { ... }
else if (condition2) { ... }
else { ... }

o switch Statement: An efficient alternative to a long if-else ladder for checking

a variable against a list of constant values.
§ Each value is a case.
§ break is used to exit the switch block after a case is executed.
§ default is an optional case that runs if no other case matches.
• Looping Statements:
o for loop: Used when the number of iterations is known.

for (initialization; condition; update) { ... }.

o while loop: An entry-controlled loop. The condition is checked

before executing the loop body. Used when the number of iterations is unknown.

o do-while loop: An exit-controlled loop. The loop body is executed

at least once, and then the condition is checked.

• Jump Statements:
o break: Immediately terminates the enclosing loop or switch statement.
o continue: Skips the rest of the current iteration of a loop and proceeds to the next
iteration.
Unit 3: Functions and Storage Classes

3.1 Functions

A function is a self-contained block of code that performs a specific task.

• Function Prototype (Declaration): Informs the compiler about the function's name,
return type, and parameters before it is called. This allows you to define the function after

main().

o Syntax: return_type function_name(parameter_type_list);

• Function Definition: Contains the actual code (statements) that the function executes.
• Function Call: The statement that executes the function.
• Library vs. User-Defined Functions:
o Library Functions: Pre-defined functions available in C's header files (e.g.,
printf in <stdio.h>, sqrt in <math.h>).
o User-Defined Functions: Functions created by the programmer to perform
specific tasks.

3.2 Recursion

A function that calls itself is recursive. It must have a

base case to terminate the recursion, otherwise, it will lead to an infinite loop and a stack
overflow error.

Execution of Factorial(4):

1. factorial(4) calls factorial(3) and waits.

2. factorial(3) calls factorial(2) and waits.
3. factorial(2) calls factorial(1) and waits.
4. factorial(1) calls factorial(0) and waits.
5. factorial(0) hits the base case and returns 1.
6. factorial(1) gets 1, returns 1 * 1 = 1.
7. factorial(2) gets 1, returns 2 * 1 = 2.
8. factorial(3) gets 2, returns 3 * 2 = 6.
9. factorial(4) gets 6, returns 4 * 6 = 24.

Unit 4: Arrays and Strings

4.1 Arrays

An array is a collection of fixed-size, same-type data items stored in

contiguous memory locations.

• One-Dimensional (1D) Array: A linear list of elements.

o Declaration: int marks[5]; (reserves space for 5 integers).
o Initialization: int marks[5] = {90, 85, 92, 78, 88};
o Accessing: Elements are accessed via an index, which starts at 0. The third
element is marks[2].
• Two-Dimensional (2D) Array: An "array of arrays," representing a grid or matrix.
o Declaration: int matrix[2][3]; (2 rows, 3 columns).
o Initialization: int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
o Accessing: matrix[row][col]. The element in the 2nd row, 3rd column is
matrix[1][2].

4.2 Strings

In C, a string is a

one-dimensional array of characters that is terminated by a null character \0.

• Initialization: char greeting[] = "Hello";

o This creates an array of 6 characters in memory: {'H', 'e', 'l', 'l', 'o',
'\0'}. The \0 is added automatically.
• String Library Functions (<string.h>):
o strlen(str): Returns the length of str.
o strcpy(dest, src): Copies src string into dest string.
o strcat(dest, src): Appends src string to the end of dest string.
o strcmp(str1, str2): Compares two strings. Returns 0 if they are equal, a
negative value if str1 < str2, and a positive value if str1 > str2.

Unit 5: Pointers

5.1 Pointer Fundamentals

A pointer is a variable whose value is the

memory address of another variable.

• Declaration: data_type *pointer_name; e.g., int *ptr;

• The & (Address-of) Operator: Gets the memory address of a variable. ptr = &var;
stores the address of var in ptr.
• The * (Dereference/Indirection) Operator: Accesses the value stored at the address
pointed to by the pointer. int value = *ptr; gets the value from var via ptr.
5.2 Pointers and Arrays

The name of an array acts as a constant pointer to its first element.

• arr is equivalent to &arr[0].

• *(arr + i) is equivalent to arr[i]. This is known as pointer arithmetic.

5.3 Call by Value vs. Call by Reference

This is a critical distinction for functions.

• Call by Value:
o The function receives a copy of the argument's value.
o Changes inside the function do not affect the original variable.
o This is the default mechanism in C for standard data types.
• Call by Reference:
o The function receives the memory address of the argument (i.e., a pointer).
o Changes made inside the function by dereferencing the pointer do affect the
original variable.
o This is achieved by passing pointers as arguments.

C
// Call by Value
void no_swap(int x, int y) {
int temp = x;
x = y;
y = temp;
// Only local copies x and y are changed.
}

// Call by Reference
void swap(int *x, int *y) { // Accepts pointers
int temp = *x;
*x = *y; // Changes value at the original address
*y = temp;
}

int main() {
int a = 10, b = 20;
no_swap(a, b); // a is still 10, b is still 20
swap(&a, &b); // a is now 20, b is now 10
}

Part 2: Essential Programs with Detailed Logic

(The code for the programs remains the same as the previous response, but the logic explanation
is expanded here.)
1. Simple Calculator using switch case

Detailed Logic:

• Input: The program first prompts for and reads the operator as a character (%c) and then
the two numbers as doubles (%lf). Reading the character first is important.
• Control Flow: The switch statement evaluates the operator variable. It compares its
value against each case label ('+', '-', etc.).
• Execution: When a match is found, the code block for that case is executed. For
example, if the user enters *, the case '*': block runs, printing the product of n1 and
n2.
• break Statement: The break keyword is essential. Without it, after executing a
matching case, the program would continue executing all the subsequent cases below it
until it hits a break or the end of the switch block. This is called "fall-through."
• default Case: If the user enters a character that does not match any case (e.g., '@'), the
default block is executed, which handles the error gracefully.

2. Check if a Number is Prime using a Function

Detailed Logic:

• Function Design: The problem is isolated into a function isPrime(int n) for

modularity and reusability.
• Prime Definition: A prime number is a natural number greater than 1 that has no
positive divisors other than 1 and itself.
• Edge Cases: The code first handles the special cases: 0 and 1 are explicitly not prime
numbers, so the flag is set to 1 (not prime).
• Optimization: The loop runs from i = 2 up to n / 2. We don't need to check beyond n
/ 2 because if a number k > n / 2 divides n, the result of the division would be less
than 2, which means the only possible factor would be n itself (which we already know).
This simple optimization reduces the number of iterations.
• The Flag: The flag variable acts as a boolean. It's initialized to 0 (true, i.e., "is prime").
If we find even one factor, we set flag = 1 (false, i.e., "is not prime") and immediately
break from the loop because we have our answer and further checks are unnecessary.
• Output: The final decision is made by checking the flag's value after the loop
completes.

3. Find the Sum and Average of Array Elements

Detailed Logic:

• Array Declaration: float numbers[100]; declares an array that can hold up to 100
floating-point numbers. This is a static size; a better approach for unknown sizes would
be dynamic memory allocation, but this is sufficient for basics.
• Iteration: The first for loop is the core of the input and summation process.
 o for (i = 0; i < n; ++i): The loop runs n times, with the index i going from
0 to n-1, which covers all array positions.
o scanf("%f", &numbers[i]);: In each iteration, it reads a float and stores it at
the current position i in the array.
o sum += numbers[i];: This is shorthand for sum = sum + numbers[i];. It
accumulates the total sum as the numbers are entered.
• Type Casting for Average: The line avg = sum / n; works correctly because sum is
already a float. If sum were an int, we would need to type-cast to avoid integer division
(which truncates the decimal part). For example: avg = (float)sum / n;.
• Formatted Output: %.2f is used in printf to display the sum and avg with exactly two
decimal places for cleaner output.

4. Swap Two Numbers using Pointers

Detailed Logic:

• Pointers as Parameters: The swap function is declared as void swap(int *a, int
*b). It doesn't return a value (void); instead, it modifies data directly in memory. The
parameters a and b are pointers, meaning they are expected to receive memory addresses.
• Passing Addresses: In main, the function is called as swap(&num1, &num2). The &
operator is used to pass the memory addresses of num1 and num2, not their values (10 and
20).
• Dereferencing: Inside the swap function:
1. int temp = *a;: A temporary variable temp is created. *a dereferences the
pointer a (which holds the address of num1), fetching the value from that address
(which is 10). So, temp becomes 10.
2. *a = *b;: This is the key step. The value at the address held by b (which is 20) is
copied to the location pointed to by a. The original num1 in main is now updated
to 20.
3. *b = temp;: The value of temp (10) is copied to the location pointed to by b. The
original num2 in main is now updated to 10.
• Result: Because the function operated on the original memory locations, the variables
num1 and num2 in main are permanently swapped after the function call. This
demonstrates the power of "call by reference."