Question bank

Question Bank - IA1

1. System Development Life Cycle (SDLC)

The System Development Life Cycle (SDLC) is a step-by-step process used to design, develop, test, and maintain high-quality software systems. It ensures that software is created in a structured, organized, and efficient way.

Why SDLC is Important:

• Provides a systematic approach to software development.
• Reduces the chances of project failure.
• Improves planning, documentation, and testing.
• Ensures that user requirements are clearly defined and met.
• Allows for better communication among teams and stakeholders.

The Waterfall Model

One of the earliest and most popular SDLC models is the Waterfall Model. It follows a linear and sequential flow — meaning each phase must be completed before the next one begins.

(Waterfall Model Diagram)

Phases of the Waterfall Model:

• 1. System Requirements:
  • Define what the system should do.
  • Gather input from users and stakeholders.
  • Output: A clear list of system goals and user requirements.
• 2. System Analysis:
  • Analyze the system requirements in detail.
  • Identify possible solutions and select the best one.
  • Focus on “what” the system must achieve, not “how.”
• 3. System Design:
  • Plan “how” the system will be built.
  • Design data flow, architecture, user interfaces, and databases.
  • Decide on hardware, software, and communication needs.
• 4. Coding (Implementation):
  • Actual programs are written using a programming language (like C).
  • Each module is coded, compiled, and tested individually.
  • This is the phase explained in this book!
• 5. Testing:
  • All modules are combined and tested as a complete system.
  • Ensures the software works correctly and meets requirements.
  • Defects and bugs are identified and corrected.
• 6. Deployment:
  • The finished system is installed and delivered to the users.
  • Training and documentation are provided for smooth usage.
• 7. Maintenance:
  • Continuous support after deployment.
  • Fix bugs, add updates, and improve performance over time.
  • Keeps the system reliable and up to date.

Iteration in the Waterfall Model:

• Although it seems linear, phases often overlap in real life.
• Developers may need to go back to a previous phase if errors are found.
• This backflow is shown as “feedback arrows” in the waterfall diagram.

2. Compilers vs. Interpreters

Understanding the difference between compilation and interpretation is crucial in programming. Both processes translate human-readable source code into a form that a computer can execute, but they differ significantly in how and when this translation occurs. The C language, being a compiled language, relies heavily on the efficiency of the compiler.

Comparison Table:

3. Structure of a C Program or Basic Concepts of a C Program

All C programs consist of one or more functions, with main() being the essential starting point.

General Form of a C Program:

1. Comments

   • At the beginning of each program is a comment with a short description of the problem to be solved.
   • We can use the comments anywhere in the program.
   • The comments section is optional.
     Ex: 1. /* Program1: To find the sum of two numbers*/
     2. // Program2: To calculate the area and perimeter of circle
   • The symbol /* and ends with */ represents the multiline comment.
   • The symbol // can also be used for representing single line comment.

2. Preprocessor directives

   • The preprocessor statements start with # symbol.
   • These statements instruct the compiler to include some of the files in the beginning of the program.
     Ex: #include<stdio.h>
     #include<math.h>
     are the files that the compiler includes in the beginning of the program.
   • The line containing #include<stdio.h> tells the compiler to allow our program to perform standard input and output 'stdio' operations.
   • The '#include' directive tells the compiler that we will be using parts of the standard function library.
   • Information about these functions is contained in a series of 'header files' (stdio.h).  .h says this file is a header file.
   • The pointed brackets < and > tell the compiler the exact location of this header file.
   • Using the preprocessor directives the user can define the constants also.
     Ex: #define PI 3.142

3. Global Declarations

   • The variables that are declared above (before) the main program are called global variables.
   • The global variables can be accessed anywhere in the main program and in all the other functions.

4. Function declarations and Definitions

   • In this section the functions are declared.
   • Immediately after the functions are declared, the functions can be defined.

5. The program header: main()

   • Every program must have a main function.
   • Always the C program begins its execution from main.

6. Body of the program

   • After the header or top lines is a set of braces ({ and }) containing a series of 'C' statements which comprise the 'body'- this is called the action portion of the program.
     #include <stdio.h>
main(void) {
   /* action portion of the program*/
}

   • The global variables can be accessed anywhere in the main program and in all the other functions.

7. Declaration section

   • The variables that are used inside the function should be declared in the declaration section.
   • For example, consider the declaration shown below:
     int sum=0;
     int a;
     float b;
     Here, the variable sum is declared as an integer variable and it is initialized to zero.
     The variable a is declared as an integer variable whereas the variable b is declared as a floating point variable.

8. Executable section

   • They represent the instructions given to the computer to perform a specific task.
   • The instructions can be input/output statements, expressions to be evaluated, simple assignment statements, control statements such as if statement, for statement etc.
   • Each executable statement ends with “;”. Example: Write a C program to display “Hello World”.
     #include <stdio.h>
void main(void) {
   printf(“Hello World”);
}


4. Storage Class Specifiers in C

Storage classes define how and where a variable is stored, its scope (where it can be used), and its lifetime (how long it exists).

• There are four main storage classes in C:
• auto
• register
• static
• extern

1. auto

• Default for local variables inside functions.
• Created when function starts, destroyed when it ends.
• Stored in memory (RAM).
• No need to write auto explicitly.

2. register

• Stored in CPU register for faster access.
• Used for frequently used variables like loop counters.
• You cannot use & to get its address.

3. static

• Remembers its value between function calls.
• Local static → keeps value across calls.
• Global static → visible only inside the file.

4. extern

• Used to declare a variable defined in another file.
• Does not create new memory.
• Used for sharing global variables between files.

Summary

5. Explain Any 5 Operators in C

Operators in C are special symbols that perform specific operations on operands (variables or values). They are fundamental for performing calculations, making decisions, and controlling program flow. Below are five important types of operators with detailed explanations and examples.

1. Arithmetic Operator (+, -, *, /, %)

   • Used to perform basic mathematical operations on numerical values.
   • Common arithmetic operators are:

   Operator	Meaning	Example
   +	Addition	a + b → Adds a and b
   -	Subtraction	a - b → Subtracts b from a
   *	Multiplication	a * b → Multiplies a and b
   /	Division	a / b → Divides a by b (integer division if both are integers)
   %	Modulus	a % b → Gives the remainder after division

   int a = 10, b = 3;
printf("%d \n", a + b); // 13
printf("%d \n", a % b); // 1

2. Relational Operator (>, <, >=, <=, ==, !=)

   • Used to compare two values. The result is either true (1) or false (0).

   Operator	Meaning	Example
   >	Greater than	a > b
   <	Less than	a < b
   >=	Greater than or equal to	a >= b
   <=	Less than or equal to	a <= b
   ==	Equal to	a == b
   !=	Not equal to	a != b

   int x = 5, y = 8;
printf("%d \n", x < y); // 1 (true)
printf("%d \n", x == y); // 0 (false)

3. Logical Operator (&&, ||, !)

   • Used to combine multiple conditions or invert logical results.
   • In C, nonzero values are considered true and zero as false.

   Operator	Meaning	Example
   &&	Logical AND	(a < b) && (b < 20)
   ||	Logical OR	(a > b) || (b < 20)
   !	Logical NOT	!(a == b)

   int a = 5, b = 10;
printf("%d \n", (a < b) && (b < 20)); // 1
printf("%d \n", !(a == 5)); // 0

4. Assignment Operator (=, +=, -=, *=, /=, %=)

   • Used to assign or modify the value of a variable.
   • Compound assignment operators combine an operation with assignment for brevity.

   Operator	Meaning	Example
   =	Assigns value	a = 10;
   +=	Add and assign	a += 5; → a = a + 5;
   -=	Subtract and assign	a -= 3; → a = a - 3;
   *=	Multiply and assign	a *= 2; → a = a * 2;
   /=	Divide and assign	a /= 2; → a = a / 2;
   %=	Modulus and assign	a %= 3; → a = a % 3;

   int x = 10;
x += 5; // x = 15
x *= 2; // x = 30

5. Increment/Decrement Operator (++, --)

   • Used to increase or decrease the value of a variable by 1.
   • Can be used in:
     • Prefix form (++x, --x): changes value before use
     • Postfix form (x++, x--): changes value after use

   Operator	Meaning	Example
   ++	Increment by 1	x++ or ++x
   --	Decrement by 1	x-- or --x

   int x = 5;
printf("%d ", ++x); // 6
printf("%d", x--); // 6, then x = 5

6. Identifiers and Variables in C

Identifiers

Definition: Identifiers are names given to variables, functions, labels, and other user-defined elements.

Variables

A variable is a named memory location that stores a value which may change during program execution. Every variable must be declared before use.

• Must begin with a letter (a-z, A-Z) or an underscore (_).
• Subsequent characters may include letters, digits (0-9), or underscores.
• Cannot include special symbols like !, @, or spaces.
• Identifiers are case-sensitive, so count, Count, and COUNT are all distinct.
• Keywords such as int, while, for cannot be used as identifiers.
• Correct Examples: count, test23, high_balance
• Incorrect Examples: 1count, hi!there, high...balance

7. Discuss Local and Global Declaration

In C programming, variables can be declared either locally inside a function or globally outside all functions. The place of declaration decides where the variable can be accessed.

1. Local Variables

• Declared inside a function or block.
• Can be used only within that function.
• Memory is allocated when the function is called and freed when it ends.
• Not known to other functions.

Output:

2. Global Variables

• Declared outside all functions (usually at the top of the program).
• Can be accessed by any function within the same program file.
• Memory remains allocated throughout program execution.
• Useful for sharing data between multiple functions.

Example Program:

8. The Four Scopes in C

In C programming, every variable or constant has a scope — which defines where in the program it can be accessed or modified. There are four types of scopes in C:

File Scope

• A variable declared using static outside all functions has file scope.
• Such a variable is accessible anywhere within the same file but not visible to other files.
• Commonly used to restrict global variable usage within a single file.

Block Scope

• Declared inside a block of code enclosed by { }.
• Exists only until the block is active; destroyed once the control exits.
• Also known as local variables.
• Variables in inner blocks can mask variables of the same name in outer blocks.
• Variables declared in an outer block are accessible in nested blocks (if not re-declared).

Function Scope

• Applies only to labels used with the goto statement.
• A label is visible from the beginning to the end of the function in which it appears.
• Two labels with the same name cannot exist within one function.

Program Scope (Global Scope)

• Variables declared outside all functions have program or global scope.
• Accessible from any function within the program file.
• Memory is allocated at the start of the program and released only after it ends.
• If a local variable has the same name, it hides (masks) the global one inside that function.

Output:

9. Explain Input and Output Functions in C

Input and Output functions in C are used to take data from the user and display results on the screen. These are available in the stdio.h library and handle character, string, and formatted data efficiently.

Common Input Functions:

• scanf() - Reads formatted input (numbers, characters, strings).
• gets() - Reads a line of text including spaces (deprecated in modern C).
• getchar(), getch(), getche() - Read single characters.

Common Output Functions:

• printf() - Displays formatted output on the screen.
• puts() - Displays a string followed by a newline.
• putchar() - Prints a single character on the screen.

Reading Strings

If we declare a string as char str[100];, we can read it in three ways:

1. Using scanf()

• Syntax: scanf("%s", str);
• No & symbol needed for strings.
• Stops reading when it encounters a space.
• Cannot read full sentences with spaces.

2. Using gets()

• Syntax: gets(str);
• Reads an entire line including spaces.
• Automatically adds a null character ('\0') at the end.
• Overcomes the limitation of scanf().

3. Using getchar() Repeatedly

• Reads one character at a time until a terminating character is found.
• Each character is stored in an array.

Writing Strings

Strings can be displayed using three main methods:

1. Using printf()

• Syntax: printf("%s", str);
• Used to print formatted strings.
• Supports width and precision (e.g. printf("%5.3s", str); prints first 3 characters).
• Left justify using a minus sign (e.g. printf("%-5.3s", str);).

2. Using puts()

• Syntax: puts(str);
• Automatically adds a newline after the string.
• Simpler than printf() for plain string output.

3. Using putchar() Repeatedly

• Prints each character one by one until null character ('\0') is reached.

10. Distinguish Between while and do-while Loop

Both while and do-while loops are used for repetitive execution of statements based on a condition. However, they differ in how and when the condition is tested.

while Loop

• Executes a set of statements repeatedly as long as a specified condition is true.
• Condition is checked before entering the loop → called an Entry-Controlled Loop.
• If the condition is false initially, the loop body is skipped.
• Control moves to the statement immediately after the loop once the condition becomes false.

(while-Loop)

while Loop - Syntax

do-while Loop

• Executes a set of statements repeatedly at least once.
• The condition is tested after executing the loop body → called an Exit-Controlled Loop.
• Unlike for and while loops, which test the condition at the beginning, the do-while loop tests it at the end.
• The loop continues as long as the test expression is true.

(Flowchart-while-Loop)

do-while Loop - Syntax

Comparison Between while and do-while

11. Calculator Using switch Statement

12. Difference Between break and continue

Both break and continue are used to control loop execution, but they behave differently:

13. C Program to Find Roots of a Quadratic Equation

This program calculates the roots of a quadratic equation of the form ax² + bx + c = 0 using the discriminant method.

Code:

Compile and Run:

Sample Output:

14. Jump Statements in C

Jump statements are used to alter the flow of control in a program by jumping to another part of the code.

Types of Jump Statements:

• break:
  • Used to exit from a loop (for, while, do-while) or switch statement immediately.
  • Control passes to the statement immediately after the loop or switch.
  • Example:
  for(int i=1; i <=10; i++) {
    if(i==5) break;
    printf("%d ", i);
  }
• continue:
  • Skips the current iteration of a loop and moves to the next iteration.
  • Useful to skip some part of loop when a condition is met.
  • Example:
  for(int i=1; i <=10; i++) {
    if(i%2==0) continue;
    printf("%d ", i);
  }
• goto:
  • Transfers control unconditionally to a labeled statement within the same function.
  • Generally discouraged, but can be used for error handling or exiting nested loops.
  • Example:
  int i=1;
  loop:
    printf("%d ", i);
    i++;
    if(i<=5) goto loop;
• return:
  • Exits from a function and optionally returns a value to the calling function.
  • Example:
  int sum(int a, int b) {
    return a+b;
  }

15. Find Greatest of 3 Numbers

This program finds the largest of three numbers entered by the user using if-else statements.

Program:

Sample Output:

16. for Loop (Counter-Controlled Loop)

• Executes a set of statements repeatedly for a specific number of times.
• Also called an entry-controlled loop or pretest loop.
• Syntax:
  for(initialization; test expression; increment/decrement) {
  statement1;
  statement2;
  statement3;
}
statement x;
• Working Principle:
  • Initialization: Set the starting value of loop variable.
  • Test expression: Evaluated before each iteration; if true, loop executes, else control moves out.
  • Increment/Decrement: Updates loop variable after each iteration.
• Infinite Loop: Omitting the test expression creates an infinite loop.
  Example: for(i=0;;i++)
{
...
}


(flowchart-for-Loop-Flow-Diagram)

Examples:

• Print natural numbers 1 to 10:
  for(int i=1;i<=10;i++) {
    printf("%d \n", i);
  }
• Factorial of a number:
  int fact=1,n; scanf("%d",&n);
  for(int i=1;i<=n;i++) {
   fact*=i;
  }
  printf("Factorial=%d", fact);
  

17. Explain 3 types of array initialization

Introduction

An array is a collection of similar data elements stored under a single name. These elements all have the same data type and are stored in consecutive memory locations. Each element is identified by a unique index (subscript), which represents its position in the array.

(Arrays-in-C)

When an array is declared or memory is allocated, its elements may contain garbage values. Therefore, it is important to initialize the array with meaningful values.

1. Initializing Arrays during Declaration

• The elements of an array can be initialized at the time of declaration, just like any other variable.
• When initializing, provide a value for every element in the array.
• Syntax: type array_name[size] = {list of values};
• The values are enclosed in curly brackets and separated by commas.
• It is an error to specify more values than the declared size of the array.

Examples:

If fewer values are provided than the declared size, remaining elements are automatically filled with 0.

2. Inputting Values from the Keyboard

• Arrays can also be initialized by taking input from the keyboard.
• A for, while, or do-while loop is used to input values for each element.

Example:

3. Assigning Values to Individual Elements

• You can assign or modify individual array elements using the assignment operator.
• Example: marks[3] = 100; assigns 100 to the fourth element.
• To copy one array to another, copy each element individually using a loop.
• You can also use the loop index to assign calculated values to each element.

Examples:

18. Transpose of a Square Matrix

What is it?

The transpose of a matrix is obtained by interchanging its rows and columns. That means, the element at position [i][j] in the original matrix becomes the element at position [j][i] in the transposed matrix.

• We use two 2D arrays — one for the original matrix and one for the result.
• Nested loops are used to interchange elements.

Program:

Example Output:

    Enter size of square matrix: 3
    Enter elements of the matrix:
    1 2 3
    4 5 6
    7 8 9

    Transpose of the matrix:
    1 4 7
    2 5 8
    3 6 9