FERMATS LITTLE THEOREM

import java.math.*;
import java.io.*;
import java.util.Scanner;
public class Main
{
public static void main(String[] args) {
   Scanner s = new Scanner(System.in);
    System.out.println("Enter a prime number");
    BigInteger a=new BigInteger(s.next());
    System.out.println("Enter a number which is co prime of above number");
    BigInteger b=new BigInteger(s.next());
    if((a.gcd(b)).intValue()==1){
        System.out.println(b.modPow(BigInteger.valueOf(a.intValue()-2),a));
        
    }
    else{
        System.out.println("Invalid input");
    }

}
}

DIFFIE HELLMAN KEY EXCHANGE

import java.math.*;
import java.io.*;
import java.util.Scanner;
public class Main
{
public static void main(String[] args) {
   Scanner s = new Scanner(System.in);
    System.out.println("Enter a public key p");
    BigInteger p=new BigInteger(s.next());
    System.out.println("Enter public key g");
    BigInteger g=new BigInteger(s.next());
    System.out.println("Enter the private key at alice side");
    BigInteger a=new BigInteger(s.next());
    System.out.println("Enter private  key at bobs side");
    BigInteger b=new BigInteger(s.next());
    BigInteger x=new BigInteger("0");
    BigInteger y=new BigInteger("0");
    
    x=g.modPow(a,p);
    System.out.println("Key generated at Alice side is: "+x);
        y=g.modPow(b,p);
    System.out.println("Key generated at Bobs side is: "+y);
    System.out.println("After key exchange :");
    System.out.println("Secret KEy shared at Alice side is: "+y.modPow(a,p));
   System.out.println("Secret KEy shared at Bobs  side is: "+x.modPow(b,p));

}
}

CHINESE REMAINDER THEOREM

import java.io.*;
import java.lang.Math;

public class Main
{ 
    static int t=1;
    int ans=0;
public static void main(String[] args) {
    int a[]={3,4,5};
    int b[]={4,5,4};
    while(true){
        int i=0;
        for( i=0;i<a.length;i++){
            if((t%a[i])!=b[i])
            break;
        }
        if(i==a.length)
        {
            System.out.println("THe MINIMUM number which satisfies condition is:"+t);break;
        }
        else{
            t++;
        }
    }
}
}

RSA ALGORITHM

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.Math;
public class Main
{
public static void main(String[] args) {
    BigInteger bi1, bi2, bi3;
    int e=0;
    Scanner s = new Scanner(System.in);
    System.out.println("Enter value of p which is prime");
    int p=s.nextInt();
    System.out.println("ENter the value of q which is prime");
    int q=s.nextInt();
  int  n=p*q;
  int phi=(p-1)*(q-1);
  bi2=new BigInteger(String.valueOf(phi));
  bi3=new BigInteger("0");
  for(int i=2;i<phi;i++){
      bi1=new BigInteger(String.valueOf(i));
      bi3=bi2.gcd(bi1);
      if((bi3).intValue()==1){
          e=i;
      break;}
  }
double d=0;
for(int i=1;i<=100;i++){
     if(((i*phi)+1)%e==0){
         d=(((i*phi)+1)/e);break;
     }
}
System.out.println("Enter value of message:");
    int m=s.nextInt();
    int c=((int)(Math.pow(Double.valueOf(m),Double.valueOf(e))))%n;
System.out.println("The ENCRYPTED MESSAGE Is:"+c);  
bi1=BigInteger.valueOf(c);
int dec=((bi1.pow((int)d)).mod(BigInteger.valueOf(n))).intValue();
System.out.println("The ORIGINAL MESSAGE Is:"+dec);
}
}

BANKERS ALGORITHM:DEAD LOCK AVOIDANCE

#include<stdio.h>
#define m1 100
int m,n,avail[m1],max[m1],alloc[m1][m1],need[m1][m1],safe[m1],req[m1][m1];
void result(){
int i,j,t=0,k=0,c=0;
for(i=0;i<n;i++)
for(j=0;j<m;j++)
req[i][j]=need[i][j]-alloc[i][j];
while(c<n){
for(i=0;i<n;i++){
t=0;
if(safe[i]==1)continue;
for(j=0;j<m;j++){
if(req[i][j]<=avail[j]){
avail[j]=avail[j]-req[i][j];
t++;}
}
if(t==j){
printf("%d\t",i+1);
c++;
safe[i]=1;
for(k=0;k<m;k++)
avail[k]=avail[k]+need[i][k];
}}
}
}

int main(){
m=0;
n=0;
int i=0,j=0;
printf("Enter number of processes\n");
scanf("%d",&n);
printf("Enter number of resources\n");
scanf("%d",&m);
printf("Enter Resources available\n");
for(i=0;i<n;i++)
safe[i]=0;
for(i=0;i<m;i++)
scanf("%d",&avail[i]);
printf("Enter allocation matrix\n");
for(i=0;i<n;i++)
for(j=0;j<m;j++)
scanf("%d",&alloc[i][j]);
printf("Enter max need matrix\n");
for(i=0;i<n;i++)
for(j=0;j<m;j++)
scanf("%d",&need[i][j]);
printf("Safe Sequence is:\n");
result();
return 0;
}

FIFO Page Replacement Algorithm

#include <stdio.h>
int f,p,nop[100],nof[100],pf,fi;
void fifo_p();
int contains(int t);
int contains(int t){
int i=0;
if(nof[0]==-1)
return 0;
for ( i = 0; i < f; ++i)
{
if(t==nof[i])
return 1;
}
return 0;
}
void fifo_p(){
int i=0;
fi=0;
for (i = 0; i < p; ++i)
{
if(contains(nop[i])==1)
continue;
   if(nof[fi]==-1 || nof[fi]!=-1 &&contains(nop[i])==0){
    pf++;
    nof[fi]=nop[i];
    fi++;
   }
   if(fi==f-1){
    fi=0; 
      }
}
}
int main()
{int i=0;
pf=0;
printf("Enter Number of Frames\n");
scanf("%d",&f);
printf("Enter Number of Pages\n");
scanf("%d",&p);
printf("Enter page Numbers\n");
for ( i = 0; i < p; ++i)
{
scanf("%d",&nop[i]);
}
for ( i = 0; i < f; ++i)
{
nof[i]=-1;
}
fifo_p();
printf("Page Faults Found are:%d\n",pf);
return 0;
}

Optimal Page replacement Algorithm

#include <stdio.h>
int f,p,nop[100],nof[100],pf,fi,in;
void fifo_p();
int contains(int t);
int func(int l);
void print();
void print(){
int i=0;
for ( i = 0; i < f; ++i)
{
printf("%d\t",nof[i]);
}
}
int con(int n,int l[],int c){
int i=0;
for( i=0;i<c;i++){
if(l[i]==n){
return 1;
}
}
return 0;
}
int ind(int l){
int i=0;
for( i=0;i<f;i++){
if(nof[i]==nop[l]){
return i;}
}
}
int func(int l){
   int t=0,i=0;
   int lru[3]={0,0,0};
for ( i = l; i < p; ++i)
{

if(nop[i]==nof[0] && lru[0]==0){
lru[0]=i;
}
if(nop[i]==nof[1] && lru[1]==0){
lru[1]=i;}
if(nop[i]==nof[2]&&lru[2]==0){
lru[2]=i;}
}
  if(lru[0]==0)
  return 0;
   if(lru[1]==0)
  return 1;
if(lru[2]==0)
  return 2;
    if(lru[0]>lru[1] && lru[0]>lru[2])
    return 0;
    else if(lru[1]>lru[0] && lru[1]>lru[2])
    return 1;
    else
    return 2;
}
int contains(int t){
int i=0;
if(nof[0]==-1)
return 0;
for ( i = 0; i < f; ++i)
{
if(t==nof[i]){
return 1;
}
}
return 0;
}
void fifo_p(){
int i=0;
fi=0;
for (i = 0; i < p; ++i)
{
if(nof[fi]==-1){
nof[fi]=nop[i];
pf++;
fi++;

}
else if(contains(nop[i])==1){
continue;
}
else{
    printf("\n");
    fi=func(i);
    nof[fi]=nop[i];
    print();
    pf++;
   }
}
}
int main()
{
    int i=0;
pf=0;
in=0;
printf("Enter Number of Frames\n");
scanf("%d",&f);
printf("Enter Number of Pages\n");
scanf("%d",&p);
printf("Enter page Numbers\n");
for ( i = 0; i < p; ++i)
{
scanf("%d",&nop[i]);
}
for ( i = 0; i < f; ++i)
{
nof[i]=-1;
}
fifo_p();
printf("\nPage Faults Found are:%d\n",pf);
return 0;
}

Least Recently Used PAGE REPLACEMENT Algorithm

#include <stdio.h>
int f,p,nop[100],nof[100],pf,fi,in,ti[100];
void fifo_p();
int contains(int t);
int func(int l);
void print();
void print(){
int i=0;
for ( i = 0; i < f; ++i)
{
printf("%d\t",nof[i]);
}
}
int con(int n,int l[],int c){
int i=0;
for( i=0;i<c;i++){
if(l[i]==n){
return 1;
}
}
return 0;
}
int ind(int l){
int i=0;
for( i=0;i<f;i++){
if(nof[i]==nop[l]){
return i;}
}
}
int func(int l){
   int t=0,i=0;
   int lru[50];
   for (i=0;i<p;i++){
    lru[i]=-1;
   }
   i=0;
  do{
    if(con(nop[l],lru,i)){
    l--;
   }
else{
lru[i]=nop[l];
i++;
if(i==3)
break;
l--;
} 
   } while(l>0);
  return ind(l);


}
int contains(int t){
int i=0;
if(nof[0]==-1)
return 0;
for ( i = 0; i < f; ++i)
{
if(t==nof[i]){
return 1;
}
}
return 0;
}
void fifo_p(){
int i=0;
fi=0;
for (i = 0; i < p; ++i)
{
if(nof[fi]==-1){
nof[fi]=nop[i];
pf++;
fi++;

}
else if(contains(nop[i])==1){
continue;
}
else{
    printf("\n");
    fi=func(i-1);
    nof[fi]=nop[i];
    print();
    pf++;
   }
}
}
int main()
{
    int i=0;
pf=0;
in=0;
printf("Enter Number of Frames\n");
scanf("%d",&f);
printf("Enter Number of Pages\n");
scanf("%d",&p);
printf("Enter page Numbers\n");
for ( i = 0; i < p; ++i)
{
scanf("%d",&nop[i]);
}
for ( i = 0; i < f; ++i)
{
nof[i]=-1;
}
fifo_p();
printf("\nPage Faults Found are:%d\n",pf);
return 0;
}

SEQUENTIAL FILE ALLOCATION

#include <stdio.h>
int main(){
int a1[50],n,i,j,k,nb,st;
for(i=0;i<50;i++)
a1[i]=0;
do{
k=0;
printf("Enter number of blocks and number of starting block\n");
scanf("%d%d",&nb,&st);
for(i=st;i<(st+nb);i++){
if(a1[i]==0)
k+=1;
}
if(k==nb){
for(i=st;i<(st+nb);i++){
     a1[i]=1;
     j+=1;
}
printf("File allocated successfully\n");
}
else{
printf("File cannot be allocated\n");
}
printf("Do you want to continue to insert another file\n1.YES\t2.NO\n");
scanf("%d",&i);
}while(i==1);
return 0;
}

LINKED FILE ALLOCATION

#include <stdio.h>
int main(){
int a1[50],i=0,j=0,k=0,nb=0,st=0,l=0,te=0;
for(i=0;i<50;i++)
a1[i]=0;
printf("Enter how many blocks already allocated\n");
scanf("%d",&l);
printf("Enter the block numbers\n");
for(i=0;i<l;i++){
scanf("%d",&j);
a1[j]=1;
}
do{
k=0;
printf("Enter start block number and length of file in blocks: \n");
scanf("%d%d",&st,&nb);
k=nb;
for(i=st;i<(st+k);i++){
if(a1[i]==0){
a1[i]=1;
printf("%d-->%d\n",i,1);
te++;}
else{
k++;
printf("%d is ALready occupied block\n",i);
}
}
if(te==0&&k==nb){
printf("File cannot be allocated\n");
}
printf("Do you want to continue to insert another file\n1.YES\t 2.NO\n");
scanf("%d",&i);
}while(i==1);
return 0;
}

Operating Systems:Indexed File Allocation

#include <stdio.h>

int main(){

int a1[50],a2[50],k=0,i,j,n,m;
for(i=0;i<50;i++)
{a1[i]=0;a2[i]=0;
}
do{
k=0;
printf("Enter indexed block number\n");
scanf("%d",&m);
if(a1[m]==0){
a1[m]=1;
do{
k=0;
printf("Enter number of blocks for file\n");
scanf("%d",&n);
for(i=0;i<n;i++){
printf("ENter block number\n");
scanf("%d",&a2[i]);
if(a1[a2[i]]==0)
k++;
}
if(k==n){
             for(i=0;i<n;i++){
              a1[a2[i]]=1;
             }
             printf("File allocated\n");
}
else{
     printf("Try another block set\n");
}
}while(k!=n);
}
else{
printf("Index is already assigned\n");
}
printf("Enter 1 if you want to insert other files else 0\n");
scanf("%d",&i);
}while(i==1);
}

PRIM'S ALGORITHM TO FIND MINIMUM SPANNING TREE

#include<stdio.h>
#define max 25
int g[max][max],v[max],n,sum;
void prims(int s);
int main(){
int s;
sum=0;
printf("enter number of vertices\n");
scanf("%d",&n);
printf("enter adjacent matrix\n");
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
scanf("%d",&g[i][j]);
}}
prims(0);
printf("min cost req is:%d\n",sum);
return 0;
}
void prims(int s){
int i,j,m=9999,k,m1,l;
v[s]=1;
m1++;
do{
for(i=0;i<n;i++){
m=9999;
if(v[i]==1){
for(j=0;j<n;j++){
if((g[i][j]!=0)&&(m>=g[i][j])&&v[j]!=1)
{
m=g[i][j];
k=i;
l=j;}
}
}}
printf("edge:%d--->%d\n",k,l);
printf("visited:%d",v[l]);
sum+=g[k][l];
v[l]=1; m1++;}while(m1!=n);
return;
}

SINGLE SOURCE SHORTEST PATH PROBLEM(DIJKSTRA'S ALGORITHM) 'C' PROGRAM

1. #include<stdio.h>
2. #include<limits.h>
3. int n;
4. int adj[10][10],vi[10];
5. int dist[10];
6. void shortest(int v);
7. int min();
8. int main(){
9. int i,j,s;
10. printf("enter number of vertices\n");
11. scanf("%d",&n);
12. for(i=1;i<=n;i++){
13. dist[i]=INT_MAX;
14. printf("%d\t",dist[i]);
15. }
16. printf("enter adjacency matrix\n");
17. for(i=1;i<=n;i++)
18. for(j=1;j<=n;j++)
19. scanf("%d",&adj[i][j]);
20. printf("enter source vertex to start\n");
21. scanf("%d",&s);
22. shortest(s);
23. printf("shortest distances from vertex %d are\n",s);
24. for(i=1;i<=n;i++){
25. if(dist[i]<INT_MAX&&vi[i]==1)
26. printf("cost:%d\tedge:(%d,%d)\n",dist[i],s,i);
27. }
28. return 0;
29. }
30.  void shortest(int v){
31. int i,j,u;
32. for(i=1;i<=n;i++){
33. vi[i]=-1;
34. if(adj[v][i]!=0)
35. dist[i]=adj[v][i];
36. }
37. vi[v]=1;
38. for(j=2;j<=n;j++){
39. u=min();
40. printf("%d\n",u);
41. vi[u]=1;
42. for(i=1;i<=n;i++){
43. if((adj[u][i]!=0)&&(dist[i]>(dist[u]+adj[u][i]))&&(vi[i]==-1)){
44. dist[i]=(dist[u]+adj[u][i]);
45. }
46. }
47. }
48. return;
49. }
50. int min(){
51.  int i,t=dist[1],j;
52. for(i=1;i<=n;i++){
53. if((dist[i]<t)&&(vi[i]==-1))
54. {
55. t=dist[i];
56. }}
57. for(j=1;j<=n;j++){
58. if(t==dist[j]&&vi[j]==-1)
59. break;}
60. return j;
61. }

QUICK SORT -'C' PROGRAM

#include<stdio.h>
#include<limits.h>
#define max 25
int arr[max];
int partition(int arr[],int l,int h);
void quick(int l,int h);
int main(){
int n;
printf("enter num: \n");
scanf("%d",&n);
printf("enter array elements\n");
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
arr[n]=INT_MAX;
quick(0,n);
printf("elements after sorting are\n");
for(int i=0;i<n;i++)
printf("%d\t",arr[i]);
}
int partition(int arr[],int l,int h)
{
int v=arr[l],i=l,j=h,temp;
do{
do{
i=i+1;
}while(arr[i]<v);
do{
j=j-1;
}while(arr[j]>v);
if (i<j)
{
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}while(i<j);
arr[l]=arr[j];arr[j]=v;
return j;
}
void quick(int l,int h){
int j;
if(l<h)
{
j=partition(arr,l,h);
quick(l,j);
quick(j+1,h);
}
}

C PROGRAM DEMONSTRATING ALL TREE TRAVERSALS RECURSIVELY AND NON RECURSIVELY

#include<stdio.h>
#include<stdlib.h>
struct Tnode{
 struct Tnode*pleft;
 struct Tnode*pright;
int ch;
};
struct Tnode *stack[50];
struct Tnode *stack1[50];
int top,top1;
void push(struct Tnode* ch1);
struct Tnode* pop();
void push1(struct Tnode *ch1);
struct Tnode *pop1();
struct Tnode*root;
struct Tnode*create_node(int c);
void create();
void insert(int c);
void non_preorder();
void non_postorder();
void non_inorder();
void inorder(struct Tnode *rot);
void preorder(struct Tnode *rot);
void postorder(struct Tnode *rot);
//main function
int main(){
top=-1;root=NULL;top1=-1;
create();
printf("RECURSIVE INORDER TRAVERSAL IS:\n");
inorder(root);
printf("\n");
printf("RECURSIVE PREORDER TRAVERSAL IS:\n");
preorder(root);
printf("\n");
printf("RECURSIVE POSTORDER TRAVERSAL IS:\n");
postorder(root);
printf("\n");
non_preorder();
printf("\n");
non_postorder();
printf("\n");
non_inorder();
 return 0;}

struct Tnode*create_node(int c){
 struct Tnode*pnew=(struct Tnode*)malloc(sizeof(struct Tnode));
 if(pnew){
 pnew->ch=c;
 pnew->pleft=NULL;
  pnew->pright=NULL;}
 return pnew;}
 void insert(int c){
  struct Tnode *pnew,*ptrav,*pa;
  pnew=create_node(c);
  if(!pnew) printf("no memeory\n");
  else{
   if(!root)
   root=pnew;
   else{
    pa=root;ptrav=root;
    while(ptrav){
     pa=ptrav;
     if(c<(ptrav->ch)){
     ptrav=ptrav->pleft;}
     else{
     ptrav=ptrav->pright;}}
    if(c<(pa->ch)){
    pa->pleft=pnew;}
    else{
    pa->pright=pnew;}}return;}}
 void create(){
 int k;
  int i,n;
  printf("enter number of values\n");scanf("%d",&n);
  for(i=0;i<n;i++) {
  scanf("%d",&k);
  insert(k);
  }}
 void push(struct Tnode *ch1){
  top++;
  stack[top]=ch1;
  return;
 }
struct Tnode *pop(){
  struct Tnode* k;
  if(top<0){
  k=NULL;return k ;}
  else
  {

    k=stack[top];
   top--;
   return k;
  }
 }
   void push1(struct Tnode *ch1){//thi function is for stack1 operations
  top1++;
  stack1[top1]=ch1;
  return;
 }//push1 end

struct Tnode *pop1(){
  struct Tnode* k;
  if(top1<0){
  k=NULL;return k ;}
  else
  {
    k=stack1[top1];
   top1--;
   return k;
  }}
//RECURSIVE FUNCTIONS
 void inorder(struct Tnode *rot){
  if(rot){
 inorder(rot->pleft);
   printf("%d\t",rot->ch);
   inorder(rot->pright);}
  }

   void preorder(struct Tnode *rot){
  if(rot){
  printf("%d\t",rot->ch);
  preorder(rot->pleft);
  preorder(rot->pright);}
  }

   void postorder(struct Tnode *rot){
  if(rot){
  postorder(rot->pleft);
   postorder(rot->pright);
   printf("%d\t",rot->ch);}
  }
//NON RECURSIVE FUNCTIONS
void non_preorder(){
char l; 
int done=0;
struct Tnode *ptemp=NULL,*ptr=root;
push(ptr);
if(!root){printf("empty tree\n");
}else{
 printf("NON RECURSIVE PREORDER IS:\n");
 while(top>=0){
ptr=pop(); 
   printf("%d\t",ptr->ch);
 if((ptr->pright)!=NULL){
 ptemp=ptr->pright;
 push(ptemp);}
 if((ptr->pleft)!=NULL){
 ptemp=ptr->pleft;
 push(ptemp);
}
}
}}

void non_postorder(){
char l; 
int done=0;
struct Tnode *ptemp=NULL,*ptr=root;
push(ptr);
if(!root){printf("empty tree\n");
}else{
 printf("NON RECURSIVE POST ORDER:\n");
 while(top>=0){
          ptr=pop();
  push1(ptr);
 if((ptr->pleft)!=NULL){
 ptemp=ptr->pleft;
 push(ptemp);}
 if((ptr->pright)!=NULL){
 ptemp=ptr->pright;
 push(ptemp);}
}
}
while(top1>=0){
 ptemp=pop1();
 printf("%d\t",ptemp->ch);
}
}

void non_inorder(){
struct Tnode *ptemp=NULL,*ptr=root;
if(!root){printf("empty tree\n");
}else{
push(ptr);
 printf("NON RECURSIVE IN ORDER IS:\n");
 while(top>=0){
  if((ptr->pleft)!=NULL){
 ptr=ptr->pleft;
 push(ptr);
}
 else{
ptemp=pop();
  printf("%d\t",ptemp->ch);
  if(ptemp->pright!=NULL){
  ptr=ptemp->pright;
  push(ptr);
 }}
}
}
}

C PROGRAM FOR BINARY SEARCH USING RECURSION

#include<stdio.h>
void bin(int l,int h,int arr[],int s);
int main()
{
int s,i,k,arr[10]={0};
printf("enter array elements\n");
for(i=0;i<5;i++)
scanf("%d",&arr[i]);
printf("enter element to search\n");
scanf("%d",&s);
bin(0,4,arr,s);//CALL TO RECURSIVE FUN
return 0;
}
void bin(int l,int h,int arr[],int s){
int m;
if(l<=h){
m=(l+h)/2;
if(arr[m]==s){
printf("element found at %d",m+1);
}
else if(s<arr[m]){
 bin( l,m-1,arr,s);//RECURSIVE CALLS
}
else 
 bin( m+1,h,arr,s);}
else
printf("element not found\n");
return;
}

GAUSS SEIDEL METHOD USING C PROGRAM

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
int n,i,j,k,s=1;
printf("enter number of variales");
scanf("%d",&n);
float a[n][n];
float  b[n];
float x[n]={0},var,itr,temp,temp1;
printf("enter approx");
scanf("%f",&itr);
for(i=0;i<n;i++)
{
printf("enter element at b[%d]",i);
scanf("%f",&b[i]);

for(j=0;j<n;j++)
{
printf("enter element at a[%d][%d]",i,j);
scanf("%f",&a[i][j]);
}
}
do
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i!=j)
{
var+=a[i][j]*x[j];
}
}
temp1=(1/a[i][i])*(b[i]-var);
var=0;
printf("initial %f\n",x[i]);
temp=fabs(temp1-x[i]);
x[i]=temp1;
temp1=0;
}
}while((temp>itr));

for(i=0;i<n;i++)
{
printf(" x%d=%f\t",i,x[i]);
}

return 0;
}

GAUSS JACOBI METHOD USING C PROGRAM

//gauss jacobi
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
int n,i,j,k,s=1;
printf("enter number of variales");
scanf("%d",&n);
float a[n][n];
float  b[n];
float x[n]={0},x1[n]={0},var,itr,temp,temp1;
printf("enter approx");
scanf("%f",&itr);
for(i=0;i<n;i++)
{
printf("enter element at b[%d]",i);
scanf("%f",&b[i]);

for(j=0;j<n;j++)
{
printf("enter element at a[%d][%d]",i,j);
scanf("%f",&a[i][j]);
}
}
do
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i!=j)
{
var+=a[i][j]*x1[j];
}
}
x[i]=(1/a[i][i])*(b[i]-var);
var=0;
printf("initial %f\n",x[i]);
temp=fabs(x[i]-x1[i]);
}
for(i=0;i<n;i++)
{
x1[i]=x[i];
}
}while((temp>itr));
for(i=0;i<n;i++)
{
printf(" x%d=%f\t",i,x[i]);
}

return 0;
}

EULER MODIFIED METHOD USING C PROGRAM

#include<stdio.h>
#include<math.h>
float fun(float x,float y)
{
float f;
f=x*x+y;
return f;
}
int main()
{
float diff,y0,y,x0,x1,h,xn,y1,y2;
printf("enter x0,y0,h,xn\n");
scanf("%f%f%f%f",&x0,&y0,&h,&xn);
do
{
  y=y0+h*(fun(x0,y0));
  x1=x0+h;
  do
  {
  y2=y;
  y1=y0+(h/2)*(fun(x0,y0)+fun(x1,y));
  y=y1;
  diff=y1-y2;
  //printf("%f\n",y1-y2);
  }while(fabs(diff)>0.000001);
  y0=y1;
  x0=x0+h;
  printf("x=%f \t y=%f\n",x0,y1);
}while(x0<xn);
return 0;

}

RANGE KUTTA METHOD USING C PROGRAM

#include<stdio.h>
#include<math.h>
float fun(float x,float y)
{
float f;
f=x+(y*y);
return f;
}
int main()
{
float x0,y0,xn,h,y,k1,k2,k3,k4,k,x;
printf("enter x0,y0,h,xn\n");
scanf("%f%f%f%f",&x,&y,&h,&xn);
do
{
k1=h*fun(x,y);
k2=h*fun(x+h/2,y+(k1/2));
k3=h*fun(x+h/2,y+(k2/2));
k4=h*fun(x+h,y+k3);
k=(1/6)*(k1+2*(k2+k3)+k4);
y0=y+k;
printf("%f\n",y);
x=x+h;
y=y0;
}while(x<xn);

return 0;

}