湖北师范大学----操作系统实训（c语言）
仅用于参考学习！！切勿私自搬运摘抄！！ 有任何问题可以联系Q:353684893
A:题目1：进程调度1—静态非剥夺式优先级调度计算平均作业周转时间
问题描述：要求输入3个进程的信息，假设这些进程均是在0时刻同时到达，若进程调度采用非剥夺式静态优先级（优先数数值大的表示优先级比较高；如果遇到优先级一样，按照输入顺序执行。），计算并输出平均作业周转时间。
输入格式：程序要求输入3行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的优先数，第3个数据类型为整型，表示进程的运行时间。
输出格式：输出结果为一个浮点数，保留到小数点后一位，为系统的平均作业周转时间。
样例输入1：
P1 1 1
P2 2 2
P3 3 3
样例输出1：
4.7
样例输入2：
P1 10 10
P2 100 100
P3 100 100
样例输出2：
170.0
#include<stdio.h>
#include<stdlib.h>
#include<string.h>int main(){ int a1=0,a2=0,b1=0,b2=0,c1=0,c2=0,a3=0,b3=0,c3=0;char a0[10],b0[10],c0[10];float sum=0;a3=0;b3=0;c3=0;scanf("%s %d %d",&a0,&a1,&a2);scanf("%s %d %d",&b0,&b1,&b2);scanf("%s %d %d",&c0,&c1,&c2);if(a1<b1) { //判断优先级b3++;}else{a3++;}if(a1<c1){ c3++;}else{a3++;}if(b1<c1){ c3++;}else{b3++;}a3=a3+1;b3=b3+1;c3=c3+1;sum=a2*a3+b2*b3+c2*c3;printf("%0.1f",sum);system("pause");return 0;
}B:题目2：进程调度2--最高响应比优先计算每个作业的周转时间
问题描述：要求输入3个进程的信息，按照最高响应比优先的调度算法计算并输出每个进程的周转时间。(若两个进程的响应比相同，则优先选择先进入的进程。若两个进程的响应比相同，而且进入时刻也相同，则按照输入的顺序执行，如：P4和P6的响应比相同且进入时刻也相同，如P4先输入则选择P4先执行)
输入格式：程序要求输入3行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的进入时刻，第3个数据类型为整型，表示进程的运行时间。
输出格式：输出三个整数之间，整数之间用空格作为分隔，为每个进程的周转时间。
样例输入1：
P1 1 1
P2 2 2
P3 3 3
样例输出1：
1 2 4
样例输入2：
P1 1 4
P2 2 8
P3 3 1
样例输出2：
4 12 3
样例输入3：
1 3 35000
2 2 33000
3 1 30000
样例输出3
97998 62999 30000
样例输入4：
P1 3 4
P2 1 8
P3 2 1
样例输出4
11 8 8
样例输入5：
P1 2 2
P2 1 8
P3 2 2
样例输出5
9 8 11
样例输入6：
P1 1 1
P2 10 1
P3 1 2
样例输出6
1 1 3
#include<stdio.h>
#include<stdlib.h>
#include<string.h>struct hrrfs{char name[10];int get_in;//进入时间int done;//运行时间int start;//作业开始时间float res;//响应比int turn_time;//周转时间int finish;//完成时间int first;//初始位置方便输出
};void sort(struct hrrfs *b){ //对进入时间进行降序排序（若进入时间一样则按输入顺序排序）struct hrrfs t;int i,j;for(i=0;i<2;i++){for(j=0;j<2-i;j++) {if(b[j].get_in>b[j+1].get_in) {//把第一个数与第二个数交换位置 t=b[j+1];b[j+1]=b[j];b[j]=t;}}}
}void Hrrfs(struct hrrfs *b){struct hrrfs temp1;temp1.get_in=-1;temp1.done=0;b[0].finish=b[0].get_in+b[0].done;//b[0]的完成时间就是b[1]和b[2]的开始时间b[0].start=b[0].get_in;b[0].turn_time=b[0].done+b[0].start-b[0].get_in;if(b[0].finish>=b[1].get_in){b[1].start=b[0].finish;}else{b[1].start=b[1].get_in;}if(b[0].finish>=b[2].get_in){b[2].start=b[0].finish;}else{b[2].start=b[2].get_in;}b[1].res=(float)(b[1].start-b[1].get_in+b[1].done)/b[1].done;b[2].res=(float)(b[2].start-b[2].get_in+b[2].done)/b[2].done;if(b[1].res>=b[2].res){b[1].finish=b[1].start+b[1].done;//b1 结束 = b1 开始 + b1 运行if(b[1].finish>=b[2].get_in){ b[2].start=b[1].finish;}else{b[2].start=b[2].get_in;} b[2].finish=b[2].start+b[2].done;b[1].turn_time=b[1].finish-b[1].get_in;b[2].turn_time=b[2].finish-b[2].get_in;}else if(b[1].res<b[2].res){b[2].finish=b[2].start+b[2].done;if(b[2].finish>=b[1].get_in){b[1].start=b[2].finish;}else{b[1].start=b[1].get_in;} b[1].finish=b[1].start+b[1].done;b[1].turn_time=b[1].finish-b[1].get_in;b[2].turn_time=b[2].finish-b[2].get_in;}else{if(b[1].first<b[2].first){b[1].finish=b[1].start+b[1].done;if(b[1].finish>=b[2].get_in){ b[2].start=b[1].finish;}else{b[2].start=b[2].get_in;} b[2].finish=b[2].start+b[2].done;b[1].turn_time=b[1].finish-b[1].get_in;b[2].turn_time=b[2].finish-b[2].get_in;}else{b[2].finish=b[2].start+b[2].done;if(b[2].finish>=b[1].get_in){b[1].start=b[2].finish;}else{b[1].start=b[1].get_in;} b[1].finish=b[1].start+b[1].done;b[1].turn_time=b[1].finish-b[1].get_in;b[2].turn_time=b[2].finish-b[2].get_in;}}
}int main(){ struct hrrfs a[3];struct hrrfs *a_p=a;int i=0,j;for(i=0;i<3;i++){scanf("%s %d %d",a[i].name,&a[i].get_in,&a[i].done);a[i].first=i;a[i].res=0;}sort(a_p);Hrrfs(a_p);///----------------///for(i=0;i<3;i++){for(j=0;j<3;j++){if(a[j].first==i){printf("%d ",a[j].turn_time);}}}system("pause");
}PS：这道题目没有完全通过，有一个测试样例可以参考一下（问题应该是出在这里）
样例输入7：
P1 3 1
P2 2 2
P3 2 2
样例输出7
4 2 4 / 2 2 5
C:题目5：死锁—利用银行家算法判断系统的安全性
问题描述：假设系统中有A、B、C三类资源，且有四个并发进程，要求输入资源总量Resource，以及每个进程运行所需的资源总量Claim和已经分配得到的资源量Allocation，利用银行家算法判断当前状态是否为安全状态，若为安全状态则给出一个安全序列。
输入格式：程序要求输入五行，以回车符号作为分隔。第一行是三个整数，整数之间以空格作为分隔，表示A、B、C三类资源的总量。下面的四行分别表示每个进程运行所需的资源总量Claim和已经分配得到的资源量Allocation；每行有7个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名；第2、3、4个数据类型为整型，表示相应进程运行所需A、B、C三种资源总量Claim；第5、6、7个数据类型为整型，表示相应进程已经分配得到的A、B、C三种资源量Allocation。
输出格式：输出一个字符串。若当前为不安全状态则输出为”false”（不含双引号，所有字母皆为小写）；若当前为安全状态则输出一个安全序列，进程名之间用空格作为分隔）。
样例输入1：
9 5 7
P1 5 3 4 2 1 3
P2 9 5 2 2 1 1
P3 3 2 2 2 2 1
P4 6 4 1 1 1 1
样例输出1：
P3 P1 P4 P2
样例输入2：
9 5 7
P1 5 3 4 2 1 4
P2 9 5 2 2 1 1
P3 3 2 2 2 2 1
P4 6 4 1 1 1 1
样例输出2：
false
样例输入3：
12 8 11
p0 5 3 4 0 2 4
p1 6 2 3 3 1 1
p2 6 2 4 5 1 3
p3 4 5 2 2 0 2
# include<stdio.h>
# include<stdlib.h>
# include<string.h>struct Resource{int a_resource;int b_resource;int c_resource;int a_available;int b_available;int c_available;
};struct Process{char name[10];int a_allocation;int b_allocation;int c_allocation;int a_claim;int b_claim ;int c_claim;int a_need;int b_need;int c_need;};struct Work{int a_work;int b_work;int c_work;int rest[4];int possible;};void compute_need_available(struct Process *a,struct Resource *b){int i;b->a_available=b->a_resource;b->b_available=b->b_resource;b->c_available=b->c_resource;for(i=0;i<4;i++){ //处理available部分以及need部分b->a_available=b->a_available-a[i].a_allocation;b->b_available=b->b_available-a[i].b_allocation;b->c_available=b->c_available-a[i].c_allocation; a[i].a_need=a[i].a_claim-a[i].a_allocation;a[i].b_need=a[i].b_claim-a[i].b_allocation;a[i].c_need=a[i].c_claim-a[i].c_allocation;}
}void Init(struct Work *a,struct Resource *b){ //初始化int i;a->a_work=b->a_available;a->b_work=b->b_available;a->c_work=b->c_available;a->possible=0;for(i=0;i<4;i++){a->rest[i]=0;}}void safe(struct Work *a,struct Resource *b,struct Process *c){int i,j,k,sum=0,sum_run=0,p;int d[5];p=0;for(i=0;i<4;i++){a->possible=0; for(j=0;j<4;j++){///此处输出当前的work以及各个进程尚缺资源量p=(p+j)%4;if(a->rest[p]==0 && a->possible==0){if( c[p].a_need <= a->a_work && c[p].b_need <= a->b_work && c[p].c_need <= a->c_work){a->a_work=a->a_work+c[p].a_allocation;a->b_work=a->a_work+c[p].b_allocation;a->c_work=a->a_work+c[p].c_allocation;a->rest[p]=1;a->possible=1;d[i]=p;p++;}}}}for(i=0;i<4;i++){sum=sum+a->rest[i];}if(sum==4){for(i=0;i<4;i++){printf("%s ",c[d[i]].name);}}else{printf("false");}
}int main(){struct Resource resource;struct Resource *resource_p=&resource;struct Process process[4];struct Process *process_p=process;struct Work work;struct Work *work_p=&work;int i;scanf("%d %d %d",&resource.a_resource,&resource.b_resource,&resource.c_resource);for(i=0;i<4;i++){scanf("%s %d %d %d %d %d %d",process[i].name,&process[i].a_claim,&process[i].b_claim,&process[i].c_claim,&process[i].a_allocation,&process[i].b_allocation,&process[i].c_allocation);}compute_need_available(process_p,resource_p);Init(work_p,resource_p);safe(work_p,resource_p,process_p);system("pause");return 0;
}D:题目6：存储管理—可变分区存储管理方式的最佳适应分配算法
问题描述：当内存管理采用可变分区分配方案时，要求输入多个空闲分区和进程内存请求序列，输出显示采用下次适应分配算法分配给各个进程的分区编号。
输入格式：程序要求输入3行，以回车符号作为分隔，第一行是一个整数n（n>=3），表示空闲分区的数量；第二行是n个整数，依次按地址递增对应第一行n个空闲分区的存储容量，每个整型数的数值代表所对应空间的剩余存储容量。n个分区（分区按地址递增依次从1开始编号，若分区X被切割分配了，剩余部分即使为0也保留原来的分区编号X）。第三行是3个整数，两个数之间以空格作为分隔，分别表示三个进程先后依次申请的内存空间的大小。
输出格式：输出一行三个整数，整数之间用空格作为分隔，分别表示三个进程所分配的分区编号；若分配失败，则用”false”表示（不含双引号，所有字母皆为小写）。
样例输入1：
6
20 5 6 18 60 4
12 7 20
样例输出1：
4 1 5
样例输入2：
5
10 20 60 30 40
50 48 25
样例输出2：
3 false 4
样例输入3：
6
20 5 6 19 60 4
12 7 20
样例输出3：
4 4 1
样例输入4：
6
20 5 6 19 60 4
100 7 20
样例输出4：
false 4 1
///*思路*///
//首先 将内存空间排序或者直接找到一个合适的（最小的内存空间与进程适配）最佳适应分配
//再从被找到的这个内存空间开始按照顺序往下寻找 合适的内存空间适配下一进程 下次适应分配法# include <stdio.h>
# include <stdlib.h>
# include <string.h>void sort(int a[],int n)
{int i,j,temp,min;for(i=0;i<n-1;i++){min=i;for(j=i+1;j<n;j++) while(a[j]<a[min])min=j;if(min!=i){temp=a[min]; a[min]=a[i];a[i]=temp;}}
}int main(){int n,i,j,k,p=0,min=10000;int *a;int b[3];int *c;//该数组用来存放a数组中原来的位置int num=0,panduan=0;scanf("%d",&n);a=(int *)malloc(n*sizeof(int));c=(int *)malloc(n*sizeof(int));memset(a, 0, n);for(i=0;i<n;i++){scanf("%d",&a[i]);c[i]=a[i];}for(i=0;i<3;i++){scanf("%d",&b[i]);}///*数据处理*///sort(a,n);//对a数组排序//p是存储当前查找的下标 p是用来下次适应分配法的下标的位置 i不应该是下标 i是控制循环的次数为n次while(num<3){panduan=0;for(i=0;i<n && b[num]!=0;i++){if(p+i>=n){ //处理下标问题 首尾相连p=p+i-n;}//printf("p--->%d\n",p);//printf("b[0]--->%d a[p+i]--->%d\n",b[num],a[p+i]);if(b[num]<=a[p+i] && b[num]!=0){panduan=1;//找到合适的存储空间p=p+i;//此处是该程序可能会出错的关键******for(j=0;j<n && b[num]!=0;j++){ //匹配原数组内容if(c[j]==a[p]){printf("%d ",j+1);c[j]=c[j]-b[num];a[p]=a[p]-b[num];//空间占用b[num]=0;//移入内存}}}}if(panduan==0){printf("false ");}num++;}free(a);free(c);system("pause");return 0;}E:题目7：存储管理—FIFO页面替换算法计算中断次数
问题描述：在请求分页式存储管理方式中，要求输入一个对5个页面的访问序列，输出当系统分配给进程物理页框数为m个时，按照FIFO页面替换算法的缺页中断次数（假设初始时页框均为空）。
输入格式：程序要求输入3行，以回车符号作为分隔，第一行是一个整数n，表示页面访问序列中访问页面的次数；第二行是n个整数，数之间以空格作为分隔，表示页面访问序列。第三行是一个整数m，表示系统分配给进程物理页框数。
输出格式：输出一个整数，表示缺页中断次数。
样例输入1：
12
4 3 2 1 4 3 5 4 3 2 1 5
3
样例输出1：
9
样例输入2：
12
4 3 2 1 4 3 5 4 3 2 1 5
4
样例输出2：
10
样例输入3：
12
4 4 4 4 4 4 4 4 4 4 4 4
3
样例输出3：
1
样例输入4：
20
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
3
样例输出4：
15
样例输入5：
5
1 2 1 3 2
3
样例输出5：
3
样例输入3：
12
4 4 4 5 4 3 4 4 2 4 4 4
3
样例输出3：
4
# include <stdio.h>
# include <stdlib.h>
# include <string.h>int main(){int n,m,i,j,temp,pd,k;int *a;//动态数组a用来存放页面访问序列int *b;//动态数组b用来表示内存结构int sum=0;//存储缺页中断次数scanf("%d",&n);a=(int *)malloc(n*sizeof(int));for(i=0;i<n;i++){scanf("%d",&a[i]);}scanf("%d",&m);b=(int *)malloc(m*sizeof(int));//初始化内存结构for(i=0;i<m;i++){ b[i]=-1; }for(i=0;i<n;i++){pd=0; //此变量用于判断新加入的数据是否和内存结构是否相同for(j=0;j<m;j++){ //此层循环用于比较内存结构中的数据和新加入的页面访问序列是否相同if(a[i]==b[j]){ //新加入的数据是a[i] pd=1;}}if(pd==0){ //无相同时：更新内存结构，缺页次数加一for(k=m;k>0;k--){ //更新内存结构b[k]=b[k-1];}b[0]=a[i]; //b[0]单独处理sum++;}}printf("%d",sum);system("pause");return 0;
}F:题目12：驱动调度—采用电梯调度算法排列出磁盘请求响应次序
问题描述：要求输入一个柱面访问请求序列以及当前磁头所在柱面号和移动方向，输出采用电梯调度算法时移动臂响应的柱面访问序列。
输入格式：程序要求输入3行，以回车符号作为分隔，第一行是2个整数n、m，之间用空格隔开，n表示当前磁头所在的柱面号；m表示第二行输入m个数；第二行是m个整数，数之间以空格作为分隔，表示柱面访问请求序列；第三行是数字-1或1，当为-1时表示移动臂向柱面号减小方向移动，当为1时表示移动臂向柱面号增大方向移动。
输出格式：输出m个整数，数之间以空格作为分隔，采用电梯调度算法时移动臂响应的柱面访问序列。
样例输入1：
15 10
24 38 2 110 43 36 5 11 6 180
-1
样例输出1：
11 6 5 2 24 36 38 43 110 180
样例输入2：
15 10
24 38 2 110 43 36 5 11 6 180
1
样例输出2：
24 36 38 43 110 180 11 6 5 2
样例输入3：
11 10
24 38 2 110 43 36 5 11 6 180
1
样例输出3：
24 36 38 43 110 180 11 6 5 2
# include <stdio.h>
# include <stdlib.h>void Sort(int a[],int n){int i,j,temp,min;for(i=0;i<n-1;i++){min=i;for(j=i+1;j<n;j++) while(a[j]<a[min])min=j;if(min!=i){temp=a[min]; a[min]=a[i];a[i]=temp;}}
}int main(){int *a;int n,m; //m表示当前磁头所在柱面号，n表示柱面访问请求序列int move=0;int i;int dw; //定位到当前磁头所在柱面的位置scanf("%d %d",&m,&n);a=(int *)malloc((n+1)*sizeof(int));for(i=0;i<n;i++){scanf("%d",&a[i]);}a[n]=m; //将当前磁头所在的柱面号添加进访问请求序列scanf("%d",&move);Sort(a,n+1);for(i=0;i<n+1;i++){if(a[i]==m){dw=i;}}if(move==-1){for(i=dw-1;i>=0;i--){printf("%d ",a[i]);}for(i=dw+1;i<=n;i++){printf("%d ",a[i]);}}else{for(i=dw+1;i<=n;i++){printf("%d ",a[i]);}for(i=dw-1;i>=0;i--){printf("%d ",a[i]);}}free(a);system("pause");return 0;
}G:题目3：进程调度3
问题描述：要求输入N个进程（N为正整型数，0<N<=25535），输出按照优先级从高到低执行的进程名字符串序列,直至结束。（如果遇到优先级一样，按照输入顺序先后执行。），本题中，优先数数值较高的进程，优先级也较高。
输入格式：程序首先要求输入一个整型变量N，接下来输入为N行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），该字符串为进程名。第2个数据类型为整型，表示进程的优先数。第3个数据类型为整型，表示进程的运行时间。
输出格式：输出1行，M个字符串，字符串之间用空格作为分隔。
样例输入1：
3
P1 1 1
P2 2 2
P3 3 3
样例输出1：
P3 P2 P3 P1 P2 P3
样例输入2：
2
P1 3 3
P2 1 1
样例输出2：
P1 P1 P1 P2
#include<stdio.h>
#include<stdlib.h>
#include<string.h>struct Pros{char name[10]; //名字int youxian; //优先级int time; //运行时间
}pros[25535];int main(){int i,j;int n; //进程数int sum_time=0;//存储运行时间总和 将当做循环的次数使用int max=-100; //该变量用于找出最大优先级int cs; //存储优先级最大的进程的下标///*输入部分*///scanf("%d",&n);for(i=0;i<n;i++){scanf("%s %d %d",pros[i].name,&pros[i].youxian,&pros[i].time);}///*处理数据*///for(i=0;i<n;i++){sum_time=sum_time+pros[i].time;}for(i=0;i<sum_time;i++){max=-100; //初始化maxfor(j=0;j<n;j++){ //该循环用于找出优先级最大的进程的下标（若优先级相同则按照输入顺序输出）if(max<pros[j].youxian && pros[j].time>0){ //找出运行时间大于0且优先级最大的数 不使用等号即可保证按照输入顺序输出max=pros[j].youxian;cs=j;}}if(i<sum_time-1){ //控制输出格式printf("%s ",pros[cs].name);pros[cs].time--;pros[cs].youxian--;}else{printf("%s",pros[cs].name);pros[cs].time--;pros[cs].youxian--;}}system("pause");return 0;
}
H:题目4：进程调度4----时间片轮转
问题描述：要求输入N个进程（0<N<=100），输入时间片M（0<M〈=5），按照进程输入的顺序以时间片轮转的方法输出指定的第K轮（K>0）执行的那个进程的进程名。
输入格式：程序首先输入一个正整数M（0<M<=5）作为时间片，下一行输入一个正整数N（0<N<=100），接下来输入为N行，以回车符号作为分隔，每行有2个数据，以空格作为分隔。第一个数据是字符串（长度小于等于10），该字符串为进程名，第2个数据类型为整型，表示该进程需要的运行时间。最后输入一个正整数K，作为时间片轮转的次数（次数从1开始计数）。
输出格式：输出一个字符串，为最后执行进程的进程名；若无进程运行，则输出“over”（不含双引号，所有字母皆为小写）。 无进程运行----->带表所有的进程均已执行完毕
样例输入1：
1
3
P1 1
P2 2
P3 3
3
样例输出1：P3
样例输入2：
1
3
P1 1
P2 2
P3 3
10
样例输出2：over
样例输入3：
2
3
P1 1
P2 2
P3 3
4
样例输出3：P3
样例输入4：
2
3
P1 1
P2 2
P3 3
5
样例输出4：over
样例输入5：
2
3
P1 2
P2 4
P3 3
5
样例输出5：P3
样例输入6：
2
4
P1 30000
P2 4
P3 3
P4 1
10000
样例输出6：P1
样例输入7：
5
5
P1 2
P2 2
P3 13
P4 11
P5 7
7
样例输出7：P4
# include <stdio.h>
# include <stdlib.h>struct Pro{char name[10];int time;
}pros[100];int main(){int panduan=-1;int i,j,i1,p=0;//p是当前次数中将要运行的下标int n,m;//n为进程数 m为时间片int k; //k为轮转次数 k为几轮转几次///* 输入部分 *///scanf("%d",&m);scanf("%d",&n);for(i=0;i<n;i++){scanf("%s %d",pros[i].name,&pros[i].time);//pros[i].right=0;}scanf("%d",&k);///* 数据处理 *///p=-1;for(i1=0;i1<k;i1++){ //循环轮转次数次p++;panduan=-1;for(i=0;i<n && panduan==-1;i++){if(pros[(i+p)%n].time!=0){panduan=1;p=(i+p)%n;//不为0的下标值已经找到}}if(panduan==1){if(pros[p].time<=m){ //该进程运行时间小于等于时间片 且该进程运行时间仍有剩余pros[p].time=0; //即该进程可以在该时间片内完全运行完 赋0 }else { //进程不能在时间片内运行完成)pros[p].time=pros[p].time-m; //运行时间减去时间片的值}}}if(panduan==-1){ //最后一次没有进程运行 printf("over");}else{printf("%s",pros[p].name);}system("pause");return 0;
}I:题目8：存储管理1
问题描述：现有一个8*8的存储器，要对其空间进行分配。（下标从0开始，最后一个内存块下标为63）。现已有块号为1、7、13、23、47、59的几个内存块被占用。现操作系统要求申请N块内存空间（0<N<=64），当输入的块数N超出其剩余空闲块数的时候，输出为“false”，当输入为合理范围的时候，就输出其以行主序分配的最后一个内存空间的下标。
输入格式：程序要求输入一个整型数N，表示要申请分配空间的大小。
输出格式：输出为一个整型数，表示最后一个被分配空间的下标。
样例输入1：
3
样例输出1：
3
样例输入2：
100
样例输出2：
false
# include <stdio.h>
# include <stdlib.h>int main(){int a[64]={0};int sum=0,i,n,sum1=0,k;a[1]=1;a[7]=1;a[13]=1;a[23]=1;a[47]=1;a[59]=1;scanf("%d",&n);for(i=0;i<64;i++){sum=sum+a[i];}if(n>64-sum){printf("false");}else{for(i=0;i<64;i++){if(a[i]==0){a[i]=1;sum1++;k=i;}if(sum1==n){break;}}if(n==0){printf("59");}elseprintf("%d",k);}system("pause");return 0;}J:题目9：存储管理2
问题描述：现有一个8*8的存储器，要对其空间进行分配。（下标从0开始，最后一个内存块下标为63）。现已有块号为2、7、13、23、37、47、59、61的几个内存块被占用。要求输入需分配的进程数M（0<M<=56），接下来输入为M个整型数，每个数为各个进程需占用的内存块数。当分配到某进程时，其剩余空闲块数可以分配，就输出当前进程分配的最后一个内存空间的下标。当分配到某进程时，其进程块数超出剩余空闲块数无法分配，输出为“false”（不含双引号，且为全小写）。输出的多个下标（或"false"）之间用空格隔开。
输入格式：程序输入分为两行，第一行要求输入一个整型数M，表示要所需分配空间的进程数，接下来的第二行输入M个整型数，每个数之间用空格隔开，表示M个进程每个进程占用的内存空间大小。
输出格式：输出为M组整型数（或"false"），每个整型数表示该进程最后一个被分配的内存空间的下标（或"false"），下标（或"false"）之间用空格隔开。
样例输入1：
3
3 3 3
样例输出1：
3 6 10
样例输入2：
4
3 3 64 3
样例输出2：
3 6 false 10
# include<stdio.h>
# include<stdlib.h>int main(){int a[64]={0};int b[56]; //每个进程需占用的内存块数int c[56]; //存放最后一个的下标位置int sum=0,i,sum1=0,n,j;a[2]=1;a[7]=1;a[13]=1;a[23]=1;a[37]=1;a[47]=1;a[59]=1;a[61]=1;scanf("%d",&n);for(i=0;i<n;i++){scanf("%d",&b[i]);}for(i=0;i<64;i++){sum=sum+a[i];}for(i=0;i<n;i++){if(b[i]<=64-sum){sum1=0;for(j=0;j<63 && sum1<b[i] ;j++){if(a[j]==0 && sum1<b[i]){a[j]=1; //存入sum1++; //使用内存数+1sum++; // 内存数-1c[i]=j; //实时更新当前位置的下标}}printf("%d ",c[i]);}else{printf("false ");}}system("pause");return 0;}
K:题目10：存储管理3
问题描述：现有一个8*8的存储器，要对其已分配的空间进行分配及回收。（下标从0开始，最后一个内存块下标为63）。现已有块号为2、7、13、23、37、41、47、59、61的几个内存块被占用。要求输入需分配的进程数M（0<M<=55），接下来输入为M个整型数，每个数为各个进程需占用的内存块数。当分配到某进程时，其剩余空闲块数可以分配，就输出当前进程分配的最后一个内存空间的下标。当分配到某进程时，其进程块数超出剩余空闲块数无法分配，输出为“false”（不含双引号，且为全小写）。输出的多个下标（或"false"）之间用空格隔开。以上进程不管是否分配成功，按照输入顺序依次命名为p1、p2、p3………pM。回收的时候输入进程名pN，则返回进程名为pN的所有占用内存块号下标，如果该进程名不存在或输入的数值为不合理范围，则返回“false”。
输入格式：程序输入分为三行，第一行是一个整型数M，表示要所需分配空间的进程数，第二行为M个整型数，每个数之间用空格隔开，表示M个进程每个进程占用的内存空间大小。第三行为需要回收的进程名pN，p为小写字母，N为正整型数。
输出格式：输出为两行，第一行为一组整型数，每个整型数表示该进程最后一个被分配的内存空间的下标，下标之间用空格隔开。第二行为一组整型数，表示被回收的进程的内存块下标，多个下标之间用空格隔开。
样例输入1：
3
3 3 3
p3
样例输出1：
3 6 10
8 9 10
样例输入2：
4
3 3 64 3
p3
样例输出2：
3 6 false 10
false
# include <stdio.h>
# include <stdlib.h>
# include <string.h>int change(char a[]){int i,len,num=0;len=strlen(a);for(i=1;i<len;i++){num=num*10+a[i]-48;}return num;
}int main(){int sum_last=0;int n,name_num;int sum=0,i,sum1=0,j;char name[10];int b[56]; //每个进程需占用的内存块数int c[56]; //存放最后一个的下标位置int a[64]={0};int d[56][56]={0};//二维数组，第一维表示是第几个进程，第二维表示的是该进程占用了哪几个内存块a[2]=1;a[7]=1;a[13]=1;a[23]=1;a[37]=1;a[41]=1;a[47]=1;a[59]=1;a[61]=1;scanf("%d",&n);for(i=0;i<n;i++){scanf("%d",&b[i]);}scanf("%s",name);for(i=0;i<64;i++){sum=sum+a[i];}for(i=0;i<n;i++){if(b[i]<=64-sum){sum1=0;for(j=0;j<63 && sum1<b[i] ;j++){if(a[j]==0 && sum1<b[i]){a[j]=1; //存入sum1++; //使用内存数+1sum++; // 内存数-1c[i]=j; //实时更新当前位置的下标d[i][j]=1;}}printf("%d ",c[i]);}else{printf("false ");}}printf("\n");name_num=change(name);for(j=0;j<56;j++){sum_last=d[name_num-1][j]+sum_last;}if(sum_last==0){printf("false");system("pause");return 0;}if(name_num<=n){for(j=0;j<56;j++){if(d[name_num-1][j]==1){printf("%d ",j);}}printf("\n");}else{printf("false");}system("pause");return 0;
}L: 题目11：带存储管理的处理器调度4
问题描述：现有一个内存为100K的采用位示图进行页面管理的道数不受限制的多道程序设计系统，若作业调度采用高优先级（优先数越大优先级越大）调度算法（如果遇到优先级一样且只能调入一道作业时，按照输入顺序选择调度对象。），进程调度采用非剥夺式的SJF调度算法（如果遇到运行时间相同的进程，按照输入顺序选择调度对象。）。要求输入3个进程信息，输出当三个作业同时提交进入调度时进程的运行顺序。
输入格式：程序要求输入3行，以回车符号作为分隔，每行有4个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名；第2个数据类型为整型，表示进程所需的内存空间；第3个数据类型为整型，表示进程的运行时间；第4个数据类型为整型，表示进程的优先数。
输出格式：输出1行，M个字符串，字符串之间用空格作为分隔。
样例输入1：
P1 20 2 1
P2 60 3 2
P3 30 4 3
样例输出1：
P2 P1 P3
样例输入2：
P1 80 2 2
P2 30 5 3
P3 40 3 1
样例输出2：
P3 P2 P1
样例输入3：
P1 20 2 1
P2 60 3 1
P3 30 4 1
样例输出3：
P1 P2 P3
样例输入4：
P1 20 2 1
P2 60 3 3
P3 30 4 3
样例输出4：
P2 P1 P3
# include <stdio.h>
# include <stdlib.h>struct Pro{char name[10];//进程名int space;//所需内存空间int time;//运行时间int pri;//优先级int grade_pri;//优先级排名 3 2 1 优先级越大排名越大int ready;
}pros [3];void sort_pri(struct Pro *pros){if(pros[0].pri<pros[1].pri){ //判断优先级pros[1].grade_pri++;}else{pros[0].grade_pri++;}if(pros[0].pri<pros[2].pri){ pros[2].grade_pri++;}else{pros[0].grade_pri++;}if(pros[1].pri<pros[2].pri){ pros[2].grade_pri++;}else{pros[1].grade_pri++;}
}int main(){struct Pro *pros_p=pros;int N=100;//可用内存int i,j,k,min,min_xb=0;int sum_space=0;//当前占用的内存///*输入部分*///for(i=0;i<3;i++){scanf("%s %d %d %d",pros[i].name,&pros[i].space,&pros[i].time,&pros[i].pri);pros[i].grade_pri=1;pros[i].ready=0;//是否进入就绪态 未进入为0 进入为1 运行为3}///*数据处理*///sort_pri(pros_p);for(j=0;j<3;j++){ //当三个作业都已经进入过就绪态 终止循环 2-sum_ready>0///*作业处理部分*///for(i=3;i>0;i--){ //找出优先级最大的作业for(k=0;k<3;k++){if(pros[k].grade_pri==i && pros[k].ready==0 && (sum_space+pros[k].space) <= N){sum_space=sum_space+pros[k].space;pros[k].ready=1;}}}///*进程处理部分*///min=101;for(i=0;i<3;i++){ //该循环用于找出运行时间最短的进程if(min>pros[i].time && pros[i].ready==1){min=pros[i].time;min_xb=i;}}sum_space=sum_space-pros[min_xb].space;//将已用内存释放pros[min_xb].ready=3;//表示该进程已经运行printf("%s ",pros[min_xb].name);}system("pause");return 0;
}
湖北师范大学----操作系统实训（c语言）相关推荐
- linux管道通信题目,操作系统实训（Linux）——习题解答、例题解析、实验指导-王红-实验实验7软中断及管道通信课案.ppt...
操作系统实训(Linux)--习题解答.例题解析.实验指导-王红-实验实验7软中断及管道通信课案.ppt 实验7 软中断及管道通信 一.实验目的(1)掌握linux系统软中断通信的实现方法.(2)掌握 ...
- 单片机应用技能实训(c语言) 李志京,基于应用型人才培养的单片机原理及应用教学改革探讨...
摘要:本文根据单片机原理及应用课程的特点,从课程教学内容优化.课堂教学改革.实验教学改革等方面进行研究和尝试,目的在于提高学生分析问题和解决问题的能力,增强学生的创新能力和综合素质,并指出了如何改善现 ...
- c语言设计指导实训,C语言程序设计实训指导
与<c语言程序设计(第2版)>配套,给出所有习题及参考答案.按知识点,精选12个典型实训,给出实训目的与要求.实训内容及实训参考程序.附有自测(考试)样卷及参考答案,供读者自测.提供Tur ...
- 进程管理系统的设计与实现 SDUT 操作系统实训 项目 Java
进程管理系统的设计与实现 要求: (1)设计一个完整的进程调度系统,至少包含三种常用的算法(FCFS.SPF.静态优先权.响应比.时间片轮转),系统中至少包含5个进程,并且能够体现进程的动态申请; ( ...
- 计算机操作系统实训心得总结,计算机操作系统安全实训心得总结
<计算机操作系统安全实训心得总结>由会员分享,可在线阅读,更多相关<计算机操作系统安全实训心得总结(2页珍藏版)>请在人人文库网上搜索. 1.本次实训,是对我能力的进一步锻炼, ...
- shell魔幻盒子_嵌入式操作系统实训报告——魔幻盒子
附录1:程序清单 #!/bin/bash #---------- 初始化参数定义----------# HLine=20 ## 横线长度 SLine=10 ## 竖线长度 draw_colour=34 ...
- 葡萄酒指标实训 Python语言
本文所需数据下载地址-->点这里下载 众所周知,葡萄酒的价格是与其品质相关的,本实训根据表中提供的数据对包葡萄酒品质数进行了分析与处理. 变量名 含义 fixed acidity 固定酸度 vo ...
- 湖北师范大学计信2018届操作系统实训（参考答案）
第一题 问题 A: 各位同学请先完成此题以规范你们的语法 参考代码(Java): import java.util.Scanner;/*** @author 作者 : 吴泽胜* @createDate ...
- 湖北师范大学计信学院C语言学期实训
目录 1.进制转换 1.1二进制转十进制 1.2十进制整数转二进制 1.3十进制小数转二进制
最新文章
- 太阳能电池基本特性实验报告_太阳能电池特性测试实验报告
- 实战脚本写入注册表，完善WindowsServer自动化运维
- linux c++ 调用matlab,ubuntu系统下C++调用matlab程序的方法详解
- ubuntu下载百度网盘文件油猴+aria2
- C++描述杭电OJ 2016.数据的交换输出 ||
- python中while语句是_如何在Python中使用while语句[适合初学者]
- 微信小程序|area组件使用的地址数据文件
- python构造自定义数据包_pytorch中的自定义数据处理详解
- Java新手求助,将两个文件合并为一个文件执行程序是发生的问题
- cdrx7拼版工具在哪里_Coreldraw x7/x8/2017/2018高版本保存为CDR 8.0低版本插件
- 计算机教育部一级学科,教育部学科门类，一级学科有多少个？
- python turtle 海龟画图歌尔号 火箭 三体 地球
- 制作PPT怎样设计图片才有观赏性
- zookeeper启动报错already running as process处理
- 软件测试时印象深刻的bug案例,请问你遇到过哪些印象深刻的bug，接口测试出现bug的原因有哪些？...
- 开发APP的java工具_程序猿必备的java的app开发工具有哪些
- spark性能优化（二）数据倾斜问题
- 【数据结构】图邻接矩阵的创建完整代码
- Markdown与LATEX
- AutoLeader控制组——51单片机学习笔记(一)