← Back to Semester 1 Hub
🏛️ CCSU Meerut ⏱️ 75 Marks External (3 Hours) 📄 3M, 7.5M & 15M Exam Blueprint ⭐ 2015–2023 Recurring Exam Question Bank
SECTION A • 3 MARKS EACH

Very Short Answer Questions & Core Definitions

CCSU Examination Blueprint: 5 Questions Compulsory • 15 Marks Total

Q1. What do you understand by Identifiers in C? State their naming rules.

🔥 Repeated: 2015, 2017, 2019 3 Marks
✍️ Model Answer:

An Identifier is a user-defined name given to program elements such as variables, functions, arrays, and structures to uniquely identify them during program execution.

Rules for Naming Identifiers in C:

  • Can contain letters (a–z, A–Z), digits (0–9), and underscore (_).
  • Must begin with an alphabet letter or an underscore; it cannot begin with a digit.
  • Cannot be a reserved C keyword (e.g., int, while, return).
  • C is case-sensitive; count, Count, and COUNT are three distinct identifiers.
  • No special characters (like @, $, #, space) are permitted.
// Valid: student_age, _totalMarks, marks1
// Invalid: 1marks (starts with digit), total marks (space), float (keyword)

Q2. Differentiate between a Variable and a Constant in C.

🔥 Repeated: 2019, 2020, 2023 3 Marks
✍️ Model Answer:
FeatureVariableConstant
Value ModificationCan be modified anytime during program execution.Fixed value; cannot be modified once initialized.
Declaration Syntaxint count = 10; count = 20;const float PI = 3.14159; or #define PI 3.14
MemoryAllocated a dedicated read-write memory block in RAM.Read-only memory or substituted at preprocess time.

Q3. What do you understand by C Tokens? List all categories.

🔥 Repeated: 2016 3 Marks
✍️ Model Answer:

A C Token is the smallest individual building block or basic grammatical unit of a C program that the compiler recognizes and parses.

There are 6 categories of C Tokens:

  1. Keywords: 32 reserved words having predefined meaning (e.g., int, if, return).
  2. Identifiers: User-defined names for variables and functions (e.g., total, calculateSum).
  3. Constants: Fixed literal values (e.g., 100, 3.14, 'A').
  4. Strings: Sequence of characters enclosed in double quotes (e.g., "CCSU BCA").
  5. Special Symbols: Punctuation characters with syntactical meaning (e.g., [], {}, ;, ,).
  6. Operators: Symbols that perform mathematical or logical operations (e.g., +, *, &&, ==).

Q4. What do you understand by Time Complexity of an algorithm?

🔥 Repeated: 2015, 2016, 2017, 2019 3 Marks
✍️ Model Answer:

Time Complexity is a measure of the computational time an algorithm takes to execute as a function of the input size $n$.

  • It does not measure physical execution time in seconds (as clock time varies across CPU hardware), but counts the total number of elementary operations / steps performed.
  • It is mathematically represented using asymptotic notations: Big-Oh ($O$), Big-Omega ($\Omega$), and Big-Theta ($\Theta$).
  • Example: Searching an element in an unsorted array of size $n$ takes $O(n)$ time in the worst case (Linear Search).

Q5. Differentiate between Primitive and Non-Primitive Data Types in C.

🔥 Repeated: 2015, 2018 3 Marks
✍️ Model Answer:
  • Primitive (Fundamental / Built-in) Data Types: Predefined basic types supported directly by the C compiler. They store a single value.
    Examples: int (2/4 bytes), char (1 byte), float (4 bytes), double (8 bytes), void.
  • Non-Primitive (Derived & User-Defined) Data Types: Constructed using fundamental types to store collections or structured data.
    Examples: Arrays (homogeneous collection), Pointers (address holders), Structures (heterogeneous collection), Unions, Enums.

Q6. What is a Preprocessor Directive? Write four preprocessor directives in C.

🔥 Repeated: 2016, 2019, 2020, 2023 3 Marks
✍️ Model Answer:

A Preprocessor Directive is an instruction starting with a hash symbol (#) that directs the C preprocessor to transform or include source text before the compiler begins syntax analysis. They do not end with a semicolon (;).

Four Common Preprocessor Directives:

  1. #include <header.h>: Copies the declarations of external header files into the current file.
  2. #define MACRO value: Defines a constant macro or inline macro function for textual substitution.
  3. #undef MACRO: Undefines an existing macro definition.
  4. #ifdef / #ifndef / #endif: Conditional compilation directives that compile code blocks conditionally.

Q7. What do you understand by Swapping? Explain two approaches in C.

🔥 Repeated: 2015, 2016, 2017, 2019 3 Marks
✍️ Model Answer:

Swapping refers to interchanging the contents of two memory variables so that the first receives the second's value, and vice-versa.

Approach 1: Using a third temporary variable:

int temp = a; a = b; b = temp;

Approach 2: Without using a third variable (Arithmetic method):

a = a + b; // Let a=5, b=10 => a becomes 15
b = a - b; // b becomes 15 - 10 = 5
a = a - b; // a becomes 15 - 5 = 10 (Swapped!)

Q8. Why is C language known as a Procedural Language?

🔥 Repeated: 2016 3 Marks
✍️ Model Answer:

C is known as a Procedural (or Procedure-Oriented) Language because:

  • Programs are organized as a sequence of procedural steps, subroutines, or functions that perform operations on data.
  • It emphasizes doing things (algorithms and action sequences) rather than data encapsulation or objects.
  • It follows a top-down design approach, where execution starts in the main() function and breaks down into child functions sequentially.

Q9. Differentiate between break and continue statements.

🔥 Repeated: 2017, 2018, 2023 3 Marks
✍️ Model Answer:
Featurebreak statementcontinue statement
ActionImmediately terminates the loop or switch completely.Skips the rest of current iteration and moves to next iteration.
Control FlowTransfers execution to the first statement outside the loop block.Transfers execution back to the loop's condition check/increment step.
Usage ContextValid inside loops (for, while, do-while) and switch.Valid only inside loops; invalid inside switch blocks.

Q10. Write the syntax and usage of the Ternary (Conditional) Operator in C.

🔥 Repeated: 2020, 2023 3 Marks
✍️ Model Answer:

The Ternary Operator (? :) is the only operator in C that takes three operands. It acts as an inline compact alternative to an if-else statement.

Syntax: variable = (condition) ? expression_if_true : expression_if_false;

int a = 15, b = 25;
// Find maximum using ternary operator
int max = (a > b) ? a : b; // max receives 25

Q11. What is the difference between getch() and getchar() in C?

🔥 Repeated: 2018 3 Marks
✍️ Model Answer:
  • getchar(): Standard C library function in <stdio.h>. It is buffered and echoed — it waits for the user to type a character and press the Enter key, displaying the typed character on screen.
  • getch(): Non-standard console function in <conio.h>. It is unbuffered and non-echoed — it captures a single keypress instantly without waiting for Enter and does not display the pressed key on screen. Often used to pause the output console screen.

Q12. What is an Interpreter? How does it differ from a Compiler?

🔥 Repeated: 2020 3 Marks
✍️ Model Answer:

An Interpreter translates high-level source code into machine code line-by-line and executes each statement immediately. If an error is encountered on line 4, execution stops right there.

FeatureCompiler (e.g., GCC in C)Interpreter (e.g., Python)
TranslationTranslates entire program at once into object code (.obj/.exe).Translates and executes line-by-line in memory; no standalone .exe.
SpeedFaster execution once compiled.Slower execution due to runtime line translation.

Q13. What is a Structure in C? Write its syntax.

🔥 Repeated: 2015 3 Marks
✍️ Model Answer:

A Structure is a user-defined derived data type in C that allows grouping together variables of different data types under a single name, representing a real-world entity (e.g., Student, Employee, Book).

struct Student {
    int roll_no;       // 4 bytes
    char name[30];     // 30 bytes
    float percentage;  // 4 bytes
}; // Total size = 38 bytes (plus alignment padding)

struct Student s1 = {101, "Rahul Sharma", 88.5};

Q14. Define Recursion. What are its two essential components?

🔥 Repeated: 2020 3 Marks
✍️ Model Answer:

Recursion is a programming technique where a function calls itself directly or indirectly to solve a smaller instance of the same problem.

  1. Base Case (Terminating Condition): The condition that stops recursion and returns a fixed value without further calls. Prevents infinite looping and stack overflow.
  2. Recursive Step: The statement where the function invokes itself with modified parameters driving toward the base case.
SECTION B • 7.5 MARKS EACH

Medium Descriptive Questions, Comparisons & Flowcharts

CCSU Examination Blueprint: Attempt Any 2 out of 3 • 15 Marks Total

Q15. What is a Flowchart? Explain standard symbols used and draw a flowchart to check if a number is positive, negative, or zero.

🔥 Repeated: 2015, 2016, 2017 7.5 Marks
✍️ Model Answer:

A Flowchart is a standardized graphical / pictorial representation of a step-by-step algorithm showing the sequence of operations required to solve a computational problem.

Standard Flowchart Symbols:

Shape PreviewSymbol NameGeometric ShapeFunction / Meaning
Terminal Oval / Rounded Pill Represents the START or STOP / END of program execution.
Input / Output Parallelogram (Slanted) Reading input from user (e.g. Read N) or displaying output (e.g. Print result).
Process Rectangle Data manipulation, variable assignments, and arithmetic computations (e.g. sum = a + b).
Decision Diamond (Rhombus) Conditional branch check with two possible paths: True / YES or False / NO.
Connector Small Circle Connects intersecting flow lines or links complex multi-page flowchart sections.
Flowlines Directional Arrows Indicates the exact logical flow sequence from one operation to the next.
📊 FLOWCHART 1 : Check Positive, Negative, or Zero (CCSU Dec 2016) Authentic Vector SVG Diagram
START Read Number N Is N == 0 ? YES Print "Zero" NO Is N > 0 ? YES Print "Positive" NO Print "Negative" STOP
📊 FLOWCHART 2 : Find Average Marks in 5 Subjects (CCSU Dec 2017 Sec-B Q8) Process & Math Computation
START Read m1, m2, m3, m4, m5 Total = m1 + m2 + m3 + m4 + m5 Average = Total / 5.0 Print Total, Average STOP

Q16. Explain the difference between while and do-while loops with suitable code examples and dry runs.

🔥 Repeated: 2017, 2018 7.5 Marks
✍️ Model Answer:
Parameterwhile loopdo-while loop
Loop CategoryEntry-Controlled Loop: Condition is tested before entering the loop body.Exit-Controlled Loop: Condition is tested after executing loop body.
Minimum Executions0 times (if initial condition is false, body never executes).At least 1 time (even if initial condition is false).
Syntaxwhile (condition) { /* body */ }do { /* body */ } while (condition); (Ends with ;)
Use CaseWhen number of iterations depends on prior validation.Menu-driven console programs where options must be shown once.

Code Example Proving Difference:

#include <stdio.h>
int main() {
    int i = 10;
    
    // while loop: condition (i < 5) is FALSE immediately
    while (i < 5) {
        printf("While loop executed\n"); // NEVER PRINTS
    }

    // do-while loop: body executes FIRST, condition tested afterwards
    do {
        printf("Do-while executed once!\n"); // PRINTS ONCE
    } while (i < 5);

    return 0;
}

Q17. Distinguish between Call by Value and Call by Reference. Write a C program to swap two numbers using Call by Reference.

🔥 Repeated: 2016, 2019, 2023 7.5 Marks
✍️ Model Answer:
FeatureCall by ValueCall by Reference
What is PassedA copy of the actual variable's value is passed.The memory address (pointer) of variable is passed.
Impact on CallerChanges made in formal parameters do not affect original variables.Changes made inside function directly alter caller's variables.
Syntaxvoid swap(int x, int y);void swap(int *x, int *y);
Function Callswap(a, b);swap(&a, &b); (Address-of operator)

C Program: Swap Two Numbers Using Call by Reference:

#include <stdio.h>

// Function taking pointer arguments (Call by Reference)
void swap(int *x, int *y) {
    int temp = *x; // Dereference pointer to get value
    *x = *y;
    *y = temp;
}

int main() {
    int a = 10, b = 20;
    printf("Before Swap: a = %d, b = %d\n", a, b);

    // Pass addresses of a and b
    swap(&a, &b);

    printf("After Swap:  a = %d, b = %d\n", a, b); // Outputs a=20, b=10
    return 0;
}

Q18. Explain the Tower of Hanoi problem. Write down its recursive algorithm for $N$ disks.

🔥 Repeated: 2018 7.5 Marks
✍️ Model Answer:

Tower of Hanoi is a classic recursive puzzle consisting of three vertical pegs or towers: Source (A), Auxiliary / Helper (B), and Destination (C), with $N$ disks of different diameters.

Rules of the Puzzle:

  1. Only one disk can be moved at a time.
  2. A disk can only be taken from the top of one peg and placed on top of another.
  3. No larger disk can ever be placed on top of a smaller disk.

Recursive Strategy for $N$ Disks:

  • Step 1: Recursively move top $N-1$ disks from Source (A) to Auxiliary (B) using Destination (C).
  • Step 2: Move the remaining $N$-th (largest) disk directly from Source (A) to Destination (C).
  • Step 3: Recursively move $N-1$ disks from Auxiliary (B) to Destination (C) using Source (A).
#include <stdio.h>

void towerOfHanoi(int n, char from_peg, char to_peg, char aux_peg) {
    if (n == 1) { // Base Case
        printf("Move disk 1 from %c to %c\n", from_peg, to_peg);
        return;
    }
    towerOfHanoi(n - 1, from_peg, aux_peg, to_peg);
    printf("Move disk %d from %c to %c\n", n, from_peg, to_peg);
    towerOfHanoi(n - 1, aux_peg, to_peg, from_peg);
}

int main() {
    int n = 3; // 3 disks
    printf("Steps for 3 disks:\n");
    towerOfHanoi(n, 'A', 'C', 'B'); // Total steps = 2^3 - 1 = 7
    return 0;
}
Mathematical Complexity: For $N$ disks, total moves required $= 2^N - 1$. Time Complexity is exponential: $O(2^N)$. Space Complexity is $O(N)$ for recursion call stack.

Q19. What is a Function? Explain its types (Library vs User-Defined) and function anatomy.

🔥 Repeated: 2015, 2017, 2018 7.5 Marks
✍️ Model Answer:

A Function is a self-contained, modular subprogram containing a block of code designed to perform a specific task, promoting code reusability and structured debugging.

Two Types of Functions in C:

  1. Library (Built-in) Functions: Pre-compiled functions included in the standard C compiler library headers (e.g., printf(), scanf() in <stdio.h>; sqrt(), pow() in <math.h>).
  2. User-Defined Functions: Created by the programmer to solve custom application logic.

Three Elements of a User-Defined Function:

// 1. Function Declaration (Prototype): Tells compiler name, return type & parameters
int add(int a, int b);

int main() {
    // 2. Function Call: Transmits control and actual arguments
    int result = add(15, 30);
    printf("Sum = %d\n", result);
    return 0;
}

// 3. Function Definition: Contains the actual executable body
int add(int a, int b) {
    return a + b;
}

Q20. Explain Decision Making structures in C with emphasis on switch-case vs if-else-if ladder.

🔥 Repeated: 2015, 2017, 2018 7.5 Marks
✍️ Model Answer:

Decision making structures evaluate a boolean expression and alter the linear control flow based on whether the condition evaluates to True (non-zero) or False (zero).

Featureswitch-case Statementif-else-if Ladder
Test ExpressionCan only test for equality against fixed integer or character constants.Can test relational expressions (>, <, >=), logical conditions, and float values.
Execution SpeedFaster because compiler builds a jump/branch table.Evaluates conditions sequentially from top to bottom.
Break StatementRequired after each case to prevent fall-through.Not needed; once a block executes, ladder terminates.

Q21. Write a complete C program to find the largest among three numbers using nested if-else.

🔥 Repeated: 2020 7.5 Marks
✍️ Model Answer:
#include <stdio.h>

int main() {
    int a, b, c, largest;
    printf("Enter three integer values: ");
    scanf("%d %d %d", &a, &b, &c);

    // Nested if-else decision logic
    if (a >= b) {
        if (a >= c)
            largest = a;
        else
            largest = c;
    } else {
        if (b >= c)
            largest = b;
        else
            largest = c;
    }

    printf("The largest number among %d, %d, and %d is: %d\n", a, b, c, largest);
    return 0;
}

Q22. Explain Console-based Input/Output functions in C (Formatted vs Unformatted).

🔥 Repeated: 2019 7.5 Marks
✍️ Model Answer:
  • Formatted I/O Functions: Format specifiers (%d, %f, %c, %s) control the layout, alignment, and data type representation.
    • printf("format string", arg1, arg2);: Writes formatted output to standard display.
    • scanf("format string", &var1, &var2);: Reads formatted input from standard keyboard into memory addresses.
  • Unformatted I/O Functions: Deal with raw character or string streams without format specifiers.
    • getchar() / putchar(ch): Reads / writes a single character.
    • gets(str) / puts(str): Reads / writes a full line of string until newline.
SECTION C • 15 MARKS EACH

Long Descriptive Questions, Algorithms & Complete Programs

CCSU Examination Blueprint: Attempt Any 3 out of 5 • 45 Marks Total

Q23. Write a flowchart to find the average of the marks obtained by a student in five subjects and determine whether the student has passed or failed.

🔥 Repeated: 2017 7.5 Marks
✍️ Model Answer:

A flowchart provides a pictorial representation of the step-by-step logic to read five subject marks, compute their cumulative total and average, and branch conditionally based on a passing threshold (standard passing grade: $ ext{Average} \ge 40\%$).

📊 FLOWCHART 3 : Student Average Marks in 5 Subjects (CCSU Dec 2017) Authentic Vector SVG Diagram
START Input Marks: M1, M2, M3, M4, M5 (Marks obtained in 5 subjects) Total = M1 + M2 + M3 + M4 + M5 Average = Total / 5.0 Is Average >= 40? (Passing Standard) YES Print "PASS" & Print Average NO Print "FAIL" & Print Average STOP
Visual Vector Flowchart: Illustrating 5-subject marks processing, arithmetic calculation, and conditional branching for Pass/Fail grade determination.
Accompanying C Program Implementation:
#include <stdio.h>

int main() {
    float m1, m2, m3, m4, m5;
    float total, average;

    // Step 1: Input marks for 5 subjects
    printf("Enter marks obtained in 5 subjects (out of 100):
");
    scanf("%f %f %f %f %f", &m1, &m2, &m3, &m4, &m5);

    // Step 2 & 3: Calculate Cumulative Total and Average
    total = m1 + m2 + m3 + m4 + m5;
    average = total / 5.0;

    // Step 4: Display Computed Metrics & Determine Status
    printf("
================ RESULT REPORT ================
");
    printf("Total Marks Obtained : %.2f / 500.00
", total);
    printf("Percentage / Average : %.2f%%
", average);

    if (average >= 40.0) {
        printf("Final Academic Result: PASSED (First Class / Good Standing)
");
    } else {
        printf("Final Academic Result: FAILED (Supplementary Required)
");
    }
    printf("===============================================
");

    return 0;
}

Q24. Explain the structure of a 'C' program with the help of a suitable diagram and complete example.

🔥 Repeated: 2019 7.5 Marks
✍️ Model Answer:

A C program adheres to a well-defined modular structure consisting of six standard hierarchical sections. Knowing the exact sequence is essential for writing clean, error-free C applications that compile seamlessly.

1. Documentation Section

Contains comments specifying program name, author, purpose, and date using /* ... */ or //. Ignored by compiler.

2. Link / Preprocessor Section

Contains #include directives linking standard library header files (e.g., <stdio.h>, <math.h>) to provide required functions.

3. Definition Section

Declares symbolic constants and macros using #define, e.g., #define PI 3.14159 and #define MAX 100.

4. Global Declaration Section

Declares global variables accessible across all functions, user-defined types (struct/union), and function prototypes.

5. main() Function Section

The mandatory starting execution point. Divided into Declaration Part (local variables) and Executable Part (logic statements).

6. Subprogram Section

Contains full definitions of all user-defined functions called from main(), promoting modular code organization.

Comprehensive Code Example Illustrating All 6 Sections:
/* ==============================================================
 * SECTION 1: DOCUMENTATION SECTION
 * Program: Circle Geometry Calculator
 * Author : IncStudy CCSU Academic Team
 * ============================================================== */

// SECTION 2: LINK SECTION
#include <stdio.h>

// SECTION 3: DEFINITION SECTION
#define PI 3.14159265359

// SECTION 4: GLOBAL DECLARATION SECTION
int calculationCount = 0;           // Global variable
float calculateCircleArea(float r); // Function Prototype

// SECTION 5: MAIN FUNCTION SECTION
int main() {
    // (a) Declaration Part (Local Variables)
    float radius, area;

    // (b) Executable Part
    printf("Enter radius of the circle: ");
    scanf("%f", &radius);

    area = calculateCircleArea(radius); // Function Call
    calculationCount++;

    printf("Radius: %.2f | Computed Area: %.4f sq units
", radius, area);
    printf("Total Calculations Performed: %d
", calculationCount);

    return 0; // Successful Termination
}

// SECTION 6: SUBPROGRAM / USER-DEFINED FUNCTION SECTION
float calculateCircleArea(float r) {
    return PI * r * r;
}

Q25. What do you understand by Storage Classes in C? Explain auto, static, extern, and register with comparison table and code.

🔥 Repeated: 2015, 2017, 2019, 2023 15 Marks
✍️ Model Answer:

A Storage Class in C determines four fundamental attributes of any variable:

  1. Storage Location: Where the variable is physically placed in hardware (CPU Register, Stack RAM, or Data Segment RAM).
  2. Default Initial Value: What value it holds if uninitialized (Garbage vs Zero).
  3. Scope (Visibility): The region of the program where the variable can be referenced (Block scope vs File/Global scope).
  4. Lifetime (Longevity): The duration over which the variable retains its allocated memory.

Master Comparison Table:

Storage ClassStorage LocationDefault ValueScopeLifetime
autoStack Memory (RAM)Garbage (unpredictable)Local to enclosing blockUntil block terminates
registerCPU Register (if available)GarbageLocal to enclosing blockUntil block terminates
staticData Segment (RAM)Zero (0)Local to enclosing blockEntire program execution
externData Segment (RAM)Zero (0)Global (across all linked files)Entire program execution

Demonstrating Difference Between auto and static:

#include <stdio.h>

void demoFunction() {
    auto int normalVar = 1;     // Re-created on each call
    static int staticVar = 1;   // Initialized ONLY ONCE at program startup

    normalVar++;
    staticVar++;

    printf("auto = %d | static = %d\n", normalVar, staticVar);
}

int main() {
    printf("Call 1: "); demoFunction(); // Prints auto = 2 | static = 2
    printf("Call 2: "); demoFunction(); // Prints auto = 2 | static = 3 (Retained!)
    printf("Call 3: "); demoFunction(); // Prints auto = 2 | static = 4 (Retained!)
    return 0;
}
Examiner Key Note: The register keyword is only a hint to the compiler; if CPU registers are full, it defaults to auto. You cannot apply the address-of operator (&regVar) to a register variable because registers do not have a memory address!

Q26. Define Asymptotic Notations: Big-Oh ($O$), Big-Omega ($\Omega$), and Big-Theta ($\Theta$). Explain best, average, and worst-case complexity analysis.

🔥 Repeated: 2017, 2018, 2019 15 Marks
✍️ Model Answer:

Asymptotic Notations are mathematical notations used to describe the limiting behavior and growth rate of an algorithm's execution time as the input size $n$ tends to infinity ($n \to \infty$).

1. Big-Oh Notation ($O$) — Upper Bound (Worst-Case):

Big-Oh defines the maximum time an algorithm can take for any input of size $n$. It represents the worst-case ceiling.

Mathematical Definition: $f(n) = O(g(n))$ if there exist positive constants $c > 0$ and $n_0 \ge 1$ such that: $$0 \le f(n) \le c \cdot g(n) \quad \forall \; n \ge n_0$$

2. Big-Omega Notation ($\Omega$) — Lower Bound (Best-Case):

Big-Omega defines the minimum execution time required by an algorithm. It represents the best-case floor.

Mathematical Definition: $f(n) = \Omega(g(n))$ if there exist positive constants $c > 0$ and $n_0 \ge 1$ such that: $$0 \le c \cdot g(n) \le f(n) \quad \forall \; n \ge n_0$$

3. Big-Theta Notation ($\Theta$) — Tight Bound (Average-Case):

Big-Theta defines both the lower and upper bounds simultaneously. It represents the exact asymptotic rate of growth.

Mathematical Definition: $f(n) = \Theta(g(n))$ if there exist positive constants $c_1, c_2 > 0$ and $n_0 \ge 1$ such that: $$0 \le c_1 \cdot g(n) \le f(n) \le c_2 \cdot g(n) \quad \forall \; n \ge n_0$$

📈 GRAPHICAL PROOF : Asymptotic Curves & Threshold $n_0$ Exam Answer Sheet Diagram
Big-Oh: f(n) ≤ c·g(n) n T(n) n₀ c·g(n) f(n) Big-Omega: f(n) ≥ c·g(n) n T(n) n₀ f(n) c·g(n) Big-Theta: Sandwich Bound n T(n) n₀ c₂·g(n) f(n) c₁·g(n)

Algorithm: Finding Maximum Element of an Array with Complexity Analysis:

int findMax(int arr[], int n) {
    int max = arr[0];          // Step 1: 1 operation
    for (int i = 1; i < n; i++) { // Loop runs (n - 1) times
        if (arr[i] > max)      // Comparison: (n - 1) times
            max = arr[i];
    }
    return max;                // 1 operation
}
  • Best Case: Elements in descending order (e.g., $[10, 8, 5, 2]$). Number of comparisons $= n - 1$. Complexity is $\Omega(n)$.
  • Worst Case: Elements in ascending order (e.g., $[2, 5, 8, 10]$). Comparison and assignment occur every iteration. Complexity is $O(n)$.
  • Average Case: Elements in random order. Still requires $(n-1)$ comparisons. Complexity is $\Theta(n)$.

Q27. Explain all types of Operators in C with complete syntax, precedence, and associativity.

🔥 Repeated: 2017, 2018, 2023 15 Marks
✍️ Model Answer:

An Operator is a special character or symbol that instructs the compiler to perform specific mathematical, relational, or logical manipulations on operands.

Classification of Operators in C:

  1. Arithmetic Operators: + (Addition), - (Subtraction), * (Multiplication), / (Quotient division), % (Modulus remainder — operates only on integers).
  2. Relational Operators: Used for comparison; evaluate to 1 (True) or 0 (False): ==, !=, >, <, >=, <=.
  3. Logical Operators: Combine conditions:
    • && (Logical AND): True only if both operands are non-zero.
    • || (Logical OR): True if at least one operand is non-zero.
    • ! (Logical NOT): Inverts condition.
  4. Bitwise Operators: Work at the binary bit level: & (AND), | (OR), ^ (XOR), ~ (1's Complement), << (Left shift), >> (Right shift).
  5. Increment & Decrement Operators:
    • Prefix (++a): Increments first, then evaluates in expression.
    • Postfix (a++): Evaluates in expression first, then increments.
  6. Assignment Operators: Simple (=) and compound (+=, -=, *=, /=, %=).
  7. Conditional / Ternary Operator: exp1 ? exp2 : exp3.
  8. Special Operators: sizeof (memory size in bytes), comma operator , (links expressions), pointer dereference *, address-of &.

Operator Precedence & Associativity Table (Top Priority to Bottom):

Priority LevelOperatorsAssociativity
1 (Highest)Parentheses (), Array subscript [], Dot ., Arrow ->Left to Right
2 (Unary)Unary +, -, ++, --, !, ~, * (pointer), & (address), sizeofRight to Left
3 (Multiplicative)*, /, %Left to Right
4 (Additive)+, -Left to Right
5 (Shift)<<, >>Left to Right
6 (Relational)<, <=, >, >=Left to Right
7 (Equality)==, !=Left to Right
8 (Bitwise)&, then ^, then |Left to Right
9 (Logical)&&, then ||Left to Right
10 (Conditional)? :Right to Left
11 (Assignment)=, +=, -=, *=, etc.Right to Left
12 (Lowest)Comma operator ,Left to Right

Q28. Differentiate among goto, continue, break, and exit() statements with suitable code examples.

🔥 Repeated: 2019 15 Marks
✍️ Model Answer:
StatementScope of JumpCondition RequirementProgram Status
breakExits innermost loop or switch immediately.Usually placed inside an if block.Program execution continues at the statement after loop.
continueSkips current iteration of loop only.Placed inside an if block in a loop.Loop proceeds to next iteration condition check.
gotoUnconditional jump to any labeled statement in function.Unconditional jump (discouraged in structured code).Program jumps directly to label: location.
exit()Terminates the entire program immediately.Standard library function declared in <stdlib.h>.Flushes all I/O buffers and returns exit status to OS.
#include <stdio.h>
#include <stdlib.h>

int main() {
    for (int i = 1; i <= 5; i++) {
        if (i == 2) continue; // Skips printing 2
        if (i == 4) break;    // Stops loop before 4
        printf("i = %d\n", i); // Prints 1 and 3
    }

    int error = 1;
    if (error) {
        printf("Fatal Error Encountered. Terminating Program.\n");
        exit(0); // Closes entire application
    }

    printf("This will never print.\n");
    return 0;
}

Q29. Explain Problem Solving Techniques: Divide and Conquer, Brainstorming, and Trial & Error.

🔥 Repeated: 2015, 2016, 2019 15 Marks
✍️ Model Answer:

Problem-solving techniques are structured mental and algorithmic frameworks used by computer scientists to break down complex real-world requirements into computable software.

1. Divide and Conquer:

This technique breaks a large, complex problem down into multiple independent, smaller sub-problems of the same type, solves them recursively, and combines their solutions:

  • Divide: Partition problem $P$ into smaller subproblems $P_1, P_2, \dots, P_k$.
  • Conquer: Solve subproblems recursively. If subproblems are small enough (base case), solve directly.
  • Combine: Merge the solutions of subproblems into the solution for original problem $P$.
  • Real Programming Examples: Binary Search ($O(\log n)$), Merge Sort ($O(n \log n)$), Quick Sort.

2. Brainstorming Technique:

  • A group creativity technique where developers collaborate to generate a large list of spontaneous ideas and architectural strategies to solve a problem without initial criticism.
  • It consists of two phases: Idea Generation Phase (quantity over quality) and Evaluation / Pruning Phase (analyzing feasibility, cost, algorithmic efficiency, and constraints).

3. Trial and Error (Heuristic Search):

  • A fundamental problem-solving method where multiple attempts/hypotheses are tried until a successful result is found or an error is detected.
  • Used in programming for debugging unknown edge cases and in artificial intelligence backtracking algorithms (e.g., solving Sudoku, N-Queens problem).

Q30. Core C Programs Pack: Prime Number Check, Factorial, Reverse & Palindrome, and Fibonacci Series.

🔥 Repeated Across All Years 15 Marks
✍️ Model Answer:

Program 1: Check Prime Number (2015):

#include <stdio.h>

int main() {
    int n, isPrime = 1;
    printf("Enter a positive integer: ");
    scanf("%d", &n);

    if (n <= 1) isPrime = 0; // 0 and 1 are not prime
    for (int i = 2; i * i <= n; i++) { // Optimized check up to sqrt(n)
        if (n % i == 0) {
            isPrime = 0;
            break;
        }
    }

    if (isPrime) printf("%d is a PRIME number.\n", n);
    else printf("%d is NOT a prime number.\n", n);
    return 0;
}

Program 2: Reverse of an $N$-Digit Number and Palindrome Check (2019):

#include <stdio.h>

int main() {
    int num, original, rev = 0, rem;
    printf("Enter an integer: ");
    scanf("%d", &num);

    original = num;
    while (num != 0) {
        rem = num % 10;
        rev = rev * 10 + rem;
        num = num / 10;
    }

    printf("Reversed Number: %d\n", rev);
    if (original == rev)
        printf("%d is a PALINDROME number.\n", original);
    else
        printf("%d is NOT a palindrome.\n", original);

    return 0;
}

Program 3: Fibonacci Series up to $N$ Terms (2018):

#include <stdio.h>

int main() {
    int n, t1 = 0, t2 = 1, nextTerm;
    printf("Enter number of terms: ");
    scanf("%d", &n);

    printf("Fibonacci Series: ");
    for (int i = 1; i <= n; i++) {
        printf("%d ", t1);
        nextTerm = t1 + t2;
        t1 = t2;
        t2 = nextTerm;
    }
    printf("\n");
    return 0;
}

Q31. Write a complete C program to multiply two $3 \times 3$ matrices. Explain the mathematical condition and analyze time complexity.

🔥 Repeated: 2023 15 Marks
✍️ Model Answer:

Condition for Matrix Multiplication: Multiplication between matrix $A_{m \times k}$ and matrix $B_{k \times n}$ is mathematically valid if and only if the number of columns in the first matrix equals the number of rows in the second matrix. The resulting matrix $C$ has dimensions $m \times n$.

#include <stdio.h>

int main() {
    int a[3][3], b[3][3], c[3][3];
    int i, j, k;

    printf("Enter 9 elements of Matrix A (3x3):\n");
    for (i = 0; i < 3; i++)
        for (j = 0; j < 3; j++)
            scanf("%d", &a[i][j]);

    printf("Enter 9 elements of Matrix B (3x3):\n");
    for (i = 0; i < 3; i++)
        for (j = 0; j < 3; j++)
            scanf("%d", &b[i][j]);

    // Matrix Multiplication logic using 3 nested loops
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            c[i][j] = 0;
            for (k = 0; k < 3; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    printf("\nResultant Product Matrix C (3x3):\n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            printf("%d\t", c[i][j]);
        }
        printf("\n");
    }

    return 0;
}
Complexity Analysis:
  • Time Complexity: $O(n^3)$ because there are three nested loops iterating from $0$ to $2$. For arbitrary $n \times n$ matrices, it requires $n^3$ multiplications.
  • Space Complexity: $O(n^2)$ to store the matrices in two-dimensional contiguous memory arrays.

Q32. Write an algorithm for finding the maximum element of an array, and perform best, worst, and average case complexity analysis with appropriate order notations.

🔥 Repeated: 2018 15 Marks
✍️ Model Answer:

Finding the maximum element among $n$ elements in an unsorted array is a fundamental computing problem. We examine both the formal algorithm, full C implementation, and rigorous asymptotic complexity derivations across all cases.

1. Formal Step-by-Step Algorithm:
Step 1: START
Step 2: Input array $A$ of size $n$, where $n \ge 1$.
Step 3: Initialize largest = A[0] (assume 1st element is the largest).
Step 4: Initialize loop counter i = 1.
Step 5: Repeat Steps 6–7 while i < n:
        Step 6: If A[i] > largest, then assign largest = A[i].
        Step 7: Increment i = i + 1.
Step 8: Print "Maximum Element is: ", largest.
Step 9: STOP.
2. Complete C Program:
#include <stdio.h>

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

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

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

    // Scan through remaining n - 1 elements
    for (i = 1; i < n; i++) {
        if (arr[i] > largest) {
            largest = arr[i]; // Update largest
        }
    }

    printf("
--- Result ---
");
    printf("The Maximum Element in the array is: %d
", largest);
    return 0;
}
3. Asymptotic Complexity Derivation (Best, Worst, Average Case):

In this algorithm, the dominant basic operation is the comparison arr[i] > largest and the secondary operation is the assignment largest = arr[i].

Analysis Case Condition / Array Distribution Comparisons Assignments Time Complexity
Best Case ($\Omega$) Array is sorted in strictly descending order (e.g., [99, 80, 65, 40, 10]). The maximum element is already at index 0. $n - 1$ $0$ updates $\mathbf{\Theta(n)}$ time, $\mathbf{\Omega(1)}$ assignments
Worst Case ($O$) Array is sorted in strictly ascending order (e.g., [10, 25, 40, 75, 99]). Every new element is greater than all previous elements. $n - 1$ $n - 1$ updates $\mathbf{\Theta(n)}$ time, $\mathbf{O(n)}$ assignments
Average Case ($\Theta$) Array elements are in random, uniform permutations. Probability that element at index $i$ is greater than all preceding $i$ elements is $1/(i+1)$. $n - 1$ $\sum_{i=1}^{n-1} rac{1}{i+1} = H_n - 1 pprox \ln n$ updates $\mathbf{\Theta(n)}$ comparisons, $\mathbf{\Theta(\log n)}$ assignments

Space Complexity: The algorithm requires only a fixed number of scalar variables (largest, i, n). Thus, the auxiliary space complexity is strictly $\mathbf{O(1)}$ (constant space).

Q33. Differentiate between a Flowchart and an Algorithm. Write an algorithm and complete C program to compute the Fibonacci series for 'n' terms.

🔥 Repeated: 2018 15 Marks
✍️ Model Answer:
1. 6-Point Comparison Table: Algorithm vs Flowchart:
Comparison Parameter Algorithm Flowchart
1. Definition A finite sequence of well-defined, step-by-step written logical instructions to solve a given task. A visual or diagrammatic representation of an algorithm using standardized geometrical shapes connected by arrows.
2. Representation Textual format using structured natural language (English) or pseudocode. Graphical / Pictorial format (Ovals, Rectangles, Diamonds, Parallelograms).
3. Modification Very easy to modify; new steps can be inserted or re-ordered with simple text edits. Difficult to modify; changing a single condition often requires erasing and redrawing branches and layout.
4. Debugging & Flow Analysis Harder to trace complex nested loops and multi-way branch conditions in large texts. Extremely intuitive to visualize control flow, loop back-edges, and dead-end logic paths.
5. Standard Rules No rigid graphical constraints; uses conventions like START, INPUT, IF-THEN, STOP. Governed by strict ANSI/ISO graphic standards (e.g., arrows must point to next valid symbol).
6. Target Audience Primarily used by software engineers and algorithms researchers for coding and complexity profiling. Ideal for non-technical stakeholders, business analysts, systems documentation, and student learning.
2. Fibonacci Series Algorithm ($F_n = F_{n-1} + F_{n-2}$ with $F_0=0, F_1=1$):
Step 1: START
Step 2: Input number of terms $n$.
Step 3: If $n \le 0$, print "Invalid term count" and jump to Step 9.
Step 4: Initialize first two terms: f1 = 0, f2 = 1.
Step 5: If $n = 1$, print f1 and jump to Step 9.
Step 6: Print f1 and f2. Set term counter count = 2.
Step 7: While count < n, repeat:
        (a) next = f1 + f2
        (b) Print next
        (c) Update: f1 = f2, f2 = next
        (d) count = count + 1
Step 8: Print newline.
Step 9: STOP.
3. Complete C Program:
#include <stdio.h>

int main() {
    int n, i;
    long long f1 = 0, f2 = 1, next;

    printf("Enter number of terms to generate in Fibonacci sequence: ");
    scanf("%d", &n);

    if (n <= 0) {
        printf("Error: Number of terms must be a positive integer greater than 0.
");
        return 1;
    }

    printf("
Fibonacci Series for first %d terms:
", n);
    if (n == 1) {
        printf("%lld
", f1);
    } else {
        printf("%lld, %lld", f1, f2);
        for (i = 3; i <= n; i++) {
            next = f1 + f2;
            printf(", %lld", next);
            f1 = f2;
            f2 = next;
        }
        printf("
");
    }

    return 0;
}

Dry Run Trace for $n = 7$: Generated sequence is 0, 1, 1, 2, 3, 5, 8. Time complexity is $\Theta(n)$ and space complexity is $O(1)$.

Q34. What are Header Files in C? Explain Standard Library Headers vs User-Defined Header Files, the difference between #include <...> and #include "...", and how Header Guards prevent multiple inclusion errors.

🔥 Repeated: 2016, 2019 15 Marks
✍️ Model Answer:
1. Definition and Role of Header Files:

A header file in C is a source file with the .h extension that contains function prototypes, macro definitions, data structure definitions (struct, union), and global variable declarations intended to be shared across multiple source (.c) files. They enable modular programming, information hiding, and clean separate compilation.

2. Standard Library Headers vs User-Defined Headers:
Category Syntax Search Directory Mechanism Common Examples
Standard Library Headers #include <filename.h> Preprocessor searches exclusively in standard system/compiler include directories (e.g., /usr/include or MinGW include folder). <stdio.h> (I/O: printf, scanf)
<stdlib.h> (malloc, exit, rand)
<string.h> (strlen, strcpy, strcmp)
<math.h> (sqrt, pow, sin, cos)
User-Defined Headers #include "filename.h" Preprocessor searches first in the current directory where the source file resides; if not found, it falls back to standard system paths. "my_math.h"
"student_records.h"
"matrix_ops.h"
3. What Does a Header File Typically Contain?
  • Function Prototypes: Informs the compiler of function names, return types, and parameter lists without providing implementation bodies (e.g., int computeGCD(int a, int b);).
  • Macro & Constant Definitions: Symbolic constants like #define MAX_BUFFER 1024.
  • Type Definitions: Custom typedef and struct templates.
  • External Variable Declarations: Using extern int globalErrorCode;.
4. The Multiple Inclusion Problem and Header Guards:

When multiple .c or .h files include the same header file directly or indirectly, the compiler encounters duplicate structure or variable definitions, causing compilation failures. To prevent this, standard C employs Header Guards using preprocessor conditional directives:

/* File: my_math.h */
#ifndef MY_MATH_H    /* If MY_MATH_H is not yet defined */
#define MY_MATH_H    /* Define MY_MATH_H */

// Function Prototypes
int add(int a, int b);
int multiply(int a, int b);
double power(double base, int exp);

#endif /* MY_MATH_H */

How it works: The first time the file is included, MY_MATH_H is undefined, so the preprocessor defines it and processes the contents. On any subsequent inclusion during the same compilation unit, #ifndef evaluates to false and the entire header body is skipped instantly!

Q35. Explain Local and Global Variables with respect to scope, lifetime, memory allocation, and default initial values. Illustrate Variable Shadowing with a complete C demonstration program.

🔥 Repeated: 2017 15 Marks
✍️ Model Answer:

In C programming, the accessibility and duration of any identifier are governed by two fundamental concepts: Scope (where the variable can be accessed) and Lifetime / Storage Duration (how long the variable occupies memory during execution).

1. Detailed Comparison Table: Local vs Global Variables:
Feature / Metric Local Variable Global Variable
Declaration Location Declared inside a function body or compound block enclosed by { ... }. Declared outside all functions, typically at the top of the C source file.
Scope (Visibility) Block Scope: Accessible only within the enclosing function or block where declared. File Scope: Accessible throughout the entire source file from the point of declaration.
Lifetime Created when function/block execution begins and destroyed immediately when the block exits. Retained in memory throughout the entire duration of the program execution from start to finish.
Memory Segment Allocated dynamically on the Call Stack. Allocated statically in the Data Segment (BSS if uninitialized, initialized data segment if initialized).
Default Initial Value Contains unpredictable Garbage Values if not explicitly initialized by the programmer. Automatically initialized to Zero (0, 0.0, or NULL) by the runtime environment.
Storage Class Default is auto (can also be register or static). Default is external linkage (extern). Can be restricted to current file using static.
2. Variable Shadowing (Name Precedence Rule):

When a local variable within an inner block is declared with the exact same identifier name as a global variable, the local variable shadows (hides) the global variable within that scope. All read and write operations inside the block operate strictly on the local instance.

3. Complete Demonstration C Program:
#include <stdio.h>

// GLOBAL VARIABLE (File Scope, Static Lifetime, Initialized to 0 by default)
int counter = 100;

void testFunction() {
    // Accesses global variable counter
    printf("[testFunction] Global counter value: %d
", counter);
    counter += 25; // Modifying global variable
}

int main() {
    printf("[main: Start] Global counter value: %d
", counter);

    // LOCAL VARIABLE shadowing the global variable of identical name
    int counter = 5; 
    printf("[main: Local Scope] Shadowed local counter: %d
", counter);

    // Inner block demo
    {
        int counter = 999; // Inner block variable shadows main's local counter
        printf("[main: Inner Block] Deeply nested counter: %d
", counter);
    }

    printf("[main: Local Scope] Local counter restored: %d
", counter);

    // Calling external function that operates on global counter
    testFunction();
    printf("[main: End] Global counter after testFunction: %d
", counter); // Still prints local!

    return 0;
}
4. Program Output and Analytical Walkthrough:
[main: Start] Global counter value: 100
[main: Local Scope] Shadowed local counter: 5
[main: Inner Block] Deeply nested counter: 999
[main: Local Scope] Local counter restored: 5
[testFunction] Global counter value: 100
[main: End] Global counter after testFunction: 5