PPS GTU Paper Solution Summer 2022 | 311003

Ternary operator can be nested. (True/False)

True. Ternary operator can be nested in C language.

What do you mean by enumerated data type in C language?

Enumerated data type in C language is a user-defined data type that consists of a set of named values. It provides a way to assign a name to a constant integer value, making the code more readable and easier to maintain.

What is the difference between char *p and char p[]?

char *p is a pointer to a character, whereas char p[] is an array of characters. The difference is that a pointer is a variable that holds the memory address of another variable, while an array is a contiguous block of memory that stores multiple values of the same type.

What do you mean by function prototype?

A function prototype in C language is a declaration of a function that specifies the function’s name, return type, and the types of its arguments. It provides information to the compiler about the function’s signature, allowing the compiler to check the type compatibility of calls to the function and to generate the necessary code for calling the function. Function prototypes are typically declared at the top of a source file before they are used.

An algorithm is a set of well-defined steps that specifies a procedure for solving a particular problem. An algorithm must be clear, effective, and unambiguous, and should be finite and terminate after a finite number of steps.

Recursion is a programming technique where a function calls itself to solve a problem. The function breaks down a complex problem into smaller sub-problems, and then solves those sub-problems by calling itself. The recursion continues until the sub-problems can be solved directly, or until a base case is reached.

Program and program control refer to the instructions that a computer follows to perform a task. A program is a set of instructions that tell the computer what to do, and program control refers to the flow of execution of these instructions. The program control determines the order in which the instructions are executed and the conditions under which certain instructions are executed.

A pointer is a variable in C programming that stores the memory address of another variable. Pointers are used to manipulate data stored in memory and to pass arguments to functions by reference. They are also used to create dynamic data structures, such as linked lists and trees.

The getc() function is used to read a single character from a file, while the getw() function is used to read a word (a binary integer) from a file. These functions are typically used to read data from a file in a sequential manner.

Programming needs logic building because a program is a set of instructions that solve a problem. To write effective and efficient code, a programmer must understand the problem they are trying to solve and use a logical and organized approach to write the code. A well-built logic in programming helps in debugging the code, reducing the chance of errors, and making the code more maintainable.

An interpreter is a program that executes instructions written in a high-level programming language, such as Python or JavaScript. The interpreter reads the source code, converts it into machine code, and executes it on the fly. Unlike compilers, which convert source code into machine code before the program is executed, interpreters execute code line by line, making it possible to run the program without precompilation.

#include <stdio.h>

int main() {
  int i, n, t1 = 0, t2 = 1, next_term;
  printf("Enter the number of terms: ");
  scanf("%d", &n);
  printf("Fibonacci Series: ");
  for (i = 1; i <= n; i++) {
    printf("%d, ", t1);
    next_term = t1 + t2;
    t1 = t2;
    t2 = next_term;
  }
  return 0;
}

In C language, the following bit-wise operators are used to perform operations on individual bits of an integer value:

Bitwise AND (&): This operator performs a bit-wise AND operation on each pair of corresponding bits in the operands. The result is 1 if both bits are 1, and 0 otherwise. For example, consider the expression 5 & 3. The binary representation of 5 is 0000 0101 and the binary representation of 3 is 0000 0011. The result of the bit-wise AND operation is 0000 0001, which is equal to 1.

Bitwise OR (|): This operator performs a bit-wise OR operation on each pair of corresponding bits in the operands. The result is 1 if either or both bits are 1, and 0 otherwise. For example, consider the expression 5 | 3. The binary representation of 5 is 0000 0101 and the binary representation of 3 is 0000 0011. The result of the bit-wise OR operation is 0000 0111, which is equal to 7.

Bitwise XOR (^): This operator performs a bit-wise exclusive OR operation on each pair of corresponding bits in the operands. The result is 1 if exactly one of the bits is 1, and 0 otherwise. For example, consider the expression 5 ^ 3. The binary representation of 5 is 0000 0101 and the binary representation of 3 is 0000 0011. The result of the bit-wise XOR operation is 0000 0110, which is equal to 6.

Bitwise NOT (~): This operator inverts the value of each bit in the operand. For example, consider the expression ~5. The binary representation of 5 is 0000 0101. The result of the bit-wise NOT operation is 1111 1010, which is equal to -6 in two’s complement representation.

Left Shift (<<): This operator shifts the bits of the first operand to the left by the number of positions specified by the second operand. For example, consider the expression 5 << 1. The binary representation of 5 is 0000 0101. The result of the left shift operation is 0000 1010, which is equal to 10.

Right Shift (>>): This operator shifts the bits of the first operand to the right by the number of positions specified by the second operand. For example, consider the expression 5 >> 1. The binary representation of 5 is 0000 0101. The result of the right shift operation is 0000 0010, which is equal to 2.

The break statement is used to immediately exit a loop or a switch statement. When a break statement is encountered inside a loop or a switch, the execution of the loop or switch is immediately terminated, and the control is transferred to the statement immediately following the loop or switch.

Example: 

for (int i = 0; i < 10; i++) {
if (i == 5) {
        break;
    }
    printf(“%d\n”, i);
}

In this example, the loop will iterate from 0 to 4 and print the numbers, but when the value of i becomes 5, the break statement will be executed, and the loop will be terminated, so the number 5 will not be printed.

The continue statement is used to skip the current iteration of a loop and continue with the next iteration. When a continue statement is encountered inside a loop, the current iteration of the loop is skipped and the control is transferred to the next iteration.

int i = 0;
while (i < 10) {
    i++;
    if (i % 2 == 0) {
        continue;
    }
    printf(“%d\n”, i);
}

In this example, the loop will iterate from 1 to 10 and print the odd numbers only, because the continue statement will be executed when the value of i is even, so the current iteration will be skipped and the control will be transferred to the next iteration.

#include <stdio.h>
int main()
{
    int i, j, n = 5;
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= i; j++) {
            printf("%c ", 'A' + j - 1);
        }
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int num, result;
    printf("Enter a positive integer: ");
    scanf("%d", &num);
    result = factorial(num);
    printf("Factorial of %d is %d\n", num, result);
    return 0;
}

Both while and do-while loops are used to repeatedly execute a block of code in C programming. However, there are some key differences between the two types of loops:

The while loop: The while loop repeatedly executes a block of code as long as a certain condition is true. The condition is evaluated at the beginning of each iteration before the code inside the loop is executed. If the condition is false, the loop is terminated and the control is transferred to the statement following the loop.

Example:

int i = 0;
while (i < 10) {
    printf(“%d\n”, i);
    i++;
}

In this example, the loop will iterate from 0 to 9 and print the numbers, and it will stop when the condition i < 10 is false.

The do-while loop: The do-while loop also repeatedly executes a block of code as long as a certain condition is true. However, the condition is evaluated at the end of each iteration, after the code inside the loop is executed. This means that the code inside the loop is always executed at least once, regardless of the initial value of the condition.

Example:

int i = 0;
do {
    printf(“%d\n”, i);
    i++;
} while (i < 10);

In this example, the loop will also iterate from 0 to 9 and print the numbers, and it will stop when the condition i < 10 is false.

In C programming language, arrays are used to store collections of elements of the same data type.

One Dimensional Array:

A one-dimensional array is a linear arrangement of elements, where each element can be accessed by a single index. The syntax for declaring a one-dimensional array is:

data_type array_name[array_size];

For example, the following code declares an array arr of size 5, which can store 5 integers:

int arr[5];

Elements of the array can be accessed using the array name and an index, like arr[0], arr[1], etc.

Two Dimensional Array:

A two-dimensional array is an array of arrays, where each element is accessed using two indices. The syntax for declaring a two-dimensional array is:

data_type array_name[row_size][column_size];

For example, the following code declares a 2D array matrix of size 3×3, which can store 9 elements:

int matrix[3][3];

Elements of the 2D array can be accessed using the array name and two indices, like matrix[0][0], matrix[0][1], etc.

Multi-Dimensional Array:

A multi-dimensional array is an array of arrays, where each element is accessed using multiple indices. The syntax for declaring a multi-dimensional array is similar to a two-dimensional array:

data_type array_name[dimension1_size][dimension2_size]...[dimensionN_size];

For example, the following code declares a 3D array cube of size 3x3x3, which can store 27 elements:

int cube[3][3][3];

Elements of the multi-dimensional array can be accessed using the array name and multiple indices, like cube[0][0][0], cube[0][0][1], etc.

In C programming language, a structure within a structure is a concept of nested structures, where one structure can contain another structure as its member. This allows you to create complex data structures that can represent real-world objects and their attributes.

Here is an example to demonstrate structure within structure:

#include<stdio.h>

struct date
{
    int day;
    int month;
    int year;
};

struct student
{
    char name[30];
    int roll_no;
    struct date dob;
};

int main()
{
    struct student s1;

    printf("Enter name: ");
    scanf("%s", s1.name);
    printf("Enter roll number: ");
    scanf("%d", &s1.roll_no);
    printf("Enter date of birth (dd mm yyyy): ");
    scanf("%d %d %d", &s1.dob.day, &s1.dob.month, &s1.dob.year);

    printf("\nDisplaying Information:\n");
    printf("Name: %s\n", s1.name);
    printf("Roll number: %d\n", s1.roll_no);
    printf("Date of birth: %d/%d/%d\n", s1.dob.day, s1.dob.month, s1.dob.year);

    return 0;
}

Error handling in file systems is the process of dealing with errors that occur while reading or writing to a file. This is important because file operations can fail due to various reasons such as incorrect file path, insufficient memory, lack of permissions, etc.

In C, error handling in file systems is usually done using the functions ferror and feof. The ferror function is used to check for errors in file operations and returns non-zero if an error occurs. The feof function is used to check for end-of-file condition and returns non-zero if the end-of-file has been reached.

Here is an example to demonstrate error handling in file system:

#include<stdio.h>

int main()
{
    FILE *fp;
    char filename[] = "sample.txt";
    char ch;

    fp = fopen(filename, "r");

    if(fp == NULL)
    {
        printf("Error in opening the file");
        return 1;
    }

    while((ch = getc(fp)) != EOF)
    {
        putchar(ch);
    }

    if(ferror(fp))
    {
        printf("Error in reading the file");
        return 1;
    }

    fclose(fp);
    return 0;
}

In this example, the file sample.txt is opened for reading using the fopen function. If the file is not found or there is an error in opening the file, fp will be set to NULL and an error message is displayed. The file is then read character by character using the getc function until the end-of-file is reached. If there is an error in reading the file, the ferror function returns non-zero and an error message is displayed. Finally, the file is closed using the fclose function.

Dynamic memory allocation is a technique in C programming that allows you to allocate memory dynamically during runtime. This means that you can allocate memory as needed, rather than declaring memory beforehand.

There are two functions in C for dynamic memory allocation: malloc() and calloc().

malloc() function: The malloc() function is used to allocate a single block of memory dynamically. The syntax of the function is as follows:

void *malloc(size_t size);

where size is the number of bytes to be allocated. The function returns a void pointer to the first byte of the newly allocated memory block, or NULL if the allocation failed.

Example:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *ptr, n = 5;
    ptr = (int*)malloc(n * sizeof(int));
    if (ptr == NULL)
    {
        printf("Memory allocation failed");
        exit(0);
    }
    for (int i = 0; i < n; i++)
    {
        ptr[i] = i + 1;
    }
    for (int i = 0; i < n; i++)
    {
        printf("%d ", ptr[i]);
    }
    free(ptr);
    return 0;
}

calloc() function: The calloc() function is used to allocate multiple blocks of memory dynamically and set all the allocated memory to 0. The syntax of the function is as follows:

void *calloc(size_t nmemb, size_t size);

where nmemb is the number of blocks to be allocated and size is the size of each block. The function returns a void pointer to the first byte of the newly allocated memory block, or NULL if the allocation failed.

Example:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *ptr, n = 5;
    ptr = (int*)calloc(n, sizeof(int));
    if (ptr == NULL)
    {
        printf("Memory allocation failed");
        exit(0);
    }
    for (int i = 0; i < n; i++)
    {
        printf("%d ", ptr[i]);
    }
    free(ptr);
    return 0;
}

In the above example, calloc() function is used to allocate memory for n integers and sets all the memory to 0. The output of the program will be all 0s.

In C, file handling functions are used to perform operations on files stored on a computer’s hard drive.

fseek( ): This function allows you to move the file pointer to a specific location within a file. Syntax: int fseek(FILE *ptr, long int offset, int position); Example: fseek(fp, 10, SEEK_SET);

ftell( ): This function returns the current position of the file pointer. Syntax: long int ftell(FILE *ptr); Example: current_position = ftell(fp);

fread( ): This function reads a specified number of elements of a specified size from a file and stores them in a buffer. Syntax: size_t fread(void *ptr, size_t size, size_t count, FILE *fp); Example: fread(buffer, 1, 10, fp);

fwrite( ): This function writes a specified number of elements of a specified size from a buffer to a file. Syntax: size_t fwrite(const void *ptr, size_t size, size_t count, FILE *fp); Example: fwrite(buffer, 1, 10, fp);

fscanf( ): This function reads formatted data from a file. Syntax: int fscanf(FILE *fp, const char *format, …); Example: fscanf(fp, “%d”, &number);

fprintf( ): This function writes formatted data to a file. Syntax: int fprintf(FILE *fp, const char *format, …); Example: fprintf(fp, “%d”, number);

rewind( ): This function sets the file pointer to the beginning of the file. Syntax: void rewind(FILE *fp); Example: rewind(fp);