From 5b39dbcc64c5f8cd8ea9593b0abc6c9f13417164 Mon Sep 17 00:00:00 2001 From: rg1107 Date: Sat, 19 Oct 2019 15:55:14 +0530 Subject: [PATCH] #1 Added Programs in C, Java, Python --- C/BST_operations.c | 104 ++++++++++++++ C/Hello-World.c | 8 ++ C/MergeSort.c | 94 +++++++++++++ C/anagram.c | 32 +++++ C/dijkstra.c | 250 +++++++++++++++++++++++++++++++++ Java/DiameterOfBinaryTree.java | 31 ++++ Java/FibonacciSeries.java | 24 ++++ Java/Floyd_algorithm.java | 56 ++++++++ Java/ReverseString.java | 24 ++++ Java/SwapNumbers.java | 18 +++ Python/Geometric_Sum.py | 14 ++ Python/array.py | 7 + Python/binary_tree.py | 76 ++++++++++ Python/bubbleSort.py | 11 ++ Python/fibonacci.py | 11 ++ Python/palindrome.py | 16 +++ Python/prime_number.py | 8 ++ 17 files changed, 784 insertions(+) create mode 100644 C/BST_operations.c create mode 100644 C/Hello-World.c create mode 100644 C/MergeSort.c create mode 100644 C/anagram.c create mode 100644 C/dijkstra.c create mode 100644 Java/DiameterOfBinaryTree.java create mode 100644 Java/FibonacciSeries.java create mode 100644 Java/Floyd_algorithm.java create mode 100644 Java/ReverseString.java create mode 100644 Java/SwapNumbers.java create mode 100644 Python/Geometric_Sum.py create mode 100644 Python/array.py create mode 100644 Python/binary_tree.py create mode 100644 Python/bubbleSort.py create mode 100644 Python/fibonacci.py create mode 100644 Python/palindrome.py create mode 100644 Python/prime_number.py diff --git a/C/BST_operations.c b/C/BST_operations.c new file mode 100644 index 0000000..f976578 --- /dev/null +++ b/C/BST_operations.c @@ -0,0 +1,104 @@ +#include +#include +struct node +{ + int data; + struct node *left; + struct node *right; +}; +typedef struct node* Node; +Node newNode(int item) +{ + Node temp = (Node)malloc(sizeof(struct node)); + temp->data=item; + temp->left=temp->right=NULL; + return temp; +} +Node insert(Node node,int key) +{ + if(node == NULL) + return newNode(key); + if(key < node->data) + node->left=insert(node->left,key); + if(key > node->data) + node->right = insert(node->right,key); + return node; +} +int search(Node root,int key) +{ + if(root==NULL) + return -1; + if(root->data==key) + return 1; + if(root->dataright,key); + return search(root->left,key); +} +void inorder(Node root) +{ + if(root!=NULL) + { + inorder(root->left); + printf("%d\t",root->data); + inorder(root->right); + } +} +void preorder(Node root) +{ + if(root!=NULL) + { + printf("%d\t",root->data); + preorder(root->left); + preorder(root->right); + } +} +void postorder(Node root) +{ + if(root!=NULL) + { + postorder(root->left); + postorder(root->right); + printf("%d\t",root->data); + } +} +int main() +{ + int n,i,ch,ch1,key,pos; + Node root=NULL; + while(1) + { + printf("\nEnter your choice\n1:Create BST\n2:Traversal\n3:Search for key\n4:Exit"); + scanf("%d",&ch); + switch(ch) + { + case 1:printf("\nEnter the no. of nodes in the BST\n"); + scanf("%d",&n); + for(i=1;i<=n;i++) + { + printf("\nEnter the element to be inserted\n"); + scanf("%d",&key); + root=insert(root,key); + } + break; + case 2:printf("\nEnter your choice\n1:Preorder\n2:Inorder\n3:Postorder"); + scanf("%d",&ch1); + if(ch1==1) + preorder(root); + else if(ch1==2) + inorder(root); + else + postorder(root); + break; + case 3:printf("\nEnter the key to be searched\n"); + scanf("%d",&key); + pos=search(root,key); + if(pos==-1) + printf("\nKey is not found\n"); + else + printf("\nKey is found\n"); + break; + case 4:exit(0); + } + } + return 0; +} \ No newline at end of file diff --git a/C/Hello-World.c b/C/Hello-World.c new file mode 100644 index 0000000..affb7e2 --- /dev/null +++ b/C/Hello-World.c @@ -0,0 +1,8 @@ +#include +int main() +{ + printf("Hello World!"); + printf("\nHi"); +return 0; +} + diff --git a/C/MergeSort.c b/C/MergeSort.c new file mode 100644 index 0000000..9fbbbbf --- /dev/null +++ b/C/MergeSort.c @@ -0,0 +1,94 @@ +#include +#include + +void merge(int arr[], int l, int m, int r) +{ + int i, j, k; + int n1 = m - l + 1; + int n2 = r - m; + + + int L[n1], R[n2]; + + + for (i = 0; i < n1; i++) + L[i] = arr[l + i]; + for (j = 0; j < n2; j++) + R[j] = arr[m + 1+ j]; + + + i = 0; + j = 0; + k = l; + while (i < n1 && j < n2) + { + if (L[i] <= R[j]) + { + arr[k] = L[i]; + i++; + } + else + { + arr[k] = R[j]; + j++; + } + k++; + } + + + while (i < n1) + { + arr[k] = L[i]; + i++; + k++; + } + + + while (j < n2) + { + arr[k] = R[j]; + j++; + k++; + } +} + + +void mergeSort(int arr[], int l, int r) +{ + if (l < r) + { + + int m = l+(r-l)/2; + + + mergeSort(arr, l, m); + mergeSort(arr, m+1, r); + + merge(arr, l, m, r); + } +} + +int main() +{ + int n,i,j; + scanf("%d", &n); + + int a[n]; + + for(i=0;i +#include +#include + +void main() { + char word[100], word1[100]; + int l1, l2, i, s1 = 0, s2 = 0; + printf("*************Program to Check for Anangrams*************\n"); + printf("Enter the first word: \n"); + gets(word); + printf("Enter the second word: \n"); + gets(word1); + l1 = strlen(word); + l2 = strlen(word1); + for (i = 0; i < l1; i++) { + s1 = s1 + (int) word[i]; + } + for (i = 0; i < l2; i++) { + s2 = s2 + (int) word1[i]; + } + if (s1 == s2) { + printf("The words are Anagrams! \n"); + } else { + printf("The Words are not Anagrams! \n"); + } + getch(); +} diff --git a/C/dijkstra.c b/C/dijkstra.c new file mode 100644 index 0000000..b40ac7f --- /dev/null +++ b/C/dijkstra.c @@ -0,0 +1,250 @@ +#include +#include +#include +#include + +struct AdjListNode +{ + int dest; + int weight; + struct AdjListNode *next; +}; + +struct AdjList +{ + struct AdjListNode *head; // pointer to head node of list +}; + +struct Graph +{ + int V; + struct AdjList *array; +}; + +struct AdjListNode *newAdjListNode(int dest, int weight) +{ + struct AdjListNode *newNode = + (struct AdjListNode *)malloc(sizeof(struct AdjListNode)); + newNode->dest = dest; + newNode->weight = weight; + newNode->next = NULL; + return newNode; +} + +struct Graph *createGraph(int V) +{ + struct Graph *graph = (struct Graph *)malloc(sizeof(struct Graph)); + graph->V = V; + + graph->array = (struct AdjList *)malloc(V * sizeof(struct AdjList)); + + for (int i = 0; i < V; ++i) + graph->array[i].head = NULL; + + return graph; +} + +void addEdge(struct Graph *graph, int src, int dest, int weight) +{ + struct AdjListNode *newNode = newAdjListNode(dest, weight); + newNode->next = graph->array[src].head; + graph->array[src].head = newNode; + + newNode = newAdjListNode(src, weight); + newNode->next = graph->array[dest].head; + graph->array[dest].head = newNode; +} + +struct MinHeapNode +{ + int v; + int dist; +}; + +struct MinHeap +{ + int size; + int capacity; + int *pos; + struct MinHeapNode **array; +}; + +struct MinHeapNode *newMinHeapNode(int v, int dist) +{ + struct MinHeapNode *minHeapNode = + (struct MinHeapNode *)malloc(sizeof(struct MinHeapNode)); + minHeapNode->v = v; + minHeapNode->dist = dist; + return minHeapNode; +} + +struct MinHeap *createMinHeap(int capacity) +{ + struct MinHeap *minHeap = + (struct MinHeap *)malloc(sizeof(struct MinHeap)); + minHeap->pos = (int *)malloc(capacity * sizeof(int)); + minHeap->size = 0; + minHeap->capacity = capacity; + minHeap->array = + (struct MinHeapNode **)malloc(capacity * sizeof(struct MinHeapNode *)); + return minHeap; +} + +void swapMinHeapNode(struct MinHeapNode **a, struct MinHeapNode **b) +{ + struct MinHeapNode *t = *a; + *a = *b; + *b = t; +} + +void minHeapify(struct MinHeap *minHeap, int idx) +{ + int smallest, left, right; + smallest = idx; + left = 2 * idx + 1; + right = 2 * idx + 2; + + if (left < minHeap->size && + minHeap->array[left]->dist < minHeap->array[smallest]->dist) + smallest = left; + + if (right < minHeap->size && + minHeap->array[right]->dist < minHeap->array[smallest]->dist) + smallest = right; + + if (smallest != idx) + { + struct MinHeapNode *smallestNode = minHeap->array[smallest]; + struct MinHeapNode *idxNode = minHeap->array[idx]; + + minHeap->pos[smallestNode->v] = idx; + minHeap->pos[idxNode->v] = smallest; + + swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]); + + minHeapify(minHeap, smallest); + } +} + +int isEmpty(struct MinHeap *minHeap) +{ + return minHeap->size == 0; +} + +struct MinHeapNode *extractMin(struct MinHeap *minHeap) +{ + if (isEmpty(minHeap)) + return NULL; + + struct MinHeapNode *root = minHeap->array[0]; + + struct MinHeapNode *lastNode = minHeap->array[minHeap->size - 1]; + minHeap->array[0] = lastNode; + + minHeap->pos[root->v] = minHeap->size - 1; + minHeap->pos[lastNode->v] = 0; + + --minHeap->size; + minHeapify(minHeap, 0); + + return root; +} + +void decreaseKey(struct MinHeap *minHeap, int v, int dist) +{ + int i = minHeap->pos[v]; + + minHeap->array[i]->dist = dist; + + while (i && minHeap->array[i]->dist < minHeap->array[(i - 1) / 2]->dist) + { + minHeap->pos[minHeap->array[i]->v] = (i - 1) / 2; + minHeap->pos[minHeap->array[(i - 1) / 2]->v] = i; + swapMinHeapNode(&minHeap->array[i], &minHeap->array[(i - 1) / 2]); + + i = (i - 1) / 2; + } +} + +bool isInMinHeap(struct MinHeap *minHeap, int v) +{ + if (minHeap->pos[v] < minHeap->size) + return true; + return false; +} + +void printArr(int dist[], int n) +{ + printf("Vertex Distance from Source\n"); + for (int i = 0; i < n; ++i) + printf("%d \t\t %d\n", i, dist[i]); +} + +void dijkstra(struct Graph *graph, int src) +{ + int V = graph->V; + int dist[V]; + + struct MinHeap *minHeap = createMinHeap(V); + + for (int v = 0; v < V; ++v) + { + dist[v] = INT_MAX; + minHeap->array[v] = newMinHeapNode(v, dist[v]); + minHeap->pos[v] = v; + } + + minHeap->array[src] = newMinHeapNode(src, dist[src]); + minHeap->pos[src] = src; + dist[src] = 0; + decreaseKey(minHeap, src, dist[src]); + + minHeap->size = V; + + while (!isEmpty(minHeap)) + { + struct MinHeapNode *minHeapNode = extractMin(minHeap); + int u = minHeapNode->v; + + struct AdjListNode *pCrawl = graph->array[u].head; + while (pCrawl != NULL) + { + int v = pCrawl->dest; + + if (isInMinHeap(minHeap, v) && dist[u] != INT_MAX && + pCrawl->weight + dist[u] < dist[v]) + { + dist[v] = dist[u] + pCrawl->weight; + + decreaseKey(minHeap, v, dist[v]); + } + pCrawl = pCrawl->next; + } + } + + printArr(dist, V); +} + +int main() +{ + int V = 9; + struct Graph *graph = createGraph(V); + addEdge(graph, 0, 1, 4); + addEdge(graph, 0, 7, 8); + addEdge(graph, 1, 2, 8); + addEdge(graph, 1, 7, 11); + addEdge(graph, 2, 3, 7); + addEdge(graph, 2, 8, 2); + addEdge(graph, 2, 5, 4); + addEdge(graph, 3, 4, 9); + addEdge(graph, 3, 5, 14); + addEdge(graph, 4, 5, 10); + addEdge(graph, 5, 6, 2); + addEdge(graph, 6, 7, 1); + addEdge(graph, 6, 8, 6); + addEdge(graph, 7, 8, 7); + + dijkstra(graph, 0); + + return 0; +} diff --git a/Java/DiameterOfBinaryTree.java b/Java/DiameterOfBinaryTree.java new file mode 100644 index 0000000..98f0363 --- /dev/null +++ b/Java/DiameterOfBinaryTree.java @@ -0,0 +1,31 @@ +import java.util.*; +import java.lang.*; + +class TreeNode { + int val; + TreeNode left; + TreeNode right; + + public TreeNode(int val){ + this.val = val; + } +} + + +public class DiameterOfBinaryTree{ + int ans = 0; + + public int diameterOfBinaryTree(TreeNode root){ + if(root == null) return 0; + TreeNode left = diameterOfBinaryTree(root.left); + TreeNode right = diameterOfBinaryTree(root.right); + ans = Math.max(left+right, ans); + return 1 + Math.max(left, right); + } + + public static void main(String[] args){ + diameterOfBinaryTree(root); + System.out.println(ans); + } + +} \ No newline at end of file diff --git a/Java/FibonacciSeries.java b/Java/FibonacciSeries.java new file mode 100644 index 0000000..c44c618 --- /dev/null +++ b/Java/FibonacciSeries.java @@ -0,0 +1,24 @@ +import java.util.Scanner; + +public class FibonacciSeries { + + public static void main(String[] args) { + + Scanner sc = new Scanner(System.in); + System.out.println("Enter the limit:"); + int number = sc.nextInt(); + + int a = 0; + int b = 0; + int c = 1; + + for(int i = 0; i <= number; i++) { + a = b; + b = c; + c = a + b; + System.out.println(a + ""); + } + + } + +} diff --git a/Java/Floyd_algorithm.java b/Java/Floyd_algorithm.java new file mode 100644 index 0000000..6ae4e6f --- /dev/null +++ b/Java/Floyd_algorithm.java @@ -0,0 +1,56 @@ +import java.util.Scanner; +public class floyd +{ + public static void Floyds(int a[][],int n) + { + int i,j,k; + int d[][]=new int[10][10]; + for(i=1;i<=n;i++) + { + for(j=1;j<=n;j++) + { + d[i][j]=a[i][j]; + + } + } + for(k=1;k<=n;k++) + { + for(i=1;i<=n;i++) + { + for(j=1;j<=n;j++) + { + d[i][j]=min(d[i][j],d[i][k]+d[k][j]); + } + } + } + System.out.println("\nThe distance matrix is\n"); + for(i=1;i<=n;i++) + { + for(j=1;j<=n;j++) + { + System.out.print(+d[i][j]+"\t"); + } + System.out.println("\n"); + } + } + public static int min(int a,int b) + { + if(a=0; i--) { + reverse.append(letters[i]); + } + + System.out.println(reverse); + + if(str.equals(reverse.toString())) { + System.out.println("Input is palindrome."); + } + else { + System.out.println("Input is not palindrome."); + } + + } + +} diff --git a/Java/SwapNumbers.java b/Java/SwapNumbers.java new file mode 100644 index 0000000..ae1c546 --- /dev/null +++ b/Java/SwapNumbers.java @@ -0,0 +1,18 @@ +public class SwapNumbers { + + public static void main(String[] args) { + + int x = 75; + int y = 50; + + System.out.println("Before Swapping\nx = " + x + "\ny = " + y); + + x = x + y; + y = x - y; + x = x - y; + + System.out.println("After Swapping\nx = " + x + "\ny = " + y); + + } + +} diff --git a/Python/Geometric_Sum.py b/Python/Geometric_Sum.py new file mode 100644 index 0000000..3a73b85 --- /dev/null +++ b/Python/Geometric_Sum.py @@ -0,0 +1,14 @@ + +#Program to find geometeric sum , with input k +#The given form is geometric series and we will find sum of this series +#1 + 1/2 + 1/4 + 1/8 + ... + 1/(2^k) + + + +def find(k): + if(k==0): + return 1 + a=1/2**k + return (a+find(k-1)) +k=int(input()) +print("{:.5f}".format(find(k))) \ No newline at end of file diff --git a/Python/array.py b/Python/array.py new file mode 100644 index 0000000..c188e71 --- /dev/null +++ b/Python/array.py @@ -0,0 +1,7 @@ +import array as arr +numbers_list = [2, 5, 62, 5, 42, 52, 48, 5] +numbers_array = arr.array('i', numbers_list) +print(numbers_array[2:5]) # 3rd to 5th +print(numbers_array[:-5]) # beginning to 4th +print(numbers_array[5:]) # 6th to end +print(numbers_array[:]) # beginning to end diff --git a/Python/binary_tree.py b/Python/binary_tree.py new file mode 100644 index 0000000..97f004d --- /dev/null +++ b/Python/binary_tree.py @@ -0,0 +1,76 @@ +class Node: + def __init__(self, val): + self.l = None + self.r = None + self.v = val + + +class Tree: + def __init__(self): + self.root = None + + def getRoot(self): + return self.root + + def add(self, val): + if self.root is None: + self.root = Node(val) + else: + self._add(val, self.root) + + def _add(self, val, node): + if(val < node.v): + if node.l is not None: + self._add(val, node.l) + else: + node.l = Node(val) + else: + if(node.r is not None): + self._add(val, node.r) + else: + node.r = Node(val) + + def find(self, val): + if self.root is not None: + return self._find(val, self.root) + else: + return None + + def _find(self, val, node): + if(val == node.v): + return node + elif val < node.v and node.l is not None: + self._find(val, node.l) + elif val > node.v and node.r is not None: + self._find(val, node.r) + + def deleteTree(self): + # garbage collector will do this for us. + self.root = None + + def printTree(self): + if self.root is not None: + self._printTree(self.root) + + def _printTree(self, node): + if node is not None: + self._printTree(node.l) + print(str(node.v) + ' ') + self._printTree(node.r) + + +# Create following tree +# 3 +# 0 4 +# 2 8 +tree = Tree() +tree.add(3) +tree.add(4) +tree.add(0) +tree.add(8) +tree.add(2) +tree.printTree() +print('Print 3rd node value : {}'.format(tree.find(3).v)) +print('Find Location of value 10 : {}'.format(tree.find(10))) +tree.deleteTree() +tree.printTree() diff --git a/Python/bubbleSort.py b/Python/bubbleSort.py new file mode 100644 index 0000000..4eec093 --- /dev/null +++ b/Python/bubbleSort.py @@ -0,0 +1,11 @@ +def bubbleSort(a): + for b in range(len(a)-1,0,-1): + for i in range(b): + if a[i]>a[i+1]: + temp = a[i] + a[i] = a[i+1] + a[i+1] = temp + +nlist = [14,46,43,27,57,41,45,21,70] +bubbleSort(nlist) +print(nlist) diff --git a/Python/fibonacci.py b/Python/fibonacci.py new file mode 100644 index 0000000..097baab --- /dev/null +++ b/Python/fibonacci.py @@ -0,0 +1,11 @@ +# Find the Nth Fibonacci Number + +class Solution: + def fib(self, N: int) -> int: + if N <= 1: + return N + previous, current = 0, 1 + for _ in range(N - 1): + new_current = previous + current + previous, current = current, new_current + return current diff --git a/Python/palindrome.py b/Python/palindrome.py new file mode 100644 index 0000000..85e5b80 --- /dev/null +++ b/Python/palindrome.py @@ -0,0 +1,16 @@ +# Python program to check if a string is a palindrome or not + +s = input("Enter your string: ") + +def isPalindrome(s): + s.lower() + rev = s[::-1] + + if (s == rev): + return True + return False + +print(isPalindrome(s)) + +if __name__ == "__main__": + isPalindrome(s) \ No newline at end of file diff --git a/Python/prime_number.py b/Python/prime_number.py new file mode 100644 index 0000000..562bd93 --- /dev/null +++ b/Python/prime_number.py @@ -0,0 +1,8 @@ +num = int(input("enter a number: ")) + +for i in range(2, num): + if num % i == 0: + print("not prime number") + break +else: + print("prime number")