A. 數組分組
#include<iostream>
using namespace std;
int a;
void fgf(void){
int t=50/a,q=50%a,i;
for(i=1;i<=t;i++)cout<<(i-1)*a+1<<'-'<<i*a<<"為一組"<<endl;
if(q)cout<<50-q+1<<'-'<<50<<"為一組"<<endl;
}
void ysf (void){
int n=50/a+1;
for (int i=0; i<n; i++){
cout<<i+1;
for (int j=i+n+1;j<=50;){
cout<<','<<j;
j+=n;
}
cout<<"為一組\n";
}
}
void sjf(void){
srand(a);
int i,j,f[51]={0},l;
for(i=1;i<=50/a;i++){
l=rand()%50+1;
while(f[l]==1)l=rand()%50+1;
cout<<l;
f[l]=1;
for(j=2;j<=a;j++){
l=rand()%50+1;
while(f[l]==1)l=rand()%50+1;
f[l]=1;
cout<<','<<l;
}
cout<<"為一組"<<endl;
}
if(50%a){
l=rand()%50+1;
while(f[l]==1)l=rand()%50+1;
f[l]=1;
cout<<l;
for(j=50-50%a+2;j<=50;j++){
l=rand()%50+1;
while(f[l]==1)l=rand()%50+1;
f[l]=1;
cout<<','<<l;
}
cout<<"為一組"<<endl;
}
}
void work(void){
cout<<"請輸入每組人數:"<<endl;
cin>>a;
cout<<"分法:\n分割法"<<endl;
fgf();
cout<<"分法:\n余數法"<<endl;
ysf();
cout<<"分法:\n隨機法"<<endl;
sjf();
}
int main(){
work();
system("PAUSE");
return 0;
}
B. 求c語言程序,500行左右,要有詳細注釋。
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
typedef struct JOB
{
int hour;//用於存儲輸入的時
int min;//用於存儲輸入的分
int ID;//記錄此作業的號
int requesttime;//存儲作業所估計運行時間
int runtime;//作業周轉時間
int cometime;//作業進入時間
int finishtime;//作業結束時間
int starttime;//作業開始時間
float runtime2;//帶權周轉時間
int prior;//響應比
}JOB;
float counttime1=0;//用於存儲總的周轉時間
float counttime2=0;//用於存儲總的帶權周轉時間
int nowtime;
int flat=0;
int sign=0;
void insert(JOB [],JOB);
void FCFS();
void SJF();
void HRN();
void getprior(JOB a,int b);
int getmin(int i);
int gethour(int i);
int trans(int i,int j);
#define N 100
JOB job[N];
JOB wait[N];//用於SJF中存儲等待的作業的時間
JOB job2[N];//由於在SJF中不好控制輸出時按照作業序號的順序輸出,用一個數組存儲
int co=0;
int jobnum;
void main()
{
int i;
printf("輸入作業數:\n");
scanf("%d",&i);
jobnum=i;
FILE *fp;
fp = fopen("in.txt","rb");
if(fp == NULL)
{
printf("Can't open in.txt");
exit(0);
}
for(int j=0;j<i;j++)
{
fscanf(fp,"%d:%d %d",&job[j].hour,&job[j].min,&job[j].requesttime);
job[j].ID=j+1;
job[j].cometime=job[j].hour*60 + job[j].min;
printf("%d\n",job[j].requesttime);
}
printf("\n ================================");
printf("\n | 1:FCFS 2:SJF |");
printf("\n | 3:HRN |");
printf("\n ================================");
printf("\nPlease select a number from (1,2,3):");
scanf("%d",&i);
switch(i)
{
case 1: FCFS();break;
case 2: SJF();break;
case 3: HRN();break;
}
}
void FCFS()
{
printf("\n\n根據先來先服務演算法:\n");
int k;
for(int i=0;i<jobnum-1;i++)//將作業數組按照進入時間先後排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].cometime<job[k].cometime) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
for(int i=0;i<jobnum;i++)
{
if(i==0)//如果是第一個任務
{
job[i].starttime=job[i].cometime;
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
}
else
{
job[i].starttime=(job[i-1].finishtime>job[i].cometime ? job[i-1].finishtime : job[i].cometime);
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
}
}
printf("作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
FILE *fp;
fp = fopen("FCFS.txt","w");
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n");
exit(0);
}
fprintf(fp,"作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
for(int i=0;i<jobnum-1;i++)//將作業數組按照作業的ID排序
{
k=i;
for(int j=i+1;j<jobnum;j++)
if(job[j].ID<job[k].ID)
k=j;
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
for(int i=0;i<jobnum;i++)
{
int a,b,c,d;
a=gethour(job[i].starttime);
b=getmin(job[i].starttime);
c=gethour(job[i].finishtime);
d=getmin(job[i].finishtime);
printf("JOB%d ",job[i].ID);
fprintf(fp,"JOB%d ",job[i].ID);
if(job[i].min==0)
{
printf("%d:%d0 ",job[i].hour,job[i].min);
fprintf(fp,"%d:%d0 ",job[i].hour,job[i].min);
}
else
{
printf("%d:%d ",job[i].hour,job[i].min);
fprintf(fp,"%d:%d ",job[i].hour,job[i].min);
}
printf("%11d ",job[i].requesttime);
fprintf(fp,"%11d ",job[i].requesttime);
if(b==0)
{
printf("%d:%d0 ",a,b);
fprintf(fp,"%d:%d0 ",a,b);
}
else
{
printf("%d:%d ",a,b);
fprintf(fp,"%d:%d ",a,b);
}
if(d==0){
printf("%d:%d0 ",c,d);
fprintf(fp,"%d:%d0 ",c,d);
}
else{
printf("%d:%d ",c,d);
fprintf(fp,"%d:%d ",c,d);
}
printf("%11d%11f\n",job[i].runtime,job[i].runtime2);
fprintf(fp,"%13d%13f\n",job[i].runtime,job[i].runtime2);
}
printf("【平均周轉周期為:%f】\n【平均帶權周轉時間:%f】",(float)counttime1/jobnum,counttime2/jobnum);
fprintf(fp,"【平均周轉周期為:%f】\n【平均帶權周轉時間:%f】",(float)counttime1/jobnum,counttime2/jobnum);
system("pause");
}
int trans(int i,int j)
{
return i*60 + j;
}
int gethour(int i)
{
return i/60;
}
int getmin(int i)
{
return i%60;
}
void SJF()
{
printf("\n\n根據短作業優先演算法:\n");
int k;
for(int i=0;i<jobnum-1;i++)//將作業數組按照進入時間先後排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].cometime<job[k].cometime) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
int numbers=jobnum;
int realnum=jobnum;
for(int i=0;i<numbers;i++)
{
if(i==0)//假如是第一個,則直接進入cpu進行作業
{
job[i].starttime=job[i].cometime;
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime;
nowtime=job[i].finishtime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
job2[co++]=job[i];
for(int u=0;u<jobnum-1;u++)//把第一個從job序列的移除
job[u]=job[u+1];
jobnum--;
int j=0;
while(job[j].cometime<=nowtime&&j<jobnum)//從剩餘的job序列中獲取正在等待的job,放進wait序列中
{
wait[flat++]=job[j++];
}
int i=0;
if(j!=0)//j!=0則表明已經從job序列中轉移了job到wait序列中
{
while(j<jobnum)//將已經轉移的job從job序列中移除
{
job[i]=job[j];
i++;
j++;
}
jobnum=i;
}
if(flat>1)//如果wait序列中不止一個等待作業
{
int r;
for(int x=0;x<flat-1;x++)//將等待數組按照估計運行時間先後排序。
{
r=x;
for(int y=x+1;y<flat;y++)
{
if(wait[y].requesttime<wait[r].requesttime)
r=y;
}
if(r!=x)
{
JOB a;
a=wait[r];
wait[r]=wait[x];
wait[x]=a;
}
}
}
}
else
{
if(flat==0)//如果wait序列中沒有,即沒有等待的序列,則將job序列中的第一個作業放入cpu進行運行
{
job[0].starttime=job[0].cometime;
job[0].finishtime=job[0].starttime+job[0].requesttime;
job[0].runtime=job[0].finishtime-job[0].cometime;
job[0].runtime2=(float)job[0].runtime/(float)job[0].requesttime;
nowtime=job[0].finishtime;
counttime1+=job[0].runtime;
counttime2+=job[0].runtime2;
job2[co++]=job[0];
for(int u=0;u<jobnum-1;u++)//將放入運行的作業從job序列中移除
job[u]=job[u+1];
jobnum--;
int j=0;
while(job[j].cometime<=nowtime&&j<jobnum)//從剩餘的job序列中獲取正在等待的job,放進wait序列中
{
wait[flat++]=job[j++];
}
int i=0;
if(j!=0)//j!=0則表明已經從job序列中轉移了job到wait序列中
{
while(j<jobnum)
{
job[i]=job[j];
i++;
j++;
}
jobnum=j;
}
int r;
if(flat>1)//如果wait序列中不止一個等待作業
{
for(int x=0;x<flat-1;x++)//將等待數組按照估計運行時間先後排序。
{
r=x;
for(int y=x+1;y<flat;y++)
{
if(wait[y].requesttime<wait[r].requesttime) r=y;
}
if(r!=x)
{
JOB a;
a=wait[r];
wait[r]=wait[x];
wait[x]=a;
}
}
}
}
else//否則如果wait序列中有等待作業,則調用wait序列的第一個作業
{
wait[0].starttime=nowtime;
wait[0].finishtime=nowtime+wait[0].requesttime;
wait[0].runtime=wait[0].finishtime-wait[0].cometime;
wait[0].runtime2=(float)(wait[0].runtime)/(float)(wait[0].requesttime);
nowtime=wait[0].finishtime;
counttime1+=wait[0].runtime;
counttime2+=wait[0].runtime2;
job2[co++]=wait[0];
for(int i=0;i<flat;i++)//將wait序列的第一個作業從wait中移除
wait[i]=wait[i+1];
flat--;
int j=0;
while(job[j].cometime<=nowtime&&j<jobnum)//從剩餘的job序列中獲取正在等待的job,放進wait序列中
{
wait[flat++]=job[j++];
}
int i=0;
if(j!=0)//j!=0則表明已經從job序列中轉移了job到wait序列中
{
if(j==1&&jobnum==1)//job序列中最後一個作業已經轉移到wait中,則將jobnum自減一到0
jobnum--;
else
{
while(j<jobnum)//否則將已轉移的作業從job中移除
{
job[i]=job[j];
i++;
j++;
}
jobnum=j;
}
}
int r;
if(flat>1)//如果wait里的等待序列多餘一個,則進行重新排序
{
for(int x=0;x<flat-1;x++)//將等待數組按照估計運行時間先後排序。
{
r=x;
for(int y=x+1;y<flat;y++)
{
if(wait[y].requesttime<wait[r].requesttime)
r=y;
}
if(r!=x)
{
JOB a;
a=wait[r];
wait[r]=wait[x];
wait[x]=a;
}
}
}
}
}
}
printf("作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
FILE *fp;
fp = fopen("SJF.txt","w");
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n");
exit(0);
}
fprintf(fp,"作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
for(int i=0;i<realnum-1;i++)//將作業數組按照作業的ID排序
{
k=i;
for(int j=i+1;j<realnum;j++)
if(job2[j].ID<job2[k].ID)
k=j;
if(k!=i)
{
JOB a;
a=job2[k];
job2[k]=job2[i];
job2[i]=a;
}
}
for(int i=0;i<realnum;i++)
{
int a,b,c,d;
a=gethour(job2[i].starttime);
b=getmin(job2[i].starttime);
c=gethour(job2[i].finishtime);
d=getmin(job2[i].finishtime);
printf("JOB%d ",job2[i].ID);
fprintf(fp,"JOB%d ",job2[i].ID);
if(job2[i].min==0)
{
printf("%d:%d0 ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d0 ",job2[i].hour,job2[i].min);
}
else
{
printf("%d:%d ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d ",job2[i].hour,job2[i].min);
}
printf("%11d ",job2[i].requesttime);
fprintf(fp,"%11d ",job2[i].requesttime);
if(b==0)
{
printf("%d:%d0 ",a,b);
fprintf(fp,"%d:%d0 ",a,b);
}
else
{
printf("%d:%d ",a,b);
fprintf(fp,"%d:%d ",a,b);
}
if(d==0){
printf("%d:%d0 ",c,d);
fprintf(fp,"%d:%d0 ",c,d);
}
else{
printf("%d:%d ",c,d);
fprintf(fp,"%d:%d ",c,d);
}
printf("%11d%11f\n",job2[i].runtime,job2[i].runtime2);
fprintf(fp,"%13d%13f\n",job2[i].runtime,job2[i].runtime2);
}
printf("【平均周轉周期為:%f】\n【平均帶權周轉時間:%f】",(float)counttime1/realnum,counttime2/realnum);
fprintf(fp,"【平均周轉周期為:%f】\n【平均帶權周轉時間:%f】",(float)counttime1/realnum,counttime2/realnum);
system("pause");
}
void HRN()
{
co=0;
printf("\n\n根據最高響應比優先演算法:\n");
int k;
for(int i=0;i<jobnum-1;i++)//將作業數組按照進入時間先後排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].cometime<job[k].cometime) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
nowtime=job[0].cometime;
for(int i=0;i<jobnum;i++)
{
int j=i;
int xx=i;
while(j++<jobnum)//依次求得未完成的作業的優先順序
job[j].prior=1+(float)(nowtime-job[j].cometime)/job[j].requesttime;
int k;
for(int i=xx;i<jobnum-1;i++)//將作業數組按照響應比由高到低排序。
{
k=i;
for(int j=i+1;j<jobnum;j++)
{
if(job[j].prior>job[k].prior) k=j;
}
if(k!=i)
{
JOB a;
a=job[k];
job[k]=job[i];
job[i]=a;
}
}
if(job[i].prior>=1)//有等待的則讓等待的開始時間等於現在時間
job[i].starttime=nowtime;
else
job[i].starttime=job[i].cometime;//沒有等待的作業的話就讓下一次第一個進入的工作的時間當作其開始時間並且賦給當前時間
job[i].finishtime=job[i].starttime+job[i].requesttime;
job[i].runtime=job[i].finishtime-job[i].cometime;
job[i].runtime2=(float)job[i].runtime/job[i].requesttime;
nowtime=job[i].finishtime;
counttime1+=job[i].runtime;
counttime2+=job[i].runtime2;
job2[co++]=job[i];
}
printf("作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
FILE *fp;
fp = fopen("HRN.txt","w");
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n");
exit(0);
}
fprintf(fp,"作業 進入時間 估計運行時間 開始時間 結束時間 周轉時間 帶權周轉時間\n");
for(int i=0;i<jobnum-1;i++)//將作業數組按照作業的ID排序
{
k=i;
for(int j=i+1;j<jobnum;j++)
if(job2[j].ID<job2[k].ID)
k=j;
if(k!=i)
{
JOB a;
a=job2[k];
job2[k]=job2[i];
job2[i]=a;
}
}
for(int i=0;i<jobnum;i++)
{
int a,b,c,d;
a=gethour(job2[i].starttime);
b=getmin(job2[i].starttime);
c=gethour(job2[i].finishtime);
d=getmin(job2[i].finishtime);
printf("JOB%d ",job2[i].ID);
fprintf(fp,"JOB%d ",job2[i].ID);
if(job2[i].min==0)
{
printf("%d:%d0 ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d0 ",job2[i].hour,job2[i].min);
}
else
{
printf("%d:%d ",job2[i].hour,job2[i].min);
fprintf(fp,"%d:%d ",job2[i].hour,job2[i].min);
}
printf("%11d ",job2[i].requesttime);
fprintf(fp,"%11d ",job2[i].requesttime);
if(b==0)
{
printf("%d:%d0 ",a,b);
fprintf(fp,"%d:%d0 ",a,b);
}
else
{
printf("%d:%d ",a,b);
fprintf(fp,"%d:%d ",a,b);
}
if(d==0){
printf("%d:%d0 ",c,d);
fprintf(fp,"%d:%d0 ",c,d);
}
else{
printf("%d:%d ",c,d);
fprintf(fp,"%d:%d ",c,d);
}
printf("%11d%11f\n",job2[i].runtime,job2[i].runtime2);
fprintf(fp,"%13d%13f\n",job2[i].runtime,job2[i].runtime2);
}
printf("【平均周轉周期為:%f】\n【平均帶權周轉時間:%f】",(float)counttime1/jobnum,counttime2/jobnum);
fprintf(fp,"【平均周轉周期為:%f】\n【平均帶權周轉時間:%f】",(float)counttime1/jobnum,counttime2/jobnum);
system("pause");
}
作業調度
C. c語言中的輸入流是什麼意思
可以把流看作是一種數據的載體,通過它可以實現數據交換和傳輸。就像水流是一串水組成的 計算機中的數據流就是由一串數據組成的東西。
C++的輸入輸出流及文件操作
1. C++保留C的輸入輸出單個字元的函數
(1) putchar(c) —— 字元輸出
常式:
#include
using namespace std;
int main()
{
char a,b,c;
a='B'; b='O';c='Y';
putchar(a); putchar(b); putchar(c);putchar('/n');
putchar(66);putchar(79);putchar(89);putchar(10); //10是換行的ASCII碼
return 0;
}
(2) getchar() ——字元輸入函數
常式:
#include
using namespace std;
int main()
{
char c;
c=getchar();
putchar(c+32); //轉化為小寫字母,大小寫之間包括[ / ] ^ - 、6個字元,因此不加26加32。'A'=65
putchar('/n');
return 0;
}
也可用cout來輸出: cout<<(c=getchar()+32);
2. scanf()、printf()函數的輸入和輸出
scanf(格式控制,輸出表列);
printf(格式控制,輸出表列);
常式:
#include
using namespace std;
int main()
{
int a;
float b;
char c;
scanf("%d % c % f", &a,&c,&b);
printf("a=%d, b=%f, c=%c /n",a,b,c);
return 0;
}
3. 標准輸入輸出流cin、cout
包括頭文件#include
輸入輸出流的控制符要加入頭文件 #include
cout<<"dec:"<
cout.put(97); //顯示a字元--使用cout的成員函數put(c)
cin成員函數get()
(1) 不帶參數的
char c=cin.get(); //用cin的成員函數get()從鍵盤讀入一個字元到c中去
(2) 帶一個參數的
cin.get(ch); //從輸入的流中接受一個字元,並賦給字元變數ch
(3) 帶三個參數的
cin.get(字元數組,字元的個數n,終止字元)
常式:
#include
using namespace std;
int main()
{
char ch[20];
cout<<"in put a string:"<
cin.get(ch,10,'/n'); /*取得輸入流的前10-1=9個字元賦值給ch數組的前9個元素,並規定換行符為為輸入流的終止結束符*/
cout<
return 0;
}
如輸入:1 2 34567890 //按換行鍵終止流輸入
則輸出:1 2 34567 //只讀得前9個送入ch數組中
cin的成員函數getline() ——從輸入流中讀入一行字元
cin.getline(字元數組(或字元指針),字元的個數n,終止字元)
常式:
#include
using namespace std;
int main()
{
char ch[20];
cout<<"input a string:"<
cin>>ch;
cout<<"The string read with cin is:"<
cin.getline(ch,20,'/'); //讀取19個字元到ch數組或遇到'/'結束
cout<<"The second part is:"<
cin.getline(ch,20); //讀取19個字元到ch數組或遇到'/n'結束,遇到'/'仍作為字元讀入
cout<<"The third part is:"<
return 0;
}
istream類的其他的成員函數如:eof(),在輸入流中讀取數據,如果到達末尾(遇到文件結束符),則eof()返回真,否則為假.
常式:
#include
using namespace std;
int main()
{
char c;
while(!cin.eof()) //若未遇到文件結束符
if((c=cin,get())!=' ') //檢查讀入的字元是否為空格字元
cout.put(c);
return 0;
}
4. 磁碟文件的打開和關閉
打開
ofstream outfile;
if(outfile.open("f1.data",ios::app)==0) // 打開
cout<<"打開失敗!";
……………………
outfile.close(); //關閉
5. 文件寫入
#include
#include
#include //一定不能少了,否則報錯 error C2679
using namespace std;
int main()
{
string str;
ofstream out("d.txt",ios::out); //等價於ofstream out("d.txt")
if(!out) //若打開失敗,out返回0值
{
cerr<<"打開失敗!"<
exit(0);
}
str="床前明月光/n疑是地上霜/n舉頭望明月/n低頭思故鄉/n";
out< return 0;
}
6. 讀文件到控制台
#include
#include
#include
using namespace std;
int main()
{
ifstream infile("d://new//d.txt",ios::in); //定義輸入文件的流對象,以輸入方式打開磁碟文件d.txt,第二個參數可去
if(!infile)
{
cerr<<"打開失敗!"< exit(1);
}
for(string str;getline(infile,str);) //逐行打開並逐行顯示,因此在循環中實現
cout< infile.close();
return 0;
}
或把 for(string str;getline(in,str);)
cout<
兩句改為 string str;
while(getline(in,str))
cout<
7. 文件復制
#include
#include
#include
using namespace std;
int main()
{
ifstream in("d.txt");
if(!in)
{
cerr<<"打開源文件失敗!"< exit(1);
}
ofstream out("b.txt");
if(!out)
{
cerr<<"打開目的文件失敗!"< exit(1);
}
for(string str;getline(in,str);)
out< cout<<"文件復製成功!"<
in.close();
out.close();
return 0;
}
8. 自定義一個文件讀入的函數 void display( char *filename)
#include
#include
#include
using namespace std;
void display(char *filename)
{
ifstream infile(filename,ios::in);
if(!infile)
{
cerr<<"打開失敗!"< exit(1);
}
char ch;
while(infile.get(ch))
cout.put(ch);
cout< infile.close();
}
int main()
{
display("d.txt");
return 0;
}
9.關於文件讀寫的綜合應用
#include
#include
using namespace std;
//從鍵盤讀入字母並存入文件「d.txt」中
void save_to_file()
{
ofstream ofile("d.txt");
if(!ofile)
{
cerr<<"打開失敗d.txt!"< exit(1);
}
char c[80];
cin.getline(c,80); //從鍵盤逐個讀入一行字元
for(int i=0;c[i]!=0;i++) //對字元逐個處理,知道遇到'/n'結束
if(c[i]>=65 && c[i]<=90||c[i]>=97 && c[i]<=122)
{
ofile.put(c[i]); //將字母存入磁碟文件d.txt
cout< }
cout< ofile.close();
}
//將"d.txt"中的字母轉化為大寫字母並存入"out.txt"中
void get_from_file()
{
char ch;
ifstream infile("d.txt");
if(!infile)
{
cerr<<"打開失敗d.txt!"< exit(1);
}
ofstream outfile("out.txt");
if(!infile)
{
cerr<<"打開失敗out.txt!"< exit(1);
}
while(infile.get(ch)) //逐個讀入字元成功後執行下面的語句
{
if(ch>=97 &&ch<=122)
ch=ch-32;
outfile.put(ch);
cout< }
cout< infile.close();
outfile.close();
}
int main()
{
save_to_file();
get_from_file();
return 0;
}
=========================== C/C++的字元或字元數組的讀入函數總結=====================
1、cin
1、cin.get()
2、cin.getline()
3、getline()
4、gets()
5、getchar()
1、cin>>
用法1:最基本,也是最常用的用法,輸入一個數字:
#include
using namespace std;
main ()
{
int a,b;
cin>>a>>b;
cout<}
輸入:2[回車]3[回車]
輸出:5
用法2:接受一個字元串,遇「空格」、「TAB」、「回車」都結束
#include
using namespace std;
main ()
{
char a[20];
cin>>a;
cout<}
輸入:jkljkljkl
輸出:jkljkljkl
輸入:jkljkl jkljkl //遇空格結束
輸出:jkljkl
2、cin.get()
用法1: cin.get(字元變數名)可以用來接收字元
#include
using namespace std;
main ()
{
char ch;
ch=cin.get(); //或者cin.get(ch);
cout<}
輸入:jljkljkl
輸出:j
用法2:cin.get(字元數組名,接收字元數目)用來接收一行字元串,可以接收空格
#include
using namespace std;
main ()
{
char a[20];
cin.get(a,20);
cout<}
輸入:jkl jkl jkl
輸出:jkl jkl jkl
輸入:abcdeabcdeabcdeabcdeabcde (輸入25個字元)
輸出:abcdeabcdeabcdeabcd (接收19個字元+1個'/0')
3、cin.getline() // 接受一個字元串,可以接收空格並輸出
getline 會將換行符替換為空字元
#include
using namespace std;
main ()
{
char m[20];
cin.getline(m,5);
cout<}
輸入:jkljkljkl
輸出:jklj
接受5個字元到m中,其中最後一個為'/0',所以只看到4個字元輸出;
如果把5改成20:
輸入:jkljkljkl
輸出:jkljkljkl
輸入:jklf fjlsjf fjsdklf
輸出:jklf fjlsjf fjsdklf
//延伸:
//cin.getline()實際上有三個參數,cin.getline(接受字元串的看哦那間m,接受個數5,結束字元)
//當第三個參數省略時,系統默認為'/0'
//如果將例子中cin.getline()改為cin.getline(m,5,'a');當輸入jlkjkljkl時輸出jklj,輸入jkaljkljkl時,輸出jk
當用在多維數組中的時候,也可以用cin.getline(m[i],20)之類的用法:
#include
#include
using namespace std;
main ()
{
char m[3][20];
for(int i=0;i<3;i++)
{
cout<<"/n請輸入第"<cin.getline(m[i],20);
}
cout<for(int j=0;j<3;j++)
cout<<"輸出m["<
}
請輸入第1個字元串:
kskr1
請輸入第2個字元串:
kskr2
請輸入第3個字元串:
kskr3
輸出m[0]的值:kskr1
輸出m[1]的值:kskr2
輸出m[2]的值:kskr3
4、getline() // 接受一個字元串,可以接收空格並輸出,需包含「#include」
#include
#include
using namespace std;
main ()
{
string str;
getline(cin,str);
cout<}
輸入:jkljkljkl
輸出:jkljkljkl
輸入:jkl jfksldfj jklsjfl
輸出:jkl jfksldfj jklsjfl
和cin.getline()類似,但是cin.getline()屬於istream流,而getline()屬於string流,是不一樣的兩個函數
5、gets() // 接受一個字元串,可以接收空格並輸出,需包含「#include」
#include
#include
using namespace std;
main ()
{
char m[20];
gets(m); //不能寫成m=gets();
cout<}
輸入:jkljkljkl
輸出:jkljkljkl
輸入:jkl jkl jkl
輸出:jkl jkl jkl
類似cin.getline()裡面的一個例子,gets()同樣可以用在多維數組裡面:
#include
#include
using namespace std;
main ()
{
char m[3][20];
for(int i=0;i<3;i++)
{
cout<<"/n請輸入第"<gets(m[i]);
}
cout<for(int j=0;j<3;j++)
cout<<"輸出m["<
}
請輸入第1個字元串:
kskr1
請輸入第2個字元串:
kskr2
請輸入第3個字元串:
kskr3
輸出m[0]的值:kskr1
輸出m[1]的值:kskr2
輸出m[2]的值:kskr3
自我感覺gets()和cin.getline()的用法很類似,只不過cin.getline()多一個參數罷了;
這里順帶說明一下,對於本文中的這個kskr1,kskr2,kskr3 的例子,對於cin>>也可以適用,原因是這里輸入的沒有空格,如果輸入了空格,比如「ks kr jkl[回車]」那麼cin就會已經接收到3個字元串,「ks,kr,jkl」;再如「kskr 1[回車]kskr 2[回車]」,那麼則接收「kskr,1,kskr」;這不是我們所要的結果!而cin.getline()和gets()因為可以接收空格,所以不會產生這個錯誤;
6、getchar() //接受一個字元,需包含「#include」
#include
#include
using namespace std;
main ()
{
char ch;
ch=getchar(); //不能寫成getchar(ch);
cout<}
輸入:jkljkljkl
輸出:j
//getchar()是C語言的函數,C++也可以兼容,但是盡量不用或少用;
總結:
1.讀入一行
gets(char a[]); //接受一行,遇回車結束
gets(m[i]) //可用於多維數組中
cin.get(char a[],int 5,'/n') //將字元數組a的前5個字元讀入,遇到換行符結束;比如:a bc12ds,將會讀入4個字元 a bc,外加一個'/0';
// 一般第三個參數不寫,默認為'/0'
eg:
#include
#include
using namespace std;
main ()
{
string str;
getline(cin,str);
cout<}
2.讀入一個字元
getchar() //接受一個字元,需包含「#include」
char ch =getchar();
cin.get(char c) 或者 cin.get()
char ch=cin.get(); 或者cin.get(ch)
getline()和cin.getline()類似,但是cin.getline()屬於istream流,而getline()屬於string流,是不一樣的兩個函數
cin.getline(char a[],int 5,'/n') //將字元數組a的前5個字元讀入,遇換行符結束;如:a bc12ds,將會讀入4個字元 a bc,外加一個'/0';
// 一般第三個參數不寫,默認為'/0'
cin.getline(m[i],20) //可用於多維數組中
getline() // 接受一個字元串,可以接收空格並輸出,需包含「#include"
D. 急求 程序代碼 c/c++ 操作系統中的 處理機調度演算法
#include <iostream>
#include <stdio.h>
#include <string>
//#include <windows.h>
using namespace std;
//hyugtyftydrtdtrdrrtrdrt
struct Node
{
string name;//進程(作業)名稱
int arriveTime;//到達時間
int ServerTime;//服務時間
int leftTime;//the left time
Node *link;//指向下一個節點的指針
};
class CProcess
{
public:
CProcess();//構造函數
~CProcess();//析構函數
const CProcess &operator =(const CProcess& p);//重載賦值操作符
void insertNode(string &na,int& at,int& st);//插入新元素(at由小到大)到鏈表合適的位置
void sort();//按照服務時間由大到小排序
bool isEmpty();//判斷是否為空
void destroy();//銷毀
int length();//求出鏈表長度
void print();//列印出元素
void FCFS();//先到先服務
void SJF();//短進程(作業)優先
void RR(int& q);//時間片輪轉
void priority();//優先權調度
protected:
Node *first;
Node *last;
};
const CProcess& CProcess::operator=(const CProcess& p)
{
Node *newNode;
Node *Current;
if(this!=&p)//避免自己給自己賦值
{
if(first!=NULL)//如果鏈表不為空
destroy();
if(p.first==NULL)
{//如果要拷貝的對象為空
this->first = NULL;
this->last = NULL;
}
else
{
Current = p.first;
first= new Node;
first->name=Current->name;//
first->arriveTime=Current->arriveTime;
first->ServerTime=Current->ServerTime;
first->link =NULL;
last =first;
Current = Current->link;
while(Current!=NULL)
{
newNode = new Node;
newNode->name=Current->name;
newNode->arriveTime=Current->arriveTime;
newNode->ServerTime=Current->ServerTime;
newNode->link=NULL;
last->link=newNode;
last=newNode;
Current = Current->link;
}
}
}
return *this;
}
CProcess::CProcess()
{//構造函數
first=NULL;
last=NULL;
}
CProcess::~CProcess()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::insertNode(string &na,int& at,int& st)
{//按照到達時間升序排序
Node *Current;
Node *trailCurrent;//指向Current的前一個節點
Node *newNode;
bool found;
newNode = new Node;//建立一個新節點
newNode->name=na;
newNode->arriveTime=at;
newNode->ServerTime=st;
newNode->link=NULL;//
if(first==NULL)//如果第一個節點為空(如果是第一次插入元素)
first=newNode;//將新節點賦給第一個節點
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL && !found)
{
if(Current->arriveTime >= at)
found = true;
else
{
trailCurrent = Current;
Current = Current->link;
}
}
if(Current==first)
{
newNode->link = first;
first = newNode;
}
else
{
trailCurrent->link = newNode;
newNode->link = Current;
}
}
}
int CProcess::length()
{
int count =0;//聲明變數,並初始化為0(用來記錄長度)
Node *Current;
Current = first;
while(Current!=NULL)//當前節點不為空,記錄值自加,一直向後遍歷,
{
count++;
Current = Current->link;
}
return count;//返回長度
}
void CProcess::sort()//按照服務時間,升序排列
{//冒泡排序
string sname;
int at;
int st;
Node *Current;//指向當前節點
Node *trailCurrent;//指向當前節點的前一個節點
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制條件有問題
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制條件有問題
{
if(trailCurrent->ServerTime > Current->ServerTime)
{
sname=trailCurrent->name;
at=trailCurrent->arriveTime;
st=trailCurrent->ServerTime;
trailCurrent->name=Current->name;
trailCurrent->arriveTime=Current->arriveTime;
trailCurrent->ServerTime=Current->ServerTime;
Current->name=sname;
Current->arriveTime=at;
Current->ServerTime=st;
}
}
}
}
bool CProcess::isEmpty()//判斷是否為空
{
return (first==NULL);//如果第一個節點為空,返回值
}
void CProcess::print()
{
Node *Current;
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)//當前節點不為空,一直向後遍歷列印
{
cout<<Current->name<<" ";
cout<<Current->arriveTime<<" ";
cout<<Current->ServerTime<<"\n";
Current = Current->link;
}
}
void CProcess::destroy()
{
Node *temp;//定義一個臨時指針變數
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::FCFS()//先到先服務
{
Node *Current;
int T0=0;//完成時間
int T1=0;//周轉時間
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周轉時間等於,完成時間 - 到達時間
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
}
}
void CProcess::SJF()//短進程(作業)優先
{
//首先執行第一個到達的作業
Node *Current;
int T0=0;//完成時間
int T1=0;//周轉時間
T0=first->link->ServerTime+T0;
T1=T0-first->link->arriveTime;
cout<<first->link->name<<"\t";
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
first->link=first->link->link;//刪除
//執行剩下的
sort();//對剩下的排序
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周轉時間等於,完成時間 - 到達時間
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
}
}
void CProcess::RR(int& q)//時間片輪轉
{
cout<<"時間片輪轉操作完成!\n";
}
void CProcess::priority()//優先權調度
{
cout<<"優先權操作完成!\n";
}
void main()
{
CProcess p0,p1,p2,p3,p4;
int at,st;
string na;
int judge=1;//控制退出程序
int choice;//控制選擇操作
while(judge)
{
cout<<"********************************************************\n";
cout<<"****** 說明:本程序適用於單道進程(作業) ******\n";
cout<<"******** 請選擇您的操作 ***************\n";
cout<<"*********輸入相應的數字,按下(Enter)鍵!**************\n";
cout<<"************* 5.錄入信息 ************\n";
cout<<"************* 1.先到先服務 ************\n";
cout<<"************* 2.短進程(作業)優先 ************\n";
cout<<"************* 3.時間片輪轉 ************\n";
cout<<"************* 4.優先權(靜態)調度 ************\n";
cout<<"************* 0.退出程序 ************\n";
cout<<"********************************************************\n";
cin>>choice;
switch(choice)
{
case 0:
judge=0;
break;
case 5:
cout<<"請輸入信息以「end」結束輸入!\n";
cout<<"進程名 到達時間 服務時間"<<endl;
while(na.compare("end"))//如果相等則會返回0
{
p0.insertNode(na,at,st);
cin>>na>>at>>st;
}
cout<<"錄入成功,目前的信息為:\n";
cout<<"進程名 到達時間 服務時間"<<endl;
p0.print();
break;
case 1://先到先服務
p1=p0;//拷貝一份
if(p1.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"先到先服務\n";
cout<<"進程名 完成時間 周轉時間\n";
p1.FCFS();
break;
}
case 2://短作業優先
p2=p0;//拷貝一份
//p2.sort();
//p2.print();
if(p2.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"短作業優先\n";
cout<<"進程名 完成時間 周轉時間\n";
p2.SJF();
break;
}
case 3://時間片輪轉
p3=p0;//拷貝一份
int q;
if(p3.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"請輸入時間片大小";
cin>>q;
cout<<"時間片輪轉\n";
cout<<"進程名 完成時間 周轉時間\n";
p3.RR(q);
break;
}
case 4://優先權
p4=p0;//拷貝一份
if(p4.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"時間片輪轉\n";
cout<<"進程名 完成時間 周轉時間\n";
p4.priority();
break;
}
default:
cout<<"請選擇目錄中的選項!\n";
break;
}
}
return;
}
E. 先來先服務調度演算法。 優先順序調度演算法。 短作業優先調度演算法 輪轉調度演算法 響應比高優先調度演算法
你試一下
#include<stdio.h>
//using namespace std;
#define MAX 10
struct task_struct
{
char name[10]; /*進程名稱*/
int number; /*進程編號*/
float come_time; /*到達時間*/
float run_begin_time; /*開始運行時間*/
float run_time; /*運行時間*/
float run_end_time; /*運行結束時間*/
int priority; /*優先順序*/
int order; /*運行次序*/
int run_flag; /*調度標志*/
}tasks[MAX];
int counter; /*實際進程個數*/
int fcfs(); /*先來先服務*/
int ps(); /*優先順序調度*/
int sjf(); /*短作業優先*/
int hrrn(); /*響應比高優先*/
int pinput(); /*進程參數輸入*/
int poutput(); /*調度結果輸出*/
void main()
{ int option;
pinput();
printf("請選擇調度演算法(0~4):\n");
printf("1.先來先服務\n");
printf("2.優先順序調度\n");
printf(" 3.短作業優先\n");
printf(" 4.響應比高優先\n");
printf(" 0.退出\n");
scanf("%d",&option);
switch (option)
{case 0:
printf("運行結束。\n");
break;
case 1:
printf("對進程按先來先服務調度。\n\n");
fcfs();
poutput();
break;
case 2:
printf("對進程按優先順序調度。\n\n");
ps();
poutput();
break;
case 3:
printf("對進程按短作業優先調度。\n\n");
sjf();
poutput();
break;
case 4:
printf("對進程按響應比高優先調度。\n\n");
hrrn();
poutput();
break;
}
}
int fcfs() /*先來先服務*/
{
float time_temp=0;
inti;
intnumber_schel;
time_temp=tasks[0].come_time;
for(i=0;i<counter;i++)
{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schel=i;
tasks[number_schel].order=i+1;
}
return 0;
}
int ps() /*優先順序調度*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
intmax_priority;
max_priority=tasks[i].priority;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].priority>tasks[i].priority)
{
max_priority=tasks[j].priority;
i=j;
}
j++;
} /*查找第一個被調度的進程*/
/*對第一個被調度的進程求相應的參數*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
max_priority=0;
for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if (tasks[j].priority>max_priority)
{
max_priority=tasks[j].priority;
number_schel=j;
}
} /*查找下一個被調度的進程*/
/*對找到的下一個被調度的進程求相應的參數*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}
int sjf() /*短作業優先*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
float run_time;
run_time=tasks[i].run_time;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].run_time<tasks[i].run_time)
{
run_time=tasks[j].run_time;
i=j;
}
j++;
} /*查找第一個被調度的進程*/
/*對第一個被調度的進程求相應的參數*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
for(j=0;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{run_time=tasks[j].run_time;number_schel=j;break;}
}
for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if(tasks[j].run_time<run_time)
{run_time=tasks[j].run_time;
number_schel=j;
}
}
/*查找下一個被調度的進程*/
/*對找到的下一個被調度的進程求相應的參數*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}
int hrrn() /*響應比高優先*/
{ int j,number_schel,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*第一個進程被調度*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/*調度其他進程*/
while(temp_counter<counter)
{
max_respond_rate=0;
for(j=1;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate)
{
max_respond_rate=respond_rate;
number_schel=j;
}
}
} /*找響應比高的進程*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].run_flag=1;
temp_counter+=1;
tasks[number_schel].order=temp_counter;
}
return 0;
}
int pinput() /*進程參數輸入*/
{ int i;
printf("please input the processcounter:\n");
scanf("%d",&counter);
for(i=0;i<counter;i++)
{printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);
printf("please input the number:\n");
scanf("%d",&tasks[i].number);
printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
int poutput() /*調度結果輸出*/
{
int i;
float turn_round_time=0,f1,w=0;
printf("name number come_time run_timerun_begin_time run_end_time priority order turn_round_time\n");
for(i=0;i<counter;i++)
{
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);
printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d,%5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);
}
printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter);
printf("weight_average_turn_round_timer=%5.2f\n",w/counter);
return 0;
}
F. 糾錯:C語言:刪除重復字元。
沒注釋, 還不如重新寫一個
#include<stdio.h>
#include<stdlib.h>
intmain()
{
charLetter[80];//用於接收輸入字元串
intresult[128]={0};//相當於一張空的ASCII碼表
gets(Letter);
intsize=strlen(Letter);
inti,j=0;
for(i=0;i<size;i++)//該循環好比
{//字元串中的每個字元在空ASCII碼表中打勾
result[Letter[i]]=1;
}
memset(Letter,'