IGNOU MCS-011 Solved Question Paper PDF Download

IGNOU MCS-011 Previous Year Solved Question Paper in Hindi

IGNOU MCS-011 Previous Year Solved Question Paper in English

Q1. (a) Write an algorithm and draw a corresponding flowchart to find the reverse of a given number and check if it is a palindrome or not. (b) List and explain various categories of operators in C along with an example for each. (c) Write a C program to generate the following pattern: * (d) Write a C program to find the factorial of a given number using a recursive function.

Ans. (a) Algorithm and Flowchart to Reverse a Number and Check for Palindrome

Algorithm:

1. Start.
2. Read an integer variable num .
3. Store the value of num in another variable, originalNum .
4. Initialize a variable reverseNum to 0.
5. Repeat the following steps until num > 0:
   • digit = num % 10
   • reverseNum = ( reverseNum * 10) + digit
   • num = num / 10
6. Print reverseNum .
7. If originalNum == reverseNum , print “The number is a palindrome”.
8. Else, print “The number is not a palindrome”.
9. End.

Flowchart: (b) Categories of Operators in C

Operators in the C programming language are classified into the following categories:

• Arithmetic Operators: Used to perform mathematical calculations. Example: `int c = a + b;` (Here `+` is an arithmetic operator). Others are `-`, `*`, `/`, `%` (modulo).
• Relational Operators: Used to compare the relationship between two values. The result is always true (1) or false (0). Example: `if (a > b)` (Here `>` is a relational operator). Others are `<`, `>=`, `<=`, `==` (equal to), `!=` (not equal to).
• Logical Operators: Used to combine two or more conditions. Example: `if (a > 5 && b < 10)` (Here `&&` (AND) is a logical operator). Others are `||` (OR), `!` (NOT).
• Bitwise Operators: These operate on the bit level. Example: `int c = a & b;` (Here `&` (Bitwise AND) is a bitwise operator). Others are `|` (Bitwise OR), `^` (Bitwise XOR), `~` (Complement), `<<` (Left Shift), `>>` (Right Shift).
• Assignment Operators: Used to assign a value to a variable. Example: `int a = 10;` (Here `=` is an assignment operator). Others are `+=`, `-=`, `*=`, `/=`.
• Increment and Decrement Operators: These increment or decrement the value of a variable by 1. Example: `a++;` (Increment value of a by 1). `b–;` (Decrement value of b by 1).
• Conditional Operator: This is a ternary operator and is a shorthand for an if-else statement. Example: `int max = (a > b) ? a : b;` (If a > b, max = a, else max = b).

(c) C Program to Print the Pattern

#include <stdio.h>
int main() { int i, j; int rows = 5; // Number of rows
 // Outer loop for rows for (i = 1; i <= rows; i++) { // Inner loop to print '*' in each row for (j = 1; j <= i; j++) { printf("* "); } // Move to the next line printf("\n"); } return 0;}

(d) C Program for Factorial using a Recursive Function

#include <stdio.h>
// Recursive function to calculate factoriallong long factorial(int n) { // Base Case: if n is 0 or 1, factorial is 1 if (n <= 1) { return 1; } // Recursive Step: n * factorial of (n-1) else { return n * factorial(n - 1); }}
int main() { int num; printf("Enter a number: "); scanf("%d", &num);
 if (num < 0) { printf("Factorial is not defined for negative numbers.\n"); } else { printf("Factorial of %d = %lld\n", num, factorial(num)); }
 return 0;}

Q2. (a) What are the differences between a while loop and a do—while loop in C ? Provide C code to illustrate your explanation for both. (b) Write a C program to search a given element in the array. If value exists, then print that value along with its position (index) in the array otherwise display “element not found”. (c) Differentiate between call by value and call by reference with an example.

Ans. (a) Differences between `while` and `do-while` loop

Both `while` and `do-while` are looping constructs in C, but they have a crucial difference in how they operate. The main distinction is when the condition is evaluated.

• While Loop (Entry-Controlled Loop):
  • The `while` loop is called an entry-controlled loop .
  • The condition is checked before entering the body of the loop.
  • If the condition is false initially, the loop body will not execute even once.
  • Syntax: `while (condition) { // code to be executed }`
• Do-While Loop (Exit-Controlled Loop):
  • The `do-while` loop is called an exit-controlled loop .
  • The body of the loop is executed at least once, and then the condition is checked.
  • This guarantees that the loop body will run at least one time, even if the condition is initially false.
  • Syntax: `do { // code to be executed } while (condition);`

Example Code:

While loop example:

#include <stdio.h>int main() { int i = 5; printf("While loop example:\n"); // This loop will not execute as the condition i > 5 is false. while (i > 5) { printf("Value of i: %d\n", i); i++; } printf("End of while loop.\n"); return 0;}// Output:// While loop example:// End of while loop.

Do-While loop example:

#include <stdio.h>int main() { int i = 5; printf("Do-While loop example:\n"); // This loop will execute once, then check the condition. do { printf("Value of i: %d\n", i); i++; } while (i > 5); printf("End of do-while loop.\n"); return 0;}// Output:// Do-While loop example:// Value of i: 5// End of do-while loop.

(b) C Program to Search an Element in an Array

This program searches for an element in an array. If the element is found, it prints its position (index); otherwise, it displays a message.

#include <stdio.h>
int main() { int arr[] = {10, 25, 4, 42, 99, 76, 15}; int n = sizeof(arr) / sizeof(arr[0]); // Size of the array int element_to_find; int found = 0; // A flag to track if the element is found int index = -1; int i;
 printf("Enter an element to search for: "); scanf("%d", &element_to_find);
 // Loop through the array for (i = 0; i < n; i++) { if (arr[i] == element_to_find) { found = 1; // Set the flag to 1 index = i; // Store the index break; // Element is found, exit the loop } }
 // Display the result if (found == 1) { printf("Element %d found at index %d in the array.\n", element_to_find, index); } else { printf("Element %d not found in the array.\n", element_to_find); }
 return 0;}

(c) Call by Value vs. Call by Reference

These are two ways of passing parameters to a function.

• Call by Value:
  • In this method, a copy of the actual argument being passed to the function is made and given to the formal parameter of the function.
  • Any changes made to the parameter inside the function do not affect the original argument.
  • This is the default method in C.
• Call by Reference:
  • In this method, the address of the argument is passed to the function.
  • Inside the function, the parameter stores the address of the original argument. Therefore, any change made to the parameter using pointers will change the value of the original variable.
  • In C, this is achieved using pointers.

Example: Swapping two numbers.

Example of Call by Value (will not work for swapping):

#include <stdio.h>void swap(int x, int y) { int temp = x; x = y; y = temp; printf("Inside swap function: x = %d, y = %d\n", x, y);}int main() { int a = 10, b = 20; printf("Before swap: a = %d, b = %d\n", a, b); swap(a, b); printf("After swap: a = %d, b = %d\n", a, b); // Values of a and b will not change return 0;}

Example of Call by Reference (will work for swapping):

#include <stdio.h>void swap(int x, int y) { int temp = *x; x = y; *y = temp; printf("Inside swap function: x = %d, y = %d\n", x, y);}int main() { int a = 10, b = 20; printf("Before swap: a = %d, b = %d\n", a, b); swap(&a, &b); // Passing addresses of variables printf("After swap: a = %d, b = %d\n", a, b); // Values of a and b will be swapped return 0;}

Q3. (a) Write a program in C to classify students’ performance based on their marks into different categories such as Excellent, Good, Satisfactory, Pass and Fail. Criteria: • Excellent : Marks greater than or equal to 90 • Good : Marks between 80 and 89 • Satisfactory : Marks between 70 and 79 • Pass : Marks between 40 and 69 • Fail : Marks less than 40 (b) Explain the concept of preprocessor directives in C programming. Provide examples of three commonly used preprocessor directives and describe their functions. (c) Describe file handling in C. Explain various access modes for opening the file.

Ans. (a) C Program to Classify Students’ Performance

This program takes the student’s marks from the user and displays the performance category based on the given criteria using an `if-else if-else` ladder.

#include <stdio.h>
int main() { int marks;
 printf("Enter the student's marks (0-100): "); scanf("%d", &marks);
 // Check to ensure marks are in a valid range if (marks < 0 || marks > 100) { printf("Invalid Marks! Please enter a value between 0 and 100.\n"); } else { // Classify performance based on marks if (marks >= 90) { printf("Performance: Excellent\n"); } else if (marks >= 80 && marks <= 89) { printf("Performance: Good\n"); } else if (marks >= 70 && marks <= 79) { printf("Performance: Satisfactory\n"); } else if (marks >= 40 && marks <= 69) { printf("Performance: Pass\n"); } else { printf("Performance: Fail\n"); } }
 return 0;}

(b) Preprocessor Directives in C

Preprocessor directives are instructions in a C program that are processed by the preprocessor before the actual compilation begins. These directives start with a `#` symbol. The preprocessor is a program that modifies the source code and sends the output to the compiler.

The main functions of preprocessor directives are:

• File Inclusion
• Macro Expansion
• Conditional Compilation

Three Common Preprocessor Directives:

1. #include :
   • Function: This directive is used to include the contents of another file into the current source file. It is most commonly used to include header files (like <stdio.h> , <string.h> ) which contain declarations for standard library functions.
   • Example:

     #include <stdio.h> // Includes the standard input/output header#include "myheader.h" // Includes a user-defined header file

2. #define :
   • Function: This is used to create macros. A macro is an identifier or a parameterized identifier that the preprocessor replaces with a token string. It is commonly used to define constants.
   • Example:

     #define PI 3.14159 // Defines a constant#define MAX(a,b) ((a) > (b) ? (a) : (b)) // A function-like macro

     Whenever PI appears in the code, the preprocessor replaces it with 3.14159 .

3. #ifdef , #endif , #ifndef (Conditional Compilation) :
   • Function: These directives allow sections of code to be compiled or skipped based on conditions. This is useful for including debugging code or creating different versions of code for different operating systems.
   • Example:

     #define DEBUG // To enable debug mode
     #ifdef DEBUG printf("Debug message: Variable x = %d\n", x);#endif // Ends the #ifdef block

     In the above code, the `printf` statement will only be compiled if the `DEBUG` macro has been defined.

(c) File Handling in C and Access Modes

File handling is a mechanism in C that allows us to permanently store, retrieve, and modify data stored on a disk (files). File operations in C are performed using a structure named `FILE`, which is defined in the `stdio.h` header file.

Before performing any operation on a file, we must open it using the `fopen()` function. `fopen()` returns a pointer to a structure of type `FILE`, which is then used for all subsequent operations on the file.

Various File Access Modes:

The `fopen()` function takes two arguments: the filename and the access mode. The access mode specifies what is to be done with the file (reading, writing, etc.).

• "r" (Read):
  • Opens a file for reading only.
  • If the file does not exist, `fopen()` returns `NULL`.
• "w" (Write):
  • Opens a file for writing only.
  • If the file does not exist, a new file is created.
  • If the file exists, its contents are erased (truncated).
• "a" (Append):
  • Opens a file for appending. Data is added to the end of the file.
  • If the file does not exist, a new file is created.
  • Existing contents are preserved.
• "r+" (Read/Write):
  • Opens a file for both reading and writing.
  • If the file does not exist, `fopen()` returns `NULL`.
  • The file pointer is positioned at the beginning.
• "w+" (Read/Write):
  • Opens a file for both reading and writing.
  • If the file exists, its contents are erased. If not, a new file is created.
• "a+" (Read/Append):
  • Opens a file for reading and appending.
  • If the file does not exist, a new file is created.
  • The file pointer is at the beginning for reading but at the end for writing, always.

Q4. (a) What will be the output of the following code ? Also, explain the reason for that output : #include<stdio.h> int main () { int x = 6, y=3, z; z = x– * y; printf (“%d, %d”, x, z); return 0; } (b) Write a C program to check if a given number is Armstrong number or not. (An Armstrong number is a special kind of number in Math. It’s a number that equals the sum of its digits, each raised to a power n, where n is the number of digits in the number for example, if you have a number like 153, it’s an Armstrong number because 1³ + 5³ + 3³ equals 153). (c) Define an array. How are arrays declared and initialized ? Write a C code segment to explain it.

Ans. (a) Code Output and Explanation

Code:

#include<stdio.h>int main () { int x = 6, y = 3, z; z = x-- * y; printf ("%d, %d", x, z); return 0;}

Output:

5, 18

Explanation: To understand the output of this code, we need to understand the post-decrement operator (`–`) and operator precedence in C.

1. Initially, the value of `x` is 6, `y` is 3, and `z` is uninitialized.
2. The statement `z = x– * y;` is executed.
   • Here, `x–` is a post-decrement operation. This means that the current value of `x` (which is 6) will be used in the expression first, and then the value of `x` will be decremented by 1.
   • The `*` (multiplication) operator has higher precedence than `–` (post-decrement), but the effect of post-decrement happens after the expression is evaluated.
   • So, the expression is evaluated as `z = 6 * 3;`.
   • Therefore, `z` is assigned the value `18`.
   • Immediately after the expression is evaluated, the value of `x` is decremented by 1, making it `5`.
3. Next, the `printf(“%d, %d”, x, z);` statement is executed.
   • At this point, the value of `x` is `5` and the value of `z` is `18`.
   • Hence, the `printf` function will print `5, 18`.

(b) C Program to Check for Armstrong Number

#include <stdio.h>#include <math.h> // For the pow() function
int main() { int number, originalNumber, remainder, n = 0; double result = 0.0;
 printf("Enter an integer: "); scanf("%d", &number);
 originalNumber = number;
 // Count the number of digits while (originalNumber != 0) { originalNumber /= 10; ++n; }
 originalNumber = number; // Reset originalNumber
 // Calculate the result while (originalNumber != 0) { remainder = originalNumber % 10; result += pow(remainder, n); originalNumber /= 10; }
 // Check if the number is an Armstrong number if ((int)result == number) { printf("%d is an Armstrong number.\n", number); } else { printf("%d is not an Armstrong number.\n", number); }
 return 0;}

How the program works: 1. It takes a number from the user. 2. It calculates the number of digits (`n`) in the number using a loop. 3. Then, it raises each digit to the power of `n` and calculates the sum (`result`) using another loop. 4. Finally, it checks if the calculated sum is equal to the original number. If it is, the number is an Armstrong number. (c) Array: Definition, Declaration, and Initialization

Definition: An Array is a fixed-size, sequential collection of elements of the same data type. These elements are stored in contiguous memory locations. An array is used to store multiple values under a single name, and each element can be accessed using an index (or subscript). In C, the array index always starts from 0.

Declaration: An array is declared by specifying its data type, name, and size. The size must be specified within square brackets `[]`.

Syntax: `data_type array_name[array_size];`

Example: `int marks[50];` This declaration creates an array named `marks` that can store 50 integer values. The elements will be accessed from `marks[0]` to `marks[49]`.

Initialization: An array can be initialized at the time of its declaration. The list of values is provided within curly braces `{}`.

C Code Segment:

#include <stdio.h>
int main() { // Declaration and initialization at the same time // The size can be omitted when an initializer list is provided int numbers[] = {10, 20, 30, 40, 50};
 // Another example: Initialization after declaration float prices[4]; // Declaration prices[0] = 99.9; // Initialization prices[1] = 14.5; prices[2] = 25.0; prices[3] = 7.75;
 printf("The first element of array 'numbers': %d\n", numbers[0]); printf("The third element of array 'prices': %.2f\n", prices[2]);
 // Printing all elements using a loop printf("\nAll elements of array 'numbers':\n"); for (int i = 0; i < 5; i++) { printf("%d ", numbers[i]); } printf("\n");
 return 0;}

Q5. (a) Differentiate between break statement, continue statement and goto statement, with examples. (b) Explain any five built-in string functions in C with examples. (c) Differentiate between Structure and Union. Write a C code segment to explain the difference.

Ans. (a) Difference between `break`, `continue`, and `goto` Statements

These three statements alter the normal sequential flow of a program in C, but their functions and use cases are distinct.

• break Statement:
  • Function: The `break` statement is used to terminate a loop (`for`, `while`, `do-while`) or a `switch` statement immediately.
  • Flow: When a `break` is encountered, control is transferred to the statement immediately following the loop or `switch` block.
  • Example (in a loop):

    for (int i = 1; i <= 10; i++) { if (i == 5) { break; // Loop terminates when i is 5 } printf("%d ", i);} // Output: 1 2 3 4 

• continue Statement:
  • Function: The `continue` statement is used to skip the rest of the current iteration of a loop and begin the next iteration.
  • Flow: When `continue` is encountered, subsequent statements inside the loop are skipped, and the loop proceeds to its next iteration (with condition check/update).
  • Example:

    for (int i = 1; i <= 5; i++) { if (i == 3) { continue; // Skips the printf for i=3 } printf("%d ", i);} // Output: 1 2 4 5 

• goto Statement:
  • Function: The `goto` statement is used to transfer the program’s flow unconditionally to a labeled statement within the same function.
  • Flow: It causes a “jump” in control to a specific label anywhere in the program.
  • Usage: Its use makes programs difficult to read and maintain, so it is generally considered bad programming practice and should be avoided.
  • Example:

    int i = 1;start: // This is a labelif (i <= 5) { printf("%d ", i); i++; goto start; // Go back to the 'start' label} // Output: 1 2 3 4 5 

(b) Five Built-in String Functions in C

String functions in C are declared in the `<string.h>` header file. Here are five common functions:

1. strlen(str) :
   • Function: It returns the length (number of characters) of a string, not including the null terminator (`\0`).
   • Example:

     char name[] = "Hello";int len = strlen(name); // len will be 5

2. strcpy(dest, src) :
   • Function: It copies the source string (`src`) into the destination string (`dest`), including the null terminator.
   • Example:

     char source[] = "World";char destination[10];strcpy(destination, source); // destination is now "World"

3. strcat(dest, src) :
   • Function: It appends (concatenates) the source string (`src`) to the end of the destination string (`dest`).
   • Example:

     char dest[20] = "Hello ";char src[] = "World";strcat(dest, src); // dest is now "Hello World"

4. strcmp(str1, str2) :
   • Function: It compares two strings lexicographically.
     • Returns < 0 if `str1 < str2`.
     • Returns 0 if `str1 == str2`.
     • Returns > 0 if `str1 > str2`.
   • Example:

     int result = strcmp("Apple", "Banana"); // result will be < 0

5. strstr(haystack, needle) :
   • Function: It finds the first occurrence of the `needle` substring within the `haystack` string.
   • Example:

     char *ptr = strstr("Programming is fun", "is");// ptr will point to the string "is fun"

(c) Difference between Structure and Union

Structure:

• It is a user-defined data type that allows grouping of items of different data types together.
• Each member of the structure is allocated its own distinct location in memory.
• The total size of a structure is the sum of the sizes of all its members (or more, due to padding).
• All member values can be stored and accessed at the same time.

Union:

• It is also a user-defined data type that groups items of different data types.
• All members of the union share the same single memory location.
• The total size of a union is the size of its largest member.
• Only one member can hold a meaningful value at any given time. When you assign a value to one member, the data of other members may be overwritten.

Example Code Segment: This code segment uses the `sizeof` operator to demonstrate the difference in memory allocation between a structure and a union.

#include <stdio.h>
// A structure definitionstruct ExampleStruct { int i; float f; char c;};
// A union definitionunion ExampleUnion { int i; float f; char c;};
int main() { printf("Memory difference between Structure and Union:\n\n");
 printf("Size of struct: %lu bytes\n", sizeof(struct ExampleStruct)); // Output will typically be the sum of int(4) + float(4) + char(1) + padding // e.g., 12 bytes on a 4-byte alignment machine
 printf("Size of union: %lu bytes\n", sizeof(union ExampleUnion)); // Output will be the size of the largest member (int or float), typically 4 bytes
 union ExampleUnion u; u.i = 65; // Setting 'i' to 65 printf("\nUnion member values:\n"); printf("As u.i: %d\n", u.i); printf("As u.c: %c\n", u.c); // The lower byte of 'i' will be interpreted as ASCII value for 'A' (65) printf("As u.f: %f (meaningless value)\n", u.f);
 return 0;}