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

Program

#include <stdio.h>

int main(void) {
    int n, i, count = 0;
    float ch[100], spacing, total, avg;

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

    printf("Enter %d chainage readings (m):\n", n);
    for (i = 0; i < n; i++)
        scanf("%f", &ch[i]);

    /* (b) total length */
    total = ch[n - 1] - ch[0];

    /* (c) average spacing and (d) count > 20 m */
    for (i = 1; i < n; i++) {
        spacing = ch[i] - ch[i - 1];
        if (spacing > 20.0f)
            count++;
    }
    avg = total / (n - 1);   /* n-1 intervals */

    printf("Total length      = %.2f m\n", total);
    printf("Average spacing   = %.2f m\n", avg);
    printf("Spacings > 20 m   = %d\n", count);
    return 0;
}

Worked example. For $n=5$ and readings $0, 18, 45, 60, 88$ m:

• Total length $= 88 - 0 = \mathbf{88\ m}$.
• Intervals $= n-1 = 4$. Spacings: $18, 27, 15, 28$ m.
• Average spacing $= 88/4 = \mathbf{22\ m}$.
• Spacings $>20$ m: $27, 28 \Rightarrow \mathbf{2}$.

Role of loops. The first for loop is an input loop that fills the array index-by-index. The second for loop is a processing loop that walks adjacent pairs ch[i]-ch[i-1]; it both accumulates the count of large gaps and conceptually drives the spacing analysis. Using $n-1$ in the average reflects that $n$ points define $n-1$ intervals.

Call by value vs call by reference

Call by value example (swap fails to affect caller):

void swap(int a, int b){ int t=a; a=b; b=t; }   /* caller unchanged */

Call by reference example (swap works):

void swap(int *a, int *b){ int t=*a; *a=*b; *b=t; }  /* call: swap(&x,&y); */

Recursive GCD (Euclid's algorithm)

int gcd(int a, int b) {
    if (b == 0)
        return a;            /* base case */
    return gcd(b, a % b);    /* recursive case */
}

Trace of gcd(48, 36) (using $\gcd(a,b)=\gcd(b, a\bmod b)$):

The result unwinds back up the call stack, giving $\gcd(48,36)=\mathbf{12}$.

Program

#include <stdio.h>
#define N 3

int main(void) {
    int A[N][N], B[N][N], C[N][N], i, j;

    printf("Enter matrix A (%d values):\n", N*N);
    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
            scanf("%d", &A[i][j]);

    printf("Enter matrix B (%d values):\n", N*N);
    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
            scanf("%d", &B[i][j]);

    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
            C[i][j] = A[i][j] + B[i][j];

    printf("Sum C = A + B:\n");
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) printf("%4d", C[i][j]);
        printf("\n");
    }

    printf("Transpose of C:\n");
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) printf("%4d", C[j][i]);
        printf("\n");
    }
    return 0;
}

Computed output. Element-wise addition $C_{ij}=A_{ij}+B_{ij}$:

Verification of a few entries: $C_{11}=2+1=3$, $C_{23}=2+3=5$, $C_{33}=5+1=6$.

Transpose $C^{T}$ (swap rows and columns, $C^{T}_{ij}=C_{ji}$):

Program

#include <stdio.h>

struct Beam {
    int id;
    float length;   /* m  */
    float load;     /* kN/m */
};

int main(void) {
    int n, i, maxIndex = 0;
    struct Beam b[50];
    float m, maxM;

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

    for (i = 0; i < n; i++) {
        printf("Beam %d -> id length load: ", i + 1);
        scanf("%d %f %f", &b[i].id, &b[i].length, &b[i].load);
    }

    maxM = (b[0].load * b[0].length * b[0].length) / 8.0f;
    for (i = 1; i < n; i++) {
        m = (b[i].load * b[i].length * b[i].length) / 8.0f;
        if (m > maxM) { maxM = m; maxIndex = i; }
    }

    printf("Beam %d has the largest Mmax = %.2f kN.m\n",
           b[maxIndex].id, maxM);
    return 0;
}

Worked calculation using $M_{max}=\dfrac{wL^{2}}{8}$:

• Beam 101: $M_{max}=\dfrac{12\times 6^{2}}{8}=\dfrac{12\times 36}{8}=\dfrac{432}{8}=\mathbf{54.00\ kN\!\cdot\!m}$.
• Beam 102: $M_{max}=\dfrac{10\times 8^{2}}{8}=\dfrac{10\times 64}{8}=\dfrac{640}{8}=\mathbf{80.00\ kN\!\cdot\!m}$.

Since $80.00 > 54.00$, the program prints Beam 102 with the largest maximum moment of $\mathbf{80.00\ kN\!\cdot\!m}$.

Program

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

int main(void) {
    FILE *fin, *fout;
    int id;
    float load, strength;
    int area = 150 * 150;   /* mm^2 */

    fin = fopen("cubes.txt", "r");
    if (fin == NULL) {
        printf("Error: cannot open cubes.txt\n");
        return 1;
    }
    fout = fopen("report.txt", "w");
    if (fout == NULL) {
        printf("Error: cannot create report.txt\n");
        fclose(fin);
        return 1;
    }

    fprintf(fout, "ID\tLoad(kN)\tStrength(MPa)\n");
    while (fscanf(fin, "%d %f", &id, &load) == 2) {
        strength = (load * 1000.0f) / area;   /* N/mm^2 = MPa */
        fprintf(fout, "%d\t%.2f\t\t%.2f\n", id, load, strength);
    }

    fclose(fin);
    fclose(fout);
    printf("Report generated in report.txt\n");
    return 0;
}

Sample conversion for load $=562.5\,\text{kN}$ on a $150\times150$ mm cube:

Since $1\ \text{N/mm}^2 = 1\ \text{MPa}$, the strength is 25.00 MPa. The fscanf return value of 2 confirms two fields were read successfully and terminates the loop at end-of-file.

Output

3.00
3.50
5

Justification.

1. c = a / b; — both a and b are int, so 7 / 2 is integer division giving 3 (the fractional part is discarded before assignment). Storing into the float c then prints 3.00.
2. c = (float)a / b; — the cast promotes a to 7.0, forcing floating-point division: $7.0/2 = 3.5$, printed as 3.50.
3. a % b + b * 2 — by precedence, % and * bind tighter than +. So $a\%b = 7\%2 = 1$, $b*2 = 4$, then $1 + 4 = \mathbf{5}$.

Key lesson: type of operands, not the type of the destination, determines whether division is integer or floating point.

Array–pointer relationship. The name of an array decays to a pointer to its first element: for float a[4], the expression a is equivalent to &a[0], and a[i] is exactly *(a + i). Pointer arithmetic scales by the element size automatically, so arr + 1 advances by one float.

Function using pointer arithmetic

float average(float *arr, int n) {
    float sum = 0.0f;
    int i;
    for (i = 0; i < n; i++)
        sum += *(arr + i);   /* same as arr[i] */
    return sum / n;
}

Call

float data[] = {12.5, 15.0, 9.5, 18.0};
printf("Average = %.2f\n", average(data, 4));

Result. Sum $=12.5+15.0+9.5+18.0 = 55.0$; average $=55.0/4 = \mathbf{13.75}$. The program prints Average = 13.75.

Program

#include <stdio.h>

int main(void) {
    float PI;
    printf("Enter plasticity index PI: ");
    scanf("%f", &PI);

    if (PI < 7.0f)
        printf("Low plasticity\n");
    else if (PI < 17.0f)        /* 7 <= PI < 17 */
        printf("Medium plasticity\n");
    else
        printf("High plasticity\n");

    return 0;
}

Note on switch. A switch works only on integer/character constant labels, so it cannot test ranges directly; the natural tool for continuous ranges is the if-else if ladder shown above. (One could switch on an integer band code, e.g. (int)(PI/7), but the ladder is clearer.)

Output for $PI = 12$. Since $12$ is not $<7$ but is $<17$, the second branch executes, printing:

Medium plasticity

Program

#include <stdio.h>

long factorial(int x) {
    long f = 1;
    int i;
    for (i = 2; i <= x; i++)
        f *= i;
    return f;          /* factorial(0)=factorial(1)=1 */
}

int main(void) {
    int n, r;
    long nCr;
    printf("Enter n and r: ");
    scanf("%d %d", &n, &r);

    nCr = factorial(n) / (factorial(r) * factorial(n - r));
    printf("C(%d,%d) = %ld\n", n, r, nCr);
    return 0;
}

Hand verification of $^{6}C_{2}$:

where $6!=720$, $2!=2$ and $4!=24$. The program prints C(6,2) = 15.

Program

#include <stdio.h>

int main(void) {
    char str[100], ch;
    int i = 0, vowels = 0, len = 0;

    printf("Enter a string: ");
    scanf("%99s", str);     /* reads one word */

    while (str[i] != '\0') {
        ch = str[i];
        if (ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||
            ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
            vowels++;
        len++;
        i++;
    }

    printf("Length = %d\n", len);
    printf("Vowels = %d\n", vowels);
    return 0;
}

Output for Tribhuvan. The string has characters T r i b h u v a n.

• Length $= 9$ (loop stops at the '\0' terminator).
• Vowels: i, u, a $\Rightarrow$ 3.

Length = 9
Vowels = 3

Definitions. An algorithm is a finite, ordered sequence of unambiguous steps that solves a problem. A flowchart is a graphical representation of an algorithm using standard symbols (oval = start/stop, parallelogram = input/output, rectangle = process, diamond = decision).

Algorithm (largest of three)

Step 1: Start
Step 2: Read a, b, c
Step 3: If a >= b and a >= c, then large = a
Step 4: Else if b >= c, then large = b
Step 5: Else large = c
Step 6: Print large
Step 7: Stop

Flowchart (ASCII)

        ( Start )
            |
     [ Read a, b, c ]
            |
      < a>=b && a>=c? > --yes--> [ large = a ]--+
            | no                                |
      < b>=c? > --------yes--> [ large = b ]-----+
            | no                                |
      [ large = c ]------------------------------+
            |
     [ Print large ]
            |
         ( Stop )

Trace for $a=14$, $b=27$, $c=19$:

• Is $a\ge b$ and $a\ge c$? $14\ge27$ is false $\Rightarrow$ skip.
• Is $b\ge c$? $27\ge19$ is true $\Rightarrow$ large = b = 27.
• Output: 27.

The largest number is $\mathbf{27}$.