What is the capacity of the disk pack?

Answer:

Capacity of disk pack = Total number of surfaces × Number of tracks per surface × Number of sectors per track × Number of bytes per sector

= 16 × 128 × 256 × 512 bytes = 256 MB

If the format overhead is 32 bytes per sector, what is the formatted disk space?

Answer:

Total number of sectors = Total number of surfaces × Number of tracks per surface × Number of sectors per track

= 16 × 128 × 256 sectors = 219 sectors

Number of bits required to address the sector = 19 bits

Formatting overhead = Total number of sectors × Overhead per sector

= 219 × 32 bytes = 219 × 25 bytes = 224 bytes = 16 MB

Formatted disk space = Total disk space - Formatting overhead

= 256 MB - 16 MB = 240 MB

If the disk is rotating at 3600 RPM, what is the data transfer rate?

Answer:

Number of rotations in one second = (3600 / 60) rotations/sec = 60 rotations/sec

Data transfer rate = Number of heads × Capacity of one track × Number of rotations in one second

= 16 × (256 × 512 bytes) × 60

= 24 × 28 × 29 × 60 bytes/sec

= 60 × 221 bytes/sec = 120 Mbps

Transmission rate = (1.5 Mbps) / 16 = (1.5 x 10⁶) / 16 Kbps

Now, the time to send data is:

Time = file size / transmission rate + delay

Substituting the values:

Time = (2 × 500,000 × 16) / (1.5 × 10⁶) + 300 / 1000

= 10.7 sec

            50
           /  \
         40    65
        / \    / \
      30  45  55  75
     / \
   20  35

int sumNodes(Node* root)
{
    if (root == NULL)
        return 0;

    return root->data + sumNodes(root->left) + sumNodes(root->right);
}

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

// Function to determine the class of an IPv4 address
string getIPAddressClass(const string& ipAddress) {
    stringstream ss(ipAddress);
    string token;

    // Get the first octet
    getline(ss, token, '.');

    // Convert first octet to integer
    int firstOctet = stoi(token);

    // Determine class
    if (firstOctet >= 1 && firstOctet <= 127) {
        return "Class A";
    }
    else if (firstOctet >= 128 && firstOctet <= 191) {
        return "Class B";
    }
    else if (firstOctet >= 192 && firstOctet <= 223) {
        return "Class C";
    }
    else if (firstOctet >= 224 && firstOctet <= 239) {
        return "Class D";
    }
    else if (firstOctet >= 240 && firstOctet <= 255) {
        return "Class E";
    }
    else {
        return "Invalid IP address";
    }
}

int main() {
    string ipAddress;
    cin >> ipAddress;

    string ipAddressClass = getIPAddressClass(ipAddress);

    cout << "IP Address: " << ipAddress 
         << " belongs to " << ipAddressClass << endl;

    return 0;
}

First, calculate the number of required bits for each subnet:

• For 4000 hosts: Needs at least 12 bits for host portion (2¹² = 4096).
• For 2000 hosts: Needs at least 11 bits for host portion (2¹¹ = 2048).
• For 6000 hosts: Needs at least 13 bits for host portion (2¹³ = 8192).
• For 8000 hosts: Needs at least 13 bits for host portion (2¹³ = 8192).

Subnet Calculations:

Department C (6000 hosts)

Subnet Mask: 172.16.0.0/19 (because 32 - 13 = 19 bits for network portion).

Subnet Range: 172.16.0.0 - 172.16.31.255

First IP: 172.16.0.1

Last IP: 172.16.31.254

Department D (8000 hosts)

Subnet Mask: 172.16.32.0/19 (same as above).

Subnet Range: 172.16.32.0 - 172.16.63.255

First IP: 172.16.32.1

Last IP: 172.16.63.254

Department A (4000 hosts)

Subnet Mask: 172.16.64.0/20 (because 32 - 12 = 20 bits for network portion).

Subnet Range: 172.16.64.0 - 172.16.79.255

First IP: 172.16.64.1

Last IP: 172.16.79.254

Department B (2000 hosts)

Subnet Mask: 172.16.80.0/21 (because 32 - 11 = 21 bits for network portion).

Subnet Range: 172.16.80.0 - 172.16.95.255

First IP: 172.16.80.1 Last IP: 172.16.95.254

i) For 2 bit binary, we can find 00, 01, 10, 11 and the equivalent decimal value is 0,1,2,3.

Now, For Binary= 00 (Decimal= 0)= abcdef is high

For Binary= 01 (Decimal=1)= bc is high

For Binary= 10 (Decimal=2) = abged is high For

Binary=11 (Decimal=3)= abgcd is high

ER Diagram → Relational Tables Conversion

Below is the relational schema (tables) derived from the ER diagram.

1. Coach Table

Coach(Coach_ID, Coach_name)

* Primary Key: Coach_ID

2. Team Table

Team(Team_ID, Team_name, Coach_ID)

* Primary Key: Team_ID * Foreign Key: Coach_ID → Coach(Coach_ID)

3. Player Table

Player(Player_ID, Player_name, Player_position, Team_ID)

* Primary Key: Player_ID * Foreign Key: Team_ID → Team(Team_ID)

4. Stadium Table

Stadium(Stadium_ID, Stadium_name, Stadium_location)

* Primary Key: Stadium_ID

5. Game Table

Game(Game_no, Game_name, Game_time)

* Primary Key: Game_no

6. Match Table

Match(Match_ID, Match_date, Match_result, Stadium_ID, Game_no)

* Primary Key: Match_ID * Foreign Key:

* Stadium_ID → Stadium(Stadium_ID) * Game_no → Game(Game_no)

Disadvantages of 5G Technology (a)Increased High Costs: The development of 5G infrastructure is very expensive. It requires upgrading existing networks and installing new equipment. The cost includes both the initial setup and continuous maintenance to ensure reliable and high-speed connectivity. Because of these high costs, service providers may charge higher prices for 5G services.

(b) Draining Battery of Devices: 5G connectivity consumes more power than previous mobile network generations. As a result, mobile devices connected to 5G networks may experience faster battery drain. Users may need to charge their devices more frequently, and some devices may also become hotter while using 5G.

(c) Increased Infrastructure Development Cost: Building the infrastructure for 5G requires installing new technologies such as small cell towers and advanced networking equipment. Many older devices are not compatible with 5G networks, so they must be replaced with newer devices. This significantly increases the overall cost of implementing 5G networks.

SELECT employee_id, COUNT(employee_id)
FROM Leave
GROUP BY employee_id;

SELECT *
FROM employee
WHERE employee_id IN (
    SELECT employee_id
    FROM leave
    GROUP BY employee_id
    HAVING COUNT(employee_id) > 5
);