~~~~~~~~~~~~~~~~~DEAD LOCK AVOIDANCE~~~~~~~~~~~~~~~~~~~

#include<stdio.h>
#include<conio.h>
int work[3]={3,3,2};
//typedefstruct pro
//{
//

intpname,need[3],alloc,finish;

//};
//pro p[5];
intpname[5]={0,1,2,3,4};
intalloc[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
int need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,0}},finish[5],seq[5];

int main()
{
inti,j=0,k=0;
L1: for(i=0;i<5;i++)
{
if(finish[i]==0 && need[i][j]<=work[j] && need[i][j+1]<=work[j+1] &&
need[i][j+2]<=work[j+2])
{
for(j=0;j<3;j++)
{
work[j]=work[j]+alloc[i][j];
finish[i]=1;
}
j=0;

printf("%d\t",pname[i]);
}
}
for(i=0;i<5;i++)
if(finish[i]==0)
goto L1;
getch();
return 0;
}

~~~~~~~~~~~~~~~~~~~~~~FIRST

IN FIRST OUT~~~~~~~~~~~~~~~~~~~~~~~~~~

#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
int proc_list[max]={0},i,j,k,l,m,n,flag=1,proc=1,counter[max]={0},index=0;
printf("ENTER THE PROCESS ARRAY SIZE");
scanf("%d",&i);
printf("enter the total processes to be executed");
scanf("%d",&j);
l1:

while(proc<=j)
{

intmaxm=0;
printf("enter the %dth process",proc);
scanf("%d",&k);
if(flag<=i)
{

for(l=1;l<=flag;l++)
{
if(proc_list[l]==k)
{
for(m=1;m<=flag;m++)
{
counter[m]++;
}
counter[l]=0;
proc++;

for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
goto l1;
}
}

proc_list[flag++]=k;
proc++;
for(l=1;l<=flag;l++)
{
counter[l]++;

}
counter[flag]=0;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
}
else
{
for(l=1;l<=j;l++)
{
if(proc_list[l]==k)
{
for(m=1;m<=j;m++)
{
counter[m]++;

}
counter[l]=0;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
proc++;
goto l1;
}
}

for(l=1;l<=j;l++)
{
if(counter[l]>maxm)
{
index=l;
}
for(l=1;l<=j;l++)
{
counter[l]++;
}
proc_list[index]=k;
counter[index]=0;
proc++;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
}

for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}

getch();
return(0);

~~~~~~~~~~~~~~~~~~~~~~~~~OPTIMAL~~~~~~~~~~~~~~~~~~~~~~~~~
~~~
#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
intproc[]={2,5,1,4,1,7,5,3,4,8,1,5};
int i,j=0,k,l,m=0,frame[max]={0},flag[max]={0},dist[max],min=max,replac;
printf("enter the process frame space :: ");
scanf("%d",&j);
for(i=0;i<12;i++)
{s1:
while(m<j)
{
if(flag[m]==0)
{ frame[m]=proc[i];
flag[m]=1;
m++;
printf("process input :: %d\n\n",proc[i]);
for(l=0;l<j;l++)
{

printf("1::process frame [%d] :: %d\n",l,frame[l]);

getch();
i++;
goto s1;
}

}
for(k=0;k<j;k++)
{

if(frame[k]==proc[i])
{
printf("2 :: process input :: %d\n\n",proc[i]);
for(l=0;l<j;l++)
{
printf("process frame [%d] :: %d\n",l,frame[l]);
}
getch();
i++;
goto s1;
}

}
for(l=0;l<j;l++)
{
for(k=i;k<12;k++)
{
if(frame[l]==proc[k])
{
dist[l]=i;
}
}
}
//min=dist[l-j]
for(l=0;l<j;l++)
{
if(dist[l]>min)
{
replac=l;
}
}

frame[replac]=proc[i];
printf("3::process input :: %d\n\n",proc[i]);
for(l=0;l<j;l++)
{

printf("process frame [%d] :: %d\n",l,frame[l]);

}
getch();
}

~~~~~~~~~~~~~~~~~``LEAST FREQUENTLY USED~~~~~~~~~~~~~~~~~~~~`

#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
int proc_list[max]={0},i,j,k,l,m,n,p,flag=1,proc=1,counter[max]={0},index=0,min=100;
printf("ENTER THE PROCESS ARRAY SIZE :: \n");
scanf("%d",&i);
printf("enter the total processes to be executed :: \n");
scanf("%d",&j);
// printf("enter the no of distinct processes :: \n");
//scanf("%d",&p);
l1:

while(proc<=j)

{
intmaxm=0;
printf("enter the %dth process",proc);
scanf("%d",&k);
if(flag<=i)
{

for(l=1;l<=flag;l++)
{
if(proc_list[l]==k)
{
// for(m=1;m<=flag;m++)

//

//

counter[m]++;

//

counter[k]++;
proc++;
for(n=1;n<=i;n++)
{
printf("1::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}

goto l1;
}
}

proc_list[flag++]=k;
proc++;
//for(l=1;l<=flag;l++)
//

//

counter[l]++;

//
//

counter[k]++;
for(n=1;n<=i;n++)
{
printf("2::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}

}
else
{
for(l=1;l<=i;l++)
{
if(proc_list[l]==k)
{
//for(m=1;m<=j;m++)
//

//

counter[m]++;

//

counter[k]++;
for(n=1;n<=i;n++)
{
printf("3::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}
proc++;
goto l1;
}
}

for(l=1;l<=i;l++)
{
if(counter[proc_list[l]]<min)
{
min=counter[proc_list[l]];

index=l;
}
}
// for(l=1;l<=j;l++)
//

//

counter[l]++;

//

min=20;
proc_list[index]=k;
counter[k]++;
proc++;
for(n=1;n<=i;n++)
{
printf("4::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}
}

for(n=1;n<=i;n++)
{
printf("5::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}

getch();
return(0);

~~~~~~~~~~~~~~~~~~~MOST FREQUENTLY

USED~~~~~~~~~~~~~~~~~~~~~~~
#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
int
proc_list[max]={0},i,j,k,l,m,n,p,flag=1,proc=1,counter[max]={0},index=0,min=100,maxim=
0;
printf("ENTER THE PROCESS ARRAY SIZE :: \n");
scanf("%d",&i);
printf("enter the total processes to be executed :: \n");
scanf("%d",&j);
// printf("enter the no of distinct processes :: \n");
//scanf("%d",&p);
l1:

while(proc<=j)

{
intmaxm=0;
printf("enter the %dth process",proc);
scanf("%d",&k);
if(flag<=i)
{

for(l=1;l<=flag;l++)
{
if(proc_list[l]==k)
{

// for(m=1;m<=flag;m++)
//

//

counter[m]++;

//

counter[k]++;
proc++;
for(n=1;n<=i;n++)
{
printf("1::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}

goto l1;
}
}

proc_list[flag++]=k;
proc++;
//for(l=1;l<=flag;l++)
//

//

counter[l]++;

//
//

counter[k]++;
for(n=1;n<=i;n++)
{
printf("2::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);

}
}
else
{
for(l=1;l<=i;l++)
{
if(proc_list[l]==k)
{
//for(m=1;m<=j;m++)
//

//

counter[m]++;

//

counter[k]++;
for(n=1;n<=i;n++)
{
printf("3::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}
proc++;
goto l1;
}
}

for(l=1;l<=i;l++)
{
if(counter[proc_list[l]]>maxim)
{
maxim=counter[proc_list[l]];

index=l;
}
}
// for(l=1;l<=j;l++)
//

//

counter[l]++;

//

proc_list[index]=k;
counter[k]++;
proc++;
for(n=1;n<=i;n++)
{
printf("4::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}
}

for(n=1;n<=i;n++)
{
printf("5::process no:: %d ,counter :: %d\n",proc_list[n],counter[proc_list[n]]);
}

getch();
return(0);

~~~~~~~~~~~~~~~~~~~~LEAST RECENTLY USED~~~~~~~~~~~~~~~~~~~

#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
int proc_list[max]={0},i,j,k,l,m,n,flag=1,proc=1,counter[max]={0},index=0;
printf("ENTER THE PROCESS ARRAY SIZE");
scanf("%d",&i);
printf("enter the total processes to be executed");
scanf("%d",&j);
l1:

while(proc<=j)

{
intmaxm=0;
printf("enter the %dth process",proc);
scanf("%d",&k);
if(flag<=i)
{

for(l=1;l<=flag;l++)
{
if(proc_list[l]==k)
{
for(m=1;m<=flag;m++)
{
counter[m]++;

}
counter[l]=0;
proc++;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
goto l1;
}
}

proc_list[flag++]=k;
proc++;
for(l=1;l<=flag;l++)
{
counter[l]++;

}
counter[flag]=0;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
}
else
{
for(l=1;l<=j;l++)

{
if(proc_list[l]==k)
{
for(m=1;m<=j;m++)
{
counter[m]++;
}
counter[l]=0;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
proc++;
goto l1;
}
}

for(l=1;l<=j;l++)
{
if(counter[l]>maxm)
{
index=l;
}
for(l=1;l<=j;l++)
{
counter[l]++;
}

proc_list[index]=k;
counter[index]=0;
proc++;
for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}
}

for(n=1;n<=j;n++)
{
printf("process no:: %d ,counter :: %d\n",proc_list[n],counter[n]);
}

getch();
return(0);

~~~~~~~~~~~~~~~~~~~~~`FIRST FIT~~~~~~~~~~~~~~~~~~~~~~~~~~
#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
int
arr[max],arr1[max],i,j,k,l,m,s,n=1,index,flag=0,flag1[max]={0},proc_no[max],pro_no[max]=
{0},flag3[max]={0},flag4[max]={0};
arr[0]=1024;
printf("enter the no of processes to be executed :: ");
scanf("%d",&i);
// for(j=o;j<i;j++)

printf("enter the process space");

scanf("%d",&k);
list: if(k<arr[0]/2)
{
flag=flag+1;
l=arr[0]/2;
arr1[0]=arr1[1]=l;
for(m=2;m<=flag;m++)
{
arr1[m]=arr[m-1];
}
for(m=0;m<=flag;m++)
{

arr[m]=arr1[m];
}
goto list;
}
else
{
flag1[0]=1;
pro_no[0]=1;
flag3[0]=1;
flag3[1]=1;

}
for(m=0;m<=flag;m++)
{
printf("arr[m] = %d ",arr[m]);
}

for(j=1;j<i;j++)
{
printf("\nenter the process space for process %d\n",j+1);
scanf("%d",&k);
list1:

if(k>arr[n])
{

n++;
list2: if(flag1[n]==0)
goto list1;

else
{

n++;

goto list2;
}
}
else if(flag1[n]==0)
{
flag1[n]=1;
pro_no[n]=j+1;
proc_no[j]=n;
n=1;
}
else
{
n++;
goto list1;
}
}
for(m=0;m<=flag;m++)
{
printf("arr[%d]=%d ,flag1[%d]=%d ,process no = %d\n",m,arr[m],m,flag1[m],pro_no[m]);

printf("enter the process to be released :: \n");

scanf("%d",&s);
for(i=0;i<=flag;i++)

{
if(pro_no[i]==s)
{
index=i;
flag1[i]=0;
}

}
if((index==0 || index==1) && (flag1[0]==0 && flag1[1]==0))
{

loop:

for(m=0;m<flag;m++)//since we have m+1.so will traverse only till flag-1

{

arr1[m]=arr[m+1];

}
for(m=0;m<=flag;m++)
{
arr[m]=arr1[m];
}
arr[0]=arr[0]+arr[0];

for(m=0;m<flag;m++)//since we have m+1.so will traverse only till flag-1

{

flag4[m]=flag1[m+1];
}
for(m=0;m<=flag;m++)
{
flag1[m]=flag4[m];
}
flag--;//since total no of elements are decreased by 1;
while(flag1[2]==0)
{
goto loop;
}

}
for(m=0;m<=flag;m++)
{
printf("arr[%d]=%d ,flag1[%d]=%d ,process no = %d\n",m,arr[m],m,flag1[m],pro_no[m]);

getch();
return(0);
}

~~~~~~~~~~~~~~~~~~~~~BEST FIT~~~~~~~~~~~~~~~~

#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
int
arr[max],arr1[max],i,j,k,l,m,n=1,flag=0,flag1[max]={0},flag2[max]={0},proc_no[max],w;
arr[0]=1024;
printf("enter the no of processes to be executed :: ");
scanf("%d",&i);
// for(j=o;j<i;j++)

printf("enter the process space");

scanf("%d",&k);
list: if(k<arr[0]/2)
{
flag=flag+1;
l=arr[0]/2;
arr1[0]=arr1[1]=l;
for(m=2;m<=flag;m++)
{
arr1[m]=arr[m-1];
}
for(m=0;m<=flag;m++)
{

arr[m]=arr1[m];
}
goto list;
}
else
{
flag1[0]=1;

}
for(m=0;m<=flag;m++)
{
printf(" arr[m] = %d \n ",arr[m]);
}

for(j=1;j<=i;j++)
{
printf("\nenter the process space \n");
scanf("%d",&k);
int min=1024,min_pos;
for(w=1;w<=flag;w++)
{
if(arr[w]>k &&arr[w]<min && flag1[w]==0)
{
min=arr[w];

min_pos=w;
}
}

list1: if(k<arr[min_pos]/2)
{
//

flag=n;

flag=flag+1;
l=arr[min_pos]/2;
arr1[min_pos]=arr1[min_pos+1]=l;
for(m=min_pos+2;m<=flag;m++)
{
arr1[m]=arr[m-1];
}
for(m=0;m<=flag;m++)
{
arr[m]=arr1[m];
}
for(m=0;m<=flag;m++)
{
flag2[m]=flag1[m];
}
for(m=min_pos+1;m<=flag;m++)
{
flag2[m]=flag1[m-1];
}
for(m=0;m<=flag;m++)

{
flag1[m]=flag2[m];
}
goto list1;
}
else
{
flag1[min_pos]=1;

}
for(m=0;m<=flag;m++)
{
printf("arr[%d]=%d ,flag1[%d]=%d\n",m,arr[m],m,flag1[m]);

}
getch();
return(0);
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~WORST

FIT~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include<stdio.h>
#include<conio.h>
#define max 20
int main()

{
int
arr[max],arr1[max],i,j,k,l,m,n=1,flag=0,flag1[max]={0},flag2[max]={0},proc_no[max],w;
arr[0]=1024;
printf("enter the no of processes to be executed :: ");
scanf("%d",&i);
// for(j=o;j<i;j++)

printf("enter the process space");

scanf("%d",&k);
list: if(k<arr[0]/2)
{
flag=flag+1;
l=arr[0]/2;
arr1[0]=arr1[1]=l;
for(m=2;m<=flag;m++)
{
arr1[m]=arr[m-1];
}
for(m=0;m<=flag;m++)
{
arr[m]=arr1[m];
}
goto list;
}
else
{

flag1[0]=1;

}
for(m=0;m<=flag;m++)
{
printf(" arr[m] = %d \n ",arr[m]);
}

for(j=1;j<=i;j++)
{
printf("\nenter the process space \n");
scanf("%d",&k);
int min=1024,min_pos,max_o=0;

for(w=1;w<=flag;w++)
{
if(arr[w]>k &&arr[w]>max_o&& flag1[w]==0)
{
max_o=arr[w];
min_pos=w;
}
}

list1: if(k<arr[min_pos]/2)

{
//

flag=n;

flag=flag+1;
l=arr[min_pos]/2;
arr1[min_pos]=arr1[min_pos+1]=l;
for(m=min_pos+2;m<=flag;m++)
{
arr1[m]=arr[m-1];
}
for(m=0;m<=flag;m++)
{
arr[m]=arr1[m];
}
for(m=0;m<=flag;m++)
{
flag2[m]=flag1[m];
}
for(m=min_pos+1;m<=flag;m++)
{
flag2[m]=flag1[m-1];
}
for(m=0;m<=flag;m++)
{
flag1[m]=flag2[m];
}
goto list1;
}

else
{
flag1[min_pos]=1;

}
for(m=0;m<=20;m++)
{
printf("arr[%d]=%d ,flag1[%d]=%d\n",m,arr[m],m,flag1[m]);

}
getch();
return(0);

~~~~~~~~~~~~~~~~~~~FIRST COME FIRST SERVE~~~~~~~~~~~~~~~~~

#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
inttot_tme=0,i,j,k,l,m,add;
printf("~~~~~~~~~~~~~~~~~first come first serve~~~~~~~~~~~~~\n\n");
printf("Enter the total no processes to be processed :: ");
scanf("%d",&j);
printf("\nEnter the current position :: ");
scanf("%d",&i);

m=i;
for(k=0;k<j;k++)
{
printf("enter the next position ::");
scanf("%d",&l);
if(m>l)
{
add=m-l;
}
else
{
add=l-m;
}
m=l;
tot_tme=tot_tme+add;

}
printf("\n Total tme :: %d",tot_tme);
getch();
return 0;

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~SCAN~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
intproc[]={98,183,37,122,14,124,65,67 };
inti,j,k,l,pos,maxi,count=0,index,sum=0;

scanf("%d",&pos);
for(i=0;i<8;i++)
{
maxi=0;
for(j=0;j<8-i;j++)
{

if(proc[j]>maxi)
{
maxi=proc[j];
index=j;
}
}
k=proc[7-i];
proc[7-i]=proc[index];
proc[index]=k;
}

for(i=0;i<8;i++)
{
printf(" %d ",proc[i]);
}
for(i=0;i<7;i++)
{
if(proc[i]<pos&&proc[i+1]>pos)
{

index=i;
}
}

i=index;
while(i>=0)
{ if(count==0)
{
sum=sum + (pos-proc[index]);
printf(" sum(%d)=sum + (pos(%d)-proc[index](%d))(%d)\n)",sum,pos,proc[index]);
printf("index :: %d sum:: %d\n",i,sum);

count++;
i--;
}

else
{

sum=sum + (proc[i+1]-proc[i]);
printf(" sum(%d)=sum + (proc[i+1](%d)-proc[i](%d)\n)",sum,proc[i+1],proc[i]);
printf("index :: %d sum:: %d\n",i,sum)
;
i--;
}
}
if(i<0)

{
sum=sum+(proc[0]);
printf(" sum(%d)=sum + proc[0](%d)\n)",sum,proc[0]);
printf("index :: %d sum:: %d\n",i,sum);

i=index+1;
}
if(i==index+1 &&i<8)
{
sum=sum+proc[index+1];
printf(" sum(%d)=sum + proc[index+1](%d)\n)",sum,proc[index+1]);
printf("index :: %d sum:: %d\n",i,sum);
i++;
}
while(i<8)
{
sum=sum+(proc[i]-proc[i-1]);
printf(" sum(%d)=sum + (proc[i](%d)-proc[i-1](%d)\n)",sum,proc[i],proc[i-1]);
printf("index :: %d sum:: %d\n",i,sum);
i++;
}

printf("sum is %d",sum);
getch();

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~C

SCAN~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include<stdio.h>
#include<conio.h>
#define max 20
int main()
{
intproc[]={98,183,37,122,14,124,65,67 };
inti,j,k,l,pos,maxi,count=0,index,sum=0;
printf("enter the current position");
scanf("%d",&pos);
for(i=0;i<8;i++)
{
maxi=0;
for(j=0;j<8-i;j++)
{

if(proc[j]>maxi)

{
maxi=proc[j];
index=j;
}
}
k=proc[7-i];
proc[7-i]=proc[index];
proc[index]=k;
}

for(i=0;i<8;i++)
{
printf(" %d ",proc[i]);
}
for(i=0;i<7;i++)
{
if(proc[i]<pos&&proc[i+1]>pos)
{
index=i;
}
}

i=index;
while(i>=0)
{ if(count==0)
{

sum=sum + (pos-proc[index]);
printf(" sum(%d)=sum + (pos(%d)-proc[index](%d))(%d)\n)",sum,pos,proc[index]);
printf("index :: %d sum:: %d\n",i,sum);

count++;
i--;
}

else
{

sum=sum + (proc[i+1]-proc[i]);
printf(" sum(%d)=sum + (proc[i+1](%d)-proc[i](%d)\n)",sum,proc[i+1],proc[i]);
printf("index :: %d sum:: %d\n",i,sum);
i--;
}
}
if(i<0)
{
sum=sum+(proc[0]);
printf(" sum(%d)=sum + proc[0](%d)\n)",sum,proc[0]);
printf("index :: %d sum:: %d\n",i,sum);

i=7;
}
if(i==7 )
{

sum=sum+200-proc[7];
printf(" sum(%d)=sum +200+proc[7](%d)\n)",sum,proc[7]);
printf("index :: %d sum:: %d\n",i,sum);
i--;
}
while(i>index)
{
sum=sum+(proc[i+1]-proc[i]);
printf(" sum(%d)=sum + (proc[i](%d)-proc[i-1](%d)\n)",sum,proc[i+1],proc[i]);
printf("index :: %d sum:: %d\n",i,sum);
i--;
}

printf("sum is %d",sum);
getch();