2nd Year Computer Science — MCQs & Practice Questions

A field is a single item of data, such as a student's name. A record is the complete set of fields describing one entity — all the details of one student. A table is a collection of records of the same type.

A numeric type would discard a leading zero, could not store spaces or dashes, and might round the value. No arithmetic is ever performed on a telephone number, so nothing is gained by making it numeric.

Redundancy is the same data stored in more than one place. Inconsistency is what happens when one copy is updated and another is not, so the system holds conflicting values. Redundancy wastes storage, which is cheap; inconsistency means no report can be trusted, because there is no way to tell which copy is correct.

1. Redundancy — the same data is duplicated across several files[1]
2. Inconsistency — updating one copy and not another leaves conflicting values[1]
3. Data dependence — the file layout is embedded in each program, so a change to the structure means editing every program[1]
4. Poor security and sharing — access is all-or-nothing per file; also accept difficulty answering unanticipated queries[1]

Redundancy, inconsistency, data dependence, and poor security or difficult queries.

1. ProductCode — text, since it may contain letters and leading zeros and is never used in arithmetic[1]
2. Quantity — integer, since you cannot sell a fraction of an item and it is counted[1]
3. Price — decimal or currency, since it has a fractional part and must keep exact precisiona float can introduce rounding errors in money[1]
4. DateSold — date, so that date arithmetic and sorting work correctly, which they would not on text[1]

Text, integer, currency, date — each justified by what will be done with it.

1. Redundancy — each patient's name, address and identifier are stored three times[1]
2. Inconsistency — a change of address entered at reception does not reach pharmacy or billing, so the systems disagree and nobody knows which is rightin a hospital this can affect care, not just correspondence[1]
3. A database stores each patient record once, so there is only one copy to update and no second copy to disagree with[1]
4. All three departments read the same record, so a change is visible everywhere immediately[1]
5. Permissions can be set per table or per field, so pharmacy sees prescriptions and billing does notbetter than all-or-nothing file access[1]
6. A database does not fix incorrect data entry — if the address is typed wrongly it is now wrong everywhere at once, so validation at entry is still essentialthe honest limitation[1]

(a) redundancy and inconsistency (b) one stored copy, seen by all, with per-table permissions (c) it cannot prevent wrong data being entered — and now the error is everywhere

A primary key is a field, or combination of fields, that uniquely identifies each record in a table. It must be unique across all records and must never be empty. It should also never change.

A field in one table that holds the primary key value of another table, creating the link between them. For example, ClassID stored in the STUDENT table refers to the primary key of the CLASS table.

Names are not unique — two students may share one — and they can change, which would break every foreign key referring to that record. A primary key should be a meaningless, stable identifier such as a roll number.

1. Data integrity — validation rules and constraints reject invalid data[1]
2. Security — access permissions per user, per table, or per field[1]
3. Concurrency control — simultaneous updates by different users cannot corrupt the data[1]
4. Backup and recovery, and a query language for answering unanticipated questionseither earns the mark[1]

Integrity, security, concurrency control, backup and recovery, and a query language.

1. Relationship identified as one to many, from instructor to student[1]
2. INSTRUCTOR(InstructorID, Name, Phone)primary key underlined or stated[1]
3. STUDENT(StudentID, Name, Address, InstructorID)[1]
4. InstructorID in STUDENT is a foreign key referring to INSTRUCTOR — the key goes on the "many" sideplacing it on the wrong side is the standard error[1]

Two tables, with InstructorID as a foreign key in STUDENT.

1. Many to many — a student takes many courses and a course has many students[1]
2. A field holds a single value, so neither table can hold a list of the other; a third table is requiredthe reason, not just the assertion[1]
3. STUDENT(StudentID, Name) and COURSE(CourseID, Title)[1]
4. ENROLMENT(StudentID, CourseID, Grade) with a composite primary key, both fields also being foreign keysaccept a separate EnrolmentID[1]
5. The grade belongs in ENROLMENT[1]
6. Because it is a property of that particular student's enrolment in that particular course — not of the student, who has many grades, nor of the course, which awards manythe reasoning is the mark[1]

(a) many to many — a field cannot hold a list (b) STUDENT, COURSE and an ENROLMENT linking table (c) the grade goes in ENROLMENT, since it belongs to the relationship

Conceptual design — identifying entities, attributes and relationships. Logical design — converting these to tables with keys and normalising them. Physical design — choosing data types, indexes and storage for the particular DBMS.

A noun with properties of its own that must be stored is an entity and becomes a table. A noun that is simply a single property of something else is an attribute and becomes a field. "Address" is usually an attribute of a customer, but becomes an entity if the system must store a district, postcode and access notes for each one.

The number of records on each side of a relationship that may be associated with one record on the other — written 1:1, 1:M or M:N. It determines the table structure, since a 1:M becomes a foreign key while an M:N requires an additional linking table.

1. Entities: TITLE and PUBLISHERbookshop is the system, not an entity[1]
2. Relationship: one publisher supplies many titles, and each title has one publisher — 1:Mstated in both directions[1]
3. PUBLISHER(PublisherID, Name, Address)[1]
4. TITLE(ISBN, Title, Price, PublisherID) — the foreign key on the many sideISBN is a natural primary key here[1]

TITLE and PUBLISHER, in a 1:M relationship, with PublisherID as a foreign key in TITLE.

1. A field holds a single value, so it cannot store a list of related recordsthe fundamental reason[1]
2. Putting a foreign key on either side would allow only one match, which contradicts "many"[1]
3. A third linking table is created, containing the primary keys of both entities as foreign keys[1]
4. This converts the M:N into two 1:M relationships, each of which tables can express; the linking table also holds any attribute of the relationship itself[1]

A field holds one value, so a linking table with both foreign keys is required, giving two 1:M relationships.

1. Entities: MEMBER, CLASS, INSTRUCTORgym is the system itself[1]
2. INSTRUCTOR to CLASS is 1:M — one instructor teaches many classes, each class has one instructor[1]
3. MEMBER to CLASS is M:N — a member attends many classes and a class has many membersstated in both directions[1]
4. INSTRUCTOR(InstructorID, Name) and CLASS(ClassID, ClassName, Time, InstructorID)InstructorID is the foreign key on the many side[1]
5. MEMBER(MemberID, Name, JoinDate)[1]
6. ATTENDANCE(MemberID, ClassID, Date) — a linking table with a composite key, resolving the M:NDate belongs here, being a property of that attendance[1]

(a) MEMBER, CLASS, INSTRUCTOR (b) instructor–class 1:M, member–class M:N (c) four tables, with ATTENDANCE linking members to classes

Validation is an automatic check that entered data is reasonable — within range, of the right type, in the right format. Verification checks that the data was entered correctly, for example by double entry or by reading it back. A date typed as 1995 instead of 1985 passes validation but fails verification.

The rule that a foreign key must either be empty or match an existing primary key in the related table. It prevents orphaned records — a student enrolled in a class that does not exist, or left pointing at a class after it is deleted.

It contains no repeating groups — every cell holds a single, indivisible value, and there are no columns such as Subject1, Subject2, Subject3. Every record is also uniquely identifiable by a primary key.

1. Insertion anomaly — a fact cannot be recorded without another. A new teacher cannot be entered until a student enrols with them[1]
2. Deletion anomaly — removing one fact destroys another. Deleting the last enrolment erases the teacher's phone number[1]
3. Update anomaly — one change must be made in many rows[1]
4. Missing one row leaves the database holding two different values for the same fact, so no report can be trustedthe consequence is the fourth mark[1]

Insertion, deletion and update anomalies, all caused by storing a fact in more than one row.

1. ClassTeacher depends on ClassID, not on the primary key RollNo[1]
2. RollNo → ClassID → ClassTeacher is a transitive dependency through a non-key field, which 3NF forbidsnaming it is required[1]
3. Split into STUDENT(RollNo, Name, ClassID)ClassID remains as a foreign key[1]
4. and CLASS(ClassID, ClassTeacher) — the teacher is now stored once per class[1]

A transitive dependency; split into STUDENT and CLASS tables.

1. MemberName is repeated on every loan by that member, and BookTitle and Author on every loan of that book — redundancy[1]
2. An update anomaly follows: correcting a member's name means editing every one of their loan records, and missing one leaves contradictory dataaccept insertion: a new book cannot be recorded until it is borrowed[1]
3. MEMBER(MemberID, MemberName)[1]
4. BOOK(BookISBN, BookTitle, Author)[1]
5. LOAN(LoanID, MemberID, BookISBN, DateOut) — both foreign keys, and DateOut belongs to the loan itself[1]
6. Benefit: each fact is stored once, so updates are single edits and no contradiction is possible. Cost: retrieving a full loan report now requires joining three tables, which is more complex and slower to queryboth halves needed for the mark[1]

(a) redundancy and update anomalies (b) MEMBER, BOOK and LOAN (c) single-point updates, at the cost of joins

Tables, queries, forms and reports. Only tables store data; queries, forms and reports all read from the tables and hold no data of their own.

Design View defines the structure — field names, data types and properties such as validation rules. Datasheet View displays the records in rows and columns and is where data is entered and edited.

An AutoNumber is an integer Access generates automatically, increasing for each new record. It makes a good primary key because it is guaranteed unique, is never empty, and — being meaningless — has no reason ever to change.

1. Data Type: Number, with Field Size Integerage is counted and compared[1]
2. Validation Rule: >=11 And <=19the boundary values are included[1]
3. Validation Text: a clear message such as "Age must be between 11 and 19"without it the user sees a generic error[1]
4. Required: Yes, so the field cannot be left emptythe presence check[1]

Number/Integer, validation rule, validation text, and Required = Yes.

1. It prevents a record being added whose foreign key does not match an existing primary keyno enrolment in a class that does not exist[1]
2. And prevents a record being deleted while other records still refer to it, avoiding orphaned records[1]
3. Cascade Delete instead allows the deletion and automatically removes every related child record[1]
4. It must be used carefully — deleting a customer would silently delete their entire order history, which may be needed for accountsthe caution is the mark[1]

It blocks unmatched foreign keys and unsafe deletions; Cascade Delete removes the children instead, which is often not what is wanted.

1. Access enforces data types, validation rules and referential integrity, so invalid or inconsistent data is rejected at entry — a spreadsheet accepts anything in any cell[1]
2. Related data is stored once across linked tables rather than duplicated, and forms and reports can be built for staff who never see the raw data[1]
3. Limitation: it supports only a small number of simultaneous users reliably[1]
4. Limitation: the single file has a size ceiling, and it runs only on Windows — not on a phone or a web server[1]
5. It would need to move if the number of concurrent users grew substantially, or if access were needed over the web or from mobile devices[1]
6. A client-server DBMS such as MySQL or SQL Server would be used, and the existing table design would largely transferthe design survives the move[1]

(a) enforced integrity and linked tables (b) few concurrent users, size and platform limits (c) growth in users or a need for web access

A query is a saved question that selects, filters, sorts or calculates from one or more tables. It stores no data — only the question — and produces its results afresh from the tables each time it runs, so the answer is always current.

AND requires a record to satisfy every condition, so the result is smaller than either condition alone. OR requires only one, so the result is larger. In the Access design grid, criteria on the same row are ANDed and criteria on different rows are ORed.

All records whose value in that field begins with A. The asterisk is a wildcard standing for any sequence of characters, so Like "*A*" would instead find values containing A anywhere.

1. SELECT Name, Marksonly the requested columns[1]
2. FROM STUDENT[1]
3. WHERE Marks > 50no quotation marks — Marks is numeric[1]
4. ORDER BY Marks DESCDESC is required for highest first[1]

SELECT Name, Marks FROM STUDENT WHERE Marks > 50 ORDER BY Marks DESC

1. A Null field is empty — the value is unknown or was never entered[1]
2. A field containing 0 holds a known value, namely zeroa real mark of nothing, not a missing one[1]
3. Criterion Is Null finds the empty ones; =0 finds the zeros[1]
4. The distinction matters because an average ignores nulls but includes zeros, giving two different answers from the same columnthe consequence is the fourth mark[1]

Null is unknown, 0 is a known value. Is Null and =0 respectively; averages treat them differently.

1. SELECT Title, DateDue[1]
2. FROM BOOK INNER JOIN LOAN ON BOOK.ISBN = LOAN.ISBNjoined on the shared key[1]
3. WHERE DateDue < #1/3/2026#dates enclosed in hash symbols[1]
4. Title is stored only in BOOK and DateDue only in LOAN, so neither table alone can produce both columnsa direct consequence of normalisation[1]
5. Use a totals query: group by MemberID[1]
6. and apply Count to LoanID, giving one row per member with their number of loansaccept SELECT MemberID, Count(LoanID) FROM LOAN GROUP BY MemberID[1]

(a) a join on ISBN with a date criterion (b) the two columns live in different tables (c) a totals query grouping by MemberID with Count

A form is designed for the screen, usually shows one record at a time, and can edit the data. A report is designed for printing, shows many records grouped and totalled, and is read-only.

A form can display only the fields a particular user should see and arrange them to match the paper form being copied from, reducing errors. It can also use controls such as a combo box, which makes an invalid entry impossible rather than merely detecting it afterwards.

To display the "many" side of a one-to-many relationship inside the form showing the "one" side — the order lines within an order. Access links them on the shared key, so only the related records appear and new ones automatically receive the correct foreign key.

1. Report Header — the title and date, printed once at the very beginning[1]
2. Page Header — column headings, printed at the top of every page[1]
3. Detail — the fields of each record, printed once per record[1]
4. Group Footer — a subtotal or average, printed at the end of each group; or Report Footer for the grand total[1]

Report Header, Page Header, Detail, Group and Report Footers — each printing at a different frequency.

1. A text box lets the user type anything, and the validation rule rejects it afterwards[1]
2. A combo box offers only the values that exist, so an invalid entry cannot be made in the first placeprevention rather than detection[1]
3. It can display a readable name while storing the underlying key value, so the foreign key is always valid[1]
4. The list updates automatically when the related table changes, whereas a validation rule listing permitted values must be edited by handmaintenance is the fourth mark[1]

It prevents rather than detects, stores the key while showing the name, and stays current automatically.

1. Report Header: the title and the date produced. Page Header: column headings for name and marks[1]
2. Group Header: the class name, printed once per classgrouping by ClassID[1]
3. Detail: each student's name and marks, once per record[1]
4. Group Footer: the class average. Report Footer: the overall average[1]
5. The Page Footer prints at the bottom of every page, so an overall average placed there would appear repeatedly and be incorrect on every page but the last[1]
6. A report is designed for printing many grouped records with totals, and is read-only — so it can be distributed without any risk of the marks being alteredthe read-only point is the strongest reason[1]

(a) header, page header, group header, detail, group footer, report footer (b) it would print once per page and be wrong (c) reports print many grouped records and cannot be edited

#include <stdio.h> instructs the preprocessor to insert the standard input/output header, making functions such as printf and scanf available. main() is the entry point — execution of every C program begins there.

A syntax error breaks the rules of the language — a missing semicolon — and is found by the compiler, which refuses to build the program. A logical error is valid C that does the wrong thing, such as using + where * was intended: it compiles, runs, and produces an incorrect result that nothing reports.

A compiler error is a fault in the source code itself — a syntax or type mistake — and is reported with a line number. A linker error occurs after successful compilation, when a function that was declared cannot be found, and names no line because the fault is a missing definition rather than bad code.

1. Preprocessor — processes # directives, inserting header files and substituting defined constants[1]
2. Compiler — translates the C into assembly, reporting syntax and type errors[1]
3. Assembler — converts assembly into machine code, producing an object file[1]
4. Linker — combines the object file with library code to produce the final executable[1]

Preprocessing, compilation, assembly, linking.

1. #include <stdio.h>without it printf is undeclared[1]
2. int main() { with a matching closing brace[1]
3. Two printf statements, each ending in a semicolon, with \n for the line breaka single printf with two \n is equally acceptable[1]
4. return 0; before the closing brace[1]

include, main, two printf calls with newlines, return 0.

1. A logical error[1]
2. It compiled successfully, so the syntax is valid, and it runs without crashing — so the fault is in what the program does rather than in how it is writtenthe reasoning is the mark[1]
3. Cause: integer division — dividing two integers in C discards the fractional part, so 7/2 gives 3 and a total smaller than the count gives 0the classic C trap[1]
4. Cause: the total is being reset inside the loop, or the division uses the wrong variableany second plausible cause[1]
5. Trace the program by hand with two or three marks whose average you already know[1]
6. Or add temporary printf statements showing the total and the count immediately before the division, to see which value is wrong[1]

(a) logical — it compiles and runs but is wrong (b) integer division, or the total reset inside the loop (c) hand trace with known data, or print the intermediate values

A declared but uninitialised variable contains whatever data happened to already be in that memory location — not zero. Reading it gives an unpredictable value that may differ between runs, producing bugs that appear and disappear.

9 / 2 is 4 — integer division discards the fractional part. 9 % 2 is 1, the remainder.

= assigns a value; == tests equality. if (x = 5) assigns 5 to x and then treats the result as the condition, which is non-zero and therefore always true — so the branch always runs and x has been changed. C accepts this without error, so nothing warns you.

1. (i) 3 — integer division discards the remaindernot 3.75 and not 4[1]
2. (ii) 3 — the remainder when 15 is divided by 4[1]
3. (iii) 3.750000 — one operand is a float, so the division is floating point%f prints six decimal places by default[1]
4. (iv) 5 — the post-increment uses the value first and increments afterwardsi becomes 6 after the printf[1]

(i) 3 (ii) 3 (iii) 3.750000 (iv) 5

1. avg = (float) total / count;accept total / (float) count[1]
2. Writing avg = total / count; divides two ints, giving 4the fractional part is discarded before assignment[1]
3. Assigning that to a float then stores 4.0, so the float type does not rescue itthe damage is already done[1]
4. The cast converts total to float before the division, so floating-point division is used and the answer is 4.25[1]

avg = (float) total / count; — the cast must come before the division, not after.

1. Output is 3.000000not 3.5[1]
2. Both a and b are int, so integer division is performed and gives 3; converting 3 to float afterwards produces 3.0the conversion happens too late[1]
3. Fix 1: cast one operand — result = (float) a / b;[1]
4. Fix 2: declare a or b as float, or divide by a float literal such as 2.0any second valid approach[1]
5. Implicit conversion is performed automatically by the compiler when types are mixed, promoting the smaller type[1]
6. Explicit conversion is requested by the programmer with a cast, and is needed when the automatic behaviour is not what you want — as here[1]

(a) 3.000000, because int/int is evaluated first (b) cast an operand, or make one a float (c) implicit is automatic promotion; explicit is a programmer-requested cast

C passes arguments by value, so a function receives a copy and cannot alter the caller's variable. The & supplies the variable's address instead, and scanf writes the input through that address into the original variable.

An array name in C already evaluates to the address of its first element, so name is already what scanf needs. Writing &name would supply the address of the array itself, which is a different type.

It prints a floating-point value to exactly two decimal places. Plain %f prints six by default, so a price would appear as 249.990000 instead of 249.99.

1. #include <stdio.h> and int main() {[1]
2. float length, width, area; with prompts before each input[1]
3. scanf("%f", &length); and the same for width — ampersands requiredmissing & loses this mark[1]
4. area = length * width; printf("Area = %.1f\n", area);%.1f for one decimal place[1]

Declare floats, prompt and scanf with &, multiply, print with %.1f.

1. Fault 1: %f is used to read into an int — it should be %dtype mismatch in scanf[1]
2. Fault 2: the ampersand is missing — it should be &agescanf needs the address[1]
3. Fault 3: %s is used to print an int — it should be %dprintf would treat the number as a memory address and read from it[1]
4. Corrected: scanf("%d", &age); and printf("You are %d\n", age);[1]

Wrong scanf placeholder, missing &, and wrong printf placeholder.

1. scanf("%s", …) stops reading at the first whitespace, so only the first word of the name is stored[1]
2. The remainder stays in the input buffer and is picked up by the next scanf, corrupting the marksthe knock-on effect is the point[1]
3. Use fgets(name, 30, stdin), which reads the whole line including spaces[1]
4. char name[30]; int m1, m2, m3; then the fgets call and scanf("%d %d %d", &m1, &m2, &m3);three placeholders, three addresses[1]
5. A buffer overflow occurs when more characters are written than the array can hold, overwriting adjacent memory[1]
6. It is avoided by using a function that takes a length limit — fgets does, plain scanf("%s") does notthe limit is the defence[1]

(a) it stops at a space and leaves the rest to corrupt the next input; use fgets (b) fgets plus scanf with three ampersands (c) writing past the end of the array; fgets limits the length

Zero is false and any non-zero value is true. A comparison such as x > 5 produces 1 when true and 0 when false, but any non-zero number — including a negative one — is accepted as true.

The semicolon forms an empty statement which becomes the entire body of the if. The block that follows is then an ordinary block, unattached to the if, and executes every time regardless of x.

Without it, execution falls through into the following case and continues until a break or the closing brace is reached, so several cases run when only one was intended.

1. if (marks >= 80) printf("A");the most restrictive condition first[1]
2. else if (marks >= 60) printf("B");no need to test < 80 — reaching here means the first test failed[1]
3. else if (marks >= 40) printf("C");[1]
4. else printf("F");, with braces used throughout[1]

A descending chain of else-ifs from 80 down, with a final else.

1. (i) = assigns rather than compares, so x is set to 10[1]
2. The result, 10, is non-zero and therefore true, so the block always executes and the original value of x is lostboth consequences[1]
3. (ii) Execution falls through into the next case[1]
4. and continues through subsequent cases until a break or the closing brace, so multiple outputs appear where one was expected[1]

(i) assignment instead of comparison, always true, value destroyed (ii) fall-through runs the following cases too.

1. A switch suits the vowel test, since it compares one character variable against a small set of fixed constant values[1]
2. An if-else chain would need five separate == comparisons joined with ||, which reads worse[1]
3. switch (ch) { case 'a': case 'e': case 'i': case 'o': case 'u':the empty cases stack[1]
4. printf("Vowel"); break; default: printf("Not a vowel"); }one statement serves all five vowels[1]
5. A digit is a range — anything from '0' to '9' — and switch can only match individual constant values[1]
6. Ten separate cases would be needed, so if (ch >= '0' && ch <= '9') is clearerthe range test is the point[1]

(a) switch, for a fixed set of values (b) five stacked cases sharing one statement (c) a digit is a range, and switch cannot express ranges

A while loop tests its condition before the body, so it may run zero times. A do-while tests after the body, so it always runs at least once.

Five times, with i taking the values 0, 1, 2, 3 and 4. Afterwards i holds 5 — the test must fail for the loop to end, so i finishes one beyond the last value used.

The menu must be displayed before the user can choose an option, including the option to quit. A do-while runs the body first and tests afterwards, so the menu always appears at least once.

1. int total = 0; initialised before the loopinside the loop it would reset every pass[1]
2. for (int i = 1; i <= 50; i++)<= because the count starts at 1 and 50 must be included[1]
3. total = total + i; inside the loopaccept total += i[1]
4. printf("%d", total); after the loop, giving 1275inside the loop it would print fifty lines[1]

total = 0 before, the for loop accumulating, and the print after — output 1275.

1. Nothing inside the loop changes n[1]
2. So n > 0 remains true for ever and the loop never terminates — an infinite loopnaming it is expected[1]
3. Add n--; inside the loop bodyaccept n = n - 1[1]
4. It must be inside the braces; placed after the loop it would never runthe placement point is a mark[1]

No decrement. Add n--; inside the loop body.

1. A for loop, because the number of marks is known in advance to be tenthe reason is required[1]
2. int total = 0, passes = 0, marks; declared and initialised before the loop[1]
3. for (int i = 0; i < 10; i++) { scanf("%d", &marks); total += marks;ampersand required[1]
4. if (marks >= 50) passes++; }the test is inside the loop, applied to each mark[1]
5. The accumulators must be initialised before the loop; inside, they would reset on every pass and the total would end as the last mark only[1]
6. The printf statements must come after the loop, and the average must use total / 10.0 so that floating-point division is performedinteger division would truncate[1]

(a) for, since ten is known (b) accumulators before, loop reads and tests, output after (c) initialise before, print after, and divide by 10.0

Reusability — code written once can be called many times, so a correction is made in one place. Testability and readability — each function can be understood and tested on its own, and a long program becomes a set of short comprehensible pieces.

A parameter is the variable named in the function definition, which receives a value. An argument is the actual value supplied at the point of call. In square(6) calling int square(int n), n is the parameter and 6 is the argument.

C processes a file from top to bottom, so a function called before its definition appears has not yet been seen by the compiler. A prototype placed above main declares the name, return type and parameter types in advance, allowing the call to be checked.

1. int larger(int a, int b) { — correct return type and two int parameters[1]
2. if (a > b) return a;[1]
3. else return b; }every path must return a value[1]
4. Called as int max = larger(7, 3); with the returned value stored or usedcalling it without using the result wastes it[1]

int larger(int a, int b) with an if-else returning a or b, called as larger(7, 3).

1. C passes arguments by value — the function receives a copy of the argument[1]
2. The parameter is a separate variable, so assigning to it changes only the copy, which is discarded when the function ends[1]
3. To change the original, pass its address using &, and declare the parameter as a pointer[1]
4. The function then writes through that address with *, reaching the caller's variable — which is exactly what scanf doesthe scanf connection earns the mark[1]

Pass by value means the function gets a copy. Pass the address instead and write through the pointer.

1. #define PI 3.14159 or const float PI = 3.14159;[1]
2. float area(float r) { return PI * r * r; }float return type and parameter[1]
3. A local variable is declared inside a function and exists only while it runs; a global is declared outside all functions and is visible everywhere[1]
4. The radius should be a parameter and any working values local, so the function depends only on what it is given and cannot be affected by the rest of the program[1]
5. C reads the file top to bottom, so calling it earlier with no prototype means the compiler has not seen the declaration[1]
6. The compiler reports an error, or in older C assumes a default return type of int and produces a wrong result silentlythe silent-failure case is the sharper point[1]

(a) float area(float r) returning PI * r * r (b) local for working values; parameters for input (c) an error, or in older C a silent wrong result from an assumed int return

Variables are held in RAM, which is volatile — their contents are lost the moment the program ends or the power fails. A file is stored on secondary storage, so the data persists and can be read by the same program on another day or by a different program entirely.

It returns NULL. Using a NULL file pointer in any subsequent read or write causes the program to crash, so the check turns an unexplained failure into a clear message such as "cannot open file".

"w" erases the entire contents of an existing file the moment it is opened, then writes from the beginning. "a" preserves the contents and adds new data at the end. Both create the file if it does not exist.

1. FILE *fp; int n; fp = fopen("data.txt", "r");[1]
2. if (fp == NULL) { printf("Cannot open file\n"); return 1; }the NULL check is a mark[1]
3. while (fscanf(fp, "%d", &n) == 1) { printf("%d\n", n); }testing the return value, not feof[1]
4. fclose(fp);[1]

Open, check NULL, loop while fscanf returns 1, close.

1. The file has been opened in "w" mode instead of "a"[1]
2. "w" truncates the file to zero length as soon as it is opened, destroying every existing recordthe truncation happens on opening[1]
3. The new record is then written into an empty file, which is why only it remains[1]
4. Correct it by opening with "a", which preserves the contents and appends at the end[1]

The file was opened with "w", which truncates it. Use "a" to append.

1. Opens the file in "r" mode and checks the pointer is not NULL[1]
2. while (fscanf(fp, "%s %d", name, &marks) == 2) {two items requested, two expected back[1]
3. if (marks >= 50) count++; } then prints the count after the loopcount initialised before the loop[1]
4. fclose flushes the output buffer, so data still held in memory is actually written to disk[1]
5. It also releases the file handle, a limited operating-system resource that would otherwise run out[1]
6. feof becomes true only after a read has already failed, so the loop body runs one extra time and the previous values are processed twicetesting the read's return value avoids this[1]

(a) open, check, loop on fscanf == 2 counting passes (b) flushes the buffer and releases the handle (c) feof is set after a failed read, so the last record is processed twice