n = int(input("No. of processes: "))
p = []
for i in range(n):
    pid = input("Process: ")
    bt = int(input("Burst Time: "))
    p.append((pid, bt))
p.sort(key=lambda x: x[1])
wt = 0
twt = ttat = 0
print("\nProcess\tBT\tWT\tTAT")
for pid, bt in p:
    tat = wt + bt
    print(f"{pid}\t{bt}\t{wt}\t{tat}")
    twt += wt
    ttat += tat
    wt = tat
print("\nAverage Waiting Time =", twt / n)
print("Average Turnaround Time =", ttat / n)
    

n = int(input("No. of processes: "))
wt = 0
twt = ttat = 0
print("\nProcess\tBT\tWT\tTAT")
for i in range(n):
    p = input("Process: ")
    bt = int(input("Burst Time: "))
    tat = wt + bt
    print(f"{p}\t{bt}\t{wt}\t{tat}")
    twt += wt
    ttat += tat
    wt = tat
print("\nAverage Waiting Time =", twt / n)
print("Average Turnaround Time =", ttat / n)
    

n = int(input("No. of processes: "))
data = []
for i in range(n):
    p = input("Process: ")
    bt = int(input("Burst Time: "))
    pr = int(input("Priority: "))
    data.append([p, bt, pr])
data.sort(key=lambda x: x[2])
wt = 0
print("\nProcess\tBT\tPriority\tWT\tTAT")
for p, bt, pr in data:
    tat = wt + bt
    print(f"{p}\t{bt}\t{pr}\t\t{wt}\t{tat}")
    wt = tat
    

n = int(input("No. of processes: "))
bt = [int(input("Burst Time: ")) for _ in range(n)]
q = int(input("Time Quantum: "))
rt = bt[:]
wt = [0] * n
t = 0
while sum(rt):
    for i in range(n):
        if rt[i]:
            x = min(rt[i], q)
            t += x
            rt[i] -= x
            if rt[i] == 0:
                wt[i] = t - bt[i]
print("\nP\tBT\tWT\tTAT")
for i in range(n):
    print(f"P{i+1}\t{bt[i]}\t{wt[i]}\t{bt[i]+wt[i]}")
print("Average Waiting Time =", sum(wt) / n)
print("Average Turnaround Time =",
      sum(bt[i] + wt[i] for i in range(n)) / n)
    

import threading, time
mutex = threading.Semaphore(1)
wrt = threading.Semaphore(1)
rc = 0
def reader(i):
    global rc
    mutex.acquire()
    rc += 1
    if rc == 1:
        wrt.acquire()
    mutex.release()
    print("Reader", i, "is reading")
    time.sleep(0.5)
    mutex.acquire()
    rc -= 1
    if rc == 0:
        wrt.release()
    mutex.release()
def writer(i):
    wrt.acquire()
    print("Writer", i, "is writing")
    wrt.release()
jobs = [(reader, 1), (reader, 2), (writer, 1), (reader, 3)]
th = [threading.Thread(target=f, args=(i,)) for f, i in jobs]
for t in th:
    t.start()
    time.sleep(0.1)
for t in th:
    t.join()
    

n = int(input("Processes: "))
m = int(input("Resources: "))
alloc = [list(map(int, input().split())) for _ in range(n)]
maxm = [list(map(int, input().split())) for _ in range(n)]
avail = list(map(int, input("Available: ").split()))
need = [[maxm[i][j] - alloc[i][j] for j in range(m)]
        for i in range(n)]
print("Need Matrix:", *need, sep="\n")
safe = []
while len(safe) < n:
    for i in range(n):
        if i not in safe and all(x <= y for x, y
                                 in zip(need[i], avail)):
            avail = [a + b for a, b in zip(avail, alloc[i])]
            safe.append(i)
            break
    else:
        break
if len(safe) == n:
    print("Safe State. Safe Sequence:",
          " -> ".join("P" + str(i) for i in safe))
else:
    print("Unsafe State. Deadlock may occur.")
    

pages = list(map(int, input("Pages: ").split()))
frames = int(input("Frames: "))
memory, faults = [], 0
for page in pages:
    if page not in memory:
        faults += 1
        if len(memory) < frames:
            memory.append(page)
        else:
            memory.pop(0)
            memory.append(page)
print("Page Faults:", faults)
    

def fit(blocks, procs, method):
    b = blocks[:]
    for p in procs:
        ok = [i for i in range(len(b)) if b[i] >= p]
        if not ok:
            print(f"Process {p} not allocated")
            continue
        if method == "First":
            i = ok[0]
        elif method == "Best":
            i = min(ok, key=lambda x: b[x])
        else:
            i = max(ok, key=lambda x: b[x])
        print(f"Process {p} allocated to block {i+1}")
        b[i] -= p
blocks = list(map(int, input("Blocks: ").split()))
procs = list(map(int, input("Processes: ").split()))
for m in ("First", "Best", "Worst"):
    print(m, "Fit:")
    fit(blocks, procs, m)