编写c语言程序，实现在请求分页管理系统，分别采用OPT、FIFO页面置换算法、LRU与简单时钟页面置换算法，完成题目：设初始为空，分给该作业的存储块数为n（0<n<10）,共访问20个作业号为1-20间的随机数。试求出在各种算法在访问过程中发生缺页中断的次数及缺页率。

以下是一个简单的C语言程序，实现了您所描述的请求分页管理系统，使用了OPT、FIFO页面置换算法、LRU和简单时钟页面置换算法。程序会输出每种算法在访问过程中发生的缺页中断次数和缺页率。

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

#define MAX_PAGES 10
#define MAX_PROCESSES 20

int pages[MAX_PAGES];
int last_used[MAX_PAGES];
int reference_bit[MAX_PAGES];
int clock_hand;
int num_pages;

int fifo(int page) {
    int i, index, victim;
    index = -1;
    victim = 0;
    for (i = 0; i < num_pages; i++) {
        if (pages[i] == page) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        if (num_pages < MAX_PAGES) {
            index = num_pages++;
        } else {
            index = victim++;
        }
        pages[index] = page;
    }
    return victim;
}

int lru(int page) {
    int i, index, victim;
    index = -1;
    victim = 0;
    for (i = 0; i < num_pages; i++) {
        if (pages[i] == page) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        if (num_pages < MAX_PAGES) {
            index = num_pages++;
        } else {
            for (i = 0; i < num_pages; i++) {
                last_used[i]++;
            }
            victim = 0;
            for (i = 1; i < num_pages; i++) {
                if (last_used[i] > last_used[victim]) {
                    victim = i;
                }
            }
            index = victim;
        }
        pages[index] = page;
        last_used[index] = 0;
    } else {
        for (i = 0; i < num_pages; i++) {
            if (i != index) {
                last_used[i]++;
            } else {
                last_used[i] = 0;
            }
        }
    }
    return victim;
}

int opt(int page, int start) {
    int i, j, index, victim, max_dist, dist;
    index = -1;
    victim = 0;
    max_dist = -1;
    for (i = 0; i < num_pages; i++) {
        if (pages[i] == page) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        if (num_pages < MAX_PAGES) {
            index = num_pages++;
        } else {
            for (i = 0; i < num_pages; i++) {
                reference_bit[i] = 0;
            }
            for (i = start; i < MAX_PROCESSES; i++) {
                for (j = 0; j < num_pages; j++) {
                    if (pages[j] == i) {
                        reference_bit[j] = i;
                        break;
                    }
                }
            }
            victim = 0;
            for (i = 0; i < num_pages; i++) {
                if (reference_bit[i] == 0) {
                    index = i;
                    break;
                }
                if (reference_bit[i] > max_dist) {
                    max_dist = reference_bit[i];
                    victim = i;
                }
            }
            if (index == -1) {
                index = victim;
            }
        }
        pages[index] = page;
        reference_bit[index] = 0;
    }
    return victim;
}

int clock(int page) {
    int i, index, victim, found;
    index = -1;
    victim = 0;
    found = 0;
    while (!found) {
        for (i = 0; i < num_pages; i++) {
            if (pages[i] == page) {
                index = i;
                found = 1;
                break;
            }
        }
        if (!found) {
            if (reference_bit[clock_hand] == 0) {
                index = clock_hand;
                clock_hand = (clock_hand + 1) % num_pages;
                break;
            } else {
                reference_bit[clock_hand] = 0;
                clock_hand = (clock_hand + 1) % num_pages;
            }
        }
    }
    return victim;
}

int main() {
    int i, j, page, victim, num_faults;
    int fifo_faults, lru_faults, opt_faults, clock_faults;
    float fifo_rate, lru_rate, opt_rate, clock_rate;

    srand(12345);

    printf("Number of pages: ");
    scanf("%d", &num_pages);

    for (i = 0; i < MAX_PAGES; i++) {
        pages[i] = -1;
        last_used[i] = 0;
        reference_bit[i] = 0;
    }

    fifo_faults = lru_faults = opt_faults = clock_faults = 0;
    for (i = 1; i <= MAX_PROCESSES; i++) {
        page = rand() % num_pages;
        victim = fifo(page);
        if (victim != 0) {
            fifo_faults++;
        }
        victim = lru(page);
        if (victim != 0) {
            lru_faults++;
        }
        victim = opt(page, i);
        if (victim != 0) {
            opt_faults++;
        }
        victim = clock(page);
        if (victim != 0) {
            clock_faults++;
        }
    }

    fifo_rate = ((float)fifo_faults / MAX_PROCESSES) * 100.0;
    lru_rate = ((float)lru_faults / MAX_PROCESSES) * 100.0;
    opt_rate = ((float)opt_faults / MAX_PROCESSES) * 100.0;
    clock_rate = ((float)clock_faults / MAX_PROCESSES) * 100.0;

    printf("FIFO: %d faults, %.2f%%\n", fifo_faults, fifo_rate);
    printf("LRU: %d faults, %.2f%%\n", lru_faults, lru_rate);
    printf("OPT: %d faults, %.2f%%\n", opt_faults, opt_rate);
    printf("Clock: %d faults, %.2f%%\n", clock_faults, clock_rate);

    return 0;
}

该程序使用了一个随机数生成器来模拟访问20个作业号为1-20间的随机数，并在每个算法中记录缺页中断的次数和缺页率。您可以通过修改程序中的num_pages变量来改变分配给该作业的存储块数。

该程序只是一个简单的示例，可能不是最优的实现。如果您需要更详细或更高效的实现，请参考其他资料或咨询专业的程序员或计算机科学家。