📝 Section 4.5 Assignments — Assignment Operators

1. Compound Chain: Declare int x = 100. Apply in sequence: x += 25, x -= 15, x *= 2, x /= 3, x %= 7. Print x after every step and verify the final value manually.
2. All Assignments Table: Declare int a = 60. Print the result of every compound assignment operator (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=) applied to a with operand 3. Reset a = 60 before each.
3. Chained Assignment: Declare three variables p, q, r. Assign all three to 999 using a single chained assignment statement p = q = r = 999. Print all three and explain the right-to-left evaluation order.
4. Accumulator Loop: Use += inside a for loop to compute the sum of numbers 1 to 50. Do NOT use a separate addition expression — only sum += i. Print the final sum (expected: 1275).
5. Running Product: Read 5 integers from the user. Use *= to compute their product iteratively. Print the product after each multiplication step showing how it grows.
6. Temperature Tracker: Read 7 daily temperatures. Use += to keep a running total, then use /= to compute and print the weekly average. Use only compound assignment — no standalone total = total + t.
7. Score Adjustment: A student starts with score = 50. Apply these rules using compound assignment: add 10 for attendance, subtract 5 for late submission, multiply by 1 (no bonus), divide by 1 (no penalty), add remainder of score÷3 as a bonus. Print final score.
8. = vs == Bug Hunt: Write a program where you intentionally write if (x = 10) and observe that it always evaluates to true. Then fix it to if (x == 10). Print which version correctly checks equality vs which version silently assigns. Add comments explaining the bug.
9. Bitwise Flag Manager: Declare int perm = 0 representing 8 permission bits. Use |= to set bits 0, 2, and 5. Use &= ~(1<<2) to clear bit 2. Use ^= to toggle bit 5. Print the final integer value and its binary equivalent (manually or with a loop).
10. Shift Assignment: Start with int n = 1. Use <<= 1 in a loop 8 times, printing n after each shift. Observe that you're computing powers of 2 (1, 2, 4, 8, 16, 32, 64, 128, 256). Then use >>= 1 8 times to reverse.

📝 Section 4.6 Assignments — Arithmetic Operators

1. Basic Calculator: Read two integers a and b from the user. Print the result of all five arithmetic operations: a+b, a-b, a*b, a/b (integer), a%b. Handle b=0 for division and modulo.
2. Integer vs Float Division: Read two integers. Print both integer division (a/b) and real division ((double)a/b) side by side. Add a note in the output explaining why they differ. Try inputs like 7/2, 10/3, 15/4.
3. Digit Extractor: Read a 3-digit integer (100–999). Using only / and %, extract and print the hundreds digit, tens digit, and units digit separately. Example: 357 → hundreds=3, tens=5, units=7.
4. Time Converter: Read a total number of seconds (e.g., 3725). Using / and %, convert it to hours, minutes, and remaining seconds. Print as H:MM:SS. Example: 3725 → 1:02:05.
5. Unary Minus Practice: Read any integer. Print its negation using unary minus. Then compute -(-n) and show it equals the original. Also compute -(n*2) and compare with (-n)*2. Show they are equal.
6. Circle Geometry: Read a radius as a double. Using arithmetic operators (no math library functions), compute:
   (a) Circumference = 2 × 3.14159 × r
   (b) Area = 3.14159 × r × r Print both to 4 decimal places.
7. Overflow Detector: Declare int x = 2147483647 (INT_MAX). Print x, then print x + 1. Observe integer overflow. Repeat with short (MAX = 32767). Explain in comments what overflow means and why it wraps around.
8. Modulo Clock: Read a starting hour (0–23) and a number of hours to add (any positive integer). Use %24 to compute the final hour on a 24-hour clock. Examples: start=22, add=5 → 3; start=0, add=36 → 12.
9. Fibonacci Step: Start with int a=0, b=1. Using only assignment and arithmetic operators (no loops), manually compute and print the first 10 Fibonacci numbers by repeatedly doing c = a+b; a = b; b = c;.
10. BMI Calculator: Read weight in kg (double) and height in metres (double). Calculate BMI = weight / (height × height) using arithmetic operators. Print the BMI to 2 decimal places and classify: "Underweight" (<18.5), "Normal" (18.5–24.9), "Overweight" (25–29.9), "Obese" (≥30).

📝 Section 4.7 Assignments — Relational Operators

1. Comparison Table: Read two integers a and b. Print the result of all six relational operators (==, !=, >, <, >=, <=) as 0 or 1 with labels. Example output: a==b : 0, a!=b : 1, etc.
2. Grade Classifier: Read a marks value (0–100). Using relational operators in if-else if, print the grade: A (≥90), B (≥80), C (≥70), D (≥60), F (<60). Also print "Invalid" if marks <0 or >100.
3. Largest of Three: Read three integers. Using only relational operators and if-else (no ternary), find and print the largest. Then extend to also print the smallest.
4. Year Validator: Read a year. Use relational operators to check:
   (a) Is it a future year (after 2025)?
   (b) Is it in the 21st century (2001–2100)?
   (c) Is it a round century year (divisible by 100)? Print YES/NO for each check.
5. Float Comparison Fix: Compute double x = 0.1 + 0.2. Compare it with 0.3 using == (will fail). Then compare using fabs(x - 0.3) < 1e-9 (will pass). Print both results and explain floating-point imprecision in comments.
6. Number Sign Checker: Read an integer. Using relational operators (>, <, ==), determine if it is positive, negative, or zero. Print a clear message. Then also check if it is divisible by both 2 and 5.
7. Triangle Validator: Read three sides of a triangle. Using relational operators, check if they form a valid triangle (each side must be less than the sum of the other two). Print "Valid Triangle" or "Invalid Triangle".
8. Relational in Arithmetic: C relational expressions return 0 or 1 as integers. Exploit this: read n and compute count = (n>0) + (n%2==0) + (n<100). Print count (0-3) and explain what each term counts. Example: n=50 → count=3.
9. Leap Year Checker: Read a year. Using relational and modulo operators, determine if it is a leap year (divisible by 4, except centuries unless divisible by 400). Print "Leap Year" or "Not a Leap Year" with the condition that matched.
10. Between Checker: Read three integers: low, value, high. Using relational operators, check and print: is value strictly between low and high? Is it within [low, high] inclusive? Is it outside the range? Test edge cases where value equals low or high.

📝 Section 4.8 Assignments — Increment & Decrement Operators

1. Pre vs Post Trace: Write a program with int x = 10. Evaluate and print these one per line: x++, x, ++x, x, x--, x, --x, x. Before running, manually predict every output value and write your predictions as comments. Verify against actual output.
2. Expression Tracing: Given int a=3, b=5: compute and print a++ + b, current values of a and b, then ++a + b--, then final values. Explain each step in detail with comments.
3. Countdown Timer: Read a positive integer n. Use a while loop with n-- (post-decrement) in the condition to print: "T-5", "T-4", ..., "T-0", "Launch!". Observe that the loop uses the value before decrementing for the print.
4. Array Traversal: Declare int arr[] = {10,20,30,40,50}. Use a for loop with i++ to print elements forward. Then use a separate loop from index 4 to 0 using i-- to print them in reverse. Print both sequences.
5. Multiplication Table: Read a number n. Use a for loop with i++ (i from 1 to 10) to print the multiplication table of n. Format: n × i = result per line.
6. Sum with Pre-increment: Use ++i inside a for loop (i from 0, condition i < 10, no increment in header) to sum 1–10. Compare with version using i++. Show both sums are equal (1275 for 1–50, 55 for 1–10) and explain why.
7. Digit Counter: Read a non-negative integer. Use a while loop with n /= 10 and a separate counter incremented with count++ to count the number of digits. Handle the special case n=0. Print the digit count.
8. Pointer Increment: Declare int arr[5] = {5,10,15,20,25} and a pointer int *p = arr. Use p++ in a loop to traverse and print each element using *p. Explain how pointer increment moves by sizeof(int) bytes, not by 1.
9. FizzBuzz with ++: Print numbers 1–30 using a for loop with i++. For multiples of 3 print "Fizz", multiples of 5 print "Buzz", multiples of both print "FizzBuzz", otherwise print the number. Use % and relational operators for checks.
10. Side-Effect Warning: Write int i=5; printf("%d %d", i++, i++); — predict the output, run it, then explain why the output is compiler-dependent (undefined evaluation order between function arguments). Rewrite safely using separate statements to get deterministic output.

📝 Section 4.9 Assignments — Conditional (Ternary) Operator

1. Max of Two: Read two integers. Use a single ternary expression to find and print the larger value. Then extend to find the maximum of three numbers using two nested ternaries.
2. Absolute Value: Read any integer. Use a ternary expression to compute its absolute value without using <math.h>: abs = (n < 0) ? -n : n. Print the result.
3. Even/Odd Formatter: Read 10 integers in a loop. For each, use a ternary to print "n is even" or "n is odd" on one line. Write the entire output statement as a single printf using the ternary inside the argument.
4. Grade String: Read a numeric score (0–100). Use nested ternary operators to assign a grade string: "A" (≥90), "B" (≥80), "C" (≥70), "D" (≥60), "F" (<60). Print "Score 75 → Grade C".
5. Plural Selector: Read a count of items. Use ternary to print the grammatically correct noun form: "1 apple" vs "2 apples", "1 ox" vs "2 oxen", "1 person" vs "2 people". The nouns should be selected by ternary, not by if-else.
6. Min of Array: Declare int arr[5] = {34, 12, 78, 5, 56}. Use a for loop and at each step update min = (arr[i] < min) ? arr[i] : min. Print the minimum value (expected: 5).
7. Ternary Assignment: Demonstrate that ternary can be an l-value argument using pointer dereferencing: read two integers a and b and a flag. If flag=1, assign 99 to a; if flag=0, assign 99 to b — using the expression *(flag ? &a : &b) = 99. Print both a and b after.
8. Ternary vs if-else: Write the same logic twice — once using if-else and once using ternary — to find the sign of a number (+1, 0, or -1). Confirm both produce identical output. Add a comment on when ternary is preferred over if-else.
9. Safe Division: Read two integers a and b. Use a ternary to compute a/b only if b != 0, otherwise print "Division by zero!". Write the entire logic as a single printf with ternary inside.
10. Triangle Type: Read three sides. Use nested ternary to classify the triangle as "Equilateral" (all sides equal), "Isosceles" (two sides equal), or "Scalene" (all different). Print the classification. No if-else allowed — ternary only.

📝 Section 4.10 Assignments — Logical Operators

1. Truth Table Printer: Write a program that prints the full truth table for &&, ||, and ! for all combinations of A=0/1 and B=0/1. Format as a table with headers. There should be 4 rows and 5 columns (A, B, A&&B, A||B, !A).
2. Range Validator: Read an integer. Use && to check if it falls in the range [1, 100] inclusive. Use || to check if it is outside (i.e., <1 or >100). Print appropriate messages for each check.
3. Login System: Define username="admin" and password=1234. Read both from user. Use && for "both correct → Access Granted", || for "at least one wrong → Access Denied", and ! to negate correct flags. Print which condition triggered.
4. Short-Circuit Proof: Write a function int sideEffect() that prints "CALLED" and returns 1. In main: evaluate 0 && sideEffect() — show "CALLED" is NOT printed. Evaluate 1 || sideEffect() — show "CALLED" is NOT printed. Explain short-circuit evaluation.
5. NULL Pointer Guard: Declare int *p = NULL. Use p != NULL && *p > 0 to safely check without crashing. Then assign p to a valid integer variable with value 42 and repeat the check. Show both results and explain why the first doesn't segfault.
6. Voting Eligibility: Read age and citizenship status (1=citizen, 0=not). Use logical operators to determine: Can vote? (age≥18 AND citizen), Cannot vote (age<18 OR not citizen). Print detailed eligibility message with reason.
7. Leap Year with Logic: Read a year. Use && and || to correctly implement the leap year rule: (year%4==0 && year%100!=0) || (year%400==0). Print "Leap" or "Not Leap". Test with 2000, 1900, 2024, and 2100.
8. NOT Operator Practice: Declare int found = 0. Use !found to print "Not found yet". Then set found = 1. Use !found again to confirm it now prints nothing. Use !!found to normalize any non-zero value to exactly 1.
9. Multi-Condition Filter: Read 10 integers in a loop. Print only those that satisfy ALL three conditions: greater than 10, less than 100, AND divisible by 3. Use a single if with && to combine all conditions.
10. De Morgan's Law: Prove De Morgan's laws in code. For any two integer inputs A and B, verify: !(A && B) == (!A || !B) and !(A || B) == (!A && !B). Test with all four combinations (0,0), (0,1), (1,0), (1,1) and print PASS/FAIL for each.

📝 Section 4.11 Assignments — Bitwise Operators

1. Binary Printer: Write a function void printBinary(int n) that prints the 8 least-significant bits of n using a loop and (n >> k) & 1. In main, call it for: 0, 1, 127, 128, 255, -1, 12, 85.
2. Bitwise Operations Table: Set int a=60, b=13. Print and explain (in comments) the result of: a&b, a|b, a^b, ~a, a<<2, a>>2. For each, also print the binary representation using your printBinary function.
3. Bit Manipulation Suite: Start with int n = 0. Perform these operations in order using bitwise compound assignment: set bits 1, 3, 5, 7; clear bit 3; toggle bit 5; check if bit 7 is set. Print n after each step and the binary using printBinary.
4. Permission System: Simulate Unix file permissions. Define: READ=4, WRITE=2, EXEC=1. Read a permission byte (0–7). Print "r", "w", "x" or "-" for each bit. Read a second number for owner/group/other (0–777 octal-like input 0–7 three times) and print rwxr-xr-- style output.
5. Odd/Even Fast Check: Read 10 integers. For each, use n & 1 to determine odd/even (faster than %2). Print the result next to each number. Also verify that (n & 1) == (n % 2) for all cases (note: careful with negatives).
6. Power of Two Checker: A number is a power of 2 if and only if n > 0 && (n & (n-1)) == 0. Read 10 integers and for each print whether it is a power of 2. Test with 1, 2, 3, 4, 7, 8, 16, 32, 63, 64.
7. Bit Counting (Hamming Weight): Count the number of 1-bits in an integer (its "popcount"). Use a loop: while n != 0, do count += n & 1; n >>= 1. Print the result for values 0, 7, 15, 85 (0b01010101 = 4 bits set), 255.
8. Swap Without Temp: Use the XOR swap trick — a ^= b; b ^= a; a ^= b; — to swap two integers without a temporary variable. Read two integers, swap them, print before and after. Then explain in comments why this works using truth table logic.
9. Color Channel Extractor: An RGB color is stored as a 32-bit integer: 0x00RRGGBB. Given color 0x00FF8040, extract the Red, Green, and Blue channels using bitwise AND and right-shift. Red = (color >> 16) & 0xFF, Green = (color >> 8) & 0xFF, Blue = color & 0xFF. Print each channel value (expected: R=255, G=128, B=64).
10. Multiply/Divide by Powers of 2: Read an integer n. Using only shift operators, compute and print: n×2, n×4, n×8, n÷2, n÷4. Then compare results with normal arithmetic (*2, *4, etc.) to verify correctness. Discuss when shifts are preferred over multiplication.

📝 Section 4.12 Assignments — Operator Precedence & Associativity

1. Manual Evaluation: Without running the code, compute the final value of x in each line, then verify by running:
   (a) int x = 2 + 3 * 4;
   (b) int x = 10 - 4 / 2 + 1;
   (c) int x = 15 % 4 * 2;
   (d) int x = 2 << 1 + 1;
   (e) int x = 8 / 2 * 4;
2. Parentheses Matter: For each pair below, predict both values before running. Then print both:
   (a) 3 + 4 * 2 vs (3 + 4) * 2
   (b) 10 / 2 + 3 vs 10 / (2 + 3)
   (c) !0 + 1 vs !(0 + 1)
   (d) 2 & 3 | 4 vs 2 & (3 | 4)
3. Relational + Logical Precedence: Predict and verify:
   (a) 3 > 2 && 5 < 10 (both true → 1)
   (b) 3 > 2 + 1 (2+1 first → 3>3 → 0)
   (c) 1 + 2 > 2 + 1 (both sides computed first)
   (d) !1 + !0 (! before + → 0 + 1 = 1)
   Print each result with its computed value as a comment.
4. Assignment Precedence: Explain and demonstrate:
   (a) Right-to-left: int a=1,b=2,c=3; a = b = c = 10; — print all three
   (b) int x = 5; x += 2 * 3; — show that * happens before +=
   (c) int y = (3 + 4) * (2 - 1); — use parens to override default precedence
5. Bitwise Precedence Trap: The classic bug: if (flags & MASK != 0) is actually parsed as flags & (MASK != 0) because != has higher precedence than &! Write a program demonstrating this bug, then fix it with if ((flags & MASK) != 0). Print both results.
6. Ternary Associativity: Ternary is right-associative. Evaluate: int x = 1 ? 2 ? 3 : 4 : 5; First predict the value manually (answer: 3). Then run and verify. Explain how right-to-left associativity means it is parsed as 1 ? (2 ? 3 : 4) : 5.
7. Unary Minus Priority: Predict and verify:
   (a) -2 + 3 → unary minus applied first → (-2)+3 = 1
   (b) -2 * -3 → 6 (two unary minuses)
   (c) -(2 + 3) → -5 (parens override)
   (d) !0 * 5 → 5 (!0=1, then 1*5)
   Print all results.
8. Complex Expression Dissection: Fully parenthesize (add explicit parentheses to show evaluation order) each expression, then run to verify:
   (a) a + b > c && d - e < f where a=3,b=4,c=6,d=10,e=3,f=8
   (b) x = y = 5 + 3 * 2 where x and y initially 0
   Print the fully parenthesized form as a string comment alongside the result.
9. Short-Circuit and Precedence: Demonstrate that in a || b && c, the && binds first (higher precedence), so it's a || (b && c) — NOT (a || b) && c. Write a program where the two interpretations give different results and print both to prove the point.
10. Precedence Table Quiz: Write a program that tests 5 more complex expressions.for each: print what you predicted, the actual computed result, and PASS/FAIL:
    (a) 2 | 3 ^ 1 & 7 (expected: 3)
    (b) 1 << 2 + 1 (expected: 8)
    (c) ~0 & 0xFF (expected: 255)
    (d) 4 / 2 == 2 + 0 (expected: 1)
    (e) 3 != 2 + 1 (expected: 0)

Unit 5 – Lab Exercises

1. Write a program to check if a number is positive, negative, or zero using if-else if-else.
2. Write a simple calculator using switch: read two numbers and an operator (+, -, *, /). Print the result. Handle division by zero.
3. Use nested if-else to check both sign (positive/negative) and parity (even/odd) of the input and print all four combinations (e.g., "Positive Even").
4. Write a vowel/consonant checker using switch with grouped cases (a, e, i, o, u → vowel; default → consonant). Handle uppercase and lowercase.
5. Demonstrate the dangling-else problem: write two versions of a nested if statement — one where the else attaches to the outer if and one where it attaches to the inner if — and print which branch executes for the same input.

Loop exercises (for, while, do-while) are in Unit 6.

#include <stdio.h>

/* goto syntax: label must be in the same function */
/*   goto label_name;                               */
/*   label_name:  statement;                        */

/* ── Use case: break out of nested loops ── */
int main() {
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (i == 2 && j == 3) {
                goto done;   // jump out of BOTH loops at once
            }
            printf("(%d,%d) ", i, j);
        }
    }
done:
    printf("\nStopped at (2,3)\n");
    return 0;
}

/* ── Alternative without goto (preferred style) ── */
int searchMatrix() {
    int found = 0;
    for (int i = 0; i < 5 && !found; i++) {
        for (int j = 0; j < 5 && !found; j++) {
            if (i == 2 && j == 3) found = 1;
        }
    }
    return found;   // cleaner than goto
}
goto_example.c

Unit 6 – Lab Exercises (10 Tasks)

1. Write a program using a for loop to print the multiplication table of any number N entered by the user (N × 1 through N × 12). Format output as “7 x  3 = 21” with right-aligned spacing using %3d.
2. Use a while loop to implement a guessing game: the program picks 42, the user keeps guessing until correct. Print “Too High”, “Too Low”, or “Correct! Attempts: N”. Count attempts.
3. Use a do-while loop to create a text menu: (1) Check Even/Odd, (2) Find Factorial, (3) Print Fibonacci, (0) Quit. Keep showing the menu until 0 is chosen. Implement each option.
4. Print all prime numbers between 2 and 100 using a nested for loop. Count and display the total found. Format: 10 primes per line using %4d.
5. Write separate functions that print: (a) right-angle star triangle 5 rows; (b) inverted triangle; (c) number pyramid; (d) Floyd’s triangle. Call all four from main.
6. Using a while loop on number 12321, compute: digit count, digit sum, digit product, reversed number. Print all results and whether the number is a palindrome.
7. Read N integers (use a for loop). Then compute: minimum, maximum, sum, average, and count of values above average. Print all results.
8. Implement the Sieve of Eratosthenes to find all primes up to 200. Use an int isPrime[201] array initialised to 1; use nested loops to mark composites. Print primes 10 per line.
9. Print a diamond pattern of stars for an odd number N entered by the user (e.g., N=5 gives a 9-row diamond). Derive space and star counts from the row number using nested loops.
10. Implement Binary Search using a while loop: create a sorted array of 10 integers; ask the user for a target; repeatedly compare mid-point and halve the search range. Print each comparison step and the final result (index or “Not found”).

Hint: Lab 8 (Sieve): mark isPrime[0]=isPrime[1]=0 first; for each prime p, mark p×p, p×(p+1), … up to 200 as 0. Lab 10 (binary search): always update low = mid + 1 or high = mid - 1, never just low = mid to avoid infinite loops. Compile with gcc -std=c99 for int array VLAs if needed.

Unit 8 – Lab Exercises

1. Write four separate functions: findMax(a,b), findMin(a,b), square(n), cube(n). Call all four from main and print results.
2. Write a function isPrime(int n) that returns 1 if prime, else 0. Use it to print all prime numbers between 1 and 100.
3. Write a recursive function power(base, exp) that computes base^exp without using pow().
4. Write a swap function that works correctly using pointers: void swap(int *a, int *b). Demonstrate that the values in main are actually swapped.
5. Demonstrate the static variable counter: write function hitCounter() that prints how many times it's been called. Call it 5 times from main.
6. Write a function sumDigits(int n) that recursively sums the digits of a positive integer (e.g., sumDigits(1234) = 10).

Hint: For sumDigits recursively: base case = n < 10, recursive case = (n % 10) + sumDigits(n / 10).

Unit 7 – Lab Exercises

1. Declare an array of 10 integers from user input. Find the max, min, and average.
2. Write a function void reverseArray(int *arr, int n) that reverses an array in-place.
3. Implement linear search: int linearSearch(int *arr, int n, int key) — return index or -1.
4. Implement bubble sort on an array of 10 integers. Print the sorted array.
5. Read a string and count: (a) vowels, (b) consonants, (c) digits, (d) spaces.
6. Write a function that reverses a string in-place without using <string.h>.
7. Check if a string is a palindrome (e.g., "madam", "racecar" are palindromes).
8. Multiply two 2×2 matrices and print the result matrix.

Hint: For matrix multiplication C[i][j] += A[i][k] * B[k][j] with a triple nested loop.

Unit 9 – Lab Exercises

1. Write a program that uses a pointer to traverse an array of ints and prints each element and its address. Observe the 4-byte gap between addresses.
2. Implement void swap(int *a, int *b) using pointers. Verify the swap in main.
3. Write a function int* findMax(int *arr, int n) that returns a pointer to the maximum element in the array. Print the value and its address.
4. Use pointer arithmetic (no array indexing []) to reverse an array in-place.
5. Dynamically allocate an array of N integers using malloc. Fill it with squares (1, 4, 9, …). Print it. Free it properly.
6. Write a function char* myStrcat(char *dest, const char *src) that does string concatenation using pointer arithmetic only (no <string.h> functions).

Hint: For exercise 6, advance the dest pointer to '\0' first, then copy characters from src one by one, then append '\0'.

Unit 13 – Lab Exercises

1. Implement myLen(const char *s) using pointer difference only.
2. Write myStrcmp(const char *a, const char *b) using pointer traversal.
3. Create a struct Student and print all fields using a pointer and the -> operator.
4. Write a function void updateSalary(Employee *e, float percent) to update struct data by reference.
5. Dynamically allocate an array of 5 structs, fill them, display them, then free memory.