SUB SET FROM A GIVEN SETS
EXNO: 1
DATE:
AIM:
To find subsets from a given sets.
ALGORITHM:
STEP 1: Start the program
STEP 2: Declare subsets and functions with accept array of element. And convert into
subsets based on index “r”
STEP 3: In the main get the value for n.
STEP 4: Get the value for array element one after one
STEP 5: Call the function subsets with array element n, k as a parameter
STEP 6: Element k is the index with split the subsets.
Example;
K=2.subset of 2 element is created
STEP 7: Display the result.
STEP 8: Stop the program.
CODING
Prg 1://Subset from a given set
#include <stdio.h>
#inlcude<conio.h>
/* Function to generate subset */
void subset(int arr[], int data[], int start, int end, int index, int r)
{
int j, i;
if (index == r)
{
for (j = 0; j < r; j++)
printf("%d\t ", data[j]);
printf("\n");
return;
}
for (i = start; i <= end && end - i + 1 >= r - index; i++)
{
data[index] = arr[i];
subset(arr, data, i+1, end, index+1, r);
}
}
/* End of subset() */
/* Function to print the subset */
void printsubset(int arr[], int n, int r)
{
int data[6];
subset(arr, data, 0, n - 1, 0, r);
}
/* End of printsubset() */
void main()
{
int arr[20], k, n, i;
clrscr();
printf("Enter the number of input : ");
scanf("%d", &n);
printf("\nEnter the integers: \n");
for ( i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter value of k: ");
scanf("%d", &k);
printsubset(arr, n, k);
getch();
}
OUTPUT:
Enter the values of input :3
Enter the integers:
1
2
3
Enter the values of K:3
1 2
2 3
3 1
RESULT:
Thus the above program has been verified and executed successfully.
TRANSITIVE CLOSURE
EX.NO:2
DATE:
AIM:
To write a program to transitive closure
ALGORITHM:
STEP 1:Start the program
STEP 2:Declare the array values and using in for loop
STEP 3:To declare the variables int I,J;
STEP 4:Get the matrix values one by one to enter
STEP 5:To enter the array values of the set bracket at main function
STEP 6:To call the function in graph
STEP 7:Print the array values from the main which return values of 0
STEP 8:To save the program
STEP 9:Stop the program
CODING:
Prg 2://Transitive closure
#include<stdio.h>
#define V 4
void printSolution(int reach[][V]);
void transitiveClosure(int graph[][V])
{
int reach[V][V], i, j, k;
for (i = 0; i < V; i++)
for (j = 0; j < V; j++)
reach[i][j] = graph[i][j];
for (k = 0; k < V; k++)
{
for (i = 0; i < V; i++)
{
for (j = 0; j < V; j++)
{
reach[i][j] = reach[i][j] || (reach[i][k] && reach[k][j]);
}
}
}
printSolution(reach);
}
void printSolution(int reach[][V])
{
int i,j;
printf ("Following matrix is transitive
closure of the given graph\n");
for ( i = 0; i < V; i++)
{
for (j = 0; j < V; j++)
printf ("%d ", reach[i][j]);
printf("\n");
}
}
int main()
{
int graph[V][V] = { {1, 1, 0, 1}, {0, 1, 1, 0},
{0, 0, 1, 1}, {0, 0, 0, 1} };
clrscr();
// Print the solution
transitiveClosure(graph);
getch();
return 0;
}
OUTPUT:
Following the matrix is transitive closure of the given graph:
1111
0111
0011
0001
RESULT:
Thus the above program has been verified and executed successfully.
TO PROVE A SERIES
EX.NO: 3
DATE:
AIM:
To find a c program to prove a series 1/ (1*2) + 1/(2*3) ………+1/(n(n+1)) =
n/(n+1) is equal or not.
ALGORITHM:
STEP 1:Start the program
STEP 2:Declare the floating point values
STEP 3:Get the values for a series
STEP 4:To using the for loop to calculate the sum. The formula has been
Sum=sum+(1/(i*(i+1).
STEP 5:To declare the values for j. formula has been j=(n/n+1).
STEP 6:To save the program
STEP 7:Stop the program.
CODING:
Prg 3://To Prove the Series is Equal or not
#include<stdio.h>
#include<conio.h>
void main()
{
int i,j;
float sum=0.0,n;
clrscr();
printf("enter the value for n:");
scanf("%f",&n);
for(i=1;i<=n;i++)
{
sum=sum+(1/(i*(i+1)));
}
printf(“\n Sum=%f”,sum);
printf(“\n”);
j=(n/(n+1));
printf(“\n n/(n+1) = %f ”,j);
if(sum==j) {
printf("\n the series is equal");
}
else {
printf("\n the series is not equal");
}
getch();
}
OUTPUT:
Enter the values of n:3
0.500000 0.666667 0.750000
Sum= 0.750000
n(n+1)= 0.750000
the series is equal..
RESULT:
Thus the above program has been verified and executed successfully.
SUM OF THE SERIES
EX.NO:4
DATE:
AIM:
To write a program to perform the sum of series 1+(1+2)+(1+2+3)+...+(1+2+...n)
ALGORITHM:
STEP 1:Start the program
STEP 2:To declare the values
STEP 3:Get the values of n
STEP 4:To calculate the sum this formula is sum=sum+j
STEP 5:To save the program
STEP 6:Stop the program
CODING:
Prg 4:/*Sum of Series
sum = 1+ (1+2) + (1+2+3) + … + (1+2…+n)
=1+(1+2) + (1+2+3) + (1+2+3+4) +(1+2+3+4+5) */
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i,j,sum=0;
clrscr();
printf("enter the value for n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
for(j=1;j<=i;j++)
{
sum=sum+j;
}
printf(“\n”);
}
printf("\n the series is =%d", sum);
getch()
}
OUTPUT:
Enter the values of n:5
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
Sum:35
RESULT:
Thus the above program has been verified and executed successfully.
FIBONACCI SERIES USING RECURSION
EX.NO:5
DATE:
AIM:
To find the Fibonacci series using recursion method.
ALGORITHM:
STEP 1:Start the program
STEP 2:Decalre the function Fibonacci which accept terms as a parameter
And return a integer values
STEP 3:Get the values for n
STEP 4:Call the function Fibonacci(counter)
STEP 5:The values of counter pass as argument to term
STEP 6:Calculate Fibonacci series for n term using
Fibonacci(term-1)+Fibonacci(term-2)using recursion call and return
The result to main
STEP 7:Display the result
STEP 8:Stop the program
CODING:
Prg 5://Fibonacci Series using Recursion
#include <stdio.h>
#include <conio.h>
int fibonacci(int term);
void main(){
int terms, counter;
printf("Enter number of terms in Fibonacci series: ");
scanf("%d", &terms);
printf("Fibonacci series till %d terms\n", terms);
for(counter = 0; counter < terms; counter++){
printf("%d\n", fibonacci(counter));
}
getch(); }
int fibonacci(int term)
{
if(term < 2)
return term;
return fibonacci(term - 1) + fibonacci(term - 2);
}
OUTPUT:
Enter the number of term in Fibonacci series:8
0
1
1
2
3
5
8
13
RESULT:
Thus the above program has been verified and executed successfully.
FACTIORIAL USING IN RECURSION
EX.NO:6
DATE:
AIM:
To find a factorial using recursion method
ALGORITHM:
STEP 1:Start the program
STEP 2:Declar factorial function with accept n as parameter and return integer values
STEP 3:Get the value for n in the main and call the Function factorial(n);
STEP 4:Method factorial execute the codes n*factorial(n-1)
STEP 5:Factorial function return the values of factorial for Main function
STEP 6:Stop the program
CODING:
Prg 6://Factorial using Recursion
#include <stdio.h>
int factorial(int n);
void main()
{
int n;
printf("Enter a positive integer: ");
scanf("%d", &n);
printf("Factorial of %d = %d", n, factorial(n));
}
int factorial(int n)
{
if (n >= 1)
return n* factorial(n-1);
else
return 1;
}
OUTPUT:
Enter the positive integer:3
Factorial of 3=6
RESULT:
Thus the above program has been verified and executed successfully.
MINIMUM COST SPANNING TREE
EX.NO:7
DATE:
AIM:
To find the program minimum cost spanning tree using Prims algorithm from a graph
ALGORITHM:
STEP 1:Start the program
STEP 2:Declare the variable array visited two dimensional array cost.minimum cost’0’
STEP 3:Get the number of nodes with”n”
STEP 4:Get adjacency matrix cost of [i][j].
STEP 5:Assign maximum values cost of [i][j]=”999” with cost of [i][j]=”0”
STEP 6:Mark visited[i]=1
STEP 7:Update the maximum cost min=cos[i][j] by visiting the unvisited nodes
STEP 8:Display the edgest with minimum cost and update the minimum path cost
STEP 9:Run the program
STEP 10:Stop the program
CODING:
Prg 7://Minimum cost spanning Tree
#include<stdio.h>
#include<conio.h>
int a,b,u,v,n,i,j,ne=1;
int visited[10]={0},min,mincost=0,cost[10][10];
void main()
{
clrscr();
printf("\n Enter the number of nodes:");
scanf("%d",&n);
printf("\n Enter the adjacency matrix:\n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
scanf("%d",&cost[i][j]);
if(cost[i][j]==0)
cost[i][j]=999;
}
visited[1]=1;
printf("\n");
while(ne<n)
{
for(i=1,min=999;i<=n;i++)
for(j=1;j<=n;j++)
if(cost[i][j]<min)
if(visited[i]!=0)
{
min=cost[i][j];
a=u=i;
b=v=j;
}
if(visited[u]==0 || visited[v]==0)
{
printf("\n Edge %d:(%d %d) cost: %d",ne++,a,b,min);
mincost+=min;
visited[b]=1;
}
cost[a][b]=cost[b][a]=999;
}
printf("\n Minimun cost=%d",mincost);
getch();
}
OUTPUT:
Enter the number of nodes:3
Enter the adjacency matrix:
0 1 2
2 0 3
3 2 0
Edge 1:(12)cost:1
Edge 2:(13)cost:2
Minimum cost=3
RESULT:
Thus the above program has been verified and executed successfully.
SHORTEST PATH USING DIJKSTRA’S ALGORITHM
EXNO:8
DATE:
AIM:
To find the shortest path of using Dijkstra’s algorithm
ALGORITHM:
STEP 1:Start the program
STEP 2:Declare the variable and declare DIJKSTRA’S method with cost source and
targets
STEP 3:Enter the cost of connecting the nodes
STEP 4:Get the source nodes and target nodes
STEP 5:Find the shortest path from source to target and display the shortest path using
Dijkstra’s Algorithm
STEP 6:Stop the program
CODING:
Prg 8://Shortest path using Dijikstra’s Algorithm
#include<stdio.h>
#include<conio.h>
void main()
{
int path[2][2],i,j,min,a[3][3],p,st=1,ed=3,stp,edp,t[3],index;
clrscr();
printf("enter the cost matrix\n");
for(i=1;i<=3;i++)
for(j=1;j<=3;j++)
scanf("%d",&a[i][j]);
printf("enter number of paths\n");
scanf("%d",&p);
printf("enter possible paths\n");
for(i=1;i<=p;i++)
for(j=1;j<=3;j++)
scanf("%d",&path[i][j]);
for(i=1;i<=p;i++)
{
t[i]=0;
stp=st;
for(j=1;j<=3;j++)
{
edp=path[i][j+1];
t[i]=t[i]+a[stp][edp];
if(edp==ed)
break;
else
stp=edp;
}
}
min=t[st];index=st;
for(i=1;i<=p;i++)
{
if(min>t[i])
{
min=t[i];
index=i;
}
}
printf("minimum cost %d",min);
printf("\n minimum cost path ");
for(i=1;i<=3;i++)
{
printf("--> %d",path[index][i]);
if(path[index][i]==ed)
break;
}
getch();
}
OUTPUT:
Enter the cost matrix :
005
002
000
enter number of paths : 2
enter possible paths :
12
23
13
minimum cost : 2
minimum cost path :
1–>2–>3
RESULT:
Thus the above program has been verified and executed successfully.
CONSTRUCT THE TRUTH TABLE
EXNO:9
DATE:
AIM:
To construct the truth table using three variables
ALGORITHM:
STEP 1:Start the program
STEP 2:Declare the 3 variables X,Y,Z and assign the values 0,1
STEP 3:Make a loop for variable X,Y,Z for 0,1
STEP 4:Find the truth table for X*Y+Z
STEP 5:Stop the program
CODING:
Prg 9://Constructing a Truth Table
#include<stdio.h>
#include<conio.h>
void main()
{
int x,y,z;
clrscr();
printf(“\n X\tY\tZ\tXY+Z”);
for(x=0;x<=1;++x)
for(y=0;y<=1;++y)
for(z=0;z<=1;++z)
{
if(x*y+z==2)
printf(“\n%d\t%d\t%d\t”,x,y,z);
else
printf(“\n%d\t%d\t%d\t%d”,x,y,z,x*y+z);
}
getch();
}
OUTPUT:
X Y Z XY+Z
0 0 0 0
0 0 1 1
0 1 0 0
0 1 1 1
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 _
RESULT:
Thus the above program has been verified and executed successfully
DEMORGAN’S LAW
EX.NO:10
DATE:
AIM:
To prove the Demorgan’s Law
ALGORITHM:
STEP 1:Start the program
STEP 2:Declare the variables X and Y
STEP 3:Get the values for X and Y
STEP 4:To prove the program DEMORGAN’S LAW using the formula:
If((!(x<5)&&!(y>=7))&&!((x<5)!!(y>=7)))
STEP 5:For values x>5 and then y<7 the expression is executed for truth table
STEP 6:For values x<5 and then y>7 the expression is executed for the truth table
STEP 7:Stop the program
CODING:
Prg 10://To Prove De- Morgan’s Law
#include <stdio.h>
#include <math.h>
int main()
{
int x;
int y;
printf("Enter x: ");
scanf("%d",&x);
printf("Enter y: ");
scanf("%d",&y);
if ((!(x < 3) && !(y >= 7)) && !((x < 3) || (y >= 7)))
{
printf("True!\n\n");
}
else
{
printf("False!\n\n");
}
}
OUTPUT:
Enter X=6
Enter y=6
TRUE!!!!!
Enter X=7
Enter y=4
FALSE!!!!!
RESULT:
Thus the above program has been verified and executed successfully
