contributed

Area.c

@@ -0,0 +1,12 @@
+#include<stdio.h>
+int main() {
+int rad; float PI = 3.14;
+float  area, ci;
+printf("\nEnter radius of circle: ");
+scanf("%d", &rad);
+area = PI * rad * rad;
+printf("\nArea of circle : %f ", area);
+ci = 2 * PI * rad;
+printf("\nCircumference: %f ", ci);
+return (0);
+}

BELMAN_FORD.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+struct Edge {
+    int source, destination, weight;
+};
+struct Graph {
+    int V, E;
+
+    struct Edge *edge;
+};
+struct Graph *createGraph(int V, int E) {
+    struct Graph *graph = (struct Graph *)malloc(sizeof(struct Graph));
+    graph->V = V;
+    graph->E = E;
+    graph->edge = (struct Edge *)malloc(graph->E * sizeof(struct Edge));
+    return graph;
+}
+void FinalSolution(int dist[], int n) {
+    printf("\nVertex\tDistance from Source Vertex - \n");
+    int i;
+    for (i = 0; i < n; ++i) {
+        printf("%d \t\t %d\n", i, dist[i]);
+    }
+}
+void BellmanFord(struct Graph *graph, int source) {
+    int V = graph->V;
+    int E = graph->E;
+    int StoreDistance[V];
+    int i, j;
+    for (i = 0; i < V; i++)
+        StoreDistance[i] = INT_MAX;
+    StoreDistance[source] = 0;
+    for (i = 1; i <= V - 1; i++) {
+        for (j = 0; j < E; j++) {
+            int u = graph->edge[j].source;
+            int v = graph->edge[j].destination;
+            int weight = graph->edge[j].weight;
+            if (StoreDistance[u] + weight < StoreDistance[v])
+                StoreDistance[v] = StoreDistance[u] + weight;
+        }
+    }
+    for (i = 0; i < E; i++) {
+        int u = graph->edge[i].source;
+        int v = graph->edge[i].destination;
+        int weight = graph->edge[i].weight;
+        if (StoreDistance[u] + weight < StoreDistance[v])
+            printf("This graph contains negative edge cycle\n");
+    }
+    FinalSolution(StoreDistance, V);
+    return;
+}
+int main() {
+    int V, E, S;
+    printf("Enter number of vertices in graph - \n");
+    scanf("%d", &V);
+    printf("Enter number of edges in graph - \n");
+    scanf("%d", &E);
+    printf("Enter your source vertex number - \n");
+    scanf("%d", &S);
+    struct Graph *graph = createGraph(V, E);
+    int i;
+    for (i = 0; i < E; i++) {
+        printf("\nEnter edge %d properties Source, destination, weight respectively - \n", i + 1);
+        scanf("%d", &graph->edge[i].source);
+        scanf("%d", &graph->edge[i].destination);
+        scanf("%d", &graph->edge[i].weight);
+    }
+    BellmanFord(graph, S);
+    return 0;
+}

BMI Calculator.py

@@ -0,0 +1,20 @@
+print('                  BMI CALCULATOR')
+name = input('What is your name?')
+weight = float(input('What is your weight (in Kgs)?'))
+height = float(input('What is your height (in meters)?'))
+bmi = weight / (height ** 2)
+
+if bmi<18.5:
+    print(f"\n{name} is underweight by {bmi} BMI")
+    print('Eat foods containing high portion of fats and carbohydrates')
+elif 18.5<bmi<24.9:
+    print(f"\n{name} has normal weight by {bmi} BMI")
+    print('You are living a healthy life and !!!KEEP IT UP!!!')
+elif 25.0<bmi<29.9:
+    print(f"\n{name} is overweight by {bmi} BMI")
+    print('\nEat foods containing less amount of fats and carbohydrates and do regular exercise.')
+else:print(f"\n{name} is obese by {bmi} BMI.\nRegular exercise is very important for you & consult a dietician to plan your diet.")
+print('\n                        ||||||||||  THANK YOU   ||||||||||')
+
+
+

C/Armstrong_number.c

@@ -0,0 +1,19 @@
+#include<stdio.h>  
+ int main()    
+{    
+int n,r,sum=0,temp;    
+printf("enter the number=");    
+scanf("%d",&n);    
+temp=n;    
+while(n>0)    
+{    
+r=n%10;    
+sum=sum+(r*r*r);    
+n=n/10;    
+}    
+if(temp==sum)    
+printf("armstrong  number ");    
+else    
+printf("not armstrong number");    
+return 0;  
+}   

C/BFS.c

@@ -0,0 +1,174 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+#define MAX 100  
+
+#define initial 1
+#define waiting 2
+#define visited 3
+
+int n;    
+int adj[MAX][MAX];
+int state[MAX]; 
+void create_graph();
+void BF_Traversal();
+void BFS(int v);
+
+int queue[MAX], front = -1,rear = -1;
+void insert_queue(int vertex);
+int delete_queue();
+int isEmpty_queue();
+
+int main()
+{
+    create_graph();
+    BF_Traversal();
+    return 0;
+}
+
+void BF_Traversal()
+{
+    int v;
+
+    for(v=0; v<n; v++) 
+        state[v] = initial;
+
+    printf("Enter Start Vertex for BFS: \n");
+    scanf("%d", &v);
+    BFS(v);
+}
+
+void BFS(int v)
+{
+    int i;
+
+    insert_queue(v);
+    state[v] = waiting;
+
+    while(!isEmpty_queue())
+    {
+        v = delete_queue( );
+        printf("%d ",v);
+        state[v] = visited;
+
+        for(i=0; i<n; i++)
+        {
+            if(adj[v][i] == 1 && state[i] == initial) 
+            {
+                insert_queue(i);
+                state[i] = waiting;
+            }
+        }
+    }
+    printf("\n");
+}
+
+void insert_queue(int vertex)
+{
+    if(rear == MAX-1)
+        printf("Queue Overflow\n");
+    else
+    {
+        if(front == -1) 
+            front = 0;
+        rear = rear+1;
+        queue[rear] = vertex ;
+    }
+}
+
+int isEmpty_queue()
+{
+    if(front == -1 || front > rear)
+        return 1;
+    else
+        return 0;
+}
+
+int delete_queue()
+{
+    int delete_item;
+    if(front == -1 || front > rear)
+    {
+        printf("Queue Underflow\n");
+        exit(1);
+    }
+
+    delete_item = queue[front];
+    front = front+1;
+    return delete_item;
+}
+
+void create_graph()
+{
+    int count,max_edge,origin,destin;
+
+    printf("Enter number of vertices : ");
+    scanf("%d",&n);
+    max_edge = n*(n-1);
+
+    for(count=1; count<=max_edge; count++)
+    {
+        printf("Enter edge %d( -1 -1 to quit ) : \n",count);
+        scanf("%d %d",&origin,&destin);
+
+        if((origin == -1) && (destin == -1))
+            break;
+
+        if(origin>=n || destin>=n || origin<0 || destin<0)
+        {
+            printf("Invalid edge!\n");
+            count--;
+        }
+        else
+        {
+            adj[origin][destin] = 1;
+        }
+    }
+}
+
+/* ""OUTPUT""
+Enter number of vertices : 9
+Enter edge 1( -1 -1 to quit ) :
+0
+1
+Enter edge 2( -1 -1 to quit ) :
+0
+3
+Enter edge 3( -1 -1 to quit ) :
+0
+4
+Enter edge 4( -1 -1 to quit ) :
+1
+2
+Enter edge 5( -1 -1 to quit ) :
+3
+6
+Enter edge 6( -1 -1 to quit ) :
+4
+7
+Enter edge 7( -1 -1 to quit ) :
+6
+4
+Enter edge 8( -1 -1 to quit ) :
+6
+7
+Enter edge 9( -1 -1 to quit ) :
+2
+5
+Enter edge 10( -1 -1 to quit ) :
+4
+5
+Enter edge 11( -1 -1 to quit ) :
+7
+5
+Enter edge 12( -1 -1 to quit ) :
+7
+8
+Enter edge 13( -1 -1 to quit ) :
+-1
+-1
+Enter Start Vertex for BFS:
+0
+0 1 3 4 2 6 5 7 8
+
+*/