mkdir A
chmod 400 A

cp -r A P

The language is:
{ w | w contains at least two a's, OR exactly two b's }

Regular Expressions:

Strings with at least two a's:
(b|a)* a (b|a)* a (b|a)*

Strings with exactly two b's:
a* b a* b a*

Combined Regular Expression (Union):
((a|b)*a(a|b)*a(a|b)*) | (a*b a*b a*)

Given:
Surfaces = 4
Tracks per surface = 64
Sectors per track = 128
Bytes per sector = 256 bytes

Disk Capacity Formula:
Capacity = Surfaces × Tracks per surface × Sectors per track × Bytes per sector

Total sectors = 4 × 64 × 128
= 256 × 128
= 32,768 sectors

Total capacity = 32,768 × 256 bytes
= 8,388,608 bytes

Convert to MB:

1 MB = 1,048,576 bytes

8,388,608 ÷ 1,048,576 = 8 MB

Answer:

Disk Capacity ≈ 8 MB

abstract class Player {
    String name;

    // Constructor
    Player(String name) {
        this.name = name;
    }

    // Abstract method
    abstract double average();

    // Display player type
    String displayType(String type) {
        return "Player Type: " + type;
    }
}

// Batsman class
class Batsman extends Player {
    int runs;
    int matches;

    // Constructor
    Batsman(String name, int runs, int matches) {
        super(name);
        this.runs = runs;
        this.matches = matches;
    }

    // Implement abstract method
    @Override
    double average() {
        return (double) runs / matches;
    }

    // Display Batsman result
    void displayResult() {
        System.out.println(displayType("Batsman"));
        System.out.println("Name: " + name);
        System.out.println("Total Runs: " + runs);
        System.out.println("Number of Matches: " + matches);
        System.out.println("Batting Average: " + average());
    }
}

// Bowler class
class Bowler extends Player {
    
    Bowler(String name) {
        super(name);
    }

    // Implement abstract method
    @Override
    double average() {
        return 0;
    }

    // Display Bowler result
    void displayResult() {
        System.out.println(displayType("Bowler"));
        System.out.println("Name: " + name);
        System.out.println("Bowler average is not calculated here.");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {

        // Create Batsman object
        Batsman batsman = new Batsman("Rahim", 500, 10);

        // Display batsman information
        batsman.displayResult();
    }
}

Player Type: Batsman
Name: Rahim
Total Runs: 500
Number of Matches: 10
Batting Average: 50.0

Deadlock is a situation in an Operating System where two or more processes are unable to continue execution because each process is waiting for a resource that is held by another process.

Two Situations Where Deadlock Occurs

• Mutual Exclusion: A resource can be used by only one process at a time. If another process requests the same resource, it must wait until the resource is released.
• Circular Wait: Deadlock occurs when a group of processes form a circular chain where each process is waiting for a resource held by the next process in the chain.

Given:
IP Address = 10.20.30.0/25

a) Subnet Mask

A /25 prefix means 25 bits are used for the network.

Subnet Mask = 255.255.255.128

Binary form:
11111111.11111111.11111111.10000000

b) Number of hosts per subnet

Host bits = 32 − 25 = 7 bits

Total IP addresses per subnet = 2⁷ = 128

Usable hosts = 128 − 2 = 126 hosts

(2 addresses are reserved for network and broadcast)

c) Broadcast address

With /25, each subnet block size = 128.

Subnet range:
10.20.30.0 → 10.20.30.127

Network address = 10.20.30.0
Broadcast address = 10.20.30.127

Usable host range:
10.20.30.1 – 10.20.30.126

Final Answers:

Given:
Jobs: J1 = 90K, J2 = 20K, J3 = 50K, J4 = 200K
Blocks: B1 = 50K, B2 = 100K, B3 = 90K, B4 = 200K, B5 = 50K

1) First Fit Method

In First Fit, each job is placed in the first block that is large enough.

Step by step:
J1 = 90K → first block that fits is B2 = 100K
Remaining in B2 = 10K

J2 = 20K → first block that fits is B1 = 50K
Remaining in B1 = 30K

J3 = 50K → first block that fits is B3 = 90K
Remaining in B3 = 40K

J4 = 200K → first block that fits is B4 = 200K
Remaining in B4 = 0K

First Fit Allocation Table:

2) Best Fit Method

In Best Fit, each job is placed in the smallest block that can hold it.

Step by step:
J1 = 90K → best block is B3 = 90K
Remaining in B3 = 0K

J2 = 20K → best block is B1 = 50K
Remaining in B1 = 30K

J3 = 50K → best block is B5 = 50K
Remaining in B5 = 0K

J4 = 200K → best block is B4 = 200K
Remaining in B4 = 0K

Best Fit Allocation Table:

Final Answer:
First Fit allocation:
J1 → B2, J2 → B1, J3 → B3, J4 → B4

Best Fit allocation:
J1 → B3, J2 → B1, J3 → B5, J4 → B4

Dijkstra(G, s)
for each vertex v in G
    dist[v] = infinity
    visited[v] = false

dist[s] = 0

for i = 1 to number of vertices
    u = vertex with minimum dist[u] among unvisited vertices
    visited[u] = true

    for each neighbor v of u
        if visited[v] == false and dist[u] + w(u,v) < dist[v]
            dist[v] = dist[u] + w(u,v)

return dist