সমাধানকৃত বিগত প্রশ্ন: ২০২৩ ও ২০২৪

উত্তর: Extract-Root অপারেশনগুলো ক্রমানুসারে 8, 11, 7, 6 ফেরত দেয়। শেষে heap-এ থাকে [5, 4]।

যুক্তি: একটি S-record ও একটি U-record তখনই সম্পর্কিত, যখন একটি সাধারণ T-record (tid) থাকে, যেখানে R-এ (sid, tid) আছে এবং Q-তে (tid, uid) আছে। তাই R ও Q-কে tid-এর ওপর join করতে হবে।

-- সংক্ষিপ্ত রূপ (R.sid ও Q.uid foreign key, তাই S ও U join না করলেও চলে)
SELECT R.sid, Q.uid
FROM   R
JOIN   Q ON R.tid = Q.tid;

-- পূর্ণ রূপ (S ও U-তে সত্যিই record আছে কিনা তাও নিশ্চিত করে)
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" মানে Composition (ভরাট diamond ◆)। অংশটি সম্পূর্ণের বাইরে আলাদাভাবে টিকে থাকে না: বই মুছে ফেললে তার part, chapter ও section-ও মুছে যায়। Multiplicity হলো সম্পূর্ণের দিকে 1 এবং অংশের দিকে 1..* ("several")।

ব্যাখ্যা লিখুন: (১) চারটি class এবং প্রতিটির attribute; (২) সম্পর্কগুলো composition, কারণ chapter কেবল একটি part-এর ভেতরেই থাকে; (৩) প্রতিটি সম্পর্কের multiplicity 1 → 1..*। চাইলে operation যোগ করতে পারেন, যেমন Book.addPart() বা Chapter.getSections()।

ধাপ ১: FP = 180 × 0.87 = 156.6
ধাপ ২: ধরে নিচ্ছি "performance factor 4" মানে productivity, অর্থাৎ ৪ FP প্রতি person-day।
Effort = 156.6 ÷ 4 = 39.15 ≈ 40 person-days

লজিক: প্রথম উপাদানকে min ধরুন। বাকি উপাদানগুলোর ওপর একবার লুপ চালান; কোনোটি min-এর চেয়ে ছোট হলে 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

C-তে array পাঠালে আসলে pointer যায়, তাই size (n) আলাদা parameter হিসেবে পাঠাতে হয়। Java-তে arr.length থেকে size পাওয়া যায়।

সার্ভারের certificate-এ যে public key আছে, তার জোড়া private key দিয়েই সার্ভার প্রমাণ করে "আমিই আসল সাইট"। এই key চুরি হলে আক্রমণকারী যা করতে পারে:

1. সার্ভারের ছদ্মবেশ (Impersonation): আসল ও বৈধ certificate-সহ একটি ভুয়া সাইট চালাতে পারে। DNS spoofing, ARP spoofing বা ভুয়া Wi-Fi-এর মাধ্যমে ব্যবহারকারীকে সেখানে নিলে ব্রাউজার কোনো সতর্কবার্তা দেখাবে না।
2. Active Man-in-the-Middle: ক্লায়েন্ট ও আসল সার্ভারের মাঝে বসে উভয় দিকের TLS সংযোগ নিজেই শেষ (terminate) করতে পারে। এতে password, OTP, কার্ড নম্বর পড়তে পারে, এবং লেনদেনের পরিমাণ বা গন্তব্য অ্যাকাউন্ট বদলে দিতে পারে।
3. রেকর্ড করা ট্রাফিক ডিক্রিপ্ট করা (passive): সার্ভার RSA key exchange ব্যবহার করলে (TLS 1.2-এর non-forward-secret cipher suite) session key ক্লায়েন্টের পাঠানো premaster secret থেকে আসে, যা ওই public key দিয়ে এনক্রিপ্ট করা। তাই আগে রেকর্ড করা এবং ভবিষ্যতের সব সেশন ডিক্রিপ্ট করা যায়।
   (EC)DHE (Forward Secrecy, TLS 1.3-এ বাধ্যতামূলক) ব্যবহার হলে private key কেবল handshake-এ signing-এর কাজে লাগে। তখন অতীতের রেকর্ড করা ট্রাফিক ডিক্রিপ্ট করা যায় না, তবে active MitM (পয়েন্ট ২) তখনও সম্ভব।
4. সার্ভারের নামে সই করা: একই key দিয়ে অন্য কিছুতে (যেমন code বা message) সই হয়ে থাকলে আক্রমণকারী সার্ভারের নামে জাল সই তৈরি করতে পারে।

Generator-এ ১১টি বিট আছে, তাই এর degree r = 11 − 1 = 10 (CRC remainder ১০ বিটের)।

এখানে L = 10 এবং r = 10, তাই L ≤ r। Generator-এর সর্বোচ্চ ও সর্বনিম্ন (x⁰) বিট দুটিই 1, তাই সব burst error ধরা পড়বে; detection probability = 1 (100%)।

তুলনার জন্য: L = 11 হলে probability = 1 − 1/2⁹ ≈ 0.998; L ≥ 12 হলে 1 − 1/2¹⁰ ≈ 0.999।

List-এ দ্রুত: ১০ লক্ষ নোড ও ৫০ লক্ষ edge-এর একটি sparse graph-এ (যেমন ব্যাংক গ্রাহকের লেনদেন নেটওয়ার্ক) BFS/DFS দিয়ে সব reachable নোড বের করা, বা প্রতিটি নোডের out-degree গোনা। List-এ এতে O(V + E) সময় লাগে, matrix-এ O(V²)।
Matrix-এ দ্রুত: "u থেকে v-তে সরাসরি edge আছে কিনা" বারবার জিজ্ঞাসা করা (O(1) lookup), dense graph-এ Floyd–Warshall all-pairs shortest path, অথবা কোনো vertex universal sink কিনা (in-degree V−1, out-degree 0) তা O(V) সময়ে বের করা।

এটি ব্রাউজারের frame navigation policy নিয়ে প্রশ্ন। বর্তমান ব্রাউজার Descendant Policy মেনে চলে: একটি frame কেবল তার নিজের ভেতরের (descendant) frame-কে অন্য URL-এ নিতে পারে।

1. Pixel delegation-এর যুক্তি: B যদি A-এর display area-র ভেতরে থাকে, তাহলে স্ক্রিনের ওই অংশটি A-রই দেওয়া। A চাইলে এমনিতেই ওই জায়গায় নিজের কনটেন্ট দেখাতে, B-কে সরিয়ে দিতে বা ওপরে কিছু বসাতে পারে। তাই B-কে অন্য origin-এ পাঠানোর অনুমতি দিলে A-এর নতুন কোনো ক্ষমতা যোগ হয় না, আর নিরাপত্তাও কমে না।
2. Same-Origin Policy অক্ষত থাকে: Navigation করলে A, B-এর DOM, cookie বা ডেটা পড়তে পারে না; শুধু B-এর জায়গায় কী লোড হবে তা ঠিক করে। তাই confidentiality ভাঙে না।
3. উদার নীতির ঝুঁকি: যেকোনো frame যেকোনো frame-কে navigate করতে পারলে (permissive policy) একটি আক্রমণকারী frame অন্য সাইটের ভেতরের login বা payment frame-কে ভুয়া পেজে পাঠিয়ে দিতে পারত (frame hijacking / Guninski attack)। ব্যবহারকারী ঠিকানা দেখে আসল সাইট ভাবত, অথচ তথ্য যেত আক্রমণকারীর কাছে।
4. তাই সীমারেখা: "যার স্ক্রিন, তার নিয়ন্ত্রণ।" A কেবল নিজের এলাকার ভেতরের frame বদলাতে পারে। পাশের বা ওপরের অন্য origin-এর frame বদলাতে পারে না।

LRU (Least Recently Used) নিয়মে page fault হলে, সবচেয়ে বেশি সময় ধরে ব্যবহার হয়নি এমন page সরানো হয়। F = fault, H = hit।

সরানোর সিদ্ধান্ত:

• Ref 4-এ সবচেয়ে পুরোনো 1, তাই 1 সরে।
• Ref 1 (৮ম)-এ ক্রম 2, 3, 4 (২ সবচেয়ে পুরোনো), তাই 2 সরে।
• Ref 2 (৯ম)-এ ক্রম 3, 4, 1, তাই 3 সরে।
• Ref 3 (১২তম)-এ ক্রম 4, 2, 1, তাই 4 সরে।
• Ref 4 (১৪তম)-এ ক্রম 2, 3, 1, তাই 2 সরে।

উত্তর: Page faults = 8, hits = 6; fault rate = 8/14 ≈ 57%।

মোট collision: 16-এ ১টি, 17-এ ৩টি, 19-এ ২টি, মোট ৬টি। Index 3 থেকে 8 পর্যন্ত একটানা ভরা অংশটি primary clustering-এর উদাহরণ, যা linear probing-এর প্রধান দুর্বলতা। এর প্রতিকার হলো quadratic probing বা double hashing। Load factor α = 7/13 ≈ 0.54।

Binary heap-এর মতো নম্বর দিলে vertex i-এর children হয় 2i ও 2i+1, আর parent হয় ⌊i/2⌋। Tree-কে undirected graph ধরা হলো।

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

Edge সংখ্যা = V − 1 = 6। List-এ মোট entry ২ × 6 = 12, matrix-এ cell 7 × 7 = 49, যার মাত্র 12টি 1। Tree sparse, তাই এখানে list বেশি সাশ্রয়ী।

Overflow এড়াতে (a / gcd) * b ক্রমে হিসাব করুন। এতে আগে ভাগ হয়, তারপর গুণ।

/* 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))।

যুক্তি: "Romantic comedy" মানে একই movie-র দুটি genre আছে: Romance এবং Comedy। প্রতিটি genre HasGenre-এ আলাদা সারিতে থাকে, তাই দুটি শর্ত একই সারিতে মেলানো যায় না।

-- পদ্ধতি ১: GROUP BY + HAVING (সবচেয়ে পরিষ্কার)
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;

-- পদ্ধতি ২: দুটি IN subquery
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');

উপসংহার: m2 ও m3 overridden। m1 ও m4 compile হবে না, তাই এখানে কোনো hiding ঘটে না। কোনো method-এর parameter list ভিন্ন নয়, তাই কোনো overloading-ও নেই। এছাড়া কোডে দুটি সমস্যা ঠিক করতে হবে: extends a হবে extends A, আর একটি .java ফাইলে দুটি public class থাকতে পারে না, তাই দুটি আলাদা ফাইলে রাখতে হবে।

Hiding ও overloading কখন হতো: A-এর m1 যদি public static void m1() হতো, তাহলে B-এর static m1() সেটিকে hide করত। B-তে যদি public void m3(double d) থাকত, তাহলে সেটি A-এর m3(int)-এর overload হতো।

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  : runtime-এ object-এর type (B) দেখে
        ref.s();   // A.s  : compile time-এ reference-এর type (A) দেখে, অর্থাৎ hiding
    }
}

CIA Triad:

• Confidentiality: অননুমোদিত কেউ তথ্য পড়তে পারবে না।
• Integrity: তথ্য অননুমোদিতভাবে বদলানো যাবে না।
• Availability: অনুমোদিত ব্যবহারকারী প্রয়োজনের সময় তথ্য পাবে।

End-to-end encryption (E2EE) মূলত confidentiality ও (MAC বা AEAD ব্যবহার করলে) integrity নিশ্চিত করে।

উত্তর: Application Layer (Layer 7)।

কারণ:

1. Development time: পরীক্ষিত লাইব্রেরি (OpenSSL, libsodium, Bouncy Castle) সরাসরি অ্যাপের কোডে ব্যবহার করা যায়। Kernel বা নেটওয়ার্ক ডিভাইসে হাত দিতে হয় না।
2. Maintainability: এনক্রিপশন লজিক অ্যাপের ভেতরেই থাকে। নেটওয়ার্ক, ক্লাউড প্রোভাইডার বা ISP বদলালেও কিছু পরিবর্তন করতে হয় না, এবং আপডেট সাধারণ সফটওয়্যার রিলিজের মতো দেওয়া যায়।
3. Development cost: বিশেষ হার্ডওয়্যার (VPN concentrator) বা প্রতিটি router কনফিগারেশনের খরচ লাগে না।
4. প্রকৃত end-to-end: একমাত্র এই লেয়ারেই মাঝের সার্ভার, এমনকি কোম্পানির নিজের সার্ভারও, ডেটা পড়তে পারে না। ফলে ডেটা লিক হলেও confidentiality বজায় থাকে।

সীমাবদ্ধতা: প্রতিটি অ্যাপে আলাদাভাবে বাস্তবায়ন করতে হয় এবং key management (key exchange, backup) সাবধানে ডিজাইন করতে হয়। বাস্তবে Application-layer E2EE-র নিচে TLS-ও রাখা হয় (defense in depth)।

মূল দুর্বলতা: সাধারণ Diffie-Hellman-এ authentication নেই। কেউ যাচাই করে না যে প্রাপ্ত public key আসলে অপর পক্ষেরই। প্রকাশ্য মান: prime q ও primitive root α।

আক্রমণের ধাপ (আক্রমণকারী Darth, Stallings-এর বিবরণ অনুযায়ী):

1. Darth দুটি private key X_D1 ও X_D2 বেছে নেয় এবং সংশ্লিষ্ট public key হিসাব করে: Y_D1 = α^X_D1 mod q, Y_D2 = α^X_D2 mod q।
2. Alice, Bob-কে Y_A পাঠায়। Darth সেটি আটকে দিয়ে Bob-কে Y_D1 পাঠায়, এবং নিজে হিসাব করে K2 = Y_A^X_D2 mod q।
3. Bob, Y_D1 পেয়ে হিসাব করে K1 = Y_D1^X_B mod q।
4. Bob, Alice-কে Y_B পাঠায়। Darth সেটি আটকে দিয়ে Alice-কে Y_D2 পাঠায়, এবং হিসাব করে K1 = Y_B^X_D1 mod q।
5. Alice, Y_D2 পেয়ে হিসাব করে K2 = Y_D2^X_A mod q।

ফল: Alice ও Darth একই key K2 পায়, আর Bob ও Darth একই key K1 পায়। Alice ও Bob ভাবে তারা নিজেদের মধ্যে একটি গোপন key ভাগ করেছে। Darth প্রতিটি বার্তা ডিক্রিপ্ট করে পড়তে বা বদলাতে পারে, তারপর আবার এনক্রিপ্ট করে সামনে পাঠায়।

প্রতিরোধ:

• Public key-কে authenticate করা: digital signature বা certificate-সহ DH (Station-to-Station protocol, TLS-এর signed ECDHE)।
• বাইরের কোনো চ্যানেলে key fingerprint মিলিয়ে দেখা (যেমন Signal-এর safety number)।
• Pre-shared key বা PKI ব্যবহার করা।

লজিক: x prime হবে যদি x ≥ 2 হয় এবং 2 থেকে √x পর্যন্ত কোনো সংখ্যা দিয়ে x বিভাজ্য না হয়। লুপের শর্ত d * d <= x লিখলে sqrt function লাগে না। প্রতিটি সংখ্যার জন্য O(√x), মোট O(n√n)। বড় n-এর জন্য Sieve of Eratosthenes দ্রুততর: 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 prime নয়, তাই লুপ 2 থেকে শুরু।

Pattern: পাশাপাশি পদের পার্থক্য 1, 2, 3, 4, …। তাই প্রতিটি পদ আগের পদের সঙ্গে k যোগ করে পাওয়া যায় (k = 1, 2, 3, …)।

যাচাই: 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। n = 7 হলে পদগুলো 16 ও 22 পর্যন্ত যায়, Sum = 63 (সূত্রে 7 + 6·7·8/6 = 63 ✔)।

Pattern বিশ্লেষণ: i-তম সারিতে i টি অঙ্ক। বিজোড় সারি 1 দিয়ে আর জোড় সারি 0 দিয়ে শুরু হয়, তারপর 1 ও 0 পালাক্রমে আসে। দুটি নিয়মকে একসাথে লেখা যায়: (i + j) জোড় হলে 1, বিজোড় হলে 0 (i ও j 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);
        }
    }
}

যাচাই: i = 1: j = 1 → 2 জোড় → "1"। i = 2: 3 → 0, 4 → 1 → "01"। i = 4: 5, 6, 7, 8 → "0101"। প্রশ্নের নমুনার সঙ্গে হুবহু মেলে ✔। প্রচলিত সংখ্যাভিত্তিক Floyd's triangle (1 / 2 3 / 4 5 6 …) চাইলে একটি counter রেখে প্রতিবার printf("%d ", c++) লিখুন।

মনে রাখুন: i-- (post-decrement) আগে মান ব্যবহার করে, তারপর কমায়। --i (pre-decrement) আগে কমায়, তারপর মান ব্যবহার করে। তাই প্রতিটি call-এ i মোট ২ কমে। দ্বিতীয় printf recursive call ফেরার পরে চলে, তাই ওই মানগুলো উল্টো ক্রমে ছাপা হয়।

ক্রম: নামার পথে 5, 3, 1 → fun(−1) ফেরে → ওঠার পথে −1 (fun(1)), 1 (fun(3)), 3 (fun(5))।

Schema সংশোধন (উত্তরে উল্লেখ করুন): Employee-র DeptCode-এর type Department-এর DeptCode-এর মতোই INT হওয়া উচিত, যাতে join ও foreign key ঠিকমতো কাজ করে। মূল DDL-এ Commission INT-এর পরে কমা নেই এবং শেষে একটি বাড়তি কমা আছে; দুটোই syntax error।

CREATE TABLE Department (
    DeptCode  INT PRIMARY KEY,
    DeptName  VARCHAR(20),
    Location  VARCHAR(20)
);
CREATE TABLE Employee (
    EmpCode    INT PRIMARY KEY,
    EmpFname   VARCHAR(20),
    Salary     INT,
    Commission INT,
    DeptCode   INT REFERENCES Department(DeptCode)
);

-- (a) Total salary; Commission NULL হলে 0 ধরা হয়
SELECT EmpFname,
       Salary + COALESCE(Commission, 0) AS TotalSalary
FROM   Employee;

-- (b) গড় বেতনের চেয়ে বেশি পান যাঁরা, তাঁদের নাম ও Location
SELECT   e.EmpFname, d.Location
FROM     Employee e
JOIN     Department d ON e.DeptCode = d.DeptCode
WHERE    e.Salary > (SELECT AVG(Salary) FROM Employee)
ORDER BY e.EmpFname;

-- (c) প্রতিটি EmpFname-এ কতজন কর্মচারী, সংখ্যার ক্রমে
SELECT   EmpFname, COUNT(EmpCode) AS EmpCount
FROM     Employee
GROUP BY EmpFname
ORDER BY EmpCount ASC;

SELECT d.DeptName, COUNT(e.EmpCode) AS EmpCount
FROM Department d LEFT JOIN Employee e ON e.DeptCode = d.DeptCode
GROUP BY d.DeptName
ORDER BY EmpCount ASC;

সংজ্ঞা: Polymorphism (poly = অনেক, morph = রূপ) মানে একই interface বা নাম দিয়ে ভিন্ন ভিন্ন type-এর object-এর সঙ্গে ভিন্ন আচরণ করা। এটি OOP-এর চারটি স্তম্ভের একটি; বাকি তিনটি encapsulation, inheritance ও 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)                    // একই call, ভিন্ন আচরণ
            System.out.println(a.interest(10000)); // 500.0, 900.0
    }
}

সুবিধা: নতুন account type যোগ করলে Bank-এর লুপ বদলাতে হয় না (Open–Closed principle)। কোড পুনর্ব্যবহারযোগ্য ও extensible হয়।

ER model-এ relationship মানে দুই বা ততোধিক entity-র মধ্যে সম্পর্ক। একে তিনভাবে শ্রেণিবিভাগ করা হয়।

(ক) Cardinality (mapping) অনুযায়ী

(খ) Degree অনুযায়ী

• Unary (recursive): একই entity নিজের সঙ্গে সম্পর্কিত, যেমন Employee manages Employee, বা Node next Node (token ring)।
• Binary: দুটি entity, যেমন Customer holds Account। এটিই সবচেয়ে প্রচলিত।
• Ternary: তিনটি entity একসাথে, যেমন Doctor–Patient–Medicine (prescribes), বা Supplier–Part–Project।

(গ) Participation অনুযায়ী

• Total (mandatory): প্রতিটি record-কে সম্পর্কে থাকতেই হবে, যেমন প্রতিটি Loan-এর একজন Borrower থাকবেই। ER diagram-এ এটি দুই দাগ দিয়ে দেখানো হয়।
• Partial (optional): সব record-এর থাকা জরুরি নয়, যেমন সব Customer-এর Loan নেই।

"Relation" শব্দটি দিয়ে যদি টেবিল বোঝানো হয়: base relation (সংরক্ষিত টেবিল), view (virtual relation) ও query result (derived relation)। প্রয়োজনে উত্তরের শেষে এক লাইনে যোগ করুন।

মডেল উত্তর (নিজের প্রজেক্ট অনুযায়ী বদলে নিন):

১. প্রজেক্ট পরিচিতি: "Micro-Loan Management System" — একটি ওয়েব অ্যাপ্লিকেশন, যা একটি NGO বা ক্ষুদ্রঋণ প্রতিষ্ঠানের ঋণ আবেদন, অনুমোদন, কিস্তি সংগ্রহ ও রিপোর্ট পরিচালনা করে। ব্যবহারকারী প্রায় ৫০ জন মাঠকর্মী ও ১০ জন শাখা ব্যবস্থাপক; গ্রাহকের রেকর্ড প্রায় ২০,০০০।

২. প্রযুক্তি ও আমার ভূমিকা: Java (Spring Boot) REST API, MySQL, React frontend, Git ও Docker। আমি backend ডেভেলপার হিসেবে database design, কিস্তি হিসাবের মডিউল ও রিপোর্টিং তৈরি করেছি। কাজ চলেছে Agile (২ সপ্তাহের sprint) পদ্ধতিতে।

৩. ফলাফল ও শিক্ষা: কাগজের খাতার বদলে রিয়েল-টাইম ড্যাশবোর্ড চালু হয় এবং হিসাবের ভুল প্রায় শূন্যে নেমে আসে। শিক্ষা: শুরুতেই ডেটার অখণ্ডতা (transaction, constraint) নিশ্চিত করা, performance মেপে তারপর অপ্টিমাইজ করা, আর ব্যবহারকারীর সঙ্গে নিয়মিত যোগাযোগ রাখা জরুরি। ব্যাংকের Assistant Programmer হিসেবে CBS-সংলগ্ন অ্যাপ বা ইন্টারনাল টুল তৈরিতে এই অভিজ্ঞতা সরাসরি কাজে লাগবে।