/*This is a program to calculate area of a circle after getting the radius as input from the user*/
#include<stdio.h>
int main()
{
    double radius,area;//variables for storing radius and area
    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
    area=(22.0/7.0)*pow(radius,2);//Mathematical function pow is used to calculate square of radius
    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
*/

C Program for Bezier Curves

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
*/

/*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
*/

/*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[0] is the (pointer to the) string "learn".
argv[1] is the (pointer to the) string "hello,".
argv[2] 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[0]
  ---        |---|       ----------------------------
             |  -|----> | h | e | l | l | o | , |\0 | This is can also be pointed to by argv[1]
             |---|       ----------------------------
             |  -|----> | w | o | r | l | d |\0 | This is can also be pointed to by argv[3]
             |---|       ---------------------------
             | 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
*/

/*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[20];//array to store entered expression
char stack[20];//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[20];
ctr=0;
while(expr[ctr]!='\0')
{//read till the end of input
if(expr[ctr]>='0'&&expr[ctr]<='9')
stack[++top]=expr[ctr];//add numbers straightaway
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++;
}
while(topOper>=0)//add remaining operators to stack
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[2];//stack to keep storing results
int rTop=-1;//top of result stack
while(stack[ctr]!='\0')
{
oper=stack[ctr];
if(oper>='0'&&oper<='9')
result[++rTop]=(int)(oper-'0');//add numbers
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[0]);
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
*/

/*This program demonstrates various operation on files*/
#include<stdio.h>
int main()
{
    FILE *fp;//we declare a file pointer fp
    fp=fopen("C:\\Users\\Desktop\\ReadExample.txt","r");
    //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.
*/

#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[0];
                    matrix[0]=temp;
                    temp=matrix[row];
                    coeff[row]=coeff[0];
                    coeff[0]=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][0]=coeff[inner][0]-multfactor*coeff[row][0];
            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][0]);
    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][0];
    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
*/

/*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
*/

/*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[10];//stroes the name
}*start;//points to beginning of the list
typedef struct node *Nodeptr;
void add(char namePassed[])//add a node
{
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[20];
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)
{
add(choice);
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[20];//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)
move=move->next;//move to the soldier which user told to start with
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
*/

/*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
void add()
{//function to add two matrices
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++)
        {
            matrixRes[row][column]=matrixA[row][column]+matrixB[row][column];//Add corresponding elements
            printf("%.2f ",matrixRes[row][column]);
        }
        printf("\n");
    }
    for(row=0;row<rowA;row++)
        free(matrixRes[row]);
    free(matrixRes);
    }
else
printf("Incompatible for addition\n");
}
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[0][0];//in case the matrix passed has size 1
else
    if(size==2)
    det=matrix[0][0]*matrix[1][1]-matrix[0][1]*matrix[1][0];//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[0][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]);
    add();//performing additon,multiplication and subtraction
    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
*/

/*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
*/

/*The following program checks whether a string is plaindrome or not.*/
#include<stdio.h>
#include<string.h>
int main()
{
    char word[20];//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)
madam
The word is a Palindrome*/

/*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
*/

/*This is a simple program to display all the prime numbers till a given range using Eratosthenes' method:
(Adapted from wikepedia)
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
*/

/*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[20];
 int consumer[20];
 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");
   scanf("%d",&choice);//Menu 
   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
 */

/*
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.
Therefore the writers must have exclusive access to the resource.
*/
#include<stdio.h>
#include<conio.h>
#include<string.h>
int choiceA,choiceB,ctr;
char c[40];
char buffer[100];
char *g;
FILE *fr,*fw;//file pointers
void readfile()
{//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
printf("\nEnter your content to write:\n");
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
printf("\nUser A enter your choice\n");
scanf("%d",&choiceA);
printf("\nUser B enter your choice\n");
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
    readfile();
}
if((choiceA==2&&choiceB==3)||(choiceA==3&&choiceB==2))
{
    printf("\nThread works for write operation\n");
    writefile();
}
if((choiceA==1&&choiceB==3)||(choiceA==3&&choiceB==1))
{
    printf("\nThread works for read operation\n");
    readfile();
}
else
printf("\nCan not do. Writers must have exclusive access to the resource.\n");
}
while(choiceA!=3&&choiceB!=3);
getch();
}
/*A sample run of the program works as:-
Enter choice 1 to read
Enter choice 2 to write
Enter choice 3 to exit
User A enter your choice
1
User B enter your choice
1
Both users can read
{The contents of the file example are diplayed}
Enter choice 1 to read
Enter choice 2 to write
Enter choice 3 to exit
User A enter your choice
1
User B enter your choice
2
Can not do. Writers must have exclusive access to the resource.
*/

/*
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[10],self[10],spoon[10];
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");
for(ctr=0;ctr<5;ctr++)//Menu driven
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");
printf("\n Enter your choice :");
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");
printf("\n Enter your choice :\n");
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 your choice :2
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 your choice :2
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 your choice :2
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 your choice :2
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 your choice :3
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 your choice :3
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 your choice :3
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
Enter your choice :1
*/

/*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
*/

/* 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
*/

/*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[21];
    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
*/

/*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
*/