C Language — BIT Exam

int age = 20;           // Integer variable
float marks = 85.5;    // Floating-point variable
char grade = 'A';      // Character variable (single quotes)
const int MAX = 100;  // Constant — cannot be changed later
long int pop = 1000000; // Larger integer

int a = 5;
printf("%d", a++);  // Output: 5  (post-increment: print first, then increase)
printf("%d", ++a);  // Output: 7  (pre-increment: increase first, then print)

int x = 10, y;
y = x--;             // y=10, x=9  (post-decrement)
y = --x;             // y=8,  x=8  (pre-decrement)

printf("Name: %s, Age: %d\n", name, age);
printf("Marks: %.2f\n", marks);  // .2f = 2 decimal places
printf("%10d\n", num);           // Right-aligned, field width 10
printf("%-10d\n", num);          // Left-aligned, field width 10
printf("%05d\n", num);           // Zero-padded, width 5

int age;
scanf("%d", &age);      // & (address-of) is MANDATORY for scanf!

float marks;
scanf("%f", &marks);

char name[50];
scanf("%s", name);      // Arrays don't need & — name is already an address
scanf("%49s", name);    // Safer — limits input to 49 chars

scanf("%d %d", &a, &b); // Multiple inputs at once

int marks = 75;

if (marks >= 80) {
    printf("Distinction!\n");
} else if (marks >= 60) {
    printf("First Division\n");    // This block runs
} else if (marks >= 45) {
    printf("Second Division\n");
} else {
    printf("Fail!\n");
}

int day = 3;
switch(day) {
    case 1: printf("Sunday");    break;
    case 2: printf("Monday");    break;
    case 3: printf("Tuesday");   break;  // This runs
    default: printf("Invalid day");
}

int a = 10, b = 20;
int max = (a > b) ? a : b;        // max = 20
printf("%s", (a%2==0) ? "Even" : "Odd");  // "Even"
int abs_val = (a < 0) ? -a : a;   // Absolute value

// Syntax: for(initialization; condition; update)
for(int i=1; i<=10; i++) {
    printf("%d ", i);   // Prints 1 2 3 4 5 6 7 8 9 10
}

// Factorial of n
int n=5, fact=1;
for(int i=1; i<=n; i++) {
    fact *= i;           // fact = 1*2*3*4*5 = 120
}
printf("Factorial = %d", fact);

int i = 1;
while(i <= 5) {
    printf("%d\n", i);
    i++;    // WARNING: Forgetting this creates an infinite loop!
}

// Sum of digits of a number
int num = 1234, sum = 0;
while(num > 0) {
    sum += num % 10;   // Get last digit
    num /= 10;          // Remove last digit
}
printf("Sum = %d", sum);  // 10

int i = 1;
do {
    printf("%d\n", i);
    i++;
} while(i <= 5);

/* KEY DIFFERENCE: Even if condition is false from start,
   do-while executes the body at least ONCE */
int x = 10;
do {
    printf("Runs once!");   // This prints even though 10 > 5 is false below
} while(x < 5);             // Condition checked AFTER first run

// Right-angle triangle pattern
for(int i=1; i<=5; i++) {       // Outer: controls rows
    for(int j=1; j<=i; j++) {   // Inner: controls columns
        printf("* ");
    }
    printf("\n");
}
/* Output:
*
* *
* * *
* * * *
* * * * *    */

// break and continue
for(int i=1; i<=10; i++) {
    if(i == 5) break;      // Exits loop entirely
    if(i % 2 == 0) continue; // Skips even numbers
    printf("%d ", i);        // Prints: 1 3
}

#include <stdio.h>

// 1. Function Declaration (Prototype) — tells compiler about the function
int add(int a, int b);

// 2. Function Definition — the actual code
int add(int a, int b) {
    return a + b;          // Returns the sum
}

// 3. Function Call — executing the function
int main() {
    int result = add(5, 3);
    printf("Sum = %d", result);  // Output: Sum = 8
    return 0;
}

// Factorial using recursion
int factorial(int n) {
    if(n == 0 || n == 1)
        return 1;                    // Base case — MUST have this!
    return n * factorial(n - 1);   // Recursive call
}
// factorial(5) = 5 * factorial(4)
//              = 5 * 4 * factorial(3)
//              = 5 * 4 * 3 * 2 * 1 = 120

// Fibonacci using recursion
int fib(int n) {
    if(n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

// Call by Value — original variable is NOT changed
void byValue(int x) {
    x = 100;               // Only local copy changes
}

// Call by Reference — original variable IS changed
void byRef(int *x) {
    *x = 100;              // Dereferences pointer — changes original
}

int main() {
    int a = 5;
    byValue(a);             // a is still 5 after this call
    byRef(&a);              // a is now 100 after this call
}

int marks[5] = {90, 85, 78, 92, 88};
//            [0]  [1]  [2]  [3]  [4]   ← indices

printf("%d", marks[0]);   // 90 — first element
printf("%d", marks[4]);   // 88 — last element

// Print all elements using a loop
int sum = 0;
for(int i=0; i<5; i++) {
    printf("%d ", marks[i]);
    sum += marks[i];
}
printf("\nTotal = %d", sum);

int matrix[3][3] = {
    {1, 2, 3},     // Row 0
    {4, 5, 6},     // Row 1
    {7, 8, 9}      // Row 2
};

printf("%d", matrix[1][2]);  // 6 — Row 1, Column 2

// Print full matrix
for(int i=0; i<3; i++) {
    for(int j=0; j<3; j++) {
        printf("%d ", matrix[i][j]);
    }
    printf("\n");
}

// Bubble Sort — swap adjacent elements
int arr[] = {64, 34, 25, 12, 22};
int n = 5;

for(int i=0; i<n-1; i++) {
    for(int j=0; j<n-i-1; j++) {
        if(arr[j] > arr[j+1]) {
            int temp = arr[j];    // Swap
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}
// Result: {12, 22, 25, 34, 64}

#include <string.h>  // Required for string functions

char name[50] = "Ram Bahadur";   // Stored as: R a m ... r \0
char city[20];

scanf("%s", city);          // Stops at space — only gets first word
fgets(city, 20, stdin);    // Reads full line — recommended!

// String stored as array of chars with \0 at end
// "Hello" = {'H','e','l','l','o','\0'}

int num = 10;
int *ptr;           // Pointer declaration — stores address of int

ptr = #         // & = "address of" operator

printf("%d\n", num);   // 10     — value of num
printf("%p\n", ptr);   // 0x7fff — memory address (varies)
printf("%d\n", *ptr);  // 10     — * dereference = value at address

*ptr = 20;            // Change value via pointer
printf("%d\n", num);   // 20     — num is now changed!

int arr[] = {10, 20, 30};
int *p = arr;       // arr already represents the address of arr[0]

printf("%d\n", *p);       // 10 — arr[0]
printf("%d\n", *(p+1));   // 20 — arr[1]
printf("%d\n", *(p+2));   // 30 — arr[2]

p++;                        // Move pointer to next element
printf("%d\n", *p);        // 20 — now points to arr[1]

int *ptr = NULL;    // Safe initialization — points to nothing

if(ptr != NULL) {   // Always check before dereferencing!
    printf("%d", *ptr);
}

// Dangling pointer — AVOID this!
int *dp;
// printf("%d", *dp);  ← Undefined behavior! Never use uninitialized pointer

#include <stdio.h>

// Define structure blueprint
struct Student {
    char name[50];
    int roll;
    float marks;
};

int main() {
    struct Student s1;        // Create a variable of type Student
    struct Student s2 = {"Hari", 102, 90.5};  // Initialize directly

    s1.roll = 101;            // Access with dot (.) operator
    s1.marks = 85.5;

    printf("Roll: %d, Marks: %.1f\n", s1.roll, s1.marks);
    return 0;
}

// typedef creates an alias — no need to write "struct" every time
typedef struct {
    int x, y;
} Point;

Point p1 = {3, 4};          // Cleaner — no "struct" keyword needed
printf("%d", p1.x);         // 3 — dot operator for direct variable

// Pointer to struct — use arrow (->) operator
Point *ptr = &p1;
printf("%d", ptr->x);       // 3 — arrow replaces (*ptr).x
printf("%d", (*ptr).y);     // 4 — equivalent way (less readable)

struct Student students[3] = {
    {"Ram",  101, 85.5},
    {"Sita", 102, 92.0},
    {"Hari", 103, 78.5}
};

for(int i=0; i<3; i++) {
    printf("Name: %s, Marks: %.1f\n", students[i].name, students[i].marks);
}

#include <stdio.h>

int main() {
    FILE *fp;                        // FILE pointer — declared in stdio.h

    // ── Write to file ──────────────────────────
    fp = fopen("data.txt", "w");
    if(fp == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    fprintf(fp, "Roll: %d, Marks: %.2f\n", 101, 85.5);
    fclose(fp);                      // Always close the file!

    // ── Read from file ─────────────────────────
    char buffer[100];
    fp = fopen("data.txt", "r");
    while(fgets(buffer, 100, fp) != NULL) {
        printf("%s", buffer);         // Print each line
    }
    fclose(fp);

    return 0;
}