Write a C program that implements the following disk-scheduling algorithms: a. FCFS b. SSTF c. SCAN d. C-SCAN e. LOOK f. C-LOOK Your program will service a disk with 5,000 cylinders numbered 0 to 4,999. The program will generate a random series of 1,000 cylinder requests and service them according to each of the algorithms listed above. The program will be passed the initial position of the disk head (as a parameter on the command line) and report the total amount of head movement required by each algorithm.

Sure, here's a sample C program that implements the disk-scheduling algorithms you mentioned:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define CYLINDERS 5000
#define REQUESTS 1000

// Struct to represent a disk request
typedef struct {
    int cylinder;
    bool visited;
} request;

// Function to generate random cylinder requests
void generateRequests(request* queue) {
    for (int i = 0; i < REQUESTS; i++) {
        queue[i].cylinder = rand() % CYLINDERS;
        queue[i].visited = false;
    }
}

// FCFS algorithm
int fcfs(request* queue, int head) {
    int totalMovement = 0;
    for (int i = 0; i < REQUESTS; i++) {
        totalMovement += abs(head - queue[i].cylinder);
        head = queue[i].cylinder;
    }
    return totalMovement;
}

// SSTF algorithm
int sstf(request* queue, int head) {
    int totalMovement = 0;
    for (int i = 0; i < REQUESTS; i++) {
        int minDistance = CYLINDERS;
        int minIndex = -1;
        for (int j = 0; j < REQUESTS; j++) {
            if (!queue[j].visited) {
                int distance = abs(head - queue[j].cylinder);
                if (distance < minDistance) {
                    minDistance = distance;
                    minIndex = j;
                }
            }
        }
        if (minIndex != -1) {
            totalMovement += minDistance;
            head = queue[minIndex].cylinder;
            queue[minIndex].visited = true;
        }
    }
    return totalMovement;
}

// SCAN algorithm
int scan(request* queue, int head) {
    int totalMovement = 0;
    int direction = 1; // 1 for up, -1 for down
    int currentIndex = -1;
    for (int i = 0; i < REQUESTS; i++) {
        if (queue[i].cylinder == head) {
            currentIndex = i;
            break;
        }
    }
    if (currentIndex == -1) {
        // Insert head into queue
        for (int i = 0; i < REQUESTS; i++) {
            if (head < queue[i].cylinder) {
                for (int j = REQUESTS - 1; j > i; j--) {
                    queue[j] = queue[j-1];
                }
                queue[i].cylinder = head;
                queue[i].visited = true;
                currentIndex = i;
                break;
            }
        }
    }
    for (int i = currentIndex; i >= 0 && i < REQUESTS; i += direction) {
        if (!queue[i].visited) {
            totalMovement += abs(head - queue[i].cylinder);
            head = queue[i].cylinder;
            queue[i].visited = true;
        }
        if (i == 0 || i == REQUESTS - 1) {
            direction = -direction;
        }
    }
    return totalMovement;
}

// C-SCAN algorithm
int cscan(request* queue, int head) {
    int totalMovement = 0;
    int currentIndex = -1;
    for (int i = 0; i < REQUESTS; i++) {
        if (queue[i].cylinder == head) {
            currentIndex = i;
            break;
        }
    }
    if (currentIndex == -1) {
        // Insert head into queue
        for (int i = 0; i < REQUESTS; i++) {
            if (head < queue[i].cylinder) {
                for (int j = REQUESTS - 1; j > i; j--) {
                    queue[j] = queue[j-1];
                }
                queue[i].cylinder = head;
                queue[i].visited = true;
                currentIndex = i;
                break;
            }
        }
    }
    // Service requests in one direction
    for (int i = currentIndex; i >= 0; i--) {
        if (!queue[i].visited) {
            totalMovement += abs(head - queue[i].cylinder);
            head = queue[i].cylinder;
            queue[i].visited = true;
        }
    }
    totalMovement += head; // Head movement to go to the end
    head = 0;
    // Service requests in the other direction
    for (int i = REQUESTS - 1; i > currentIndex; i--) {
        if (!queue[i].visited) {
            totalMovement += abs(head - queue[i].cylinder);
            head = queue[i].cylinder;
            queue[i].visited = true;
        }
    }
    return totalMovement;
}

// LOOK algorithm
int look(request* queue, int head) {
    int totalMovement = 0;
    int direction = 1; // 1 for up, -1 for down
    int currentIndex = -1;
    for (int i = 0; i < REQUESTS; i++) {
        if (queue[i].cylinder == head) {
            currentIndex = i;
            break;
        }
    }
    if (currentIndex == -1) {
        // Insert head into queue
        for (int i = 0; i < REQUESTS; i++) {
            if (head < queue[i].cylinder) {
                for (int j = REQUESTS - 1; j > i; j--) {
                    queue[j] = queue[j-1];
                }
                queue[i].cylinder = head;
                queue[i].visited = true;
                currentIndex = i;
                break;
            }
        }
    }
    for (int i = currentIndex; i >= 0 && i < REQUESTS; i += direction) {
        if (!queue[i].visited) {
            totalMovement += abs(head - queue[i].cylinder);
            head = queue[i].cylinder;
            queue[i].visited = true;
        }
        if (i == 0 || i == REQUESTS - 1) {
            direction = -direction;
        }
    }
    return totalMovement;
}

// C-LOOK algorithm
int clook(request* queue, int head) {
    int totalMovement = 0;
    int currentIndex = -1;
    for (int i = 0; i < REQUESTS; i++) {
        if (queue[i].cylinder == head) {
            currentIndex = i;
            break;
        }
    }
    if (currentIndex == -1) {
        // Insert head into queue
        for (int i = 0; i < REQUESTS; i++) {
            if (head < queue[i].cylinder) {
                for (int j = REQUESTS - 1; j > i; j--) {
                    queue[j] = queue[j-1];
                }
                queue[i].cylinder = head;
                queue[i].visited = true;
                currentIndex = i;
                break;
            }
        }
    }
    // Service requests in one direction
    for (int i = currentIndex; i >= 0; i--) {
        if (!queue[i].visited) {
            totalMovement += abs(head - queue[i].cylinder);
            head = queue[i].cylinder;
            queue[i].visited = true;
        }
    }
    // Service requests in the other direction
    for (int i = REQUESTS - 1; i > currentIndex; i--) {
        if (!queue[i].visited) {
            totalMovement += abs(head - queue[i].cylinder);
            head = queue[i].cylinder;
            queue[i].visited = true;
        }
    }
    return totalMovement;
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s <initial position>\n", argv[0]);
        return 1;
    }
    int initial = atoi(argv[1]);
    if (initial < 0 || initial >= CYLINDERS) {
        printf("Initial position must be between 0 and %d\n", CYLINDERS - 1);
        return 1;
    }

    request queue[REQUESTS];
    generateRequests(queue);

    printf("FCFS: %d\n", fcfs(queue, initial));
    for (int i = 0; i < REQUESTS; i++) {
        queue[i].visited = false;
    }
    printf("SSTF: %d\n", sstf(queue, initial));
    for (int i = 0; i < REQUESTS; i++) {
        queue[i].visited = false;
    }
    printf("SCAN: %d\n", scan(queue, initial));
    for (int i = 0; i < REQUESTS; i++) {
        queue[i].visited = false;
    }
    printf("C-SCAN: %d\n", cscan(queue, initial));
    for (int i = 0; i < REQUESTS; i++) {
        queue[i].visited = false;
    }
    printf("LOOK: %d\n", look(queue, initial));
    for (int i = 0; i < REQUESTS; i++) {
        queue[i].visited = false;
    }
    printf("C-LOOK: %d\n", clook(queue, initial));

    return 0;
}

To compile and run the program, you can use the following commands:

$ gcc disk-scheduling.c -o disk-scheduling
$ ./disk-scheduling <initial position>

Replace `<initial position>` with the desired starting position of the disk head. The program will generate a random series of 1,000 cylinder requests and service them according to each of the algorithms listed above, reporting the total amount of head movement required by each algorithm.