Solved Past Questions: 2023 and 2024

Answer: The Extract-Root operations return 8, 11, 7, 6 in order. The heap finally holds [5, 4].

Logic: An S-record and a U-record are related only when a common T-record (tid) exists such that R has (sid, tid) and Q has (tid, uid). So join R and Q on tid.

-- Short form (R.sid and Q.uid are foreign keys, so joining S and U is optional)
SELECT R.sid, Q.uid
FROM   R
JOIN   Q ON R.tid = Q.tid;

-- Full form (also confirms that the records really exist in S and U)
SELECT S.sid, U.uid
FROM   S
JOIN   R ON S.sid = R.sid
JOIN   Q ON R.tid = Q.tid
JOIN   U ON Q.uid = U.uid;

"Composed of" means Composition (filled diamond ◆). The part cannot exist apart from the whole: if the book is deleted, its parts, chapters and sections are deleted too. Multiplicity is 1 on the whole side and 1..* on the part side ("several").

Write this explanation: (1) four classes and the attributes of each; (2) the relationships are composition, because a chapter exists only inside one part; (3) the multiplicity of every relationship is 1 → 1..*. You may also add operations, such as Book.addPart() or Chapter.getSections().

Step 1: FP = 180 × 0.87 = 156.6
Step 2: Assume "performance factor 4" means productivity, i.e. 4 FP per person-day.
Effort = 156.6 ÷ 4 = 39.15 ≈ 40 person-days

Logic: Treat the first element as min. Loop once over the remaining elements; if one is smaller than min, update min. Time O(n), extra space O(1).

/* C */
#include <stdio.h>

int findMin(int arr[], int n) {
    int min = arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i] < min)
            min = arr[i];
    return min;
}

int main(void) {
    int a[] = {34, -7, 19, 0, 8};
    int n = sizeof(a) / sizeof(a[0]);
    printf("Smallest = %d\n", findMin(a, n));
    return 0;
}
/* Output: Smallest = -7 */

// Java
public class MinFinder {
    static int findMin(int[] arr) {
        if (arr == null || arr.length == 0)
            throw new IllegalArgumentException("empty");
        int min = arr[0];
        for (int i = 1; i < arr.length; i++)
            if (arr[i] < min) min = arr[i];
        return min;
    }

    public static void main(String[] args) {
        int[] a = {34, -7, 19, 0, 8};
        System.out.println("Smallest = " + findMin(a));
    }
}
// Output: Smallest = -7

In C, passing an array actually passes a pointer, so the size (n) must be passed as a separate parameter. In Java, the size comes from arr.length.

The server proves "I am the real site" using the private key that pairs with the public key in its certificate. If this key is stolen, the attacker can do the following:

1. Impersonate the server: Run a fake site with the genuine, valid certificate. If users are redirected there by DNS spoofing, ARP spoofing or a fake Wi-Fi, the browser shows no warning.
2. Active Man-in-the-Middle: Sit between the client and the real server and terminate the TLS connection on both sides. The attacker can read passwords, OTPs and card numbers, and can change the amount or destination account of a transaction.
3. Decrypt recorded traffic (passive): If the server uses RSA key exchange (a non-forward-secret cipher suite of TLS 1.2), the session key comes from the premaster secret sent by the client, encrypted with that public key. So previously recorded sessions and all future sessions can be decrypted.
   If (EC)DHE is used (Forward Secrecy, mandatory in TLS 1.3), the private key is used only for signing in the handshake. Then past recorded traffic cannot be decrypted, but an active MitM (point 2) is still possible.
4. Sign in the server's name: If the same key was also used to sign something else (such as code or messages), the attacker can forge signatures in the server's name.

The generator has 11 bits, so its degree is r = 11 − 1 = 10 (the CRC remainder is 10 bits).

Here L = 10 and r = 10, so L ≤ r. The highest and lowest (x⁰) bits of the generator are both 1, so every burst error is detected; detection probability = 1 (100%).

For comparison: if L = 11, probability = 1 − 1/2⁹ ≈ 0.998; if L ≥ 12, probability = 1 − 1/2¹⁰ ≈ 0.999.

Faster with a list: In a sparse graph of 1 million nodes and 5 million edges (such as a bank customer transaction network), finding all reachable nodes by BFS/DFS, or counting the out-degree of every node. With a list this takes O(V + E); with a matrix, O(V²).
Faster with a matrix: Repeatedly asking "is there a direct edge from u to v?" (O(1) lookup), Floyd–Warshall all-pairs shortest path on a dense graph, or checking in O(V) time whether a vertex is a universal sink (in-degree V−1, out-degree 0).

This question is about the browser's frame navigation policy. Current browsers follow the Descendant Policy: a frame may navigate only its own descendant frames to another URL.

1. Pixel delegation argument: If B is inside the display area of A, that part of the screen was given by A itself. A could already show its own content there, remove B, or draw something over it. So allowing A to navigate B to another origin gives A no new power and does not reduce security.
2. Same-Origin Policy stays intact: By navigating, A cannot read B's DOM, cookies or data; it only decides what loads in B's place. So confidentiality is not broken.
3. Risk of a permissive policy: If any frame could navigate any frame (permissive policy), an attacker frame could send a login or payment frame inside another site to a fake page (frame hijacking / Guninski attack). The user would see the address of the real site, but the data would go to the attacker.
4. Hence the limit: "Whoever owns the screen controls it." A can change only frames inside its own area. It cannot change frames of other origins beside or above it.

In LRU (Least Recently Used), on a page fault the page that has not been used for the longest time is replaced. F = fault, H = hit.

Replacement decisions:

• At ref 4, 1 is the oldest, so 1 is replaced.
• At ref 1 (8th), the order is 2, 3, 4 (2 is the oldest), so 2 is replaced.
• At ref 2 (9th), the order is 3, 4, 1, so 3 is replaced.
• At ref 3 (12th), the order is 4, 2, 1, so 4 is replaced.
• At ref 4 (14th), the order is 2, 3, 1, so 2 is replaced.

Answer: Page faults = 8, hits = 6; fault rate = 8/14 ≈ 57%.

Total collisions: 1 for 16, 3 for 17, 2 for 19, total 6. The continuous filled run from index 3 to 8 is an example of primary clustering, the main weakness of linear probing. Remedies are quadratic probing or double hashing. Load factor α = 7/13 ≈ 0.54.

With binary-heap numbering, the children of vertex i are 2i and 2i+1, and its parent is ⌊i/2⌋. The tree is treated as an undirected graph.

1 → 2 → 3
2 → 1 → 4 → 5
3 → 1 → 6 → 7
4 → 2
5 → 2
6 → 3
7 → 3

Number of edges = V − 1 = 6. The list has 2 × 6 = 12 entries in total; the matrix has 7 × 7 = 49 cells, of which only 12 are 1. The tree is sparse, so the list saves more space here.

To avoid overflow, compute in the order (a / gcd) * b. This divides first, then multiplies.

/* C */
#include <stdio.h>
#include <stdlib.h>

long long gcd(long long a, long long b) {
    while (b != 0) {
        long long t = a % b;
        a = b;
        b = t;
    }
    return a;
}

int main(void) {
    long long a, b;
    printf("Enter A and B: ");
    scanf("%lld %lld", &a, &b);
    a = llabs(a); b = llabs(b);
    if (a == 0 || b == 0) {
        printf("LCM = 0\n");
        return 0;
    }
    long long lcm = (a / gcd(a, b)) * b;
    printf("LCM = %lld\n", lcm);
    return 0;
}
/* Input: 12 18  ->  LCM = 36 */

// Java
import java.util.Scanner;

public class LCM {
    static long gcd(long a, long b) {
        while (b != 0) {
            long t = a % b;
            a = b;
            b = t;
        }
        return a;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long a = Math.abs(sc.nextLong());
        long b = Math.abs(sc.nextLong());
        long lcm = (a == 0 || b == 0) ? 0
                 : (a / gcd(a, b)) * b;
        System.out.println("LCM = " + lcm);
    }
}
// Input: 12 18  ->  LCM = 36

Trace (12, 18): gcd(12, 18) → gcd(18, 12) → gcd(12, 6) → gcd(6, 0) = 6; LCM = 12/6 × 18 = 36. Time complexity O(log min(A, B)).

Logic: "Romantic comedy" means the same movie has two genres: Romance and Comedy. Each genre is in a separate row of HasGenre, so the two conditions cannot be matched in a single row.

-- Method 1: GROUP BY + HAVING (cleanest)
SELECT COUNT(*) AS romantic_comedy_count
FROM (
    SELECT hg.mid
    FROM   HasGenre hg
    JOIN   Genres g ON g.gid = hg.gid
    WHERE  g.genre IN ('Romance', 'Comedy')
    GROUP  BY hg.mid
    HAVING COUNT(DISTINCT g.genre) = 2
) AS rc;

-- Method 2: two IN subqueries
SELECT COUNT(*) AS romantic_comedy_count
FROM   Movies m
WHERE  m.mid IN (SELECT hg.mid FROM HasGenre hg JOIN Genres g ON g.gid = hg.gid
                 WHERE g.genre = 'Romance')
  AND  m.mid IN (SELECT hg.mid FROM HasGenre hg JOIN Genres g ON g.gid = hg.gid
                 WHERE g.genre = 'Comedy');

Conclusion: m2 and m3 are overridden. m1 and m4 will not compile, so no hiding happens here. No method has a different parameter list, so there is no overloading either. Also fix two problems in the code: extends a must be extends A, and one .java file cannot contain two public classes, so put them in two separate files.

When hiding and overloading would occur: If A's m1 were public static void m1(), B's static m1() would hide it. If B had public void m3(double d), it would overload A's m3(int).

class A {
    public static void s()   { System.out.println("A.s"); }
    public void m()          { System.out.println("A.m"); }
}
class B extends A {
    public static void s()   { System.out.println("B.s"); }   // hiding
    @Override public void m(){ System.out.println("B.m"); }   // overriding
    public void m(int x)     { System.out.println("B.m(int)"); } // overloading
}
public class Demo {
    public static void main(String[] args) {
        A ref = new B();
        ref.m();   // B.m  : at runtime, uses the object's type (B)
        ref.s();   // A.s  : at compile time, uses the reference's type (A), i.e. hiding
    }
}

CIA Triad:

• Confidentiality: Unauthorized parties cannot read the information.
• Integrity: Information cannot be changed without authorization.
• Availability: Authorized users get the information when they need it.

End-to-end encryption (E2EE) mainly ensures confidentiality and, with a MAC or AEAD, integrity.

Answer: Application Layer (Layer 7).

Reasons:

1. Development time: Tested libraries (OpenSSL, libsodium, Bouncy Castle) can be used directly in the app code. No need to touch the kernel or network devices.
2. Maintainability: The encryption logic stays inside the app. Nothing needs to change if the network, cloud provider or ISP changes, and updates ship like any normal software release.
3. Development cost: No cost for special hardware (VPN concentrator) or for configuring every router.
4. True end-to-end: Only at this layer can intermediate servers, even the company's own servers, not read the data. So confidentiality holds even if data leaks.

Limitations: it must be implemented separately in each app, and key management (key exchange, backup) must be designed carefully. In practice, TLS is also kept underneath Application-layer E2EE (defense in depth).

Core weakness: Basic Diffie-Hellman has no authentication. Nobody verifies that a received public key really belongs to the other party. Public values: prime q and primitive root α.

Attack steps (attacker Darth, as described by Stallings):

1. Darth picks two private keys X_D1 and X_D2 and computes the matching public keys: Y_D1 = α^X_D1 mod q, Y_D2 = α^X_D2 mod q.
2. Alice sends Y_A to Bob. Darth intercepts it, sends Y_D1 to Bob, and computes K2 = Y_A^X_D2 mod q.
3. Bob receives Y_D1 and computes K1 = Y_D1^X_B mod q.
4. Bob sends Y_B to Alice. Darth intercepts it, sends Y_D2 to Alice, and computes K1 = Y_B^X_D1 mod q.
5. Alice receives Y_D2 and computes K2 = Y_D2^X_A mod q.

Result: Alice and Darth share the same key K2, and Bob and Darth share the same key K1. Alice and Bob think they share a secret key with each other. Darth can decrypt and read or modify every message, then re-encrypt it and forward it.

Prevention:

• Authenticate the public keys: DH with digital signatures or certificates (Station-to-Station protocol, signed ECDHE in TLS).
• Compare key fingerprints over a separate channel (e.g. Signal's safety number).
• Use a pre-shared key or PKI.

Logic: x is prime if x ≥ 2 and no number from 2 to √x divides x. Using the loop condition d * d <= x avoids the need for a sqrt function. Each number costs O(√x), total O(n√n). For large n, the Sieve of Eratosthenes is faster: O(n log log n).

/* C */
#include <stdio.h>

int isPrime(int x) {
    if (x < 2) return 0;
    for (int d = 2; d * d <= x; d++)
        if (x % d == 0) return 0;
    return 1;
}

int main(void) {
    int n;
    printf("Enter n: ");
    scanf("%d", &n);
    printf("Primes between 1 and %d:\n", n);
    for (int i = 2; i <= n; i++)
        if (isPrime(i))
            printf("%d ", i);
    printf("\n");
    return 0;
}

// Java
import java.util.Scanner;

public class Primes {
    static boolean isPrime(int x) {
        if (x < 2) return false;
        for (int d = 2; d * d <= x; d++)
            if (x % d == 0) return false;
        return true;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter n: ");
        int n = sc.nextInt();
        for (int i = 2; i <= n; i++)
            if (isPrime(i))
                System.out.print(i + " ");
        System.out.println();
    }
}

Sample: Enter n: 30 → 2 3 5 7 11 13 17 19 23 29. 1 is not prime, so the loop starts at 2.

Pattern: The differences between adjacent terms are 1, 2, 3, 4, …. So each term is the previous term plus k (k = 1, 2, 3, …).

Check: t₅ = 1 + 5·4/2 = 11 ✔; S₅ = 5 + 4·5·6/6 = 5 + 20 = 25 = 1 + 2 + 4 + 7 + 11 ✔

/* C */
#include <stdio.h>

int main(void) {
    int n;
    long long term = 1, sum = 0;
    printf("Enter n: ");
    scanf("%d", &n);
    for (int k = 1; k <= n; k++) {
        printf("%lld%s", term, k < n ? " + " : "");
        sum += term;
        term += k;      /* next term = term + k */
    }
    printf("\nSum = %lld\n", sum);
    return 0;
}

// Java
import java.util.Scanner;

public class SeriesSum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter n: ");
        int n = sc.nextInt();
        long term = 1, sum = 0;
        for (int k = 1; k <= n; k++) {
            System.out.print(term + (k < n ? " + " : ""));
            sum += term;
            term += k;
        }
        System.out.println("\nSum = " + sum);
        // closed form check:
        long f = n + (long)(n - 1) * n * (n + 1) / 6;
        System.out.println("Formula = " + f);
    }
}

Sample: n = 5 → 1 + 2 + 4 + 7 + 11, Sum = 25. For n = 7 the terms go up to 16 and 22, Sum = 63 (by formula 7 + 6·7·8/6 = 63 ✔).

Pattern analysis: Row i has i digits. Odd rows start with 1 and even rows start with 0, then 1 and 0 alternate. Both rules combine into one: if (i + j) is even print 1, if odd print 0 (i and j counted from 1).

/* C */
#include <stdio.h>

int main(void) {
    int n;
    printf("Enter n: ");
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++)
            printf("%d", (i + j) % 2 == 0 ? 1 : 0);
        printf("\n");
    }
    return 0;
}

// Java
import java.util.Scanner;

public class BinaryFloyd {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            StringBuilder row = new StringBuilder();
            for (int j = 1; j <= i; j++)
                row.append((i + j) % 2 == 0 ? 1 : 0);
            System.out.println(row);
        }
    }
}

Check: i = 1: j = 1 → 2 is even → "1". i = 2: 3 → 0, 4 → 1 → "01". i = 4: 5, 6, 7, 8 → "0101". Matches the sample in the question exactly ✔. If you want the usual number-based Floyd's triangle (1 / 2 3 / 4 5 6 …), keep a counter and write printf("%d ", c++) each time.

Remember: i-- (post-decrement) uses the value first, then decrements. --i (pre-decrement) decrements first, then uses the value. So in each call, i decreases by 2 in total. The second printf runs after the recursive call returns, so those values print in reverse order.

Order: going down: 5, 3, 1 → fun(−1) returns → coming back up: −1 (fun(1)), 1 (fun(3)), 3 (fun(5)).

Definition: Polymorphism (poly = many, morph = form) means using the same interface or name to get different behavior from objects of different types. It is one of the four pillars of OOP; the other three are encapsulation, inheritance and abstraction.

// Compile-time: overloading
class Calculator {
    int    add(int a, int b)          { return a + b; }
    double add(double a, double b)    { return a + b; }
    int    add(int a, int b, int c)   { return a + b + c; }
}

// Runtime: overriding
abstract class Account {
    abstract double interest(double balance);
}
class Savings extends Account {
    @Override double interest(double b) { return b * 0.05; }
}
class FixedDeposit extends Account {
    @Override double interest(double b) { return b * 0.09; }
}

public class Bank {
    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println(c.add(2, 3));        // 5    (int version)
        System.out.println(c.add(2.5, 3.5));    // 6.0  (double version)

        Account[] list = { new Savings(), new FixedDeposit() };
        for (Account a : list)                    // same call, different behavior
            System.out.println(a.interest(10000)); // 500.0, 900.0
    }
}

Benefits: Adding a new account type does not require changing Bank's loop (Open–Closed principle). Code becomes reusable and extensible.

In the ER model, a relationship is an association between two or more entities. It is classified in three ways.

(a) By cardinality (mapping)

(b) By degree

• Unary (recursive): An entity is related to itself, e.g. Employee manages Employee, or Node next Node (token ring).
• Binary: Two entities, e.g. Customer holds Account. This is the most common.
• Ternary: Three entities together, e.g. Doctor–Patient–Medicine (prescribes), or Supplier–Part–Project.

(c) By participation

• Total (mandatory): Every record must take part in the relationship, e.g. every Loan must have a Borrower. In an ER diagram it is shown with a double line.
• Partial (optional): Not every record needs to take part, e.g. not every Customer has a Loan.

If "relation" means a table: base relation (stored table), view (virtual relation) and query result (derived relation). Add this in one line at the end of the answer if needed.

Model answer (adapt it to your own project):

1. Project overview: "Micro-Loan Management System" — a web application that manages loan applications, approval, installment collection and reports for an NGO or microfinance institution. About 50 field workers and 10 branch managers use it; about 20,000 customer records.

2. Technology and my role: Java (Spring Boot) REST API, MySQL, React frontend, Git and Docker. As backend developer, I built the database design, the installment calculation module and reporting. Work followed Agile (2-week sprints).

3. Result and lessons: A real-time dashboard replaced paper registers, and calculation errors fell to almost zero. Lessons: ensure data integrity (transactions, constraints) from the start, measure performance before optimizing, and keep regular communication with users. As a bank Assistant Programmer, this experience applies directly to building CBS-adjacent apps or internal tools.