cooked 3

10.c

@@ -0,0 +1,84 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAX 50
+
+
+void fcfs(int requests[], int n, int head) {
+    int total = 0;
+
+    printf("\n--- FCFS ---\n");
+    printf("Order: %d", head);
+
+    for (int i = 0; i < n; i++) {
+        total += abs(requests[i] - head);
+        head = requests[i];
+        printf(" -> %d", head);
+    }
+
+    printf("\nTotal Head Movement: %d\n", total);
+}
+
+// ── SCAN ──────────────────────────────────────────────────────────────────
+void scan(int requests[], int n, int head, int disk_size) {
+    int total = 0;
+    int req[MAX];
+
+    // copy and sort requests
+    for (int i = 0; i < n; i++) req[i] = requests[i];
+    for (int i = 0; i < n - 1; i++)
+        for (int j = 0; j < n - i - 1; j++)
+            if (req[j] > req[j+1]) { int t = req[j]; req[j] = req[j+1]; req[j+1] = t; }
+
+    // find where head sits in sorted array
+    int pos = 0;
+    while (pos < n && req[pos] < head) pos++;
+
+    printf("\n--- SCAN (moving towards higher tracks first) ---\n");
+    printf("Order: %d", head);
+
+    // go right (higher) first
+    for (int i = pos; i < n; i++) {
+        total += abs(req[i] - head);
+        head = req[i];
+        printf(" -> %d", head);
+    }
+    if (head != disk_size - 1) {
+
+        total += abs((disk_size - 1) - head);
+        head = disk_size - 1;
+
+        printf(" -> %d", head);
+    }
+
+    // go left (lower)
+    for (int i = pos - 1; i >= 0; i--) {
+        total += abs(req[i] - head);
+        head = req[i];
+        printf(" -> %d", head);
+    }
+
+    printf("\nTotal Head Movement: %d\n", total);
+}
+
+// ── MAIN ──────────────────────────────────────────────────────────────────
+int main() {
+    int requests[MAX], n, head, disk_size;
+
+    printf("Enter number of requests: ");
+    scanf("%d", &n);
+    printf("Enter requests: ");
+    for (int i = 0; i < n; i++)
+        scanf("%d", &requests[i]);
+
+    printf("Enter initial head position: ");
+    scanf("%d", &head);
+
+    printf("Enter disk size: ");
+    scanf("%d", &disk_size);
+
+    fcfs(requests, n, head);
+    scan(requests, n, head, disk_size);
+
+    return 0;
+}

11.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+
+// ── PAGING ────────────────────────────────────────────────────────────────
+void paging() {
+    int page_size, num_pages;
+    printf("\n--- PAGING ---\n");
+    printf("Enter page size: ");
+    scanf("%d", &page_size);
+    printf("Enter number of pages: ");
+    scanf("%d", &num_pages);
+
+    int page_table[num_pages];
+    printf("Enter frame number for each page:\n");
+    for (int i = 0; i < num_pages; i++) {
+        printf("  Page %d -> Frame: ", i);
+        scanf("%d", &page_table[i]);
+    }
+
+    int logical;
+    printf("Enter logical address: ");
+    scanf("%d", &logical);
+
+    int page  = logical / page_size;   // which page
+    int offset = logical % page_size;  // offset within page
+
+    if (page >= num_pages) {
+        printf("Invalid! Page %d does not exist.\n", page);
+        return;
+    }
+
+    int frame   = page_table[page];
+    int physical = frame * page_size + offset;
+
+    printf("\nPage Number : %d\n", page);
+    printf("Offset      : %d\n", offset);
+    printf("Frame Number: %d\n", frame);
+    printf("Physical Address: %d\n", physical);
+}
+
+// ── SEGMENTATION ──────────────────────────────────────────────────────────
+void segmentation() {
+    int num_seg;
+    printf("\n--- SEGMENTATION ---\n");
+    printf("Enter number of segments: ");
+    scanf("%d", &num_seg);
+
+    int base[num_seg], limit[num_seg];
+    printf("Enter base and limit for each segment:\n");
+    for (int i = 0; i < num_seg; i++) {
+        printf("  Segment %d -> Base: ", i);
+        scanf("%d", &base[i]);
+        printf("  Segment %d -> Limit: ", i);
+        scanf("%d", &limit[i]);
+    }
+
+    int seg, offset;
+    printf("Enter segment number: ");
+    scanf("%d", &seg);
+    printf("Enter offset: ");
+    scanf("%d", &offset);
+
+    if (seg >= num_seg) {
+        printf("Invalid! Segment %d does not exist.\n", seg);
+        return;
+    }
+
+    if (offset >= limit[seg]) {
+        printf("Segmentation Fault! Offset %d exceeds limit %d.\n", offset, limit[seg]);
+        return;
+    }
+
+    int physical = base[seg] + offset;
+    printf("\nSegment Base  : %d\n", base[seg]);
+    printf("Segment Limit : %d\n", limit[seg]);
+    printf("Offset        : %d\n", offset);
+    printf("Physical Address: %d\n", physical);
+}
+
+// ── MAIN ──────────────────────────────────────────────────────────────────
+int main() {
+    int ch;
+    while (1) {
+        printf("\n1. Paging");
+        printf("\n2. Segmentation");
+        printf("\n3. Exit");
+        printf("\nEnter choice: ");
+        scanf("%d", &ch);
+
+        if      (ch == 1) paging();
+        else if (ch == 2) segmentation();
+        else if (ch == 3) break;
+        else printf("Invalid choice\n");
+    }
+    return 0;
+}

6.c

@@ -0,0 +1,75 @@
+#include <stdio.h>
+
+#define MAX 10
+
+int main() {
+    int n, r;
+    printf("Enter number of processes: ");
+    scanf("%d", &n);
+    printf("Enter number of resources: ");
+    scanf("%d", &r);
+
+    int alloc[MAX][MAX], max[MAX][MAX], need[MAX][MAX];
+    int avail[MAX], finish[MAX] = {0};
+    int safeSeq[MAX];
+
+    printf("Enter Allocation matrix:\n");
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < r; j++)
+            scanf("%d", &alloc[i][j]);
+
+    printf("Enter Max matrix:\n");
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < r; j++)
+            scanf("%d", &max[i][j]);
+
+    printf("Enter Available resources:\n");
+    for (int j = 0; j < r; j++)
+        scanf("%d", &avail[j]);
+
+
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < r; j++)
+            need[i][j] = max[i][j] - alloc[i][j];
+
+    
+    int count = 0;
+    while (count < n) {
+        int found = 0;
+        for (int i = 0; i < n; i++) {
+            if (finish[i]) continue;
+
+    
+            int ok = 1;
+            for (int j = 0; j < r; j++) {
+                if (need[i][j] > avail[j]) {
+                    ok = 0;
+                    break;
+                }
+            }
+
+            if (ok) {
+        
+                for (int j = 0; j < r; j++)
+                    avail[j] += alloc[i][j];
+                finish[i] = 1;
+                safeSeq[count++] = i;
+                found = 1;
+            }
+        }
+
+        if (!found) break;  
+    }
+
+    if (count == n) {
+        printf("\nSystem is in SAFE state\n");
+        printf("Safe sequence: ");
+        for (int i = 0; i < n; i++)
+            printf("P%d ", safeSeq[i]);
+        printf("\n");
+    } else {
+        printf("\nSystem is in UNSAFE state (Deadlock possible)\n");
+    }
+
+    return 0;
+}

7.c

@@ -0,0 +1,112 @@
+#include <stdio.h>
+#include <string.h>
+
+#define MAX 25
+
+void firstFit(int blocks[], int m, int process[], int n) {
+    int alloc[MAX];
+    memset(alloc, -1, sizeof(alloc));
+
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            if (blocks[j] >= process[i]) {
+                alloc[i] = j;
+                blocks[j] -= process[i];
+                break;  // first block that fits, stop
+            }
+        }
+    }
+
+    printf("\n--- First Fit ---\n");
+    printf("Process\tSize\tBlock\n");
+    for (int i = 0; i < n; i++) {
+        if (alloc[i] == -1)
+            printf("P%d\t%d\tNot Allocated\n", i+1, process[i]);
+        else
+            printf("P%d\t%d\tBlock %d\n", i+1, process[i], alloc[i]+1);
+    }
+}
+
+void bestFit(int blocks[], int m, int process[], int n) {
+    int alloc[MAX];
+    memset(alloc, -1, sizeof(alloc));
+
+    for (int i = 0; i < n; i++) {
+        int bestIdx = -1;
+        for (int j = 0; j < m; j++) {
+            if (blocks[j] >= process[i]) {
+                // pick the smallest block that still fits
+                if (bestIdx == -1 || blocks[j] < blocks[bestIdx])
+                    bestIdx = j;
+            }
+        }
+        if (bestIdx != -1) {
+            alloc[i] = bestIdx;
+            blocks[bestIdx] -= process[i];
+        }
+    }
+
+    printf("\n--- Best Fit ---\n");
+    printf("Process\tSize\tBlock\n");
+    for (int i = 0; i < n; i++) {
+        if (alloc[i] == -1)
+            printf("P%d\t%d\tNot Allocated\n", i+1, process[i]);
+        else
+            printf("P%d\t%d\tBlock %d\n", i+1, process[i], alloc[i]+1);
+    }
+}
+
+void worstFit(int blocks[], int m, int process[], int n) {
+    int alloc[MAX];
+    memset(alloc, -1, sizeof(alloc));
+
+    for (int i = 0; i < n; i++) {
+        int worstIdx = -1;
+        for (int j = 0; j < m; j++) {
+            if (blocks[j] >= process[i]) {
+                // pick the largest block
+                if (worstIdx == -1 || blocks[j] > blocks[worstIdx])
+                    worstIdx = j;
+            }
+        }
+        if (worstIdx != -1) {
+            alloc[i] = worstIdx;
+            blocks[worstIdx] -= process[i];
+        }
+    }
+
+    printf("\n--- Worst Fit ---\n");
+    printf("Process\tSize\tBlock\n");
+    for (int i = 0; i < n; i++) {
+        if (alloc[i] == -1)
+            printf("P%d\t%d\tNot Allocated\n", i+1, process[i]);
+        else
+            printf("P%d\t%d\tBlock %d\n", i+1, process[i], alloc[i]+1);
+    }
+}
+
+int main() {
+    int m, n;
+    int blocks[MAX], process[MAX];
+    int b1[MAX], b2[MAX], b3[MAX];
+
+    printf("Enter number of memory blocks: ");
+    scanf("%d", &m);
+    printf("Enter block sizes: ");
+    for (int i = 0; i < m; i++) {
+        scanf("%d", &blocks[i]);
+        b1[i] = b2[i] = b3[i] = blocks[i];  // each strategy gets a fresh copy
+    }
+
+    printf("Enter number of processes: ");
+    scanf("%d", &n);
+    printf("Enter process sizes: ");
+    for (int i = 0; i < n; i++)
+        scanf("%d", &process[i]);
+
+    firstFit(b1, m, process, n);
+    bestFit (b2, m, process, n);
+    worstFit(b3, m, process, n);
+
+    return 0;
+}

8.c

@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <string.h>
+
+#define MAX 50
+
+// ── FIFO ──────────────────────────────────────────────────────────────────
+void fifo(int pages[], int n, int frames) {
+    int mem[MAX], front = 0, faults = 0;
+    memset(mem, -1, sizeof(mem));
+
+    printf("\n--- FIFO ---\n");
+    printf("Page\tFrames\t\t\tFault\n");
+
+    for (int i = 0; i < n; i++) {
+        int found = 0;
+
+        // check if page already in memory
+        for (int j = 0; j < frames; j++)
+            if (mem[j] == pages[i]) { found = 1; break; }
+
+        printf("%d\t", pages[i]);
+
+        if (!found) {
+            mem[front] = pages[i];       // replace oldest page
+            front = (front + 1) % frames;
+            faults++;
+
+            for (int j = 0; j < frames; j++)
+                if (mem[j] == -1) printf("- "); else printf("%d ", mem[j]);
+            printf("\t\tFault");
+        } else {
+            for (int j = 0; j < frames; j++)
+                if (mem[j] == -1) printf("- "); else printf("%d ", mem[j]);
+        }
+        printf("\n");
+    }
+
+    printf("Total Page Faults: %d\n", faults);
+}
+
+// ── OPTIMAL ───────────────────────────────────────────────────────────────
+void optimal(int pages[], int n, int frames) {
+    int mem[MAX], faults = 0, count = 0;
+    memset(mem, -1, sizeof(mem));
+
+    printf("\n--- Optimal ---\n");
+    printf("Page\tFrames\t\t\tFault\n");
+
+    for (int i = 0; i < n; i++) {
+        int found = 0;
+
+        // check if page already in memory
+        for (int j = 0; j < frames; j++)
+            if (mem[j] == pages[i]) { found = 1; break; }
+
+        printf("%d\t", pages[i]);
+
+        if (!found) {
+            if (count < frames) {
+                // frames not full yet, just fill
+                mem[count++] = pages[i];
+            } else {
+                // find which page in memory is used farthest in future
+                int replaceIdx = -1, farthest = -1;
+                for (int j = 0; j < frames; j++) {
+                    int nextUse = n;  // assume never used again
+                    for (int k = i + 1; k < n; k++) {
+                        if (pages[k] == mem[j]) { nextUse = k; break; }
+                    }
+                    if (nextUse > farthest) {
+                        farthest = nextUse;
+                        replaceIdx = j;
+                    }
+                }
+                mem[replaceIdx] = pages[i];
+            }
+            faults++;
+
+            for (int j = 0; j < frames; j++)
+                if (mem[j] == -1) printf("- "); else printf("%d ", mem[j]);
+            printf("\t\tFault");
+        } else {
+            for (int j = 0; j < frames; j++)
+                if (mem[j] == -1) printf("- "); else printf("%d ", mem[j]);
+        }
+        printf("\n");
+    }
+
+    printf("Total Page Faults: %d\n", faults);
+}
+
+// ── MAIN ──────────────────────────────────────────────────────────────────
+int main() {
+    int pages[MAX], n, frames;
+
+    printf("Enter number of pages in reference string: ");
+    scanf("%d", &n);
+    printf("Enter reference string: ");
+    for (int i = 0; i < n; i++)
+        scanf("%d", &pages[i]);
+
+    printf("Enter number of frames: ");
+    scanf("%d", &frames);
+
+    fifo(pages, n, frames);
+    optimal(pages, n, frames);
+
+    return 0;
+}

9.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+
+#define MAX 50
+
+int stack[MAX], top = -1;
+
+// check if page is in stack
+int inStack(int page, int frames) {
+    for (int i = top; i > top - frames && i >= 0; i--)
+        if (stack[i] == page) return i;
+    return -1;
+}
+
+int main() {
+    int pages[MAX], n, frames;
+
+    printf("Enter number of pages: ");
+    scanf("%d", &n);
+    printf("Enter reference string: ");
+    for (int i = 0; i < n; i++)
+        scanf("%d", &pages[i]);
+    printf("Enter number of frames: ");
+    scanf("%d", &frames);
+
+    int faults = 0;
+
+    printf("\nPage\tFrames\t\t\tFault\n");
+
+    for (int i = 0; i < n; i++) {
+        int pos = inStack(pages[i], frames);
+
+        printf("%d\t", pages[i]);
+
+        if (pos == -1) {
+            // page not found — fault
+            stack[++top] = pages[i];
+            faults++;
+
+            // print current frames (top 'frames' elements)
+            int start = top - frames + 1;
+            if (start < 0) start = 0;
+            for (int j = start; j <= top; j++)
+                printf("%d ", stack[j]);
+            printf("\t\tFault");
+        } else {
+            // page found — move it to top (most recently used)
+            for (int j = pos; j < top; j++)
+                stack[j] = stack[j + 1];
+            stack[top] = pages[i];
+
+            // print current frames
+            int start = top - frames + 1;
+            if (start < 0) start = 0;
+            for (int j = start; j <= top; j++)
+                printf("%d ", stack[j]);
+        }
+
+        printf("\n");
+    }
+
+    printf("\nTotal Page Faults: %d\n", faults);
+    return 0;
+}