(i) Net ID and Host ID:
The CIDR notation /20 means the first 20 bits are for the Net ID and the remaining 12 bits are for the Host ID.
Net ID (first 20 bits): 105.38.80.0/20
Host ID (remaining 12 bits) represents the specific host in the network.

(ii) Network Address and Broadcast Address:
Network Address: Set all host bits to 0.
=>105.38.80.0 (first 20 bits).
Broadcast Address: Set all host bits to 1.
=>105.38.95.255 (last 12 bits as 1).

(iii) Network Size:
12 host bits: 2^12 = 4096 total addresses.

Usable addresses: 4096 - 2 = 4094 (since network and broadcast are reserved).

(iv) Classful IP Address:
The first octet 105 in binary is 01101001, which starts with 0.

This indicates the address is Class A (1.0.0.0 to 127.255.255.255).

Gantt Chart:

Average Time: 25/4 = 6.25

Examples
Impact: Dot matrix printer, Daisy wheel printer,
Non Impact: Inkjet printer, Laser printer

Given:

• Hit Ratio = 75% = 0.75
• RAM Access Time = 10 ns = 10 × 10^-9 seconds
• SSD Access Time = 10 ms = 10 × 10^-3 seconds

We Know

Average Access Time = (Hit Ratio × RAM Time) + (Miss Ratio × SSD Time)

Miss Ratio = 1 - Hit Ratio = 1 - 0.75 = 0.25

Calculation:

Average Access Time = (0.75 × 10 × 10^-9) + (0.25 × 10 × 10^-3)
= 7.5 × 10^-9 + 2.5 × 10^-3
= 0.0000000075 + 0.0025 = 0.0025000075 seconds

=0.0025000075 × 1000 = 2.5000075 ms

Average Access Time ≈ 2.5 milliseconds

Method Overloading and Method Overriding

Method Overloading

Method Overloading is an Object-Oriented Programming (OOP) feature that allows a class to have multiple methods with the same name but different parameter lists. The methods must differ in the number, type, or order of parameters. This enables the same method name to perform different tasks based on the arguments passed to it. Method Overloading is an example of Compile-time Polymorphism (Static Polymorphism).

Characteristics of Method Overloading

• Methods have the same name.
• Methods must have different parameter lists (number, type, or order of parameters).
• Return type alone cannot distinguish overloaded methods.
• It occurs within the same class.
• It is resolved during compile time.

Example

Suppose a class has a method named add().
add(int a, int b) → Adds two integers.
add(int a, int b, int c) → Adds three integers.
add(double a, double b) → Adds two decimal numbers.

Although all methods have the same name add(), they perform different operations depending on the parameters supplied.

Method Overriding

Method Overriding is an Object-Oriented Programming (OOP) feature in which a subclass provides its own implementation of a method that is already defined in its superclass. The overriding method must have the same name, same parameter list, and compatible return type as the parent method. Method Overriding is an example of Run-time Polymorphism (Dynamic Polymorphism).

Characteristics of Method Overriding

• Occurs between a superclass and a subclass.
• The method name, parameters, and return type remain the same.
• The child class provides a new implementation of the inherited method.
• It is resolved during runtime using dynamic method dispatch.

Example

Suppose a parent class Animal contains a method named sound() that prints "Animal makes a sound".
A child class Dog overrides the sound() method to print "Dog barks".
When the sound() method is called using a Dog object, the overridden method in the Dog class is executed.

Difference Between Method Overloading and Method Overriding

NAT (Network Address Translation) is a networking technique used in routers to translate private IP addresses into a public IP address before sending data to the Internet.

It allows multiple devices in a private network to access the Internet using a single public IP address.

Why NAT is Used

• IP Address Conservation: NAT helps save public IPv4 addresses by allowing many devices to share one public IP.
• Security: Internal private IP addresses are hidden from external networks, which increases network security.
• Internet Access: It allows devices in a private network to communicate with external networks like the Internet.

How NAT Translation Works

• A device in a private network sends a request to the Internet using its private IP address.
• The router replaces the private IP address with its own public IP address.
• The request is sent to the destination server on the Internet.
• When the response comes back, the router converts the public IP address back to the original private IP address and sends the data to the correct device.

Swapping in Operating System

Swapping is a memory management technique used by an operating system to efficiently manage the limited primary memory (RAM) and the larger but slower secondary memory such as a hard disk or SSD.

What is Swapping?
Swapping is the process of moving entire processes between primary memory (RAM) and secondary memory. When the RAM becomes full and the system needs memory to run active programs, the operating system moves some inactive or low-priority processes from RAM to secondary memory. This process is called swapping out.

Later, when the swapped-out process is required again, the operating system brings the process back into RAM from secondary memory. This process is called swapping in.

Through this back-and-forth movement of processes between RAM and secondary memory, the operating system can run more processes than the physical memory can normally support.

Confidentiality:
Confidentiality means keeping information secret and accessible only to authorized users. It ensures that sensitive data is not viewed or accessed by unauthorized people.

Example: Encrypting emails so that only the intended receiver can read the message.

Integrity:
Integrity means that the information is accurate, complete, and unchanged. It ensures that data is not modified or tampered with during storage or transmission.

Example: Using checksums or digital signatures to verify that a file has not been altered.

Relationship Between Confidentiality and Integrity

• Integrity without Confidentiality: It is possible to have integrity without confidentiality. For example, a public website may allow everyone to view the data (no confidentiality), but it uses checksums or digital signatures to ensure the data has not been altered.
• Confidentiality without Integrity: It is also possible to have confidentiality without integrity. For example, data may be encrypted so that only authorized users can read it, but if someone modifies the encrypted message without detection, the integrity of the data is compromised.

Each circuit has a transmission rate of (1.536 Mbps)/24 = 64kbps

It takes 640,000 bits/64 kbps = 10 seconds to transmit the file.

To this time, we have to add the time taken to establish the connection. That makes it 10.5 seconds.

ER-Diagram:

Schema Diagram:

Merge Sort Algorithm

Merge Sort is a divide and conquer algorithm. It recursively splits an array into two halves, sorts each half, and then merges the sorted halves back together.

Merge Sort Function

void MergeSort(int A[], int p, int r) {
    if (p < r) {
        int q = (p + r) / 2;  // Find the middle index
        MergeSort(A, p, q);    // Recursively sort the left half
        MergeSort(A, q + 1, r); // Recursively sort the right half
        merge(A, p, q, r);      // Merge the sorted halves
    }
}

Merge Function

void merge(int A[], int p, int q, int r) {
    int n1 = q - p + 1;
    int n2 = r - q;
    int L[n1], R[n2];

    // Copy data into temporary arrays
    for (int i = 0; i < n1; i++) L[i] = A[p + i];
    for (int j = 0; j < n2; j++) R[j] = A[q + 1 + j];

    int i = 0, j = 0, k = p;
    // Merge the two subarrays
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) A[k++] = L[i++];
        else A[k++] = R[j++];
    }

    // Copy remaining elements of L[]
    while (i < n1) A[k++] = L[i++];
    // Copy remaining elements of R[]
    while (j < n2) A[k++] = R[j++];
}

Physical Address Space = 64MB = \(2^{26}\text{B}\)

Virtual Address = 32-bits, \(\therefore\) Virtual Address Space = \(2^{32}\text{B}\)

Page Size = 4KB = \(2^{12}\text{B}\)

Number of pages = \(\frac{2^{32}}{2^{12}} = 2^{20}\) pages.

Number of frames = \(\frac{2^{26}}{2^{12}} = 2^{14}\) frames.

\(\therefore\) Page Table Size = \(2^{20} \times 14\text{-bits} \approx 2^{20} \times 16\text{-bits} \approx 2^{20} \times 2\text{B} = 2\text{MB}\).