BE Civil Engineering (IOE, TU) Computer Programming in C (IOE, CT 401) Question Paper 2076 Nepal

Four basic (primitive) data types in C (32-bit compiler):

Implicit conversion (type promotion): The compiler automatically converts a lower-rank type to a higher-rank type in a mixed expression. Example:

int n = 3; float f = n + 2.5;  // n promoted to float -> f = 5.5

Explicit conversion (type casting): The programmer forces a conversion using the cast operator (type). Example:

int total = 7, count = 2; float avg = (float)total / count; // avg = 3.5

Step-by-step evaluation of the expression with a = 17, b = 5:

1. a / b -> integer division: $17 / 5 = 3$ (fractional part truncated). Type: int, value $3$.
2. (float)a / b -> a cast to 17.0, then 17.0 / 5 promotes b to float: $17.0 / 5 = 3.4$. Type: float, value $3.4$.
3. a % b -> modulus (remainder): $17 \bmod 5 = 2$. Type: int, value $2$.
4. Sum: $3 + 3.4 + 2$. The int operands are promoted to float: $3.0 + 3.4 + 2.0 = 8.4$.
5. Assigned to float r, so no truncation occurs.

Final result: r = 8.4 (type float).

Call by value vs call by reference:

• Call by value: A copy of the actual argument is passed to the function. Changes made to the parameter inside the function do not affect the original variable. Used when the caller's data must be protected.
• Call by reference: The address of the actual argument is passed (via pointers). The function can modify the original variable directly. Used to return multiple values or modify caller data.

C program (call by value, returning the factored load):

#include <stdio.h>

float factoredLoad(float D, float L) {
    return 1.2f * D + 1.6f * L;   // ACI/IS load combination
}

int main(void) {
    float dead = 25.0f, live = 40.0f;
    float W = factoredLoad(dead, live);
    printf("Factored design load W = %.2f kN\n", W);
    return 0;
}

Dry run for $D = 25$, $L = 40$:

1. factoredLoad(25.0, 40.0) is called; D = 25.0, L = 40.0 (copies).
2. $1.2 \times 25 = 30.0$.
3. $1.6 \times 40 = 64.0$.
4. Return $30.0 + 64.0 = 94.0$.

Program output:

Factored design load W = 94.00 kN

Final factored design load: $W = 94.00\ \text{kN}$.

C program:

#include <stdio.h>

int main(void) {
    float s[6] = {28.5f, 31.0f, 27.2f, 33.4f, 29.8f, 30.1f};
    float sum = 0.0f, max = s[0], avg;
    int i, count = 0;

    for (i = 0; i < 6; i++) {
        sum += s[i];
        if (s[i] > max) max = s[i];
        if (s[i] >= 30.0f) count++;
    }
    avg = sum / 6;

    printf("Average strength = %.2f MPa\n", avg);
    printf("Maximum strength = %.2f MPa\n", max);
    printf("Samples >= 30 MPa = %d\n", count);
    return 0;
}

Hand verification:

(a) Sum $= 28.5 + 31.0 + 27.2 + 33.4 + 29.8 + 30.1 = 180.0$ MPa. Average $= 180.0 / 6 = 30.00$ MPa.

(b) Comparing values, the largest is $33.4$ MPa.

(c) Samples $\geq 30$: $31.0$, $33.4$, $30.1$ -> 3 samples. (Note $29.8 < 30$ is excluded.)

Program output:

Average strength = 30.00 MPa
Maximum strength = 33.40 MPa
Samples >= 30 MPa = 3

Final answers: average $= 30.00$ MPa, maximum $= 33.40$ MPa, count $= 3$.

Structure definition and program:

#include <stdio.h>

struct Survey {
    char name[20];
    float x, y, z;   // metres
};

int main(void) {
    struct Survey st[3];
    int i;
    FILE *fp;

    /* (a) read input */
    for (i = 0; i < 3; i++) {
        printf("Enter name x y z for station %d: ", i + 1);
        scanf("%s %f %f %f", st[i].name, &st[i].x, &st[i].y, &st[i].z);
    }

    /* (b) write to file */
    fp = fopen("stations.txt", "w");
    if (fp == NULL) { printf("File error\n"); return 1; }
    for (i = 0; i < 3; i++)
        fprintf(fp, "%s %.2f %.2f %.2f\n", st[i].name, st[i].x, st[i].y, st[i].z);
    fclose(fp);

    /* (c) read back and print */
    struct Survey r;
    fp = fopen("stations.txt", "r");
    if (fp == NULL) { printf("File error\n"); return 1; }
    printf("\nStation records:\n");
    while (fscanf(fp, "%s %f %f %f", r.name, &r.x, &r.y, &r.z) == 4)
        printf("%s (%.2f, %.2f, %.2f)\n", r.name, r.x, r.y, r.z);
    fclose(fp);
    return 0;
}

Role of file functions:

• fopen(name, mode) opens the file and returns a FILE* pointer; mode "w" creates/overwrites for writing, "r" opens for reading. Returns NULL on failure.
• fprintf(fp, ...) writes formatted data to the file (like printf but to a stream).
• fscanf(fp, ...) reads formatted data from the file (like scanf but from a stream); returns the count of items successfully read.
• fclose(fp) flushes buffers and closes the file, releasing the resource.

Sample run (input: A 100 200 1500, B 150 250 1502, C 200 300 1498) produces output:

Station records:
A (100.00, 200.00, 1500.00)
B (150.00, 250.00, 1502.00)
C (200.00, 300.00, 1498.00)

Pointers and arrays relationship: The name of an array decays to a pointer to its first element. Thus arr is equivalent to &arr[0], and arr[i] is identical to *(arr + i). Pointer arithmetic scales by the element size: p + i advances by i * sizeof(int) bytes.

Evaluations (arr at 2000, sizeof(int) = 4):

Function using pointer arithmetic:

int sumArray(int *a, int n) {
    int sum = 0, i;
    for (i = 0; i < n; i++)
        sum += *(a + i);   // same as a[i]
    return sum;
}

Dry run for arr = {12, 24, 36, 48, 60}, n = 5:

Final returned sum: $12 + 24 + 36 + 48 + 60 = 180$.

while vs do-while:

• while is entry-controlled: the condition is tested first, so the body may execute zero times.
• do-while is exit-controlled: the body runs once before the condition is tested, so it executes at least once.

C program:

#include <stdio.h>
int main(void) {
    int n = 10, i = 1, sum = 0;
    while (i <= n) {
        sum += i;
        i++;
    }
    printf("Sum of first %d natural numbers = %d\n", n, sum);
    return 0;
}

Verification for $n = 10$: Formula gives $\dfrac{10 \times 11}{2} = \dfrac{110}{2} = 55$.

Program output:

Sum of first 10 natural numbers = 55

Final answer: sum $= 55$ (matches the formula).

Recursive factorial function:

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

Call stack for $n = 5$ (winding down to base case, then unwinding):

factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1            <- base case

Unwinding (returning values):

• $factorial(2) = 2 \times 1 = 2$
• $factorial(3) = 3 \times 2 = 6$
• $factorial(4) = 4 \times 6 = 24$
• $factorial(5) = 5 \times 24 = 120$

Final value: $5! = 120$.

C program (2x2 matrix addition):

#include <stdio.h>
int main(void) {
    int A[2][2] = {{3,5},{7,2}};
    int B[2][2] = {{1,4},{6,8}};
    int C[2][2], i, j;
    for (i = 0; i < 2; i++)
        for (j = 0; j < 2; j++)
            C[i][j] = A[i][j] + B[i][j];
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) printf("%d ", C[i][j]);
        printf("\n");
    }
    return 0;
}

Hand computation ($C_{ij} = A_{ij} + B_{ij}$):

• $C_{11} = 3 + 1 = 4$
• $C_{12} = 5 + 4 = 9$
• $C_{21} = 7 + 6 = 13$
• $C_{22} = 2 + 8 = 10$

Program output:

4 9 
13 10 

String library functions:

• strlen(s) returns the number of characters in s excluding the terminating \0.
• strcpy(dest, src) copies the string src (including \0) into dest.
• strcmp(s1, s2) compares two strings character-by-character by ASCII value; returns $0$ if equal, a negative value if s1 < s2, and a positive value if s1 > s2.

For a = "BRIDGE": strlen(a) counts B-R-I-D-G-E = 6.

strcmp(a, b) with a = "BRIDGE", b = "BEAM": Compare char by char:

• Index 0: 'B' vs 'B' -> equal, continue.
• Index 1: 'R' (ASCII 82) vs 'E' (ASCII 69) -> differ. Since $82 > 69$, a > b.

strcmp(a, b) returns a positive value (specifically $82 - 69 = 13$ in many implementations), because at the first differing position 'R' has a higher ASCII code than 'E'.

Final answers: strlen(a) = 6; strcmp(a, b) returns a positive value (13).

C program:

#include <stdio.h>
int main(void) {
    float L = 7200.0f, delta = 18.0f;
    float limit = L / 360.0f;
    if (delta <= limit)
        printf("SAFE\n");
    else
        printf("UNSAFE\n");
    return 0;
}

Hand test for $L = 7200$ mm, $\delta = 18$ mm:

1. Allowable limit $= L/360 = 7200 / 360 = 20.0$ mm.
2. Compare: $\delta = 18 \leq 20.0$ -> condition true.
3. Therefore the program prints SAFE.

Program output:

SAFE

Final answer: limit $= 20.0$ mm, $\delta = 18$ mm $\leq 20.0$ mm, so the beam is SAFE.

(a) Structure vs Union:

For a type containing one int (4 bytes) and one float (4 bytes): a struct needs $4 + 4 = 8$ bytes, while a union needs only $\max(4,4) = 4$ bytes. (Sizes may grow due to padding.)

(b) Pointer to structure (-> operator):

The -> operator dereferences a structure pointer and accesses a member: ptr->member is equivalent to (*ptr).member.

#include <stdio.h>
struct Column { float width, depth; }; // mm
int main(void) {
    struct Column c = {300.0f, 450.0f};
    struct Column *p = &c;
    float area = p->width * p->depth;   // mm^2
    printf("Area = %.2f mm^2\n", area);
    return 0;
}

For width = 300, depth = 450: area $= 300 \times 450 = 135000\ \text{mm}^2$. Output: Area = 135000.00 mm^2.

(c) break vs continue:

• break terminates the loop immediately.
• continue skips the rest of the current iteration and proceeds to the next iteration.

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

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

Summary: break prints 1 2 (stops at 3); continue prints 1 2 4 5 (skips 3).