OS2-Slip-Solutions

Slip 1
Q1: Banker's Algorithm (Menu Driven)
#include <stdio.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3

void displayMatrix(int matrix[MAX_PROCESSES][MAX_RESOURCES], char* title) {
    printf("\n%s:\n", title);
    for(int i = 0; i < MAX_PROCESSES; i++) {
        for(int j = 0; j < MAX_RESOURCES; j++)
            printf("%d ", matrix[i][j]);
        printf("\n");
    }
}

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{2,3,2}, {4,0,0}, {5,0,4}, {4,3,3}, {2,2,4}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{9,7,5}, {5,2,2}, {1,0,4}, {4,4,4}, {6,5,5}};
    int available[MAX_RESOURCES] = {3,3,2};
    int need[MAX_PROCESSES][MAX_RESOURCES];
    int choice;

    do {
        printf("\nMenu:\n1. Accept Available\n2. Display Allocation, Max\n3. Display Need\n4. Display Available\n5. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1: printf("Enter Available (A B C): "); scanf("%d %d %d", &available[0], &available[1], &available[2]); break;
            case 2: displayMatrix(allocation, "Allocation"); displayMatrix(max, "Max"); break;
            case 3:
                for(int i = 0; i < MAX_PROCESSES; i++)
                    for(int j = 0; j < MAX_RESOURCES; j++)
                        need[i][j] = max[i][j] - allocation[i][j];
                displayMatrix(need, "Need"); break;
            case 4: printf("\nAvailable: %d %d %d\n", available[0], available[1], available[2]); break;
            case 5: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 5);
    return 0;
}

Q2: FCFS Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

int main() {
    int requests[] = {55, 58, 39, 18, 90, 160, 150, 38, 184};
    int n = 9, head = 50, totalMovement = 0;
    printf("FCFS Order: %d ", head);
    for(int i = 0; i < n; i++) {
        printf("%d ", requests[i]);
        totalMovement += abs((i == 0 ? head : requests[i-1]) - requests[i]);
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 2
Q1: Banker's Algorithm (Menu Driven)
#include <stdio.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3

void displayMatrix(int matrix[MAX_PROCESSES][MAX_RESOURCES], char* title) {
    printf("\n%s:\n", title);
    for(int i = 0; i < MAX_PROCESSES; i++) {
        for(int j = 0; j < MAX_RESOURCES; j++)
            printf("%d ", matrix[i][j]);
        printf("\n");
    }
}

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{0,1,0}, {4,0,0}, {5,0,4}, {4,3,3}, {2,2,4}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{0,0,0}, {5,2,2}, {1,0,4}, {4,4,4}, {6,5,5}};
    int available[MAX_RESOURCES] = {0,0,0}; // To be accepted
    int need[MAX_PROCESSES][MAX_RESOURCES];
    int choice;

    do {
        printf("\nMenu:\n1. Accept Available\n2. Display Allocation, Max\n3. Display Need\n4. Display Available\n5. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1: printf("Enter Available (A B C): "); scanf("%d %d %d", &available[0], &available[1], &available[2]); break;
            case 2: displayMatrix(allocation, "Allocation"); displayMatrix(max, "Max"); break;
            case 3:
                for(int i = 0; i < MAX_PROCESSES; i++)
                    for(int j = 0; j < MAX_RESOURCES; j++)
                        need[i][j] = max[i][j] - allocation[i][j];
                displayMatrix(need, "Need"); break;
            case 4: printf("\nAvailable: %d %d %d\n", available[0], available[1], available[2]); break;
            case 5: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 5);
    return 0;
}

Q2: SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {86, 147, 91, 170, 95, 130, 102, 70};
    int n = 8, head = 125, totalMovement = 0;
    int direction = 0; // 0 for Left
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1); // Ascending order
    printf("SCAN Order: %d ", head);

    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 0) { // Left
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        totalMovement += head; printf("0 ");
        head = 0;
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 3
Q1: Linked File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int start;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1; // Random allocation

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Create New File\n3. Show Directory\n4. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Enter file length: ");
                int len; scanf("%d", &len);
                int start = -1;
                for(int i = 0; i < n && start == -1; i++)
                    if(!bitVector[i]) {
                        int free = 0;
                        for(int j = i; j < i+len && j < n; j++)
                            if(!bitVector[j]) free++;
                        if(free == len) start = i;
                    }
                if(start != -1) {
                    for(int i = start; i < start+len; i++) bitVector[i] = 1;
                    files[fileCount].start = start;
                    files[fileCount].length = len;
                    fileCount++;
                    printf("File created at block %d\n", start);
                } else printf("Not enough space!\n");
                break;
            case 3:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Start=%d, Length=%d\n", i, files[i].start, files[i].length);
                break;
            case 4: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 4);
    return 0;
}

Q2: C-SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {80, 150, 60, 135, 40, 35, 170};
    int n = 7, head = 70, totalMovement = 0;
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n);
    printf("C-SCAN Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    for(int i = start; i < n; i++) {
        printf("%d ", sorted[i]);
        totalMovement += abs(head - sorted[i]);
        head = sorted[i];
    }
    totalMovement += (199 - head); printf("199 "); head = 199;
    totalMovement += 199; printf("0 "); head = 0;
    for(int i = 0; i < start; i++) {
        printf("%d ", sorted[i]);
        totalMovement += abs(head - sorted[i]);
        head = sorted[i];
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 4
Q1: Resource-Request Algorithm (Safety Check)
#include <stdio.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 4

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{2,0,0,1}, {3,1,2,1}, {2,1,0,3}, {1,3,1,2}, {1,4,3,2}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{4,2,1,2}, {5,2,5,2}, {2,3,1,6}, {1,4,2,4}, {3,6,6,5}};
    int available[MAX_RESOURCES] = {3,3,2,1};
    int need[MAX_PROCESSES][MAX_RESOURCES], work[MAX_RESOURCES], finish[MAX_PROCESSES] = {0};
    int safeSequence[MAX_PROCESSES], count = 0;

    for(int i = 0; i < MAX_PROCESSES; i++)
        for(int j = 0; j < MAX_RESOURCES; j++)
            need[i][j] = max[i][j] - allocation[i][j];

    for(int j = 0; j < MAX_RESOURCES; j++) work[j] = available[j];

    while(count < MAX_PROCESSES) {
        int found = 0;
        for(int i = 0; i < MAX_PROCESSES; i++) {
            if(!finish[i]) {
                int canExecute = 1;
                for(int j = 0; j < MAX_RESOURCES; j++)
                    if(need[i][j] > work[j]) canExecute = 0;
                if(canExecute) {
                    for(int j = 0; j < MAX_RESOURCES; j++) work[j] += allocation[i][j];
                    finish[i] = 1;
                    safeSequence[count++] = i;
                    found = 1;
                }
            }
        }
        if(!found) break;
    }

    if(count == MAX_PROCESSES) {
        printf("System is in safe state. Safe sequence: ");
        for(int i = 0; i < MAX_PROCESSES; i++) printf("P%d ", safeSequence[i]);
        printf("\n");
    } else printf("System is not in safe state.\n");
    return 0;
}

Q2: SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {82, 170, 43, 140, 24, 16, 190};
    int n = 7, head = 50, totalMovement = 0;
    int direction = 1; // Right
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1);
    printf("SCAN Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 1) {
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        totalMovement += (199 - head); printf("199 "); head = 199;
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 5
Q1: Contiguous File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int start;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1;

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Create New File\n3. Show Directory\n4. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Enter file length: ");
                int len; scanf("%d", &len);
                int start = -1;
                for(int i = 0; i <= n-len && start == -1; i++) {
                    int free = 1;
                    for(int j = i; j < i+len; j++) if(bitVector[j]) free = 0;
                    if(free) start = i;
                }
                if(start != -1) {
                    for(int i = start; i < start+len; i++) bitVector[i] = 1;
                    files[fileCount].start = start;
                    files[fileCount].length = len;
                    fileCount++;
                    printf("File created at block %d\n", start);
                } else printf("Not enough contiguous space!\n");
                break;
            case 3:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Start=%d, Length=%d\n", i, files[i].start, files[i].length);
                break;
            case 4: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 4);
    return 0;
}

Q2: SSTF Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

int findNearest(int arr[], int n, int head, int visited[]) {
    int minDist = 9999, index = -1;
    for(int i = 0; i < n; i++)
        if(!visited[i] && abs(arr[i] - head) < minDist) {
            minDist = abs(arr[i] - head);
            index = i;
        }
    return index;
}

int main() {
    int requests[] = {186, 89, 44, 70, 102, 22, 51, 124};
    int n = 8, head = 70, totalMovement = 0;
    int visited[n] = {0};

    printf("SSTF Order: %d ", head);
    for(int i = 0; i < n; i++) {
        int next = findNearest(requests, n, head, visited);
        visited[next] = 1;
        totalMovement += abs(head - requests[next]);
        head = requests[next];
        printf("%d ", head);
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 6
Q1: Resource-Request Algorithm (Safety Check)
#include <stdio.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 4

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{0,0,1,2}, {1,0,0,0}, {1,3,5,4}, {0,6,3,2}, {0,0,1,4}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{0,0,1,2}, {1,7,5,0}, {2,3,5,6}, {0,6,5,2}, {0,6,5,6}};
    int available[MAX_RESOURCES] = {1,5,2,0};
    int need[MAX_PROCESSES][MAX_RESOURCES], work[MAX_RESOURCES], finish[MAX_PROCESSES] = {0};
    int safeSequence[MAX_PROCESSES], count = 0;

    for(int i = 0; i < MAX_PROCESSES; i++)
        for(int j = 0; j < MAX_RESOURCES; j++)
            need[i][j] = max[i][j] - allocation[i][j];

    for(int j = 0; j < MAX_RESOURCES; j++) work[j] = available[j];

    while(count < MAX_PROCESSES) {
        int found = 0;
        for(int i = 0; i < MAX_PROCESSES; i++) {
            if(!finish[i]) {
                int canExecute = 1;
                for(int j = 0; j < MAX_RESOURCES; j++)
                    if(need[i][j] > work[j]) canExecute = 0;
                if(canExecute) {
                    for(int j = 0; j < MAX_RESOURCES; j++) work[j] += allocation[i][j];
                    finish[i] = 1;
                    safeSequence[count++] = i;
                    found = 1;
                }
            }
        }
        if(!found) break;
    }

    if(count == MAX_PROCESSES) {
        printf("System is in safe state. Safe sequence: ");
        for(int i = 0; i < MAX_PROCESSES; i++) printf("P%d ", safeSequence[i]);
        printf("\n");
    } else printf("System is not in safe state.\n");
    return 0;
}

Q2: LOOK Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {176, 79, 34, 60, 92, 11, 41, 114};
    int n = 8, head = 65, totalMovement = 0;
    int direction = 0; // Left
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1);
    printf("LOOK Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 0) {
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 7
Q1: Banker's Algorithm (Safety Check)
#include <stdio.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3

void displayNeed(int need[MAX_PROCESSES][MAX_RESOURCES]) {
    printf("\nNeed Matrix:\n");
    for(int i = 0; i < MAX_PROCESSES; i++) {
        for(int j = 0; j < MAX_RESOURCES; j++)
            printf("%d ", need[i][j]);
        printf("\n");
    }
}

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{0,1,0}, {2,0,0}, {3,0,3}, {2,1,1}, {0,0,2}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{0,0,0}, {2,0,2}, {0,0,0}, {1,0,0}, {0,0,2}};
    int available[MAX_RESOURCES] = {0,0,0};
    int need[MAX_PROCESSES][MAX_RESOURCES], work[MAX_RESOURCES], finish[MAX_PROCESSES] = {0};
    int safeSequence[MAX_PROCESSES], count = 0;

    for(int i = 0; i < MAX_PROCESSES; i++)
        for(int j = 0; j < MAX_RESOURCES; j++)
            need[i][j] = max[i][j] - allocation[i][j];

    displayNeed(need);
    for(int j = 0; j < MAX_RESOURCES; j++) work[j] = available[j];

    while(count < MAX_PROCESSES) {
        int found = 0;
        for(int i = 0; i < MAX_PROCESSES; i++) {
            if(!finish[i]) {
                int canExecute = 1;
                for(int j = 0; j < MAX_RESOURCES; j++)
                    if(need[i][j] > work[j]) canExecute = 0;
                if(canExecute) {
                    for(int j = 0; j < MAX_RESOURCES; j++) work[j] += allocation[i][j];
                    finish[i] = 1;
                    safeSequence[count++] = i;
                    found = 1;
                }
            }
        }
        if(!found) break;
    }

    if(count == MAX_PROCESSES) {
        printf("System is in safe state. Safe sequence: ");
        for(int i = 0; i < MAX_PROCESSES; i++) printf("P%d ", safeSequence[i]);
        printf("\n");
    } else printf("System is not in safe state.\n");
    return 0;
}

Q2: SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {176, 79, 34, 60, 92, 11, 41, 114};
    int n = 8, head = 65, totalMovement = 0;
    int direction = 0; // Left
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1);
    printf("SCAN Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 0) {
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        totalMovement += head; printf("0 "); head = 0;
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 8
Q1: Sequential File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int start;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1;

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Show Directory\n3. Delete File\n4. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Start=%d, Length=%d\n", i, files[i].start, files[i].length);
                break;
            case 3:
                printf("Enter file index to delete (0-%d): ", fileCount-1);
                int idx; scanf("%d", &idx);
                if(idx >= 0 && idx < fileCount) {
                    for(int i = files[idx].start; i < files[idx].start + files[idx].length; i++)
                        bitVector[i] = 0;
                    for(int i = idx; i < fileCount-1; i++) files[i] = files[i+1];
                    fileCount--;
                    printf("File deleted.\n");
                } else printf("Invalid index!\n");
                break;
            case 4: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 4);
    return 0;
}

Q2: SSTF Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

int findNearest(int arr[], int n, int head, int visited[]) {
    int minDist = 9999, index = -1;
    for(int i = 0; i < n; i++)
        if(!visited[i] && abs(arr[i] - head) < minDist) {
            minDist = abs(arr[i] - head);
            index = i;
        }
    return index;
}

int main() {
    int requests[] = {55, 58, 39, 18, 90, 160, 150, 38, 184};
    int n = 9, head = 50, totalMovement = 0;
    int visited[n] = {0};

    printf("SSTF Order: %d ", head);
    for(int i = 0; i < n; i++) {
        int next = findNearest(requests, n, head, visited);
        visited[next] = 1;
        totalMovement += abs(head - requests[next]);
        head = requests[next];
        printf("%d ", head);
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 9
Q1: Linked File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int start;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1;

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Create New File\n3. Show Directory\n4. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Enter file length: ");
                int len; scanf("%d", &len);
                int start = -1;
                for(int i = 0; i < n && start == -1; i++)
                    if(!bitVector[i]) {
                        int free = 0;
                        for(int j = i; j < i+len && j < n; j++)
                            if(!bitVector[j]) free++;
                        if(free == len) start = i;
                    }
                if(start != -1) {
                    for(int i = start; i < start+len; i++) bitVector[i] = 1;
                    files[fileCount].start = start;
                    files[fileCount].length = len;
                    fileCount++;
                    printf("File created at block %d\n", start);
                } else printf("Not enough space!\n");
                break;
            case 3:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Start=%d, Length=%d\n", i, files[i].start, files[i].length);
                break;
            case 4: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 4);
    return 0;
}

Q2: C-SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {80, 150, 60, 135, 40, 35, 170};
    int n = 7, head = 70, totalMovement = 0;
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n);
    printf("C-SCAN Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    for(int i = start; i < n; i++) {
        printf("%d ", sorted[i]);
        totalMovement += abs(head - sorted[i]);
        head = sorted[i];
    }
    totalMovement += (199 - head); printf("199 "); head = 199;
    totalMovement += 199; printf("0 "); head = 0;
    for(int i = 0; i < start; i++) {
        printf("%d ", sorted[i]);
        totalMovement += abs(head - sorted[i]);
        head = sorted[i];
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 10
Q1: Indexed File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int indexBlock;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1;

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Show Directory\n3. Delete File\n4. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Index=%d, Length=%d\n", i, files[i].indexBlock, files[i].length);
                break;
            case 3:
                printf("Enter file index to delete (0-%d): ", fileCount-1);
                int idx; scanf("%d", &idx);
                if(idx >= 0 && idx < fileCount) {
                    bitVector[files[idx].indexBlock] = 0;
                    for(int i = idx; i < fileCount-1; i++) files[i] = files[i+1];
                    fileCount--;
                    printf("File deleted.\n");
                } else printf("Invalid index!\n");
                break;
            case 4: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 4);
    return 0;
}

Q2: LOOK Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {23, 89, 132, 42, 187, 69, 36, 55};
    int n = 8, head = 40, totalMovement = 0;
    int direction = 0; // Left
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1);
    printf("LOOK Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 0) {
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 11
Q1: Indexed File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int indexBlock;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1;

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Create New File\n3. Show Directory\n4. Delete File\n5. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Enter file length: ");
                int len; scanf("%d", &len);
                int idx = -1;
                for(int i = 0; i < n && idx == -1; i++)
                    if(!bitVector[i]) idx = i;
                if(idx != -1) {
                    bitVector[idx] = 1;
                    files[fileCount].indexBlock = idx;
                    files[fileCount].length = len;
                    fileCount++;
                    printf("File created with index %d\n", idx);
                } else printf("No free blocks!\n");
                break;
            case 3:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Index=%d, Length=%d\n", i, files[i].indexBlock, files[i].length);
                break;
            case 4:
                printf("Enter file index to delete (0-%d): ", fileCount-1);
                int del; scanf("%d", &del);
                if(del >= 0 && del < fileCount) {
                    bitVector[files[del].indexBlock] = 0;
                    for(int i = del; i < fileCount-1; i++) files[i] = files[i+1];
                    fileCount--;
                    printf("File deleted.\n");
                } else printf("Invalid index!\n");
                break;
            case 5: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 5);
    return 0;
}

Q2: SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {33, 99, 142, 52, 197, 79, 46, 65};
    int n = 8, head = 72, totalMovement = 0;
    int direction = 1; // Right
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1);
    printf("SCAN Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 1) {
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        totalMovement += (199 - head); printf("199 "); head = 199;
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 12
Q1: Banker's Algorithm (Safety Check)
#include <stdio.h>
#define MAX_PROCESSES 6
#define MAX_RESOURCES 4

void displayNeed(int need[MAX_PROCESSES][MAX_RESOURCES]) {
    printf("\nNeed Matrix:\n");
    for(int i = 0; i < MAX_PROCESSES; i++) {
        for(int j = 0; j < MAX_RESOURCES; j++)
            printf("%d ", need[i][j]);
        printf("\n");
    }
}

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{0,3,2,4}, {1,2,0,1}, {0,0,0,0}, {3,3,2,2}, {1,4,3,2}, {2,4,1,4}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{6,5,4,4}, {4,4,4,4}, {0,0,1,2}, {3,9,3,4}, {2,5,3,3}, {4,6,3,4}};
    int available[MAX_RESOURCES] = {3,4,4,2};
    int need[MAX_PROCESSES][MAX_RESOURCES], work[MAX_RESOURCES], finish[MAX_PROCESSES] = {0};
    int safeSequence[MAX_PROCESSES], count = 0;

    for(int i = 0; i < MAX_PROCESSES; i++)
        for(int j = 0; j < MAX_RESOURCES; j++)
            need[i][j] = max[i][j] - allocation[i][j];

    displayNeed(need);
    for(int j = 0; j < MAX_RESOURCES; j++) work[j] = available[j];

    while(count < MAX_PROCESSES) {
        int found = 0;
        for(int i = 0; i < MAX_PROCESSES; i++) {
            if(!finish[i]) {
                int canExecute = 1;
                for(int j = 0; j < MAX_RESOURCES; j++)
                    if(need[i][j] > work[j]) canExecute = 0;
                if(canExecute) {
                    for(int j = 0; j < MAX_RESOURCES; j++) work[j] += allocation[i][j];
                    finish[i] = 1;
                    safeSequence[count++] = i;
                    found = 1;
                }
            }
        }
        if(!found) break;
    }

    if(count == MAX_PROCESSES) {
        printf("System is in safe state. Safe sequence: ");
        for(int i = 0; i < MAX_PROCESSES; i++) printf("P%d ", safeSequence[i]);
        printf("\n");
    } else printf("System is not in safe state.\n");
    return 0;
}

Q2: C-SCAN Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {23, 89, 132, 42, 187, 69, 36, 55};
    int n = 8, head = 40, totalMovement = 0;
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n);
    printf("C-SCAN Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    for(int i = start-1; i >= 0; i--) {
        printf("%d ", sorted[i]);
        totalMovement += abs(head - sorted[i]);
        head = sorted[i];
    }
    totalMovement += head; printf("0 "); head = 0;
    totalMovement += 199; printf("199 "); head = 199;
    for(int i = start; i < n; i++) {
        printf("%d ", sorted[i]);
        totalMovement += abs(head - sorted[i]);
        head = sorted[i];
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 13
Q1: Dynamic Banker's Algorithm
#include <stdio.h>
#define MAX_PROCESSES 10
#define MAX_RESOURCES 10

int main() {
    int m, n, allocation[MAX_PROCESSES][MAX_RESOURCES], max[MAX_PROCESSES][MAX_RESOURCES], available[MAX_RESOURCES];
    int need[MAX_PROCESSES][MAX_RESOURCES];

    printf("Enter number of processes: "); scanf("%d", &m);
    printf("Enter number of resource types: "); scanf("%d", &n);
    printf("Enter instances for each resource type:\n");
    for(int j = 0; j < n; j++) scanf("%d", &available[j]);
    printf("Enter Allocation Matrix:\n");
    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
            scanf("%d", &allocation[i][j]);
    printf("Enter Max Matrix:\n");
    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
            scanf("%d", &max[i][j]);

    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
            need[i][j] = max[i][j] - allocation[i][j];

    printf("\nNeed Matrix:\n");
    for(int i = 0; i < m; i++) {
        for(int j = 0; j < n; j++) printf("%d ", need[i][j]);
        printf("\n");
    }

    int request[MAX_RESOURCES], p;
    printf("Enter process number for request (0-%d): ", m-1); scanf("%d", &p);
    printf("Enter request vector:\n");
    for(int j = 0; j < n; j++) scanf("%d", &request[j]);

    int canGrant = 1;
    for(int j = 0; j < n; j++)
        if(request[j] > need[p][j] || request[j] > available[j]) canGrant = 0;

    if(canGrant) printf("Request can be granted immediately.\n");
    else printf("Request cannot be granted immediately.\n");
    return 0;
}

Q2: SSTF Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

int findNearest(int arr[], int n, int head, int visited[]) {
    int minDist = 9999, index = -1;
    for(int i = 0; i < n; i++)
        if(!visited[i] && abs(arr[i] - head) < minDist) {
            minDist = abs(arr[i] - head);
            index = i;
        }
    return index;
}

int main() {
    int requests[] = {24, 90, 133, 43, 188, 70, 37, 55};
    int n = 8, head = 58, totalMovement = 0;
    int visited[n] = {0};

    printf("SSTF Order: %d ", head);
    for(int i = 0; i < n; i++) {
        int next = findNearest(requests, n, head, visited);
        visited[next] = 1;
        totalMovement += abs(head - requests[next]);
        head = requests[next];
        printf("%d ", head);
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Slip 14
Q1: LOOK Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

void sort(int arr[], int n, int asc) {
    for(int i = 0; i < n-1; i++)
        for(int j = 0; j < n-i-1; j++)
            if(asc ? arr[j] > arr[j+1] : arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

int main() {
    int requests[] = {86, 147, 91, 170, 95, 130, 102, 70};
    int n = 8, head = 125, totalMovement = 0;
    int direction;
    printf("Enter direction (0-Left, 1-Right): "); scanf("%d", &direction);
    int sorted[n];
    for(int i = 0; i < n; i++) sorted[i] = requests[i];

    sort(sorted, n, 1);
    printf("LOOK Order: %d ", head);
    int start = 0;
    for(int i = 0; i < n; i++) if(sorted[i] >= head) { start = i; break; }

    if(direction == 0) {
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    } else {
        for(int i = start; i < n; i++) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
        for(int i = start-1; i >= 0; i--) {
            printf("%d ", sorted[i]);
            totalMovement += abs(head - sorted[i]);
            head = sorted[i];
        }
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}

Q2: Linked File Allocation
#include <stdio.h>
#include <stdlib.h>
#define MAX_BLOCKS 100

struct File {
    int start;
    int length;
};

int main() {
    int n, bitVector[MAX_BLOCKS] = {0}, choice;
    struct File files[10];
    int fileCount = 0;

    printf("Enter total number of blocks: ");
    scanf("%d", &n);
    for(int i = 0; i < n/2; i++) bitVector[rand() % n] = 1;

    do {
        printf("\nMenu:\n1. Show Bit Vector\n2. Create New File\n3. Show Directory\n4. Exit\nChoice: ");
        scanf("%d", &choice);
        switch(choice) {
            case 1:
                printf("Bit Vector: ");
                for(int i = 0; i < n; i++) printf("%d ", bitVector[i]);
                printf("\n");
                break;
            case 2:
                printf("Enter file length: ");
                int len; scanf("%d", &len);
                int start = -1;
                for(int i = 0; i < n && start == -1; i++)
                    if(!bitVector[i]) {
                        int free = 0;
                        for(int j = i; j < i+len && j < n; j++)
                            if(!bitVector[j]) free++;
                        if(free == len) start = i;
                    }
                if(start != -1) {
                    for(int i = start; i < start+len; i++) bitVector[i] = 1;
                    files[fileCount].start = start;
                    files[fileCount].length = len;
                    fileCount++;
                    printf("File created at block %d\n", start);
                } else printf("Not enough space!\n");
                break;
            case 3:
                printf("Directory:\n");
                for(int i = 0; i < fileCount; i++)
                    printf("File %d: Start=%d, Length=%d\n", i, files[i].start, files[i].length);
                break;
            case 4: printf("Exiting...\n"); break;
            default: printf("Invalid choice!\n");
        }
    } while(choice != 4);
    return 0;
}

Slip 15
Q1: Banker's Algorithm (Safety Check)
#include <stdio.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 4

void displayNeed(int need[MAX_PROCESSES][MAX_RESOURCES]) {
    printf("\nNeed Matrix:\n");
    for(int i = 0; i < MAX_PROCESSES; i++) {
        for(int j = 0; j < MAX_RESOURCES; j++)
            printf("%d ", need[i][j]);
        printf("\n");
    }
}

int main() {
    int allocation[MAX_PROCESSES][MAX_RESOURCES] = {{0,0,1,2}, {1,0,0,0}, {1,3,5,4}, {0,6,3,2}, {0,0,1,4}};
    int max[MAX_PROCESSES][MAX_RESOURCES] = {{0,0,1,2}, {1,7,5,0}, {2,3,5,6}, {0,6,5,2}, {0,6,5,6}};
    int available[MAX_RESOURCES] = {1,5,2,0};
    int need[MAX_PROCESSES][MAX_RESOURCES], work[MAX_RESOURCES], finish[MAX_PROCESSES] = {0};
    int safeSequence[MAX_PROCESSES], count = 0;

    for(int i = 0; i < MAX_PROCESSES; i++)
        for(int j = 0; j < MAX_RESOURCES; j++)
            need[i][j] = max[i][j] - allocation[i][j];

    displayNeed(need);
    for(int j = 0; j < MAX_RESOURCES; j++) work[j] = available[j];

    while(count < MAX_PROCESSES) {
        int found = 0;
        for(int i = 0; i < MAX_PROCESSES; i++) {
            if(!finish[i]) {
                int canExecute = 1;
                for(int j = 0; j < MAX_RESOURCES; j++)
                    if(need[i][j] > work[j]) canExecute = 0;
                if(canExecute) {
                    for(int j = 0; j < MAX_RESOURCES; j++) work[j] += allocation[i][j];
                    finish[i] = 1;
                    safeSequence[count++] = i;
                    found = 1;
                }
            }
        }
        if(!found) break;
    }

    if(count == MAX_PROCESSES) {
        printf("System is in safe state. Safe sequence: ");
        for(int i = 0; i < MAX_PROCESSES; i++) printf("P%d ", safeSequence[i]);
        printf("\n");
    } else printf("System is not in safe state.\n");
    return 0;
}

Q2: FCFS Disk Scheduling
#include <stdio.h>
#include <stdlib.h>

int main() {
    int requests[] = {56, 59, 40, 19, 91, 161, 151, 39, 185};
    int n = 9, head = 48, totalMovement = 0;
    printf("FCFS Order: %d ", head);
    for(int i = 0; i < n; i++) {
        printf("%d ", requests[i]);
        totalMovement += abs((i == 0 ? head : requests[i-1]) - requests[i]);
    }
    printf("\nTotal Head Movement: %d\n", totalMovement);
    return 0;
}