BE Computer Engineering (Pokhara University) Programming in C (PU, CMP 124) Question Paper 2079 Nepal

(a) Basic structure of a C program (6)

Every C program is built from a few well-defined sections. A minimal example:

#include <stdio.h>          /* 1. Preprocessor directive */
#define PI 3.14159          /* symbolic constant */

int main(void)              /* 2. main() function  */
{
    float r, area;          /* 3. Declaration section */

    printf("Enter radius: "); /* 4. Executable statements */
    scanf("%f", &r);
    area = PI * r * r;
    printf("Area = %f\n", area);

    return 0;               /* return value to OS */
}

• Preprocessor directives (#include, #define): processed before compilation. #include <stdio.h> pulls in the standard I/O header so printf/scanf can be used; #define creates symbolic constants/macros.
• main() function: the entry point where execution begins. Every C program must have exactly one main().
• Declaration section: variables (e.g. float r, area;) are declared with their data types before use.
• Executable statements: the actual instructions (input, processing, output) ending with return 0; which signals successful termination.

(b) Data types, sizes and type conversion (6)

(i) int vs unsigned int (typically 4 bytes / 32 bits each):

int is signed (stores negatives using the sign bit); unsigned int has no sign bit, so all bits represent magnitude, doubling the positive range.

(ii) float vs double:

double (double precision) stores more bits, giving greater range and accuracy than float (single precision).

Type conversion means converting a value of one data type into another.

• Implicit conversion (type promotion): done automatically by the compiler, usually from a lower to a higher type to avoid data loss.

  int i = 5; float f;
  f = i + 2.5;   /* i promoted to float automatically -> 7.5 */
  

• Explicit conversion (type casting): done manually by the programmer using a cast operator (type).

  float x = 7.9;
  int y = (int)x;  /* x explicitly cast to int -> 7 (fraction dropped) */
  

(a) Recursion vs Iteration (4)

Recursion is a technique in which a function calls itself (directly or indirectly) to solve a problem by reducing it to smaller sub-problems, until a base case stops the calls.

(b) Recursive factorial + stack trace (6)

#include <stdio.h>

long factorial(int n) {
    if (n == 0 || n == 1)   /* base case */
        return 1;
    return n * factorial(n - 1);  /* recursive case */
}

int main(void) {
    int n;
    printf("Enter a non-negative integer: ");
    scanf("%d", &n);
    printf("%d! = %ld\n", n, factorial(n));
    return 0;
}

Stack behaviour for n = 4 — calls are pushed until the base case, then popped as they return:

Pushing (winding):

factorial(4) -> 4 * factorial(3)
factorial(3) -> 3 * factorial(2)
factorial(2) -> 2 * factorial(1)
factorial(1) -> 1            (base case reached)

Popping (unwinding) — each frame returns its result to the one below it:

factorial(1) returns 1
factorial(2) returns 2 * 1  = 2
factorial(3) returns 3 * 2  = 6
factorial(4) returns 4 * 6  = 24

Final result: $4! = 24$.

(c) Call by value vs Call by reference (4)

Call by value: a copy of the argument is passed; changes inside the function do not affect the caller's variables.

void swap(int x, int y) {       /* copies */
    int t = x; x = y; y = t;
}                                /* a, b in main remain unchanged */

Call by reference: the addresses of the variables are passed (via pointers); the function works on the originals.

void swap(int *x, int *y) {      /* addresses */
    int t = *x; *x = *y; *y = t;
}
int main(void){ int a=3,b=5; swap(&a,&b); /* now a=5, b=3 */ }

Call by reference actually exchanges the caller's values, because the function dereferences the passed addresses and modifies the original memory locations, whereas call by value only modifies local copies.

(a) Pointers and the & / * operators (5)

A pointer is a variable that stores the memory address of another variable rather than a data value itself.

• & (address-of) gives the memory address of a variable.
• * (dereference / indirection) accesses the value stored at the address held by a pointer.

#include <stdio.h>
int main(void) {
    int x = 10;
    int *p = &x;          /* p holds the address of x */
    printf("Address of x : %p\n", (void*)p);   /* same as &x */
    printf("Value of x   : %d\n", *p);          /* dereference -> 10 */
    return 0;
}

(b) Arrays and pointers (4)

In C, an array name acts as a constant pointer to its first element: a is equivalent to &a[0]. Pointer arithmetic accounts for element size, so a + i points to element i.

For int a[5];, element a[i] can be accessed equivalently as:

$$a[i] \equiv *(a + i) \equiv *(p + i) \quad \text{where } p = a$$

int a[5] = {10,20,30,40,50};
int *p = a;
printf("%d", a[2]);     /* 30 */
printf("%d", *(a + 2)); /* 30 */
printf("%d", *(p + 2)); /* 30 */

Thus a[i], *(a+i), *(p+i) and p[i] are all equivalent.

(c) Dynamic memory management (5)

• malloc(size) — allocates a block of size bytes; memory is uninitialised (garbage). Returns void* or NULL on failure.
• calloc(n, size) — allocates memory for n elements of size bytes each and initialises all bytes to zero.
• realloc(ptr, newsize) — resizes a previously allocated block to newsize bytes, preserving existing data.
• free(ptr) — releases memory previously allocated, preventing memory leaks.

#include <stdio.h>
#include <stdlib.h>
int main(void) {
    int n, i, sum = 0;
    printf("Enter n: ");
    scanf("%d", &n);

    int *arr = (int*)malloc(n * sizeof(int));
    if (arr == NULL) { printf("Allocation failed\n"); return 1; }

    for (i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        sum += arr[i];
    }
    printf("Sum = %d\n", sum);

    free(arr);   /* release memory */
    return 0;
}

(a) Student structure with file I/O (7)

#include <stdio.h>

struct Student {
    int   roll;
    char  name[50];
    float marks;
};

int main(void) {
    int n, i;
    struct Student s;
    FILE *fp;

    printf("How many students? ");
    scanf("%d", &n);

    /* ---- write records to file ---- */
    fp = fopen("students.dat", "wb");
    if (fp == NULL) { printf("Cannot open file\n"); return 1; }
    for (i = 0; i < n; i++) {
        printf("Roll, Name, Marks: ");
        scanf("%d %s %f", &s.roll, s.name, &s.marks);
        fwrite(&s, sizeof(struct Student), 1, fp);
    }
    fclose(fp);

    /* ---- read records back and display ---- */
    fp = fopen("students.dat", "rb");
    if (fp == NULL) { printf("Cannot open file\n"); return 1; }
    printf("\nRoll\tName\tMarks\n");
    while (fread(&s, sizeof(struct Student), 1, fp) == 1) {
        printf("%d\t%s\t%.2f\n", s.roll, s.name, s.marks);
    }
    fclose(fp);
    return 0;
}

The records are written in binary mode with fwrite() and read back with fread() until end of file.

(b) Structure vs Union (3)

struct S { int a; char b; float c; };  /* size ~ 12 bytes */
union  U { int a; char b; float c; };  /* size = 4 bytes (largest) */

In a union, writing to one member overwrites the others because they occupy the same memory location, so unions save memory when only one member is needed at a time.

while vs do-while

C program to check whether a number is prime

#include <stdio.h>
int main(void) {
    int n, i, isPrime = 1;
    printf("Enter an integer: ");
    scanf("%d", &n);

    if (n <= 1)
        isPrime = 0;
    else {
        for (i = 2; i <= n / 2; i++) {
            if (n % i == 0) { isPrime = 0; break; }
        }
    }

    if (isPrime) printf("%d is a prime number\n", n);
    else         printf("%d is not a prime number\n", n);
    return 0;
}

A number $n>1$ is prime if it is not divisible by any integer from $2$ to $n/2$.

Given int a = 5, b = 2, c; (each part evaluated independently from these initial values):

(a) c = a++ + ++b;

• a++ is post-increment: uses 5, then a becomes 6.
• ++b is pre-increment: b becomes 3, value used is 3.
• $c = 5 + 3 = 8$.
• Result: c = 8, a = 6, b = 3.

(b) c = a % b + a / b; (with a = 5, b = 2)

• a % b = $5 \bmod 2 = 1$ (remainder).
• a / b = $5 / 2 = 2$ (integer division).
• $c = 1 + 2 = 3$.
• Result: c = 3.

(c) c = (a > b) ? a : b; (with a = 5, b = 2)

• Condition a > b i.e. 5 > 2 is true, so the value before : (a) is chosen.
• Result: c = 5.

= vs ==

• = is the assignment operator: it stores the value on its right into the variable on its left, e.g. x = 5.
• == is the equality (relational) operator: it compares two operands and yields 1 (true) or 0 (false), e.g. x == 5.

Using = where == is intended (e.g. if (x = 5)) is a common bug — it assigns instead of comparing and the condition becomes true for any non-zero value.

C program to count vowels, consonants and spaces (no string library)

#include <stdio.h>
int main(void) {
    char str[200], ch;
    int i = 0, vowels = 0, consonants = 0, spaces = 0;

    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);   /* reads line incl. spaces */

    for (i = 0; str[i] != '\0'; i++) {
        ch = str[i];
        /* convert uppercase to lowercase manually */
        if (ch >= 'A' && ch <= 'Z')
            ch = ch + 32;

        if (ch == 'a' || ch == 'e' || ch == 'i' ||
            ch == 'o' || ch == 'u')
            vowels++;
        else if (ch >= 'a' && ch <= 'z')
            consonants++;
        else if (ch == ' ')
            spaces++;
    }

    printf("Vowels     = %d\n", vowels);
    printf("Consonants = %d\n", consonants);
    printf("Spaces     = %d\n", spaces);
    return 0;
}

The loop walks the array until the null terminator '\0'. Each character is classified using ASCII range checks only (no strlen, isalpha, etc.). Uppercase letters are folded to lowercase by adding 32 so a single set of comparisons suffices.

C program to find largest and second largest elements

#include <stdio.h>
#include <limits.h>
int main(void) {
    int n, i, a[100];
    int largest = INT_MIN, second = INT_MIN;

    printf("Enter number of elements: ");
    scanf("%d", &n);
    printf("Enter %d integers:\n", n);
    for (i = 0; i < n; i++)
        scanf("%d", &a[i]);

    for (i = 0; i < n; i++) {
        if (a[i] > largest) {
            second  = largest;   /* old largest becomes second */
            largest = a[i];
        } else if (a[i] > second && a[i] != largest) {
            second = a[i];
        }
    }

    printf("Largest        = %d\n", largest);
    if (second == INT_MIN)
        printf("No distinct second largest element\n");
    else
        printf("Second largest = %d\n", second);
    return 0;
}

The array is scanned once. Whenever a new maximum is found, the previous maximum slides down to second; otherwise an element larger than second (but not equal to the largest) updates second. This single-pass approach runs in $O(n)$ time.

break vs continue

• break immediately terminates the nearest enclosing loop (or switch) and transfers control to the statement after it.

  for (i = 1; i <= 10; i++) {
      if (i == 5) break;   /* loop stops at 5; prints 1 2 3 4 */
      printf("%d ", i);
  }
  

• continue skips the rest of the current iteration and jumps to the loop's next iteration (condition/update).

  for (i = 1; i <= 5; i++) {
      if (i == 3) continue;  /* skips 3; prints 1 2 4 5 */
      printf("%d ", i);
  }
  

C program to print the pattern

#include <stdio.h>
int main(void) {
    int i, j;
    for (i = 1; i <= 4; i++) {          /* one row per i */
        for (j = 1; j <= i; j++)        /* print 1..i */
            printf("%d ", j);
        printf("\n");
    }
    return 0;
}

Output:

1
1 2
1 2 3
1 2 3 4

The outer loop controls the row number, and the inner loop prints numbers 1 to i on that row.

Storage of a 2-D array (row-major order)

C stores a two-dimensional array in row-major order: the elements of the first row are stored contiguously, followed by the second row, and so on (memory is one-dimensional). For an array int a[R][C], the address of element a[i][j] is:

$$\text{address}(a[i][j]) = \text{base} + (i \times C + j) \times \text{sizeof(int)}$$

Example for int a[2][3] — storage order is: a[0][0], a[0][1], a[0][2], a[1][0], a[1][1], a[1][2].

C program: sum of diagonal elements of a 3 x 3 matrix

#include <stdio.h>
int main(void) {
    int a[3][3], i, j, sum = 0;

    printf("Enter 9 elements of 3x3 matrix:\n");
    for (i = 0; i < 3; i++)
        for (j = 0; j < 3; j++)
            scanf("%d", &a[i][j]);

    for (i = 0; i < 3; i++)
        sum += a[i][i];      /* main diagonal: row index == column index */

    printf("Sum of main diagonal = %d\n", sum);
    return 0;
}

The main-diagonal elements are those where the row index equals the column index, i.e. a[0][0], a[1][1], a[2][2].

File opening modes in C

(Adding b, e.g. rb, wb, opens the file in binary mode.)

Text file vs Binary file

Short notes on any THREE:

(a) Storage classes in C

A storage class defines a variable's scope, lifetime, default initial value and storage location.

• auto — default for local variables; scope is local to the block, lifetime ends when the block exits, stored in stack, garbage initial value.
• register — requests the variable be stored in a CPU register for faster access (e.g. loop counters); & (address) cannot be taken.
• static — preserves a local variable's value between function calls (lifetime = whole program); initialised once to 0 by default; scope still local.
• extern — declares a global variable defined in another file/translation unit, giving it external linkage so it can be shared across files.

(b) The C preprocessor and #define macros

The preprocessor runs before compilation and handles all lines beginning with #. #include inserts header files and #define creates macros. A #define macro performs simple textual substitution:

#define PI 3.14159          /* object-like (symbolic constant) */
#define SQ(x) ((x)*(x))     /* function-like macro */
area = PI * SQ(r);          /* expands to ((r)*(r)) */

Macros have no type checking and are not actual functions; parentheses are used to avoid precedence errors.

(c) getchar()/putchar() vs scanf()/printf()

• getchar() / putchar() read/write a single character at a time from/to standard I/O; they are simple and fast for character processing.
• scanf() / printf() are formatted I/O functions that handle multiple values of different data types using format specifiers (%d, %f, %s, …). They are more flexible but heavier than the single-character functions.

(d) Enumerated data type (enum)

An enum defines a user-defined type whose values are named integer constants, improving readability.

enum Weekday { MON, TUE, WED, THU, FRI };  /* MON=0, TUE=1, ... */
enum Weekday today = WED;   /* today holds 2 */

By default the first constant is 0 and each subsequent one increases by 1; values may also be assigned explicitly (e.g. enum {LOW=1, HIGH=10};).