Isomorphic Pairs:

• Graph 1 and Graph 2 are isomorphic because they have the same number of vertices, same number of edges, and identical degree sequence with preserved adjacency structure.
• Graph 3 and Graph 4 are also isomorphic since their vertex connections follow the same pattern, even though their drawings look different.

Graph-1:
Vertices = 6
(u1, u2, u3, u4, u5, u6)
Degree sequence = (3, 3, 3, 3, 3, 3)

Graph-2:
Vertices = 6
(v1, v2, v3, v4, v5, v6)
Degree sequence = (3, 3, 3, 3, 3, 3)

Conclusion for Graph-1 & Graph-2:
Both graphs have the same number of vertices (6) and the same degree sequence, so they are isomorphic.

Graph-3:
Vertices = 6
(u1, u2, u3, u4, u5, u6)
Degree sequence = (3, 3, 2, 2, 3, 3)

Graph-4:
Vertices = 6
(v1, v2, v3, v4, v5, v6)
Degree sequence = (2, 3, 3, 2, 2, 3)

Conclusion for Graph-3 & Graph-4:
have not the identical degree sequences, so they are not isomorphic.

Quick Sort Algorithm Quick Sort is a divide-and-conquer sorting algorithm. It works by selecting a pivot element, partitioning the array into two parts (elements smaller than pivot and elements greater than pivot), and then recursively sorting the sub-arrays. It is fast and widely used in practice.

Steps of Quick Sort Choose a pivot → Partition the array → Recursively apply Quick Sort on left and right sub-arrays.

Worst-Case Time Complexity The worst-case time complexity of Quick Sort is O(n²).

When does Worst Case Occur? Worst case occurs when the pivot element is always the smallest or largest element in the array.
Examples: already sorted array, reverse sorted array (when first or last element is chosen as pivot).

Why does this happen? In this case, partitioning creates highly unbalanced sub-arrays (one with n−1 elements and the other with 0). This leads to maximum number of recursive calls, resulting in O(n²) time complexity.

Given
Logical address space = 512 pages
Page size = 2 KB = 2048 bytes
Physical memory = 128 frames

a) Bits required in the Logical Address
Number of pages = 512 = 2⁹ → Page number bits = 9 bits
Page size = 2048 bytes = 2¹¹ → Offset bits = 11 bits
So, Logical address bits = Page number bits + Offset bits = 9 + 11 = 20 bits

b) Bits required in the Physical Address
Number of frames = 128 = 2⁷ → Frame number bits = 7 bits
Offset remains same = 11 bits
So, Physical address bits = Frame number bits + Offset bits = 7 + 11 = 18 bits

Why DNS primarily uses UDP instead of TCP
DNS mainly uses UDP because it is fast and lightweight. UDP does not require connection establishment, which reduces delay and overhead. Most DNS queries and responses are small in size and can easily fit within a single UDP packet. Using UDP allows DNS to provide quick responses, which is important for fast web browsing. TCP is only used in special cases, such as zone transfers or when the response size is too large.

DNS Name Resolution Process for www.companybd.com

1. The user enters www.companybd.com in the web browser and presses Enter.
2. The browser first checks its local DNS cache to see if the IP address is already available.
3. If not found, the request is sent to the local DNS resolver (usually provided by the ISP).
4. The resolver contacts the Root DNS Server, which directs it to the .com Top-Level Domain (TLD) server.
5. The TLD server provides the address of the authoritative DNS server for companybd.com.
6. The authoritative DNS server returns the IP address of www.companybd.com.
7. The resolver sends the IP address back to the browser and stores it in cache for future use.
8. Using the obtained IP address, the browser connects to the web server and loads the website.

Thrashing in Operating System
Thrashing is a condition in an operating system where the system spends most of its time swapping pages in and out of memory instead of executing actual processes. It mainly occurs in a demand-paged virtual memory system when there are not enough frames to support the working sets of active processes.

How Thrashing Occurs in Demand Paging
In demand paging, pages are loaded into memory only when they are needed. If too many processes are running and physical memory is insufficient, frequent page faults occur. The OS continuously replaces pages, but the required pages are again needed immediately, causing excessive paging activity. This situation leads to thrashing.

Impact on CPU Utilization
During thrashing, CPU utilization becomes very low because the CPU waits for disk I/O operations caused by page faults. Even though many processes are active, the CPU remains mostly idle.

Impact on System Performance
Overall system performance degrades severely. Response time increases, throughput decreases, and the system becomes slow and inefficient. To handle thrashing, the OS may reduce the degree of multiprogramming or use working set and page fault frequency control techniques.

#include <stdio.h>
/* Function to calculate sum of even numbers from 1 to n */
int sumOfEven(int n) {
    int sum = 0;
    for (int i = 2; i <= n; i += 2) {
        sum += i;
    }
    return sum;
}
int main() {
    int n, result;
    printf("Enter an integer: ");
    scanf("%d", &n);
    result = sumOfEven(n);
    printf("Sum of even numbers from 1 to %d = %d\n", n, result);
    return 0;
}

    
Sample I/O:
  Enter an integer: 50
Sum of even numbers from 1 to 50 = 650
=== Code Execution Successful ===

#include <iostream>
using namespace std;

class BankAccount {
private:
    string name;
    int accountNumber;
    double balance;

public:
    void setDetails(string n, int accNo, double bal) {
        name = n;
        accountNumber = accNo;
        balance = bal;
    }

    void deposit(double amount) {
        balance += amount;
        cout << "Deposited: " << amount << endl;
    }

    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            cout << "Withdrawn: " << amount << endl;
        } else {
            cout << "Insufficient balance" << endl;
        }
    }
    void display() {
        cout << "\nAccount Details\n";
        cout << "Account Holder: " << name << endl;
        cout << "Account Number: " << accountNumber << endl;
        cout << "Balance: " << balance << endl;
    }
};
int main() {
    BankAccount acc;
    string name;
    int accNo;
    double bal, dep, wit;
    cout << "Enter account holder name: ";
    getline(cin, name);

    cout << "Enter account number: ";
    cin >> accNo;
    cout << "Enter initial balance: ";
    cin >> bal;
    acc.setDetails(name, accNo, bal);
    cout << "Enter amount to deposit: ";
    cin >> dep;
    acc.deposit(dep);
    cout << "Enter amount to withdraw: ";
    cin >> wit;
    acc.withdraw(wit);
    acc.display();
    return 0;
}

    
        Sample I/O:
 Enter account holder name: itjobqns
Enter account number: 02252016
Enter initial balance: 5000
Enter amount to deposit: 300
Deposited: 300
Enter amount to withdraw: 100
Withdrawn: 100
Account Details
Account Holder: itjobqns
Account Number: 2252016
Balance: 5200
=== Code Execution Successful ===

SQL Query
The following query displays the region, average sale amount, and total number of sales for each region where the average sale amount is greater than BDT 50,000 and the total number of sales is at least 3.

Addressing Modes in 8086 Microprocessor

1) Immediate Addressing Mode
In immediate addressing mode, the actual data (operand) is specified directly in the instruction itself.

Example:

Here, 1234H is the immediate data loaded directly into the AX register.

2) Register Addressing Mode
In register addressing mode, the operand is stored in a CPU register, and the instruction specifies the register name.

Example:

Here, data is moved from register AX to register BX.

3) Direct Addressing Mode
In direct addressing mode, the memory address of the operand is directly specified in the instruction.

Example:

Here, the data stored at memory location 2000H is loaded into the AX register.

ACID Properties in Database Transactions
ACID properties are a set of rules that ensure reliability, consistency, and integrity of a database during transactions. Each transaction must satisfy these four properties to maintain a correct database state.

1) Atomicity
Atomicity ensures that a transaction is treated as a single unit. Either all operations of the transaction are completed successfully, or none of them are applied. If any part fails, the entire transaction is rolled back, preventing partial updates.

2) Consistency
Consistency ensures that a transaction moves the database from one valid state to another valid state. All integrity constraints, rules, and conditions must be satisfied before and after the transaction.

3) Isolation
Isolation ensures that multiple transactions executed at the same time do not interfere with each other. Each transaction behaves as if it is executed independently, preventing problems like dirty reads or lost updates.

4) Durability
Durability guarantees that once a transaction is committed, its changes are permanently stored in the database. Even if the system crashes, the committed data will not be lost.

SOAP API
SOAP (Simple Object Access Protocol) is a protocol used in web services to exchange structured information between applications. It relies on XML for message format and follows strict standards. SOAP is commonly used in enterprise-level applications where security and reliability are critical.

RESTful API
REST (Representational State Transfer) is an architectural style for designing web services. RESTful APIs use standard HTTP methods such as GET, POST, PUT, DELETE and can exchange data in multiple formats like JSON, XML, or plain text. REST is lightweight and widely used in modern web and mobile applications.

Main Difference (Data Exchange)
The main difference is that SOAP exchanges data only in XML format, while REST can exchange data in multiple formats, most commonly JSON.

Reinforcement Learning (RL)
Reinforcement Learning is a type of machine learning where an agent learns by interacting with an environment. The agent takes actions and receives rewards or penalties, and its goal is to maximize cumulative reward over time.
Learning Mechanism: Trial-and-error with reward feedback.
Data Usage: Generated through interaction with the environment.
Applications: Robotics, game playing (AlphaGo), autonomous vehicles, recommendation systems.

Deep Learning (DL)
Deep Learning is a subset of machine learning that uses multi-layer neural networks to automatically learn features from large datasets. It is inspired by the human brain structure.
Learning Mechanism: Supervised/unsupervised learning using deep neural networks.
Data Usage: Requires large, labeled or unlabeled datasets.
Applications: Image recognition, speech recognition, natural language processing, medical diagnosis.

Federated Learning (FL)
Federated Learning is a distributed learning approach where the model is trained across multiple devices without sharing raw data. Only model updates are sent to a central server.
Learning Mechanism: Collaborative learning with local model updates.
Data Usage: Data remains on local devices (privacy-preserving).
Applications: Mobile keyboards, healthcare data analysis, IoT systems, privacy-sensitive applications.

Use of Generative AI in a Government Citizen Service Chatbot
Generative AI can be used to power a government chatbot by enabling it to automatically generate human-like responses, summarize long policy documents, and provide accurate policy-related information to citizens. Using large language models, the chatbot can understand citizens’ questions in natural language and generate clear, context-aware answers. It can also analyze official documents, extract key points, and present simplified summaries, making government services more accessible and efficient.

Role of Explainable AI (XAI)
Explainable AI (XAI) techniques help ensure that the chatbot’s responses are transparent, reliable, and accountable. XAI allows the system to explain why a particular response was generated by showing the source policy, rules, or reasoning behind the answer. This helps government officials and citizens trust the system and verify that the information is correct and unbiased.

Benefits of Using XAI

• Transparency: Citizens can understand how and from where the answer was derived.
• Reliability: Officials can audit and validate chatbot decisions.
• Accountability: The system can justify responses, reducing the risk of misinformation.
• Public Trust: Clear explanations increase confidence in AI-based public services.

Confidentiality, Integrity, and Availability (CIA Triad)
The CIA Triad represents three fundamental principles used to protect organizational data and information systems. These principles work together to ensure data security and trustworthiness.

Confidentiality
Confidentiality ensures that sensitive information is accessible only to authorized users. Techniques such as encryption, authentication, and access control are used to prevent unauthorized data disclosure.

Integrity
Integrity ensures that data remains accurate, complete, and unaltered during storage or transmission. Mechanisms like hashing, checksums, and digital signatures help detect and prevent unauthorized data modification.

Availability
Availability ensures that data and systems are accessible when needed by authorized users. Redundancy, backups, and protection against attacks like DoS help maintain system availability.

How They Work Together
All three principles must be maintained simultaneously. For example, data may be confidential and accurate, but if systems are unavailable, the organization cannot operate effectively. Weakness in any one principle can compromise overall security.

Real-World Security Breach Example
Equifax Data Breach (2017): In this incident, attackers exploited a vulnerability to access sensitive personal data of millions of users. Confidentiality was compromised as private data was exposed, and Integrity was also affected because attackers accessed systems without authorization.

Testing a 4-Digit PIN Input Field
To test a 4-digit PIN input field in a banking application, I would verify that the system accepts only numeric values with exactly 4 digits and rejects any other input. This involves both functional testing and validation testing at the input level.

Test Cases

• Valid Input: Enter 1234 → Should be accepted (correct 4-digit number).
• Less than 4 digits: Enter 123 → Should be rejected (too short).
• More than 4 digits: Enter 12345 → Should be rejected (too long).
• Non-numeric input: Enter 12ab → Should be rejected (contains letters).
• Special characters: Enter 12@# → Should be rejected.
• Empty input: Leave the field blank → Should be rejected.

Importance of This Testing
This testing is important for security because it prevents invalid or malicious inputs that could be used to bypass authentication. It also improves reliability by ensuring that the system behaves correctly and consistently, reducing login errors and protecting user accounts.