Structure: A structure in C is a user-defined data type that allows grouping variables of different types under a single name.
Example:

struct Student {
    int id;
    char name[20];
    float marks;
};

Nested Structure: A nested structure is a structure that contains another structure as a member.
Example:

struct Date {
    int day, month, year;
};
struct Student {
    int id;
    char name[20];
    struct Date dob; // nested structure
};

#include <stdio.h>

struct Fibonacci {
    int n;
    int term;
};

struct Result {
    struct Fibonacci fib; // nested structure
    int isPrime;
};

// Function to generate nth Fibonacci term
int generateFibonacci(int n) {
    if(n == 1) return 0;
    if(n == 2) return 1;
    return generateFibonacci(n - 1) + generateFibonacci(n - 2);
}

// Function to check whether a number is prime
int isPrime(int num) {
    if(num <= 1) return 0;
    for(int i = 2; i*i <= num; i++) {
        if(num % i == 0) return 0;
    }
    return 1;
}

int main() {
    struct Result res;
    printf("Enter the value of n: ");
    scanf("%d", &res.fib.n);

    res.fib.term = generateFibonacci(res.fib.n);
    res.isPrime = isPrime(res.fib.term);

    printf("The %dth Fibonacci term is %d.\n", res.fib.n, res.fib.term);
    if(res.isPrime)
        printf("%d is a prime number.\n", res.fib.term);
    else
        printf("%d is not a prime number.\n", res.fib.term);

    return 0;
}

Relation between Array and Pointer:

• In C, the name of an array acts as a pointer to its first element.

• Array elements can be accessed using pointer arithmetic.

• Example:

int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr; // ptr points to arr[0]
printf("%d\n", *(ptr + 2)); // Outputs 30

Call by Value vs Call by Reference:

Example Program:

#include <stdio.h>

// Call by Value
void squareByValue(int x) {
    x = x * x;
}

// Call by Reference
void squareByReference(int *x) {
    *x = (*x) * (*x);
}

int main() {
    int a = 5, b = 5;

    squareByValue(a);        // a remains 5
    squareByReference(&b);   // b becomes 25

    printf("After call by value, a = %d\n", a);
    printf("After call by reference, b = %d\n", b);

    return 0;
}

Output:

After call by value, a = 5
After call by reference, b = 25

Source Code vs. Object Code Differentiation

Source code and object code represent different stages in the software development process, particularly in compiled languages.

• Source Code:

  • Definition: Source code is a high-level programming language code written by a programmer that is human-readable and understandable. It consists of instructions, statements, and declarations following the syntax rules of a specific programming language (e.g., C, C++, Java, Python).
  • Format: Typically plain text files with specific file extensions (e.g., .c, .cpp, .java).
  • Creation: Written by software developers using text editors or Integrated Development Environments (IDEs).
  • Executability: Cannot be directly executed by the computer's CPU. It must first be translated into machine-executable form.
  • Purpose: Primarily for development, human understanding, modification, and maintenance of software.
  • Portability: Generally more portable across different hardware architectures and operating systems (with recompilation).

• Object Code:

  • Definition: Object code is the machine-level code generated by a compiler or assembler from source code. It is an intermediate representation, largely unreadable by humans, consisting of machine instructions and data in a binary format.
  • Format: Binary files with specific file extensions (e.g., .obj on Windows, .o on Unix-like systems). It contains machine instructions, relocation information, and symbols.
  • Creation: Generated automatically by a compiler (from high-level language source code) or an assembler (from assembly language source code).
  • Executability: Not directly executable on its own; it typically needs to be linked with other object files and libraries by a linker to form a complete executable program.
  • Purpose: To provide a low-level, machine-understandable translation of the source code, ready for the linking phase.
  • Portability: Highly machine-specific and processor-architecture dependent. Object code generated for one architecture (e.g., x86) will not run on another (e.g., ARM).

Book Structure and Data Processing

#include <stdio.h>
#include <string.h> // Required for string operations if needed, though not strictly for this exact problem

// Structure definition for Book
struct Book {
    char Book_Name[50];
    float Price;
    char Author_Name[50];
};

int main() {
    // Declare an array of 10 Book structures
    struct Book library[10];
    int i;

    printf("Enter details for 10 books:\n");

    // Take input for 10 records of Book
    for (i = 0; i < 10; i++) {
        printf("\nBook %d:\n", i + 1);

        printf("  Enter Book Name: ");
        // Using scanf for strings, handle potential issues with spaces for simplicity in exam context
        scanf("%s", library[i].Book_Name);

        printf("  Enter Price: ");
        scanf("%f", &library[i].Price);

        printf("  Enter Author Name: ");
        scanf("%s", library[i].Author_Name);
    }

    printf("\nAuthors of books with price greater than 1000:\n");

    // Iterate through records and print author names for books with price > 1000
    for (i = 0; i < 10; i++) {
        if (library[i].Price > 1000.0) {
            printf("- %s\n", library[i].Author_Name);
        }
    }

    return 0;
}

In C, file handling uses File Pointers (FILE *) and different I/O functions. They are mainly of three types:

1. Character I/O Functions

• Read/write one character at a time.

• Syntax:

int fgetc(FILE *fp);     // read a character
int fputc(int ch, FILE *fp); // write a character

2. String/Line I/O Functions

• Read/write strings or lines.

• Syntax:

char *fgets(char *str, int n, FILE *fp); // read a line
int fputs(const char *str, FILE *fp);    // write a string

3. Formatted I/O Functions

• Read/write formatted data (numbers, strings).

• Syntax:

int fscanf(FILE *fp, const char *format, ...);  // read formatted data
int fprintf(FILE *fp, const char *format, ...); // write formatted data

C program that reads a P × Q matrix, finds the largest integer in each row, and displays it.

#include <stdio.h>

int main() {
    int P, Q, i, j;

    printf("Enter number of rows (P): ");
    scanf("%d", &P);
    printf("Enter number of columns (Q): ");
    scanf("%d", &Q);

    int matrix[P][Q];

    // Input matrix elements
    printf("Enter the elements of the matrix:\n");
    for(i = 0; i < P; i++) {
        for(j = 0; j < Q; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    // Find and display largest element of each row
    printf("Largest element of each row:\n");
    for(i = 0; i < P; i++) {
        int max = matrix[i][0];
        for(j = 1; j < Q; j++) {
            if(matrix[i][j] > max) {
                max = matrix[i][j];
            }
        }
        printf("Row %d: %d\n", i+1, max);
    }

    return 0;
}

This program will correctly handle any P × Q matrix of integers and display the largest number of each row.

#include <stdio.h>

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

int main() {
    int num;
    scanf("%d", &num);
    if(num < 0)
        printf("Factorial is not defined for negative numbers.\n");
    else
        printf("%lld\n", factorial(num));
    return 0;
}

def check_palindrome():
    word = input("Enter a word: ")
    processed_word = word.lower()
    reversed_word = processed_word[::-1]

    if processed_word == reversed_word:
        print(f"'{word}' is a palindrome.")
    else:
        print(f"'{word}' is not a palindrome.")

if __name__ == "__main__":
    check_palindrome()

Different types of operators are used to perform operations on variables and values.

The common types of operators include:

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Assignment Operators
• Bitwise Operators
• Unary Operators
• Ternary/Conditional Operator
• Special Operators (e.g., sizeof, address-of &, dereference *, member access . and ->)

Explanation of four types of operators:

• Arithmetic Operators
  These operators perform basic mathematical calculations. They operate on numerical operands and return a numerical result.

  • Operators:
    • + (Addition): Adds two operands.
    • - (Subtraction): Subtracts the second operand from the first.
    • * (Multiplication): Multiplies two operands.
    • / (Division): Divides the first operand by the second. For integer division, it truncates the fractional part.
    • % (Modulus): Returns the remainder of an integer division.
  • Example:

    int a = 10, b = 3;
    int sum = a + b;       // sum is 13
    int remainder = a % b; // remainder is 1
    

• Relational Operators
  These operators compare two operands and return a Boolean result (true or false, often represented as 1 or 0 in languages like C/C++). They are primarily used in conditional statements and loops.

  • Operators:
    • == (Equal to): Returns true if both operands are equal.
    • != (Not equal to): Returns true if operands are not equal.
    • > (Greater than): Returns true if the first operand is greater than the second.
    • < (Less than): Returns true if the first operand is less than the second.
    • >= (Greater than or equal to): Returns true if the first operand is greater than or equal to the second.
    • <= (Less than or equal to): Returns true if the first operand is less than or equal to the second.
  • Example:

    int x = 20, y = 15;
    bool is_greater = (x > y);   // is_greater is true (1)
    bool are_equal = (x == y);   // are_equal is false (0)
    

• Logical Operators
  These operators are used to combine or negate Boolean expressions. They evaluate conditions and return a Boolean result (true or false).

  • Operators:
    • && (Logical AND): Returns true if both operands are true.
    • || (Logical OR): Returns true if at least one operand is true.
    • ! (Logical NOT): Reverses the logical state of its operand (true becomes false, false becomes true).
  • Example:

    bool condition1 = true, condition2 = false;
    bool result_and = condition1 && condition2; // result_and is false
    bool result_or = condition1 || condition2;  // result_or is true
    bool result_not = !condition1;              // result_not is false
    

• Assignment Operators
  Assignment operators are used to assign a value to a variable. The simple assignment operator = assigns the value on the right to the variable on the left. Compound assignment operators combine an arithmetic (or bitwise) operation with assignment, providing a shorthand for common operations.

  • Operators:
    • = (Simple Assignment): Assigns the value of the right operand to the left operand.
    • += (Add and Assign): x += y is equivalent to x = x + y.
    • -= (Subtract and Assign): x -= y is equivalent to x = x - y.
    • *= (Multiply and Assign): x *= y is equivalent to x = x * y.
    • /= (Divide and Assign): x /= y is equivalent to x = x / y.
    • %= (Modulus and Assign): x %= y is equivalent to x = x % y.
  • Example:

    int value = 5;
    value += 3;  // value is now 8 (equivalent to value = 5 + 3)
    value *= 2;  // value is now 16 (equivalent to value = 8 * 2)
    

Program Trace:

• Initialization:

  • i is initialized to 0.
  • k is declared.

• Loop Execution (for(k=5; k>=0; k--)):

  • k = 5: i = i + k becomes i = 0 + 5 → i = 5.
  • k = 4: i = i + k becomes i = 5 + 4 → i = 9.
  • k = 3: i = i + k becomes i = 9 + 3 → i = 12.
  • k = 2: i = i + k becomes i = 12 + 2 → i = 14.
  • k = 1: i = i + k becomes i = 14 + 1 → i = 15.
  • k = 0: i = i + k becomes i = 15 + 0 → i = 15.
  • k = -1: The loop condition k >= 0 (-1 >= 0) is false. Loop terminates.

• Print Statement:

  • printf("%d\t", i); prints the final value of i.

Output:

15

#include<stdio.h>

int calculateSum(int num, int count, int sum){

if(count!=0){
return calculateSum(num+2,count-1,sum+num);
}

return sum;
}
int main(){

printf("The sum of first 10 even number is: %d",calculateSum(2,12,0));

return 0;
}

Dynamic memory allocation is the process of allocating memory during program execution (runtime) from the heap segment of memory, rather than at compile time or upon function call (stack). This allows programs to handle variable amounts of data whose size is not known until the program is running.

Key characteristics:

• Runtime allocation: Memory is requested and allocated while the program is actively executing.
• Heap memory: The allocated memory resides in the heap, a large pool of free memory managed by the operating system.
• Flexibility: It enables programs to create data structures (like arrays or lists) whose size can change dynamically based on user input or other runtime conditions.
• Manual management: Programmers are responsible for both allocating and deallocating (freeing) dynamically allocated memory. Failure to deallocate leads to memory leaks.
• Pointers: Memory is accessed via pointers returned by allocation functions.

Program Example (C Language):

This program demonstrates allocating an integer array of user-specified size at runtime using malloc and then deallocating it with free.

#include <stdio.h>
#include <stdlib.h> // Required for malloc and free

int main() {
    int *arr;       // Pointer to hold the base address of the allocated memory
    int n, i;

    printf("Enter the number of elements: ");
    scanf("%d", &n);

    // Allocate memory for 'n' integers using malloc
    // malloc returns a void pointer, which is then cast to int*
    // If allocation fails, malloc returns NULL
    arr = (int *) malloc(n * sizeof(int));

    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1; // Indicate an error
    }

    printf("Enter %d integers:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &arr[i]); // Store values in the allocated memory
    }

    printf("Elements entered are: ");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Access values
    }
    printf("\n");

    // Free the allocated memory to prevent memory leaks
    free(arr);
    printf("Memory freed successfully.\n");

    return 0; // Indicate successful execution
}

#include <stdio.h>

int main() {
    int arr[10], i, j, temp;

    // Input 10 numbers
    for(i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }

    // Sorting in ascending order (Bubble Sort)
    for(i = 0; i < 9; i++) {
        for(j = 0; j < 9 - i; j++) {
            if(arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // Display sorted array
    for(i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}