Computer Science‎ > ‎

## Computing the Area of a Circle in C

```/*This is a program to calculate area of a circle after getting the radius as input from the user*/
#include<stdio.h>
int main()
{
printf("Enter the radius of the circle whose area is to be calculated\n");
scanf("%lf",&radius);//entering the value for radius of the circle as float data type
printf("The area of the circle is %lf",area);//displaying the results
getch();
}
/*A test run for the program was carried out and following output was observed
Enter the radius of the circle whose area is to be calculated
5.00
The area of the circle is 78.571429*/```

## C Program to check for Armstrong Numbers

```/*The following program checks whether a number is armstrong number or not and also displays all armstrong numbers
from 1 to 1000. Armstrong numbers are such numbers whose sum of the cubes of digits is equal to the number itself.
For Example
371 is an Armstrong number
371=3*3*3+7*7*7+1*1*1
*/
#include<stdio.h>
#include<conio.h>
#include<math.h>
int main()
{
int numcheck;
int choice;
int rem;
int sum;
int temp;
printf("Enter Choice 1 to check whether a number is armstrong or not and Choice 2 to display all armstrong numbers from 1 to 1000\n");
scanf("%d",&choice);//It's a menu driven program and we work as per user's choice
switch(choice)
{
case 1:
printf("Enter the number\n");
scanf("%d",&numcheck);
temp=numcheck;/*We create a temporary copy of the number we will require to divide the number zero which changes it
and we need the actual number to compare after the loop operations.*/
sum=0;//variable to hold the sum of cubes of digits
while(temp>0)
{
rem=temp%10;//We find the digit at last place by finding the remainder after division by 10
sum=sum+rem*rem*rem;
temp=temp/10;
}
if(sum==numcheck)//Finally we check if the sum of the cubes of the digits equals the number or not
printf("The Number is an armstrong number\n");
else
printf("The Number is not an armstrong number\n");
break;
case 2:
for(numcheck=1;numcheck<=1000;numcheck++)
{//A loop which allows us to move through all numbers from 1 to 1000
//Now we perform the same operations on all numbers
temp=numcheck;
sum=0;
while(temp>0)
{
rem=temp%10;
sum=sum+rem*rem*rem;
temp=temp/10;
}
if(sum==numcheck)
printf("The Number %d is an armstrong number\n",numcheck);

}
break;
}
getch();
return 0;
}
/*A sample run of the program was carried out and it was found to give result as
Enter Choice 1 to check whether a number is armstrong or not and Choice 2 to display all armstrong numbers from 1 to 1000
2
The Number 1 is an armstrong number
The Number 153 is an armstrong number
The Number 370 is an armstrong number
The Number 371 is an armstrong number
The Number 407 is an armstrong number
*/```

## C Program implementing the Bisection Method ( Numerical Computing )

```/*This program in C is used to demonstarte bisection method.
Bisection method is one of the many root finding methods.
In this method we are given a function f(x) and we approximate 2 roots a and b for the function such that f(a).f(b)<0.
Then we find another point
c=(a+b)/2
if f(c)==0
then root=c;
else
if f(a).f(c)<0
b=c;
if f(b).f(c)<0
a=c;
and we repeat these steps for the given number of iterations*/
#include<stdio.h>
#include<math.h>
double F(double x)
{
return(pow(x,3)+3*x-5);//This return the value of the function
}
int main()
{
printf("This program illustrates the bisection method in C\n");
printf("x^3 + 3*x - 5 = 0\n");
double x0,x1;
printf("Enter the first approximation to the root\n");
scanf("%lf",&x0);
printf("Enter the second approximation to the root\n");
scanf("%lf",&x1);
int iter;
printf("Enter the number of iterations you want to perform\n");
scanf("%d",&iter);
int ctr=1;
double l1=x0;
double l2=x1;
double r,f1,f2,f3;
//We check if the initail approximations are the root or not
if(F(l1)==0)
r=l1;
else
if(F(l2)==0)
r=l2;
else
{
while(ctr<=iter)
{//this is an implementation of the algorithm mentioned above
f1=F(l1);
r=(l1+l2)/2.0;
f2=F(r);
f3=F(l2);
if(f2==0)
{
r=f2;
break;
}
printf("The root after %d iteration is %lf\n",ctr,r);
if(f1*f2<0)
l2=r;
else
if(f2*f3<0)
l1=r;
ctr++;
}
}
printf("The approximation to the root is %lf",r);
getch();
}
/*A sample run of the program was carried out and the results were found as:-
This program illustrates the bisection method in C
x^3 + 3*x - 5 = 0
Enter the first approximation to the root
1
Enter the second approximation to the root
2
Enter the number of iterations you want to perform
9
The root after 1 iteration is 1.500000
The root after 2 iteration is 1.250000
The root after 3 iteration is 1.125000
The root after 4 iteration is 1.187500
The root after 5 iteration is 1.156250
The root after 6 iteration is 1.146025
The root after 7 iteration is 1.148438
The root after 8 iteration is 1.152344
The root after 9 iteration is 1.154297
The root is 1.154297
*/```

## C Program demonstrating the use of Bitwise Operators

```/*This program demonstartes the bitwise operations OR,XOR,NOT,AND,LEFT SHIFT and RIGHT SHIFT.*/
#include<stdio.h>
int main()
{
int num1,num2,resOR,resAND,resXOR,resNOT,resLSHIFT,resRSHIFT;
printf("This is program to demonstrate the results of bitwise OR,AND,NOT,XOR,LEFT SHIFT and RIGHT SHIFT operations \n");
printf("Enter the numbers on which the operations are to be performed\n");
scanf("%d%d",&num1,&num2);
/*In the OR operatrion the numbers are represented by the computer in binary form and then
Logical OR operation is performed on each subsequent pair.The resulting binary number is converted in decimal form and is the result.*/
resOR=num1|num2;
printf("The result of bitwise OR operation is %d\n",resOR);
/*In the AND operatrion the numbers are represented by the computer in binary form and then
Logical AND operation is performed on each subsequent pair.The resulting binary number is converted in decimal form and is the result.*/
resAND=num1&num2;
printf("The result of bitwise AND operation is %d\n",resAND);
/*In the NOT operatrion the number is represented by the computer in binary form and then
each bit is inverted.The resulting binary number is converted in decimal form and is the result.*/
resNOT=~num1;
printf("The result of bitwise NOT operation on %d is %d\n",num1,resNOT);
resNOT=~num2;
printf("The result of bitwise NOT operation on %d is %d\n",num2,resNOT);
//Logical XOR operation is performed on the indivisual pair of bits.
resXOR=num1^num2;
printf("The result of bitwise XOR operation is %d\n",resXOR);
resLSHIFT=num1<<1;    //The bits are shifted left wards by one place and the MSD occupies the LSD
printf("The result of bitwise LEFT SHIFT by 1 bits operation on %d is %d\n",num1,resLSHIFT);
resLSHIFT=num2<<1;
printf("The result of bitwise LEFT SHIFT by 1 bits operation on %d is %d\n",num2,resLSHIFT);
resRSHIFT=num1>>1; //The bits are shifted right wards by one place and the MSD occupies its place unchanged
printf("The result of bitwise RIGHT SHIFT by 1 bits operation on %d is %d\n",num1,resRSHIFT);
resRSHIFT=num2>>1;
printf("The result of bitwise RIGHT SHIFT by 1 bits operation on %d is %d\n",num2,resRSHIFT);
getch();
}
/*A sample run of the program was carried out and the results were found as:-
This is program to demonstrate the results of bitwise OR,AND,NOT,XOR,LEFT SHIFT and RIGHT SHIFT operations
Enter the numbers on which the operations are to be performed
2 3
The result of bitwise OR operation is 3
The result of bitwise AND operation is 2
The result of bitwise NOT operation on 2 is -3
The result of bitwise NOT operation on 3 is -4
The result of bitwise XOR operation is 1
The result of bitwise LEFT SHIFT by 1 bits operation on 2 is 4
The result of bitwise LEFT SHIFT by 1 bits operation on 3 is 6
The result of bitwise RIGHT SHIFT by 1 bits operation on 2 is 1
The result of bitwise RIGHT SHIFT by 1 bits operation on 3 is 1
*/```

C Program demonstrating the use of Command Line Arguments

```/*A C program is executed as if it is a function called by the Operating System, the Operating System can and does pass parameters to the program.
There are two parameters. These two parameters fully specify the command line that was used to invoke the executing program.
The first parameter is argc. It is an integer that represents the number of white space separated strings on the command line.
For example if we execute program learn , where we pass command line arguments as
learn hello, world then the argc=3
The second parameter is argv.
It is an array of pointers to strings. The strings(represented in a charcter array form) and the array pointer(argv) points to the first string.
If a program is executed (invoked) with a command line that looks like
learn hello, world
then the value of argc is 3 (three), and argv can be diagrammed as
argv
---         ---        -------------------------
|  -|---->  |  -|----> | l | e | a | r | n |\0 |
---        |---|       -------------------------
|  -|----> | h | e | l | l | o | , |\0 |
|---|       -------------------
|  -|----> | w | o | r | l | d |\0 |
|---|       ---------------------------

Each of the values within the boxes to the right (representing each string) is a single character.
argv is the (pointer to the) string "learn".
argv is the (pointer to the) string "hello,".
argv is the (pointer to the) string "world".

In addition, for ANSI standard C, the array element argv[argc] exists, and is defined to be a null pointer. Therefore, the diagram for the example command line given will be:

argv
---         ---        -------------------------
|  -|---->  |  -|----> | l | e | a | r | n |\0 | This is can also be pointed to by argv
---        |---|       ----------------------------
|  -|----> | h | e | l | l | o | , |\0 | This is can also be pointed to by argv
|---|       ----------------------------
|  -|----> | w | o | r | l | d |\0 | This is can also be pointed to by argv
|---|       ---------------------------
| 0 | This points to NULL
|---|
*/
#include<stdio.h>
int main(int argc,char *argv[])
{
int i;
//Displaying the value of the argc
printf("%d\n",argc);
//loop to siplay all the arguments passed after the program name on separate lines
for(i=1;i<argc;i++)
printf("%s%s",argv[i],"\n");//Displaying the argument first and then changing the line
getch();
}
/*
A test run on the program was carried out with arguments being passed as commandline Learning Point is Awsum.commandline here is
the name of the program and rest of the arguments are diplayed indivsually on separate lines after displaying hte number of arguments(argc).
Hence the resulting output was
5
Learning
Point
is
Awsum
*/```

## C Program for an Expression Evaluator

```/*This program in C evaluates very basic arithemtic expressions.
The program converts an infix expression into a postfix expression and then evaluates the postfix expression.
*/
#include<stdio.h>
char expr;//array to store entered expression
char stack;//store the postfix expression
int precedence(char a,char b)
{//returns true if precedence of operator a is more or equal to than that of b
if(((a=='+')||(a=='-'))&&((b=='*')||(b=='/')))
return 0;
else
return 1;
}
int i;
int ctr;
int top=-1;//top of postfix stack
int topOper=-1;//top of operator stack
int operate(int a,int b,char oper)
{
int res=0;
switch(oper)
{
case '+':res=a+b;break;
case '-':res=a-b;break;
case '*':res=a*b;break;//return result of evaluation
case '/':res=a/b;break;
}
return res;
}
void postfixConvert()
{
char topsymb,operatorStack;
ctr=0;
while(expr[ctr]!='\0')
{//read till the end of input
if(expr[ctr]>='0'&&expr[ctr]<='9')
else
{
while(topOper>=0&&precedence(operatorStack[topOper],expr[ctr]))
{//check for the operators of higher precedence and then add them to stack
topsymb=operatorStack[topOper--];
stack[++top]=topsymb;
}
operatorStack[++topOper]=expr[ctr];
}
ctr++;
}
stack[++top]=operatorStack[topOper--];
printf("The Resulting Postfix expression for the given infix expression\n%s\n",stack);
}
int main()
{
printf("\t\tExpression Evaluator\n");
printf("This Program Evaluates Basic Expressions(without brackets) with arithmetic operations(+,-,*,/) on single digit operand length below 20\n");
printf("Enter the Expression\n");
scanf("%s",expr);
postfixConvert();//function to convert in postfix form
char oper;
int operand1,operand2;
ctr=0;
int result;//stack to keep storing results
int rTop=-1;//top of result stack
while(stack[ctr]!='\0')
{
oper=stack[ctr];
if(oper>='0'&&oper<='9')
else
{//if an operator is encountered than pop twice and push the result of operation to the stack
operand1=result[rTop--];
operand2=result[rTop--];
result[++rTop]=operate(operand2,operand1,oper);
}
ctr++;
}
printf("The result of the expression is\n%d\n",result);
getch();
}
/*
A sample run of the program works as:-
Expression Evaluator
This Program Evaluates Basic Expressions(without brackets) with arithmetic operations(+,-,*,/) on single digit operand length below 20
Enter the Expression
2+3*6-5+7+8/4
The Resulting Postfix expression for the given infix expression
236*+5-7+84/+
The result of the expression is
24
*/```

## C Program to demonstrate File Handling Functions

```/*This program demonstrates various operation on files*/
#include<stdio.h>
int main()
{
FILE *fp;//we declare a file pointer fp
//This tries to open the file ReadExample in reading mode present at location C:\Users\Desktop\
//(we have to specify the location of the file before reading it)
if(fp!=NULL)//if fp==NULL then there exists no such file
{
char c="";//by ysing getc we read the file from charcater by character and then dipslay its contents
while(c!=EOF)
{
c=getc(fp);
printf("%c",c);
}
}
else
printf("No such file exists");
char *str;
fscanf(stdin,"%s",str);//The I/O devices can also be treated as files and we use file pointers stdin and stdout for them
//So we use fscanf to read a string from the standard input device and store it in str
fprintf(stdout,"%s",str);////Similarly we use fprintf to write a string to the standard output device
fp=fopen("C:\\Users\\Desktop\\WriteExample.txt","w");
//Now we open the file pointer in write mode and try to open(if exists) or create(if doesnot exist) file WriteExample
fprintf(fp,"The Learning Poin");
putc('t',fp);//We use fprintf and putc to write contents in the file
close(fp);
getch();
}
/*A sample run of the program is found to work as follows:-
The program tries to open the file ReadExample from the specified location and then displays the content of the file on standar O/P device
Otherwise NULL is stored in file pointer. After this the program reads a string from the standard I/P device and diplays it back in standard
O/P device. Then a file WriteExample is created at the specified location and The Learning Point is stored in it using fprintf and put c.
*/```

## C Program to demonstrate the Gaussian Elimination Method

```#include<stdio.h>
double **matrix;
double *temp;
double **coeff;
double *unknownvar;
int variables;
int row,column,inner;
void setdiagonal(int row)
{//this function exchanges rows in case we have the diagonal entries while tranforming as zero
int ctr=0;
while(matrix[row][row]==0)
{
if(row+1!=variables)
{//exchange with the next row until we are not on the last row
temp=matrix[row];
matrix[row]=matrix[row+1];
matrix[row+1]=temp;
temp=coeff[row];
coeff[row]=coeff[row+1];
coeff[row+1]=temp;
}
else
{//exchange the last row with thr first one
temp=matrix[row];
matrix[row]=matrix;
matrix=temp;
temp=matrix[row];
coeff[row]=coeff;
coeff=temp;
}
ctr++;
if(ctr==variables)
{//exchanging the row with all others rows doesnot make diagonal entry non-zero then we do not have a solution
printf("The system of equations can not be solved by gauss elimination method");
getch();
exit(0);
}
}
}
void reduceMatrices()
{//this function reduces the matrix in upper triangular form
double multfactor;
for(row=0;row<variables;row++)
{
if(matrix[row][row]==0)
setdiagonal(row);//set the diagonal if it's entry is 0
for(inner=row+1;inner<variables;inner++)
{
multfactor=matrix[inner][row]/matrix[row][row];//the multfactor is a factor which is used to multiply with a row to make the next row's some entry 0
coeff[inner]=coeff[inner]-multfactor*coeff[row];
for(column=0;column<variables;column++)
matrix[inner][column]=matrix[inner][column]-multfactor*matrix[row][column];
}
}
}
int main()
{
printf("Enter the number of variables\n");
scanf("%d",&variables);
matrix=(double**)malloc(variables*sizeof(double));//declare the matrix to hold the coefficents
coeff=(double **)malloc(variables*sizeof(double));//declare the matrix to hold the rhs coefficients
unknownvar=(double*)malloc(variables*sizeof(double));//declare the matrix of the unknown variables
int i,j;
for(row=0;row<variables;row++)
{
matrix[row]=(double*)malloc(variables*sizeof(double));
coeff[row]=(double*)malloc(variables*sizeof(double));
}
temp=(double*)malloc(variables*sizeof(double));//temporary array used while swapping rows
printf("Enter the coefficent matrix of the unknown variables\n");
for(row=0;row<variables;row++)
for(column=0;column<variables;column++)
scanf("%lf",&matrix[row][column]);
printf("Enter the coefficent matrix of the RHS\n");
for(row=0;row<variables;row++)
scanf("%lf",&coeff[row]);
reduceMatrices();//We call the function to reduce both coefficent matrices to a form to allow apllication of backward substitution
double sum;
for(row=variables-1;row>=0;row--)
{//This is the coding for the backward substitution
sum=coeff[row];
for(column=row+1;column<variables;column++)
sum=sum-matrix[row][column]*unknownvar[column];
if(matrix[row][row]==0)
{//If any diagonal entry in the reduced matrix is 0 we can not find solution
printf("The system of equations can not be solved by gauss elimination method");
getch();
exit(0);
}
unknownvar[row]=sum/matrix[row][row];
}
printf("The unknowns are\n");//display the unknowns
for(row=0;row<variables;row++)
printf("%lf  ",unknownvar[row]);
for(row=0;row<variables;row++)
{
free(matrix[row]);
free(coeff[row]);
}
free(matrix);
free(temp);
free(coeff);
free(unknownvar);
getch();
}
/*A sample run of the program was carried and the resulta were found as:-
Enter the number of variables
3
Enter the coefficent matrix of the unknown variables
0 1 1
2 0 3
1 1 1
Enter the coefficent matrix of the RHS
2
5
3
The unknowns are
1.000000 1.000000 1.000000
*/```

## C Program to compute the GCD (HCF) of two numbers

```/*This program finds out the GCD of two numbers with and without using recursion.
The method using recursion for finding the GCD was given by EUCLID and one can read more about EULICD's algorithm.
*/
#include<stdio.h>
#include<conio.h>
int num1,num2;
int Recursiveapproach(int copy1,int copy2);//recursive function which return the GCD of two numbers
void NonRecursiveapproach(int copy1,int copy2);//non recursive function
int main()
{
int gcd;
printf("This programs demonstrate GCD calculation using recursive and non-recursive approach\n");
printf("\nEnter first number\n");
scanf("%d",&num1);
printf("\nEnter second number\n");
scanf("%d",&num2);
if(num1>num2)//Our first parameter is the larger of the two numbers
gcd=Recursiveapproach(num1,num2);
else
gcd=Recursiveapproach(num2,num1);
printf("The GCD calculated using recursive approach is %d\n",gcd);
NonRecursiveapproach(num1,num2);
getch();
return 0;
}
int Recursiveapproach(int copy1,int copy2)
{/*In the recursive method the larger number is divided by the smaller number ,the remainder is checked and then another call is made with
paramters as smaller number and the remainder*/
if(copy2==0)//when the rmainder passed is zero than we have GCD as the smaller number passed(wiz copy1)
return copy1;
else
Recursiveapproach(copy2,copy1%copy2);
}
void NonRecursiveapproach(int copy1,int copy2)
{
int div=2;//We divide both the numbers with div. We use the prime factorisation method.
int gcd=1;//Initialise the GCD as 1
while(!(copy1==1||copy2==1||div>copy1||div>copy2))
{
if((copy1%div==0)&&(copy2%div==0))
{//If both the numbers are divisible by div then divide and multiply div to the gcd
gcd=gcd*div;
copy1=copy1/div;
copy2=copy2/div;
}
else//Otherwise divide the number which is divisible by div
if((copy1%div==0)&&(copy2%div!=0))
copy1=copy1/div;
else
if((copy1%div!=0)&&(copy2%div==0))
copy2=copy2/div;
else
if((copy1%div!=0)&&(copy2%div!=0))
div++;//else increment div
}
printf("The GCD calculated without using recursion is %d",gcd);
}
/*A sample run of the program was carried out and the results were found as:-
This programs demonstrate GCD calculation using recursive and non-recursive approach
Enter first number
45
Enter second number
36
The GCD calculated using recursive approach is 9
The GCD calculated without using recursion is 9
*/```

## C Program to solve the Josephus Problem

```/*The following program is an implementation of the Josephus Problem in C.
Consider a problem of a group of soldiers overpowered and surrounded by enemy forces. A single soldier can escape and all soldiers stand
in a circle and a number n is picked up and a soldier's name is picked up. Beggining with the soldier whose name is picked they begin to count clock wise
When count reaches n,the soldier is removed and count begins with next soldier. This countinues till only one soldier remains. Josephus Problem
is to determine the soldier which escapes.
*/
#include<stdio.h>
struct node
{
struct node *next;//stroes address to next node
char name;//stroes the name
}*start;//points to beginning of the list
typedef struct node *Nodeptr;
{
Nodeptr temp=(struct node *)malloc(sizeof(struct node));//newly declared node
Nodeptr move;
move=start;//points to the start
if(temp==NULL)
{
printf("OverFlow\n");
return;//can not allocate space so return
}
while((move->next)!=NULL)
move=move->next;//move to appropriate place to add new node to end
strcpy(temp->name,namePassed);
temp->next=NULL;
move->next=temp;
}
int main()
{
char choice;
start=(Nodeptr)malloc(sizeof(struct node));
printf("\t\tJosephus Problem\n");
printf("Enter the name \n");//Enter the begining node
scanf("%s",start->name);
start->next=NULL;
printf("Enter end to stop entering data otherwise enter the name\n");
scanf("%s",choice);
while(strcmp(choice,"end")!=0)
{
printf("Enter end to stop entering data otherwise enter the name\n");
scanf("%s",choice);
}
Nodeptr move=start;
while((move->next)!=NULL)
move=move->next;
move->next=start;//Make the list circular by making the end point to start
move=start;
int count;//takes the count after which the soldier is removed
char begin;//stores name of soldier to begin with
printf("Enter the count after which deletion is to happen and Enter the name of starting soldier\n");
scanf("%d%s",&count,begin);
int ctr=0;
while(strcmp(move->name,begin)!=0)
int pass=1;
while(move->next!=move)//when move->next==move than we have only one soldier left
{
ctr++;
if(ctr==count-1)//delete next node
{
Nodeptr temp=move->next;
move->next=temp->next;
printf("The soldier who eliminated in pass number %d is %s\n",pass,temp->name);
free(temp);//free space
ctr=0;
pass++;
}
move=move->next;
}
printf("The soldier who escapes is %s\n",move->name);
getch();
}
/*A sample run of the program works as:-
Josephus Problem
Enter the name
A
Enter end to stop entering data otherwise enter the name
B
Enter end to stop entering data otherwise enter the name
C
Enter end to stop entering data otherwise enter the name
D
Enter end to stop entering data otherwise enter the name
E
Enter end to stop entering data otherwise enter the name
end
Enter the count after which deletion is to happen and Enter the name of starting soldier
3
A
The soldier who eliminated in pass number 1 is C
The soldier who eliminated in pass number 2 is A
The soldier who eliminated in pass number 3 is E
The soldier who eliminated in pass number 4 is B
The soldier who escapes is D
*/```

## C Program to demonstrate operations on Matrices

```/*This program performs matrix addition ,subtraction, multiplication ,finds the determinant and inverse of the entered matrices.*/
#include<stdio.h>
float **matrixA;//for the first matrix
float **matrixB;//for the second matrix
float **matrixRes;//for the results of additon,multiplication and subtraction matrix
int rowA,columnA,rowB,columnB,row,column,navigate;//rowA,columnA,rowB,columnB store sizes of A and B row and column are counters
if((rowA==rowB)&&(columnA==columnB))
{
printf("A+B\n");//Unless the dimensions are same addition not possible
matrixRes=(float **)malloc(rowA*sizeof(float));
for(row=0;row<rowA;row++)
matrixRes[row]=(float *)malloc(columnA*sizeof(float));
for(row=0;row<rowB;row++)
{
for(column=0;column<columnB;column++)
{
printf("%.2f ",matrixRes[row][column]);
}
printf("\n");
}
for(row=0;row<rowA;row++)
free(matrixRes[row]);
free(matrixRes);
}
else
}
void sub()
{
if((rowA==rowB)&&(columnA==columnB))
{//unless dimension are smae subtraction not possible
printf("A-B\n");
matrixRes=(float **)malloc(rowA*sizeof(float));
for(row=0;row<rowA;row++)
matrixRes[row]=(float *)malloc(columnA*sizeof(float));//dynamic allocation
for(row=0;row<rowB;row++)
{
for(column=0;column<columnB;column++)
{
matrixRes[row][column]=matrixA[row][column]-matrixB[row][column];//subtracting the corresponding elements
printf("%.2f ",matrixRes[row][column]);
}
printf("\n");
}
for(row=0;row<rowA;row++)
free(matrixRes[row]);
free(matrixRes);
}
else
printf("Incompatible for subtraction\n");
}
void mult()
{
if((columnA==rowB))
{//for two matrices to allow for multiplication number of column of first matrix should be equal to number of rows in other matrix
printf("A*B\n");
matrixRes=(float **)malloc(rowA*sizeof(float));
for(row=0;row<rowA;row++)
matrixRes[row]=(float *)malloc(columnB*sizeof(float));
for(row=0;row<rowB;row++)
{
for(column=0;column<columnB;column++)
{//code to multiply two matrices
matrixRes[row][column]=0;
for(navigate=0;navigate<columnA;navigate++)
matrixRes[row][column]+=matrixA[row][navigate]*matrixB[navigate][column];
printf("%.2f ",matrixRes[row][column]);
}
printf("\n");
}
for(row=0;row<rowA;row++)
free(matrixRes[row]);
free(matrixRes);
}
else
printf("Incompatible for multiplication\n");
}
float determinant(float **matrix,int size)
{
//A recursive function to get the determinant
float **temp;//the temporary matrix to store subsequent smaller matrix
float det=0;//initalise value of deteminant zero

if(size==1)
det=matrix;//in case the matrix passed has size 1
else
if(size==2)
det=matrix*matrix-matrix*matrix;//in case the matrix passed has size 2
else
{

int cctr,ictr,ctr;
for(column=0;column<size;column++)
{//now we create another matrix properly exculding the first row and the element's corresponding colummn and then find its resulting determinant
temp=(float **)malloc((size-1)*sizeof(float));
for(ctr=0;ctr<size-1;ctr++)
temp[ctr]=(float *)malloc((size-1)*sizeof(float));
for(ctr=1;ctr<size;ctr++)
{
cctr=0;
for(ictr=0;ictr<size;ictr++)
{
if(ictr==column)
continue;
temp[ctr-1][cctr]=matrix[ctr][ictr];
cctr++;
}
}
det=det+pow(-1,column)*matrix[column]*determinant(temp,size-1);//pass the new matrix
for(ctr=0;ctr<size-1;ctr++)
free(temp[ctr]);
free(temp);
}
}
return det;//return claculated determinant
}
void matrixInverse(float **matrix,int size,float res)
{
float **tem;//matrix to store smaller matrix whose determinant we find out
int ctr,ictr,rowT,columnT;
float **matrixCft;
matrixCft=(float **)malloc(size*sizeof(float));//matrix to store cofactor matrix
tem=(float **)malloc((size-1)*sizeof(float));
for(ctr=0;ctr<size-1;ctr++)
tem[ctr]=(float *)malloc((size-1)*sizeof(float));
for(ctr=0;ctr<size;ctr++)
matrixCft[ctr]=(float *)malloc(size*sizeof(float));
for(row=0;row<size;row++)
{
for(column=0;column<size;column++)
{//we in these loops calculate the smaller matrix which is we pass to the determinant function which allows us to calculate the cofactors
rowT=0;
columnT=0;
for(ctr=0;ctr<size;ctr++)
for(ictr=0;ictr<size;ictr++)
if(ctr!=row&&ictr!=column)
{
tem[rowT][columnT++]=matrix[ctr][ictr];
if(columnT==size-1)
{
rowT++;
columnT=0;
}
}
matrixCft[row][column]=pow(-1,(row+column))*determinant(tem,size-1);//multiplying the minor obtained with appropriate power of -1 to get the cofactor
}
}
for(column=0;column<size;column++)
for(row=0;row<size;row++)
matrixCft[column][row]=matrixCft[column][row]/res;//In this step i divide the cofactor matrix with the determinant of the matrix
float **Result;
Result=(float **)malloc(size*sizeof(float));
for(ctr=0;ctr<size;ctr++)
Result[ctr]=(float *)malloc(size*sizeof(float));
for(column=0;column<size;column++)
for(row=0;row<size;row++)
Result[column][row]=matrixCft[row][column];//calulating the transpose of the cofactor matrix
for(row=0;row<size;row++)
{
for(column=0;column<size;column++)
printf("%.2f ",Result[row][column]);
printf("\n");//display the inverse
}
for(ctr=0;ctr<size-1;ctr++)
free(tem[ctr]);
free(tem);
for(row=0;row<size;row++)
{
free(Result[row]);
free(matrixCft[row]);
}
free(Result);
free(matrixCft);
}
int main()
{
printf("Enter the number of rows and column in A\n");
scanf("%d%d",&rowA,&columnA);
printf("Enter the number of rows and column in B\n");
scanf("%d%d",&rowB,&columnB);//entering sizes
matrixA=(float **)malloc(rowA*sizeof(float));
matrixB=(float **)malloc(rowB*sizeof(float));
for(row=0;row<rowA;row++)
matrixA[row]=(float *)malloc(columnA*sizeof(float));
for(row=0;row<rowA;row++)
matrixB[row]=(float *)malloc(columnB*sizeof(float));
printf("Enter the matrix A\n");
for(row=0;row<rowA;row++)//entering the matrices
for(column=0;column<columnA;column++)
scanf("%f",&matrixA[row][column]);
printf("Enter the matrix B\n");
for(row=0;row<rowB;row++)
for(column=0;column<columnB;column++)
scanf("%f",&matrixB[row][column]);
sub();
mult();
if(rowA==columnA)
{//It is only possible to find detrminant and inverse for square matrix so checking that condition
float resA=determinant(matrixA,rowA);
printf("Determinant of matrix A is %.2f\n",resA);
if(resA!=0)
{//If determinant is zero than inverse can not be calculated
printf("The matrix inverse is\n");
matrixInverse(matrixA,rowA,resA);
}
else
printf("The inverse can not be calculated\n");
}
else
{
printf("Determinant of matrix A can not be calculated\n");
printf("Inverse of matrix A can notbe calculated\n");
}
if(rowB==columnB)
{
float resB=determinant(matrixB,rowB);
printf("Determinant of matrix B is %.2f\n",resB);
if(resB!=0)
{//Similarly operate on matrix B
printf("The matrix inverse is\n");
matrixInverse(matrixB,rowB,resB);
}
else
printf("The inverse can not be calculated");
}
else
{
printf("Determinant of matrix B can not be calculated\n");
printf("Inverse of matrix B can not be calculated\n");
}
for(row=0;row<rowA;row++)
free(matrixA[row]);
for(row=0;row<rowB;row++)
free(matrixB[row]);
free(matrixA);
free(matrixB);
getch();
}
/*A sample run of the program is found to give rseult as:-
Enter the number of rows and column in A
3
3
Enter the number of rows and column in B
3
3
Enter the matrix A
4 5 6
4 4 7
8 9 0
Enter the matrix B
1 2 3
5 6 7
3 2 1
A+B
5.00 7.00 9.00
9.00 10.00 14.00
11.00 11.00 1.00
A-B
3.00 3.00 3.00
-1.00 -2.00 0.00
5.00 7.00 -1.00
A*B
47.00 50.00 53.00
45.00 46.00 47.00
53.00 70.00 87.00
Determinant of matrix A is 52.00
The matrix inverse is
-1.21 1.04 0.21
1.08 -0.92 -0.08
0.08 0.08 -0.08
Determinant of matrix A is 0.00
Inverse of matrix B can not be calculated
*/```

## C Program implementing the Newton Raphson Method (Numerical Computing)

```/*This program in C illustrates the Newton Raphson method.
This program calulate the approximation to the root of x*x-5.
The maximum error between 2 succesive approximation is taken as input from the user
alongwith the maximum number of iterations and the initial approximation.
*/
#include<stdio.h>
#include<math.h>
double F(double x)
{//our function
return ((x)*(x)-5);
}
double Fd(double x)
{//function's differentiation
return (2*(x));
}
int main()
{
double x0,h,err,root,x1;
int miter,iter;
printf("Enter the first approximation ,the max error and the maximum number of iterations\n");
scanf("%lf%lf%d",&x0,&err,&miter);
iter=1;
while(iter<=miter)
{
h=F(x0)/Fd(x0);//calculatinf f(x)/f'(x)as we do in Newton Raphson method
x1=x0-h;//x1=x0-f(x)/f'(x)
printf("The approximation's value after %d iteration is %.12lf\n",iter,x1);
if(fabs(h)<err)//If the difference between the 2 approximations is below the max error
{
root=x1;//then make the approximation as the root
break;
}
else
x0=x1;
iter++;
}
if(root==x1)
{//display root and the function value
printf("The root is: %.12lf\n",root);
double fncvalue = F(root);
printf("Value of F(root) is: %.12lf",fncvalue);
}
else
printf("The unsufficent number of iteration");//In case root!=x1 then number of iteration were insufficient
getch();
}
/*A sample run of thje program was carried out and the results were found to be as:-
Enter the first approximation ,the max error and the maximum number of iterations
2
0.0000000001
7
The approximation's value after 1 iteration is 2.250000000000
The approximation's value after 2 iteration is 2.236111111111
The approximation's value after 3 iteration is 2.236067977916
The approximation's value after 4 iteration is 2.236067977500
The approximation's value after 5 iteration is 2.236067977500
The root is: 2.236067977500
Value of F(root) is: 0.000000000000
*/```

## C Program to check whether a string is a palindrome or not

```/*The following program checks whether a string is plaindrome or not.*/
#include<stdio.h>
#include<string.h>
int main()
{
char word;//The array to store the word entered
char *temp;
int ctr;
printf("Enter the word(in lower case) to check whether it is palindrome or not(Length of the word must be below 20)\n");
scanf("%s",word);
int length=strlen(word);//We get the length of the string entered
temp=(char*)malloc(length*sizeof(char));//We create a temprary array to store the word while being reversed
for(ctr=0;ctr<=length;ctr++)
temp[ctr]=word[length-ctr-1];
temp[length]='\0';//terminate with null
if(strcmp(word,temp)==0)//Then compare the initial and the reversed string
printf("The word is a Palindrome");
else
printf("The word is not a Palindrome");
getch();
}
/*This program is made keeping in mind all the characters are in the same case.
A sample run of the program is found to work as follows:-
Enter the word(in lower case) to check whether it is palindrome or not(Length of the word must be below 20)
The word is a Palindrome*/```

## C Program to print the Pascal Triangle

```/*This program prints the Pascal's triangle
The number of terms to be displayed is given as input by the user.
At the tip of Pascal's Triangle is the number 1, which makes up the zeroth row.
The first row contains two 1's, at the end both .
Do the same to create the 2nd row,make the elements at the ends as 1 and by adding the two numbers above and to the left and the right 1+1=2.
And the third: 1+2=3; 2+1=3.
In this way, the rows of the triangle go on infinitly.
A number in the triangle can also be found by nCr (n Choose r) where n is the number of the row and r is the element in that row.
*/
#include<stdio.h>
int main()
{
int **tri;//A 2-D array is used to store the triangle
int terms,ictr,octr;
printf("Enter the number of terms you want to see in the triangle\n");
scanf("%d",&terms);
printf("\nPASCAL TRIANGLE\n");
tri=(int **)malloc(terms*sizeof(int));
for(ictr=0;ictr<terms;ictr++)
{
tri[ictr]=(int *)malloc((ictr+1)*sizeof(int));
for(octr=0;octr<ictr+1;octr++)
if(octr==0||octr==ictr)
tri[ictr][octr]=1;//making elements at the ends as 1
else
tri[ictr][octr]=tri[ictr-1][octr-1]+tri[ictr-1][octr];//for any other element add the elemnt of previous row
}
for(ictr=0;ictr<terms;ictr++)
{//display the triangle
for(octr=0;octr<ictr+1;octr++)
printf("%d ",tri[ictr][octr]);
printf("\n");
free(tri[ictr]);
}
free(tri);
getch();
}
/*A sample run of the program was carried out and the results were found as:-
Enter the number of terms you want to see in the triangle
7
PASCAL TRIANGLE
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
*/```

## C Program to display Prime Numbers using the sieve of Eratosthenes

```/*This is a simple program to display all the prime numbers till a given range using Eratosthenes' method:
To find all the prime numbers less than or equal to a given integer n by Eratosthenes' method:

1.    Create a list of consecutive integers from 2 to n: (2, 3, 4, ..., n).
2.    Initially, let p equal 2, the first prime number.
3.    Starting from p, count up in increments of p and mark each of these numbers greater than p itself in the list.
These numbers will be 2p, 3p, 4p, etc.; note that some of them may have already been marked.
4.    Find the first number greater than p in the list that is not marked.
If there was no such number, stop. Otherwise, let p now equal this number (which is the next prime), and repeat from step 3.
*/
#include<stdio.h>
void Eratosthenes(int n)
{
int boolean[n-1];//boolean array holds 0 if the numbers is not prime
int list[n-1];//store the numbers till given range from 2 onwards
int ctr,outctr,inctr,primeassm;
for(ctr=0;ctr<n-1;ctr++)
{
list[ctr]=ctr+2;//start storing numbers from 2 onwars
boolean[ctr]=1;//assume all to be prime
}
for(outctr=0;outctr<n/2+1;outctr++)
{
if(boolean[outctr]==1)
{
primeassm=list[outctr];//perform primality check for indivusal numbers
for(inctr=outctr+1;inctr<n-1;inctr++)
if(list[inctr]%primeassm==0)//if divisible set boolean to 0
boolean[inctr]=0;
}
}
printf("\nThe prime numbers till the given range are\n");
for(ctr=0;ctr<n-1;ctr++)
if(boolean[ctr]==1)//display the list of prime numbers
printf("%d\n",list[ctr]);
}
int main()
{
int num;
printf("ENTER THE RANGE WITHIN WHICH YOU WANT TO SEE THE PRIME NUMBERS\n");
scanf("%d",&num);
Eratosthenes(num);

getch();
}
/* A sample run of the program works as:-
ENTER THE RANGE WITHIN WHICH YOU WANT TO SEE THE PRIME NUMBERS
30
The prime numbers till the given range are
2
3
5
7
11
13
17
19
23
29
*/```

## C Program for the Producer - Consumer Problem

```/*The problem describes two processes, the producer and the consumer, who share a common, fixed-size buffer.
The producer's job is to generate a piece of data, put it into the buffer and start again.
At the same time, the consumer is consuming the data (i.e., removing it from the buffer) one piece at a time.
The problem is to make sure that the producer won't try to add data into the buffer if it's full and that the consumer won't try to remove data from an empty buffer.
The solution for the producer is to either go to sleep or discard data if the buffer is full.
The next time the consumer removes an item from the buffer, it notifies the producer, who starts to fill the buffer again.
In the same way, the consumer can go to sleep if it finds the buffer to be empty. The next time the producer puts data into the buffer, it wakes up the sleeping consumer.
*/
#include<stdio.h>
void displayContent(int size,int stack[])
{
//This function displays the stack's of producer and consumer
int ctr;
if(size==0)
printf("Empty state\n");
else
for(ctr=1;ctr<=size;ctr++)
printf("\t%d",stack[ctr]);
printf("\n");
}
int main()
{
int choice;
int size;
int sizeprod=0;//variables for size of the producer and consumer
int sizecons=0;
int producer;
int consumer;
printf("Enter Producer Consumer size :\n",size);
scanf("%d",&size);
while(1)
{
printf("Producer Stack  (Stack Size : %d)\n",size);
displayContent(sizeprod,producer);
printf("Consumer Stack (Stack Size : %d)\n",size);
displayContent(sizecons,consumer);
printf("Enter the choice 1 to add data to buffer(Producer)\n");
printf("Enter the choice 2 to remove data from buffer(Consumer)\n");
printf("Enter the choice 3 to exit\n");
switch(choice)
{
case 1:
if(sizeprod==size)
printf("Produer stack is full.\n");
else//add to producer if space is there
{
sizeprod++;
printf("Enter producer item :");
scanf("%d",&producer[sizeprod]);
}
break;
case 2:
if(sizecons==size)
{//consume one lement if not empty
printf("Consumer Stack is full.\nReset the Cosumer Stack\n",sizecons);
sizecons=0;
}
else if(sizeprod==0)
printf("Producer stack is empty\n");
else
{
sizecons++;
consumer[sizecons]=producer[sizeprod];
printf("Consume one item\n");
sizeprod--;
}
break;
case 3:
return 1;

default:
printf("Incorrect choice enter again\n");
}
getch();
}
}
/*
Enter Producer Consumer size :
3
Producer Stack (Stack Size : 3)
Empty state
Consumer Stack (Stack Size : 3)
Empty state

Enter the choice 1 to add data to buffer(Producer)
Enter the choice 2 to remove data from buffer(Consumer)
Enter the choice 3 to exit
1
Enter producer item :10
Producer Stack (Stack Size : 3)
10
Consumer Stack (Stack Size : 3)
Empty state

Enter the choice 1 to add data to buffer(Producer)
Enter the choice 2 to remove data from buffer(Consumer)
Enter the choice 3 to exit
2
Consume one item
Producer Stack (Stack Size : 3)
Empty state
Consumer Stack (Stack Size : 3)
10
Enter the choice 1 to add data to buffer(Producer)
Enter the choice 2 to remove data from buffer(Consumer)
Enter the choice 3 to exit
1
Enter producer item :20
Producer Stack (Stack Size : 3)
20
Consumer Stack (Stack Size : 3)
10
Enter the choice 1 to add data to buffer(Producer)
Enter the choice 2 to remove data from buffer(Consumer)
Enter the choice 3 to exit
3
*/```

## C Program for the Reader - Writer Problem

```/*
The following is a very basic program to illustrate Reader Writer problem.
The reader writer problem consists of readers and writers which share a data resource.
The reader reads data from the resource, the writers writes the data to it.
There is no problem if two or more readers access the resource simultaneously.
But if a writer and a reader or two writers access the resource simultaneously, the result becomes indeterminable.
*/
#include<stdio.h>
#include<conio.h>
#include<string.h>
int choiceA,choiceB,ctr;
char c;
char buffer;
char *g;
FILE *fr,*fw;//file pointers
{//The function to read file contents
fr=fopen("C:\\Users\\Desktop\\Example.txt","r");
printf("\n File content is:\n");
while(!feof(fr))//read till we reach the end of the file
{
c[ctr]=getc(fr);//read the contents to array c
printf("%c",c[ctr]);
ctr++;
}
fclose(fr);//close file pointer
}
void writefile()
{//The function to write contents
scanf("%s",buffer);
fw=fopen("C:\\Users\\Desktop\\Example.txt","w");
fprintf(fw,"%s",buffer);//writer operation
fclose(fw);//close file pointer
}
int main()
{
do
{
printf("\nEnter choice 1 to read\n \nEnter choice 2 to write\n \nEnter choice 3 to exit");//enter choice from user
scanf("%d",&choiceA);
scanf("%d",&choiceB);
if(choiceA==1&&choiceB==1)
{
printf("\nBoth users can read\n");//when both users want to read then we have no ambiguity
}
if((choiceA==2&&choiceB==3)||(choiceA==3&&choiceB==2))
{
writefile();
}
if((choiceA==1&&choiceB==3)||(choiceA==3&&choiceB==1))
{
}
else
}
while(choiceA!=3&&choiceB!=3);
getch();
}
/*A sample run of the program works as:-
Enter choice 2 to write
Enter choice 3 to exit
1
1
{The contents of the file example are diplayed}
Enter choice 2 to write
Enter choice 3 to exit
1
2
*/
```

## C Program to demonstrate the Dining Philosopher problem

```/*
The following program illustrates the dining philosopher problem in C.The problem can be described as follows(adapted from en.wikipedia.org/wiki/Dining_philosophers_problem):-
Five silent philosophers sit at a table around a bowl of rice. A spoon is placed between each pair of adjacent philosophers.
Each philosopher must alternately think and eat. Eating is not limited by the amount of rice left.
However, a philosopher can only eat while holding both the spoon to the left and the fork to the right
Each philosopher can pick up an adjacent spoon, when available, and put it down, when holding it.
These are separate actions: spoon must be picked up and put down one by one.
*/
#include<stdio.h>
char statePhil,self,spoon;
void test(int k)
{
if((statePhil[(k+4)%5]!='e')&&(statePhil[k]=='h')&&(statePhil[(k+1)]!='e'))
{//check whether the alternate philosopher's are eating or not and check the philosopher's state to be hungry
statePhil[k]='e';
self[k]='s';
//set alternate spoon not available
spoon[k]='n';
spoon[(k+4)%5]='n';
}
}
void pickupSpoon(int ctr)
{//This function checks whether a philosopher can pick up the spoon for eating or not
statePhil[ctr]='h';//set philospher's state to hungry
test(ctr);//check whether the alternate spoons are available or not
if(statePhil[ctr]=='h')//if the state is wtill hungy
self[ctr]='w';//change to waiting
}
void putdownSpoon(int ctr)
{
statePhil[ctr]='t';//set the state of philosopher to thinking
spoon[ctr]='s';//make the alternate spoons available
if(ctr!=0)
spoon[ctr-1]='s';
else
spoon[(ctr+4)%5]='s';
test((ctr+4)%5);//Also check if the alternate neighbour is in waiting state and if so make it eat
test((ctr+1)%5);
}
main()
{
int ch,n,ctr;
printf("\n Dining Philosopher's Problem:");
for(ctr=0;ctr<5;ctr++)
{//set all initial states as thinking all spoons as available and all philosopher satisfied
statePhil[ctr]='t';
self[ctr]='s';
spoon[ctr]='s';
}
printf("\n Initial state of each philososphers:");
printf("\n Phil No : \t Think/Eat \t Status \t\t Spoon");
printf("\n %d \t\t %c \t\t %c \t\t %c",ctr+1,statePhil[ctr],self[ctr],spoon[ctr]);
printf("\n Enter 1 to Exit \n Enter 2 if philosopher is Hungry \n Enter 3 if philosopher is Thinking");
scanf("%d",&ch);
while(ch!=1)
{
switch(ch)
{
case 1:
return 0;
case 2:
printf("\n Enter which philosophers is Hungry :");
scanf("%d",&n);
pickupSpoon(n-1);//call for pick spoon to pick the spoon up
break;
case 3:
printf("\n Enter which Philosopher is Thinking :");
scanf("%d",&n);
putdownSpoon(n-1);//put down the spoon if philospher is thinking
break;
}
printf("\n State of each Philosepher :");
printf("\n Phil no: \t Think/Eat \t Status \t\t Spoon");
for(ctr=0;ctr<5;ctr++)
printf("\n %d \t\t %c \t\t %c \t\t %c",ctr+1,statePhil[ctr],self[ctr],spoon[ctr]);
printf("\n Enter 1 to Exit \n Enter 2 if philosopher is Hungry \n Enter 3 if philosopher is Thinking");
scanf("%d",&ch);
}
getch();
}
/*A sample run of the program works as:-
Dining Philosopher's Problem:
Initial state of each philososphers:
Phil No :    Think/Eat     Status     Spoon
1           t           s       s
2           t           s       s
3           t           s       s
4           t           s       s
5           t           s       s
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Hungry :3
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           t           s       s
2           t           s       n
3           e           s       n
4           t           s       s
5           t           s       s
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Hungry :2
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           t           s       s
2           h           w       n
3           e           s       n
4           t           s       s
5           t           s       s
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Hungry :5
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           t           s       s
2           h           w       n
3           e           s       n
4           t           s       n
5           e           s       n
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Hungry :1
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           h           w       s
2           h           w       n
3           e           s       n
4           t           s       n
5           e           s       n
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Thinking :5
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           e           s       n
2           h           w       n
3           e           s       n
4           t           s       s
5           t           s       n
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Thinking :3
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           e           s       n
2           h           w       s
3           t           s       s
4           t           s       s
5           t           s       n
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
Enter which philosophers is Thinking :1
State of each Philosepher :
Phil No :    Think/Eat     Status     Spoon
1           t           s       n
2           e           s       n
3           t           s       s
4           t           s       s
5           t           s       s
Enter 1 to Exit
Enter 2 if philosopher is Hungry
Enter 3 if philosopher is Thinking
*/```

C Program to find the roots of Quadratic Equations

```/*The following program finds out the roots of a quadriatic equation by taking the coefficents as the input
from the user.*/
#include<stdio.h>
#include<math.h>
int main()
{
double a,b,c;
printf("Enter the coefficents of the quadriatic equation of the form ax^2+bx+c\n");
scanf("%lf%lf%lf",&a,&b,&c);//We ask for the coefficents from the user
double D=pow(b,2)-4*a*c;
if(D<0)//We check the determinant whether it is greater or lesser than zero and accordingly find real or imaginary roots
{
printf("The roots are imaginary\n");
double real,img;
real=(-1*b)/(2*a);//The real part of the root
img=sqrt(-1*D)/(2*a);//The imaginary part of the root
printf("The first root is %lf+i%lf\n",real,img);
printf("The first root is %lf-i%lf\n",real,img);
}
if(D>=0)
{
printf("The roots are real\n");
if(D!=0)
{   //We find both roots if D>0
double root1=(-1*b+sqrt(D))/(2*a);
double root2=(-1*b-sqrt(D))/(2*a);
printf("The first root is %lf\n",root1);
printf("The second root is %lf\n",root2);
}
else
{   //We find the root if D==0 and display that we have equal roots
double root=(-1*b)/(2*a);
printf("The roots are equal\n");
printf("The root is %lf\n",root);
}
}
getch();
}
/*A sample run of the program is found to work as follows:-
Enter the coefficents of the quadriatic equation of the form ax^2+bx+c
1 5 6
The roots are real
The first root is -2.000000
The second root is -3.000000
*/```

## C Program to reverse the order of words in a sentence

```/* This is a program in C to reverse the order of words in a line of text.
*/
#include<stdio.h>
#include<string.h>
int main()
{
char *text=(char *)malloc(100*sizeof(char));//the array to store the entered sentence
char *temp=(char *)malloc(10*sizeof(char));//used for storing words
printf("Enter the line of text(length<100 and word length <10)\n");
gets(text);//use gets
int ctr=0;
int words=1;//initalize words as one because there would be atleast one word
int row;
while(text[ctr]!='\0')
if(text[ctr++]==' ')
words++;//count number of words by counting spaces
char **word=(char **)malloc(words*sizeof(char));//A 2-D array of words is made
for(row=0;row<words;row++)
word[row]=(char *)malloc(10*sizeof(char));
int len=0;
row=0;
while(len<strlen(text))
{
sscanf(text+len,"%s",temp);//scanf from appropriate length
strcpy(word[row++],temp);//copy the extracted word to the 2D array
len=len+strlen(temp)+1;//scan the next word so sum up the length for previous word and 1 for the space
}
char *swaptemp=(char *)malloc(10*sizeof(char));
for(row=0;row<words/2;row++)
{
strcpy(swaptemp,word[row]);//swap the first with last second with second last and so on
strcpy(word[row],word[words-row-1]);
strcpy(word[words-row-1],swaptemp);
}
strcpy(text,"");
for(row=0;row<words;row++)
{
strcat(text,word[row]);
strcat(text," ");//form the new text by concatenating the reverse words
}
printf("%s",text);
getch();
}
/*A sample run of the program works as:-
Enter the line of text(length<100 and word length <10)
The best place to learn is learning point
point learning is learn to place best The
*/```

## C Program to reverse a string

```/*The following program reverses a string of length below 20 characters entered by the user*/
#include<stdio.h>
#include<string.h>
int main()
{
char word;
char *temp;//This will be our temporary array to store the string while being reversed
int ctr;
printf("Enter the word to reverse(Length of the word must be below 20)\n");
scanf("%s",word);
int length=strlen(word);//strlen function returns the length of the string. Here it returns length of the string stored in word.
temp=(char*)malloc(length*sizeof(char));//We create a temprary array of required length
for(ctr=0;ctr<length;ctr++)
temp[ctr]=word[length-ctr-1];
temp[length]='\0';//We terminate the string with null character as it is required that a string should end with null character
printf("The reversed string is %s\n",temp);
free(temp);//free the memory
getch();
}
/*A sample run of the program was done and output was:-
Enter the word to reverse(Length of the word must be below 20)
rabbit
The reversed string is tibbar
*/```

## C Program to demonstrate the values in the series expansion of exp(x),sin(x),cos(x),tan(x)

```/*The following program demonstrates the values of series expansion of
exp(x),sine(x),cosine(x) and tan(x).*/
#include<stdio.h>
#include<math.h>
int factorial(int num)
{
int ctr;
int fact=1;//This function calculates and returns the factorial of number num
for(ctr=1;ctr<=num;ctr++)
fact=fact*ctr;
return fact;
}
int main()
{
int terms;
int ctr;
printf("Enter the number of terms till which you want to calculate the value of expansion\n");
scanf("%d",&terms);//Enter the number of terms
double sum=0.0;
double x;
printf("Enter the value for x\n");
scanf("%lf",&x);
printf("1+x+x^2/2!+x^3/3!.......This series when expanded till infinity is expansion for exp(x)\n");
for(ctr=0;ctr<terms;ctr++)
sum+=pow(x,ctr)/factorial(ctr);//finding the value for sum appropriately
printf("The value from the expansion is %.14lf\n",sum);
sum=0.0;
printf("1-x^2/2!+x^4/4!.......This series when expanded till infinity is expansion for cosine(x)\n");
for(ctr=0;ctr/2<terms;ctr+=2)
sum=sum+pow(-1,ctr/2)*pow(x,ctr)/(factorial(ctr));
printf("The value from the expansion is %.14lf\n",sum);
sum=0.0;
printf("x-x^3/3!+x^5/5!.......This series when expanded till infinity is expansion for sine(x)\n");
for(ctr=1;(ctr-1)/2<terms;ctr+=2)
sum=sum+pow(-1,(ctr-1)/2)*pow(x,ctr)/(factorial(ctr));
printf("The value from the expansion is %.14lf\n",sum);
printf("x+x^3/3+2x^5/15.......This series when expanded till infinity is expansion for tan(x)\n");
sum=0.0;
double B,temp;
int Bn,k,r;
for(ctr=1;ctr<=terms;ctr+=1)
{//This loops here calculate Bernoulli number which is further used to get the coefficient in expansion of tan x
B=0;
Bn=2*ctr;
for(k=0;k<=Bn;k++)
{
temp=0;
for(r=0;r<=k;r++)
{
temp=temp+pow(-1,r)*factorial(k)*pow(r,Bn)/(factorial(r)*factorial(k-r));
}
B=B+temp/((double)(k+1));
}
sum=sum+pow(-4,ctr)*(1-pow(4,ctr))*B*pow(x,2*ctr-1)/factorial(2*ctr);
}
printf("The value from the expansion is %.14lf\n",sum);
getch();
}
/* A sample run of the program works as:-
Enter the number of terms till which you want to see
6
Enter the value for x
1
1+x+x^2/2!+x^3/3!.......This series when expanded till infinity is expansion for exp(x)
The value from the expansion is 2.71666666666667
1-x^2/2!+x^4/4!.......This series when expanded till infinity is expansion for cosine(x)
The value from the expansion is 0.54030230379189
x-x^3/3!+x^5/5!.......This series when expanded till infinity is expansion for sine(x)
The value from the expansion is 0.84147098464807
x+x^3/3+2x^5/15.......This series when expanded till infinity is expansion for tan(x)
The value from the expansion is 1.55137626113259
*/```

## C Program to demonstrate common operations on Sets

```#include<stdio.h>
int *setA,*setB;
int ctr,octr,ictr,sizeA,sizeB;
void unionsets()
{//The function to calculate union of two sets
int *unions=(int *)malloc((sizeA+sizeB)*sizeof(int));
ctr=0;//array unions declared to hold size of max possible union set
for(octr=0;octr<sizeA;octr++)
unions[ctr++]=setA[octr];//copy Set A
for(octr=0;octr<sizeB;octr++)
{
int flag=0;//Copy those elements of set B which are not in set A
for(ictr=0;ictr<sizeA;ictr++)
{
if(setA[ictr]==setB[octr])
flag=1;//flag keeps track whether element is found or not
}
if(flag==0)
unions[ctr++]=setB[octr];
}
printf("\nA Union B is \n");
for(octr=0;octr<ctr;octr++)//display set
printf("%d\t",unions[octr]);
free(unions);

}
void intersection()
{
int size;
if(sizeA>=sizeB)
size=sizeB;
else//the sizxe of intersection set will be of the size of the smaller of two sets
size=sizeA;
ctr=0;
int *intersection=(int *)malloc(size*sizeof(int));
for(octr=0;octr<sizeA;octr++)
{
for(ictr=0;ictr<sizeB;ictr++)
{
if(setA[octr]==setB[ictr])//copy those elemts which are common to both
intersection[ctr++]=setB[ictr];
}
}
printf("\nA Intersection B is \n");
if(ctr==0)
{//if no elemnts are there show null and return
printf("NULL");
return;
}//display
for(octr=0;octr<ctr;octr++)
printf("%d\t",intersection[octr]);
free(intersection);

}
void difference()
{
int *BdiffA=(int *)malloc(sizeB*sizeof(int));
ctr=0;//the difeernce array can have size at max Of B if we find B-A
for(octr=0;octr<sizeB;octr++)
{
int flag=0;
for(ictr=0;ictr<sizeA;ictr++)
{
if(setA[ictr]==setB[octr])
flag=1;//if flag=1 the elemnt is in A and in B
}
if(flag==0)//copy only those elemnts which are in B not A
BdiffA[ctr++]=setB[octr];
}
printf("\nB - A is \n");
if(ctr==0)
{    printf("NULL");
return;//if ctr=0 then NULL
}
for(octr=0;octr<ctr;octr++)
printf("%d\t",BdiffA[octr]);//display
free(BdiffA);

}
void CardinalProduct()
{
int **cardinalProduct=(int **)malloc(sizeA*sizeB*sizeof(int));//There will be sizeA*sizeB rows in the cardinal product matrix
for(ctr=0;ctr<sizeA*sizeB;ctr++)
cardinalProduct[ctr]=(int *)malloc(2*sizeof(int));//1 cardinal product has 2 elements (a,b)
ictr=0;
for(ctr=0;ctr<sizeA*sizeB;ctr++)
{
cardinalProduct[ctr]=setA[ctr/sizeB];//way to fill the first element with appropriate set A element
cardinalProduct[ctr]=setB[ctr%sizeB];//way to fill the second element with appropriate set B element
}
printf("\nA*B is \n");
for(ctr=0;ctr<sizeA*sizeB;ctr++)
printf("(%d,%d)\t",cardinalProduct[ctr],cardinalProduct[ctr]);//displaying in cartesian form
for(ctr=0;ctr<sizeA*sizeB;ctr++)
free(cardinalProduct[ctr]);
free(cardinalProduct);
}
int main()
{
printf("Enter the size for set A\n");
scanf("%d",&sizeA);
printf("Enter the size for set B\n");
scanf("%d",&sizeB);
setA=(int *)malloc(sizeA*sizeof(int));
setB=(int *)malloc(sizeB*sizeof(int));
printf("Enter the elements of set A\n");
for(ctr=0;ctr<sizeA;ctr++)
scanf("%d",&setA[ctr]);
printf("Enter the elements of set B\n");
for(ctr=0;ctr<sizeB;ctr++)
scanf("%d",&setB[ctr]);
unionsets();
intersection();
difference();
CardinalProduct();
free(setA);
free(setB);
getch();
}
/*A sample run of the program runs as follows:-
Enter the size for set A
3
Enter the size for set B
4
Enter the elements of set A
1 2 3
Enter the elements of set B
4 5 6 7
A Union B is
1 2 3 4 5 6 7
A Intersection B is
NULL
B - A is
4 5 6 7
A*B is
(1,4) (1,5) (1,6) (1,7) (2,4) (2,5) (2,6) (2,7) (3,4) (3,5) (3,6) (3,7)
*/```

## C Program to solve Simultaneous Linear Equations in two variables

```/*The following program finds out the solutions to simultaneous equation in two variables.The equations are of the form
ax+by=c and px+qy=r.
The coefficents of the 2 equations are taken as input and we evaluate the unknown x and y accordingly.
*/
#include<stdio.h>
int main()
{
double a,b,c,p,q,r,x,y;
printf("Enter the coefficents of the first equation of the form ax+by=c\n");
scanf("%lf%lf%lf",&a,&b,&c);//The coefficents of the first equation
printf("Enter the coefficents of the second equation of the form px+qy=r\n");
scanf("%lf%lf%lf",&p,&q,&r);//The coefficents of the second equation
if(((a*q-p*b)!=0)&&((b*p-q*a)!=0))
{//In this case we have a unique solution and display x and y
printf("The solution to the equations is unique\n");
x=(c*q-r*b)/(a*q-p*b);
y=(c*p-r*a)/(b*p-q*a);
printf("The value of x=%lf\n",x);
printf("The value of y=%lf\n",y);
}
else
if(((a*q-p*b)==0)&&((b*p-q*a)==0)&&((c*q-r*b)==0)&&((c*p-r*a)==0))//In such condition we can have infinitely many solutions to the equation.
{//When we have such a condition than mathematically we can choose any one unknown as free and other unknown can be calculated using the free variables's value.
//So we choose x as free variable and then get y
printf("Infinitely many solutions are possible\n");
printf("The value of x can be varied and y can be calculated according to x's value using relation\n");
printf("y=%lf+(%lf)x",(c/b),(-1*a/b));
}
else
if(((a*q-p*b)==0)&&((b*p-q*a)==0)&&((c*q-r*b)!=0)&&((c*p-r*a)!=0))//In such condition no solutions are possible.
printf("No solutions are possible\n");
getch();
}
/*A sample run of the program was carried out and the results found were as follows:-
Enter the coefficents of the first equation of the form ax+by=c
2 4 6
Enter the coefficents of the second equation of the form px+qy=r
3 6 9
Infinitely many solutions are possible
The value of x can be varied and y can be calculated according to x's value using relation
y=1.500000+(-0.500000)x
*/```

C Program to solve a Sudoku

```/*The following program is an implementation of a Sudoku Solver in C.
Sudoku is a 9*9 grid in which each row,each column and each 3*3 grid contains all numbers from 1 to 9 only once.
The program uses backtracking approach to solve the sudoku. There is a recursive function to solve the sudoku.
*/
#include<stdio.h>
int sudoku;//The array which stores entries for the sudoku
void solvesudoku(int,int);
int checkrow(int row,int num)
{//This function checks whether we can put the number(num) in the row(row) of the Sudoku or not
int column;
for(column=0;column<9;column++)
if(sudoku[row][column]==num)
return 0 ;//If the number is found already present at certain location we return zero
}
int checkcolumn(int column,int num)
{//This function checks whether we can put the number(num) in the column(column) of the Sudoku or not
int row;
for(row=0;row<9;row++)
if(sudoku[row][column]==num)
return 0;//If the number is found already present at certain location we return zero
}
int checkgrid(int row,int column,int num)
{//This function checks whether we can put the number(num) in the 3*3 grid or not
//We get the starting row and column for the 3*3 grid
row=(row/3)*3 ;
column=(column/3)*3;
int r,c;
for(r=0;r<3;r++)
for(c=0;c<3;c++)
if(sudoku[row+r][column+c]==num)
return 0;//If the number is found already present at certain location we return zero
}
void navigate(int row,int column)
{//Function to move to the next cell in case we have filled one cell
if(column<8)
solvesudoku(row,column+1);
else
solvesudoku(row+1,0);
}
void display()
{//The function to display the solved Sudoku
int row,column;
printf("THE SOLVED SUDOKU \n");
for(row=0;row<9;row++)
{
for(column=0;column<9;column++)
printf("%d ",sudoku[row][column]);
printf("\n");
}
getch();
}
void solvesudoku(int row,int column)
{
if(row>8)//If the row number is greater than 8 than we have filled all cells hence we have solved the sudoku
display();
if(sudoku[row][column]!=0)
navigate(row,column);//If the value filled at a cell is not zero than it is filled with some value from 0 to 9 hence we move further
else
{
int ctr;//This is a counter to check numbers from 1 to 9 whether the number can be filled in the cell or not
for(ctr=1;ctr<=9;ctr++)
{//We check row,column and the grid
if((checkrow(row,ctr)==1)&&(checkcolumn(column,ctr)==1)&&(checkgrid(row,column,ctr)==1))
{
sudoku[row][column]=ctr;
navigate(row,column);
}
}
sudoku[row][column]=0;//No valid number was found so we clean up and return to the caller.
}

}
int main()
{
int row,column;
printf("Enter the desired sudoku and enter 0 for unknown entries\n");
for(row=0;row<9;row++)
for(column=0;column<9;column++)
scanf("%d",&sudoku[row][column]);
solvesudoku(0,0);//We start solving the sudoku.
}
/*A sample run of the program was carried out and the results were as follows:-
1 0 3 4 0 0 7 0 9
0 5 6 0 8 9 0 2 3
0 8 9 1 0 3 4 0 6
2 1 4 0 6 5 0 9 7
3 0 0 8 0 7 0 1 4
8 0 7 0 1 4 0 6 5
0 3 1 0 4 0 9 7 8
6 4 0 9 7 0 5 3 1
0 7 8 0 0 1 0 4 2
THE SOLVED SUDOKU
1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 1 4 3 6 5 8 9 7
3 6 5 8 9 7 2 1 4
8 9 7 2 1 4 3 6 5
5 3 1 6 4 2 9 7 8
6 4 2 9 7 8 5 3 1
9 7 8 5 3 1 6 4 2
*/```

## C program to display the total number of words,the number of unique words and the frequency of each word

```/* The following C program displays the total number of words,the number of unique words and the frequency of each word
The program uses simple implementaion of sscanf to read from a charcater array text and scans for the frequency of word
*/
#include<stdio.h>
#include<string.h>
char *text;
int main()
{
text=(char *)malloc(100*sizeof(char));//The text array stores the entered string by the user and we assume max text size is 99
char *word=(char *)malloc(10*sizeof(char));//We create 2 more arrays word and temp to store the wors ands we assume max word size is 10
char *temp=(char *)malloc(10*sizeof(char));
printf("\nEnter the text of max length 99 and max length of any word should be 10\n");
gets(text);//use gets to input the line of text
int len=0;//works as counter variable to move through text
int words=0;//store total number of words
int unique=0;//count unique wors
while(len<strlen(text))
{
words++;
sscanf(text+len,"%s",word);//scanf from appropriate length
int ctr=0;//gives correct scanning poistion
int freq=0;//set frequency zero
while(ctr<strlen(text))
{//again scan from the start
sscanf(text+ctr,"%s",temp);
if(strcmp(word,temp)==0)//compare the words
freq++;//increment
ctr=ctr+strlen(temp)+1;//scan the next word so sum up the length for previous word and 1 for the space
}
if(freq!=1)
printf("\n<%s> is not unique and has frequency %d\n",word,freq);//the word has frequency more than 1
else
{
printf("\nThe word <%s> is unique\n",word);//unique
unique++;
}
len=len+strlen(word)+1;//scan the next word so sum up the length for previous word and 1 for the space
}
printf("\nThe number of unique words is %d\n",unique);
printf("\nThe total number of words are %d\n",words);
getch();
}
/*A sample run of the program works as:-
Enter the text of max length 99 and max length of any word should be 10
The Learning Point
The word <The> is unique
The word <Learning> is unique
The word <Point> is unique
The number of unique words is 3
The total number of words are 3
Enter the text of max length 99 and max length of any word should be 10
the learning point is the best
<the> is not unique and has frequency 2
The word <learning> is unique
The word <point> is unique
The word <is> is unique
<the> is not unique and has frequency 2
The word <best> is unique
The number of unique words is 4
The total number of words are 6
*/```

C program to display the
upper triangular matrix and lower triangular matrix
for any given matrix

```/*This is a program to display the
upper triangular matrix and lower triangular matrix
for any given matrix. The method used here is
LU decomposition method. This program works for matrices
of order equal to or below 10x10*/
#include<stdio.h>
int main()
{
int size,row,column,ctr1,ctr2;
printf("ENTER THE SIZE OF THE MATRIX(size<10)\n");
scanf("%d",&size);
float matrix;
printf("ENTER THE MATRIX\n");
for(row=0;row<size;row++)
for(column=0;column<size;column++)
scanf("%f",&matrix[row][column]);
float lowertriangle;//matrices for lower and uppper triangle
float uppertriangle;
for(row=0;row<size;row++)
for(column=0;column<size;column++)
{
if(row>column)//initialise all elements of lower triangle in upper triangular matrix as 0
uppertriangle[row][column]=0.0;
if(row<column)//initialise all elements of upper triangle in lower triangular matix as 0
lowertriangle[row][column]=0.0;
if(row==column)//initialise all diagonal elements of lower triangular matrix as 1
lowertriangle[row][column]=1.0;
}
/*The algorithm used later is from the book Introduction to algorithms by Thomas Cormen.For a better understaning one can
read this text under chapter Matrix Operations. */
for(ctr1=0;ctr1<size;ctr1++)
{
uppertriangle[ctr1][ctr1]=matrix[ctr1][ctr1];
for(ctr2=ctr1+1;ctr2<size;ctr2++)
{
uppertriangle[ctr1][ctr2]=matrix[ctr1][ctr2];
lowertriangle[ctr2][ctr1]=matrix[ctr2][ctr1]/uppertriangle[ctr1][ctr1];
}
for(row=ctr1+1;row<size;row++)
for(column=ctr1+1;column<size;column++)
matrix[row][column]=matrix[row][column]-lowertriangle[row][ctr1]*uppertriangle[ctr1][column];
}
printf("UPPER TRIANGULAR MATRIX\n");
for(row=0;row<size;row++)
{//displays upper triangular matrix
for(column=0;column<size;column++)
printf("%.2f ",uppertriangle[row][column]);
printf("\n");
}
printf("LOWER TRIANGULAR MATRIX\n");
for(row=0;row<size;row++)
{//displays lower triangular matrix
for(column=0;column<size;column++)
printf("%.2f ",lowertriangle[row][column]);
printf("\n");
}
getch();
}
/*A sample run of the program is found to give following result
ENTER THE SIZE OF THE MATRIX
4
ENTER THE MATRIX
2.00 3.00 1.00 5.00
6.00 13.00 5.00 19.00
2.00 19.00 10.00 23.00
4.00 10.00 11.00 31.00
UPPER TRIANGULAR MATRIX
2.00 3.00 1.00 5.00
0.00 4.00 2.00 4.00
0.00 0.00 1.00 2.00
0.00 0.00 0.00 3.00
LOWER TRIANGULAR MATRIX
1.00 0.00 0.00 0.00
3.00 1.00 0.00 0.00
1.00 4.00 1.00 0.00
2.00 1.00 7.00 1.00
*/```

C program for the Distance Vector Routing algorithm

```/*
Distance Vector Routing in this program is implemented using Bellman Ford Algorithm:-
*/
#include<stdio.h>
struct node
{
unsigned dist;
unsigned from;
}rt;
int main()
{
int costmat;
int nodes,i,j,k,count=0;
printf("\nEnter the number of nodes : ");
scanf("%d",&nodes);//Enter the nodes
printf("\nEnter the cost matrix :\n");
for(i=0;i<nodes;i++)
{
for(j=0;j<nodes;j++)
{
scanf("%d",&costmat[i][j]);
costmat[i][i]=0;
rt[i].dist[j]=costmat[i][j];//initialise the distance equal to cost matrix
rt[i].from[j]=j;
}
}
do
{
count=0;
for(i=0;i<nodes;i++)//We choose arbitary vertex k and we calculate the direct distance from the node i to k using the cost matrix
//and add the distance from k to node j
for(j=0;j<nodes;j++)
for(k=0;k<nodes;k++)
if(rt[i].dist[j]>costmat[i][k]+rt[k].dist[j])
{//We calculate the minimum distance
rt[i].dist[j]=rt[i].dist[k]+rt[k].dist[j];
rt[i].from[j]=k;
count++;
}
}while(count!=0);
for(i=0;i<nodes;i++)
{
printf("\n\n For router %d\n",i+1);
for(j=0;j<nodes;j++)
{
printf("\t\nnode %d via %d Distance %d ",j+1,rt[i].from[j]+1,rt[i].dist[j]);
}
}
printf("\n\n");
getch();
}
/*
A sample run of the program works as:-
Enter the number of nodes :
3
Enter the cost matrix :
0 2 7
2 0 1
7 1 0
For router 1
node 1 via 1 Distance 0
node 2 via 2 Distance 2
node 3 via 3 Distance 3
For router 2
node 1 via 1 Distance 2
node 2 via 2 Distance 0
node 3 via 3 Distance 1
For router 3
node 1 via 1 Distance 3
node 2 via 2 Distance 1
node 3 via 3 Distance 0
*/```

C program to display the Hamming Codes

## C program to display the IP address

```/*The following program is used to display IP address of the system using the system command */
#include<stdlib.h>

int main()
{
/*system invokes the command processor to execute a command.
Once the command execution has terminated, the processor gives the control back to the program,
returning an int value, whose interpretation is system-dependent.*/
system("C:\\Windows\\System32\\ipconfig");

getch();
}
/*A run of the program executes ipconfig file in the command prompt */```

## C program implementing the Jacobi method (Numerical Computing)

```/*This program is an implementaion of the Jacobi iteration method.
The relation used is
X(k+1)=(Diagonal matrix Inverse)(RHS Coefficient-)*(Lower triangle+Upper triangle)X(k))
*/
#include<stdio.h>
float coeff;
float Dinv;
float approx;
float R;//declare the relevant matrices
float matrixRes;
float b;
float temp;
int row,column,size,navigate;
void multiply(float matrixA[],float matrixB[])
{
int ctr,ictr;
//function to perform multiplication
for(ctr=0;ctr<size;ctr++)
{
matrixRes[ctr]=0;
for(navigate=0;navigate<size;navigate++)
matrixRes[ctr]=matrixRes[ctr]+matrixA[ctr][navigate]*matrixB[navigate];
}
}
int main()
{
printf("Enter the number of unknown(below 10)\n");
scanf("%d",&size);//enter the size
printf("Enter the coefficent matrix\n");
for(row=0;row<size;row++)
for(column=0;column<size;column++)
scanf("%f",&coeff[row][column]);
printf("Enter the first approximation\n");
for(row=0;row<size;row++)
scanf("%f",&approx[row]);
printf("Enter the RHS coefficient\n");
for(row=0;row<size;row++)
scanf("%f",&b[row]);
for(row=0;row<size;row++)//We calculate the diagonal inverse matrix make all other entries as zero except Diagonal entries whose resciprocal we store
for(column=0;column<size;column++)
{    if(row==column)
Dinv[row][column]=1/coeff[row][column];
else
Dinv[row][column]=0;
}
for(row=0;row<size;row++)
for(column=0;column<size;column++)//calculating the R matrix L+U
{    if(row==column)
R[row][column]=0;
else
if(row!=column)
R[row][column]=coeff[row][column];
}
int iter;
printf("Enter the number of iterations:\n");
scanf("%d",&iter);//enter the number of iterations
int ctr=1;
int octr;
while(ctr<=iter)
{
multiply(R,approx);//multiply L+U and the approximation
for(row=0;row<size;row++)
temp[row]=b[row]-matrixRes[row];//the matrix(b-Rx)
multiply(Dinv,temp);//multiply D inverse and (b-Rx)
for(octr=0;octr<size;octr++)
approx[octr]=matrixRes[octr];//store matrixRes value in the next approximation
printf("The Value after iteration %d is\n",ctr);
for(row=0;row<size;row++)
printf("%.3f\n",approx[row]);//display the value after the pass
ctr++;
}
getch();
}
/*A sample run of the program works as:-
Enter the number of unknown(below 10)
3
Enter the coefficent matrix
5 -2 3
-3 9 1
2 -1 -7
Enter the first approximation
0
0
0
Enter the RHS coefficient
-1
2
3
Enter the number of iterations:
7
The Value after iteration 1 is
-0.200
0.222
0.429
The Value after iteration 2 is
0.146
0.203
-0.517
The Value after iteration 3 is
0.192
0.328
-0.416
The Value after iteration 4 is
0.181
0.332
-0.421
The Value after iteration 5 is
0.185
0.329
-0.424
The Value after iteration 6 is
0.186
0.331
-0.423
The Value after iteration 7 is
0.186
0.331
-0.423*/```

C program implementing the Gaussian Elimination technique (Numerical Computing)

/*This is a program to calculate area of a circle after getting the radius as input from the user*/
#include<stdio.h>
int main()
{
printf("Enter the radius of the circle whose area is to be calculated\n");
scanf("%lf",&radius);//entering the value for radius of the circle as float data type
printf("The area of the circle is %lf",area);//displaying the results
getch();
}
/*A test run for the program was carried out and following output was observed
Enter the radius of the circle whose area is to be calculated
5.00
The area of the circle is 78.571429*/

/*The following program checks whether a number is armstrong number or not and also displays all armstrong numbers
from 1 to 1000. Armstrong numbers are such numbers whose sum of the cubes of digits is equal to the number itself.
For Example
371 is an Armstrong number
371=3*3*3+7*7*7+1*1*1
*/

#include<stdio.h>
#include<conio.h>
#include<math.h>
int main()
{
int numcheck;
int choice;
int rem;
int sum;
int temp;
printf("Enter Choice 1 to check whether a number is armstrong or not and Choice 2 to display all armstrong numbers from 1 to 1000\n");
scanf("%d",&choice);//It's a menu driven program and we work as per user's choice
switch(choice)
{
case 1:
printf("Enter the number\n");
scanf("%d",&numcheck);
temp=numcheck;/*We create a temporary copy of the number we will require to divide the number zero which changes it
and we need the actual number to compare after the loop operations.*/

sum=0;//variable to hold the sum of cubes of digits
while(temp>0)
{
rem=temp%10;//We find the digit at last place by finding the remainder after division by 10
sum=sum+rem*rem*rem;
temp=temp/10;
}
if(sum==numcheck)//Finally we check if the sum of the cubes of the digits equals the number or not
printf("The Number is an armstrong number\n");
else
printf("The Number is not an armstrong number\n");
break;
case 2:
for(numcheck=1;numcheck<=1000;numcheck++)
{//A loop which allows us to move through all numbers from 1 to 1000
//Now we perform the same operations on all numbers
temp=numcheck;
sum=0;
while(temp>0)
{
rem=temp%10;
sum=sum+rem*rem*rem;
temp=temp/10;
}
if(sum==numcheck)
printf("The Number %d is an armstrong number\n",numcheck);

}
break;
}
getch();
return 0;
}
/*A sample run of the program was carried out and it was found to give result as
Enter Choice 1 to check whether a number is armstrong or not and Choice 2 to display all armstrong numbers from 1 to 1000
2
The Number 1 is an armstrong number
The Number 153 is an armstrong number
The Number 370 is an armstrong number
The Number 371 is an armstrong number
The Number 407 is an armstrong number
*/