Forty Slots, Forty-Five Students

1. Array bound overrun. names[40][20] and marks[40] cannot hold 45 students. Writing names[40] to names[44] writes past the end of the array - undefined behaviour, not a defined error. Fix: size the arrays to a named maximum (#define MAX 60) and reject any n > MAX before the loop, or allocate with malloc(n * sizeof *marks).
2. %s stops at whitespace. scanf("%s", names[i]) stores only 'Ramesh' and leaves ' Shrestha\n' in the input buffer. The next scanf("%d") sees 'S', fails, and returns 0 without consuming anything; marks[i] keeps an uninitialised value and the following iterations keep hitting the same leftover text, which is why the prompts appear to be skipped. Fix: fgets(names[i], sizeof names[i], stdin) and strip the newline, or scanf(" %[^\n]", names[i]) with a width limit.
3. Integer division. sum/n divides int by int and truncates: 2781/45 gives 61, and only then is the result converted to float. Fix: avg = (float) sum / n;.
4. Pointer comparison instead of string comparison. names[i] == "Sita" compares two addresses, which are never equal. Fix: strcmp(names[i], "Sita") == 0 with #include <string.h>.
5. Division by zero. n = 0 makes sum/n undefined; on most systems it raises a floating-point exception and aborts. Fix: validate n after reading it.

All five are logic or memory errors the compiler does not report, which is why the program builds cleanly and still fails.

#include <stdio.h>
#include <string.h>
#define MAX 60
#define NAMELEN 40

int main(void) {
    char names[MAX][NAMELEN];
    int  marks[MAX];
    int  n, i, sum = 0;
    float avg;

    printf("Number of students: ");
    if (scanf("%d", &n) != 1 || n <= 0 || n > MAX) {
        printf("Invalid class size\n");
        return 1;
    }
    getchar();                    /* consume the newline after n */

    for (i = 0; i < n; i++) {
        printf("Name of student %d: ", i + 1);
        if (fgets(names[i], NAMELEN, stdin) == NULL) return 1;
        names[i][strcspn(names[i], "\n")] = '\0';

        printf("Marks: ");
        if (scanf("%d", &marks[i]) != 1) {
            printf("Bad marks\n");
            return 1;
        }
        getchar();
        sum += marks[i];
    }

    avg = (float) sum / n;
    printf("Average = %.2f\n", avg);

    for (i = 0; i < n; i++)
        if (marks[i] > avg)
            printf("%s\n", names[i]);

    return 0;
}

Why each change was made, in order of importance: the bound check on n removes the overrun and the divide-by-zero in one guard; fgets reads the whole line including the space in 'Ramesh Shrestha' and cannot overflow because it is given the buffer size; strcspn strips the newline that fgets keeps, otherwise the printed names carry a blank line; getchar() after scanf("%d") throws away the newline that would otherwise be read as an empty name; checking the return value of every scanf means bad input is reported rather than silently propagated; and the cast before division forces floating-point division. %.2f then prints 61.80.

Writing past the end of an array is undefined behaviour: the C standard says nothing about what must happen, so the compiler is free to produce code that appears to work. In practice names and marks are local variables on the stack. Beyond them lie other locals, saved registers, padding, and finally the return address. Writing 5 elements past the end of an array of 40 overwrites whatever happens to be there.

With 30 students there is no write past the end at all - the loop stays inside the declared 40 - so the program is behaving within its bounds and the output is genuinely correct for that run. That is not a lucky break, it is simply the case that never exercises the bug. The same source file compiled with different optimisation settings, a different compiler, or run on a system with a different stack layout will overwrite the return address instead of padding, and main will return to a garbage address - the classic 'sometimes crashes' symptom.

Three lessons worth stating in an exam answer. First, undefined behaviour can be silent; the absence of a crash proves nothing. Second, testing with one input size only tests that input size - boundary values (0, 1, 40, 41, 45) must be tested deliberately. Third, tools exist for exactly this: compiling with -Wall -Wextra and running under AddressSanitizer or valgrind would have flagged the overflow on the very first 45-student run, before any crash made it visible.