From b66a7e1e74423247bd60f7e9ef9d239301e16f4e Mon Sep 17 00:00:00 2001 From: Lakshyajit Laxmikant <30868587+lakshyajit165@users.noreply.github.com> Date: Mon, 16 Mar 2020 12:19:37 +0530 Subject: [PATCH 001/265] Karatsuba algorithm (#2490) * added karatsuba multiplication in python along with readme * modifications for karatsuba algorithm --- .../Karatsuba_multiplication_algo.cpp | 0 Karatsuba_Algorithm/Readme.md | 54 +++++++++++++++++++ Karatsuba_Algorithm/karatsuba.py | 29 ++++++++++ 3 files changed, 83 insertions(+) rename {Karatsuba_Algo => Karatsuba_Algorithm}/Karatsuba_multiplication_algo.cpp (100%) create mode 100644 Karatsuba_Algorithm/Readme.md create mode 100755 Karatsuba_Algorithm/karatsuba.py diff --git a/Karatsuba_Algo/Karatsuba_multiplication_algo.cpp b/Karatsuba_Algorithm/Karatsuba_multiplication_algo.cpp similarity index 100% rename from Karatsuba_Algo/Karatsuba_multiplication_algo.cpp rename to Karatsuba_Algorithm/Karatsuba_multiplication_algo.cpp diff --git a/Karatsuba_Algorithm/Readme.md b/Karatsuba_Algorithm/Readme.md new file mode 100644 index 000000000..7df095146 --- /dev/null +++ b/Karatsuba_Algorithm/Readme.md @@ -0,0 +1,54 @@ +# Karatsuba Multiplication +Karatsuba multiplication is an effective and efficient way of multiplication, which comes handy when multiplying really large numbers. It is different from the steps followed in conventional multiplication technique due to the fact that, it recursively performs the multiplication, thereby, making it possible to accomodate really large numbers. + +#### Consider the following example: +#### 5678 x 1234 = 7006652 + +While carrying out traditional multiplication(I mean the method we're usually taught at schools), we first have to multiply 5678 by 4, then by 3...upto 1 and then add all the intermediary products. It turns out that, while implementing this logic in code, we have to make 2n operations(n being the number of digits in the larger number) - (n operations to calculate the intermediary products + n operations to add those products,a long with keeping track of the carry overs). This is a lot of computation. + +#### Now let's have a look at how karatsuba multiplication, decreases the computations +#### Following are the steps for karatsuba multiplication: +- Consider the above 2 numbers, let x = 5678 and y = 1234 +- Break each number into 2 halves and store them in variables +- In this case, let a = 56, b = 78, c = 12, d = 34 +- Now we can express x and y as, x = 10 ^ (n/2) * a + b and y = 10 ^ (n/2) * c + d, where a,b,c,d are n/2 digit numbers. +- Therefore, x * y = 10 ^ n * a * c + 10 ^ (n/2) * (a * d + b * c) + b * d +- Now, on the first look it may seem that there are 4 recursive calls, to compute ac, ad, bc and bd - but here is the trick: +- It's also called as Gauss's trick - which requires only 3 recursive calls. +- If we carefully observe, we have already computed ac and bd in the first 2 steps, so if we subtract this result from the result of (a+b) * (c+d), we reduce 1 recursive call. +- It may seems strange, but when the computations to be performed are of very high level(multiplying really large digit numbers in this case), reducing even a single recursive call significantly affects performance. +- Checkout the code in python, to understand the recursive work flow better as well as the base case for the recursive function. + +### Pseudo code +``` +karatsuba(x, y): + + m = ceil(n/2) + + a = floor(x / 10**m) + b = x % (10**m) + + c = floor(y / 10**m) + d = y % (10**m) + + #recursive steps + ac = karatsuba(a,c) + bd = karatsuba(b,d) + ad_plus_bc = karatsuba(a + b, c + d) - ac - bd + + return int(ac*(10**(m*2)) + ad_plus_bc*(10**m) + bd) +``` + +### Complexity + +To analyze the complexity of the Karatsuba algorithm, consider the number of multiplications the algorithm performs as a function of n, M(n). + +The algorithm multiplies together two nn-bit numbers. If n=2^k for some k then the algorithm recurses three times on n/2-bit number. The recurrence for this is: + +M(n) = 3M(n/2) + +This takes care of the multiplications required for Karatsuba--now to consider the additions and subtractions. There are O(n)O(n) additions and subtractions required for the algorithm. Therefore, the overall recurrence for the Karatsuba algorithm is: + +T(n) = 3T(n/2) + O(n) + +Using the master theorem on the above recurrence yields that the running time of the Karatsuba algorithm is: $\Theta$(nlog23) \ No newline at end of file diff --git a/Karatsuba_Algorithm/karatsuba.py b/Karatsuba_Algorithm/karatsuba.py new file mode 100755 index 000000000..1fa796bcb --- /dev/null +++ b/Karatsuba_Algorithm/karatsuba.py @@ -0,0 +1,29 @@ +#!/usr/bin/python3 +from math import ceil, floor + +def karatsuba(x,y): + # base case + if x < 10 and y < 10: # in other words, if x and y are single digits + return x*y + + n = max(len(str(x)), len(str(y))) + m = ceil(n/2) # Cast n into a float because n might lie outside the representable range of integers. + + a = floor(x / 10**m) + b = x % (10**m) + + c = floor(y / 10**m) + d = y % (10**m) + + # recursive steps + ac = karatsuba(a,c) + bd = karatsuba(b,d) + ad_plus_bc = karatsuba(a + b, c + d) - ac - bd + + return int(ac*(10**(m*2)) + ad_plus_bc*(10**m) + bd) + +# INPUT 123456789, 987654321 +a,b = map(int, input().split(' ')) + +# OUTPUT 121932631112635269 +print(karatsuba(a, b)) From d6cc947e77cf61595ec9000c28ef0ecbff401ccd Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 16 Mar 2020 13:52:51 +0530 Subject: [PATCH 002/265] Menu Driven Circular Doubly Linked List in c++ (#2423) * Menu Driven Program * Updated and Renamed File * Delete Circular-Doubly-Linked-List.cpp * Menu Driven Program Updated and Renamed File * Update Circular_Doubly_Linked_List.cpp * Delete Circular_Doubly_Linked_List.cpp * Delete Circular-Doubly-Linked-List.cpp * all done * Commited Latest Changes * Commited Latest Changes * Commited Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * # This is a combination of 6 commits. # This is the 1st commit message: Menu Driven Program Updated and Renamed File # This is the commit message #2: Menu Driven Program # This is the commit message #3: Updated and Renamed File # This is the commit message #4: Delete Circular-Doubly-Linked-List.cpp # This is the commit message #5: Update Circular_Doubly_Linked_List.cpp # This is the commit message #6: all done * parent 575de38ca91337ed5420385cf26f76d03460068d author Hardev_Khandhar 1583005888 +0530 committer Hardev_Khandhar 1583948499 +0530 Menu Driven Program Updated and Renamed File Menu Driven Program Updated and Renamed File Delete Circular-Doubly-Linked-List.cpp Update Circular_Doubly_Linked_List.cpp all done Commited Latest Changes Commited Latest Changes Commited Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes * Updated Changes --- .../Circular_Doubly_Linked_List.cpp | 486 ++++++++++++++---- 1 file changed, 381 insertions(+), 105 deletions(-) diff --git a/Circular_Doubly_Linked_List/Circular_Doubly_Linked_List.cpp b/Circular_Doubly_Linked_List/Circular_Doubly_Linked_List.cpp index 8b6d71ce0..3551c1e33 100644 --- a/Circular_Doubly_Linked_List/Circular_Doubly_Linked_List.cpp +++ b/Circular_Doubly_Linked_List/Circular_Doubly_Linked_List.cpp @@ -1,131 +1,407 @@ +/** + Code contributed by Hardev Khandhar for GirlScript Summer of Code 2020 + link: https://github.com/HardevKhandhar +*/ + #include using namespace std; -class node{ -private: + +// Declaring the structure of node +struct node +{ int data; - node *next; - node *prev; -public: - node(int d) - { - data=d; - next=NULL; - prev=NULL; - } - friend class Linked_List; + struct node *lptr; + struct node *rptr; }; -class Linked_List + +struct node *HEAD = NULL; + +// Creating a node +node *createNode(int value) { -private: - node *head; -public: - Linked_List() + struct node *ptr; + ptr = new(struct node); + if(ptr == NULL) + { + cout << "Memory Not Allocated!" << endl; + return 0; + } + else { - head=NULL; - } -void insertatbeg(int d) - { - node *n=new node(d); - node*ptr=head; - if(head==NULL) - { - head=n; - n->next=head; - n->prev=n; - } - else - { - head->prev->next=n; - n->prev=head->prev; - n->next=head; - head->prev=n; - head=n; - - } - - - } - void insertatend(int d) + ptr -> data = value; + ptr -> lptr = NULL; + ptr -> rptr = NULL; + return ptr; + } +} + +// Insert node at the beginning of circular-doubly-linked-list +void insertAtFront() { - node *n=new node(d); - head->prev->next=n; - n->prev=head->prev; - n->next=head; + struct node *newNode; + struct node *trav = HEAD; + int value; + cout << "Enter the value to be inserted: "; + cin >> value; + newNode = createNode(value); + if(HEAD == NULL) + { + HEAD = newNode; + newNode -> rptr = HEAD; + } + else + { + newNode -> lptr = NULL; + newNode -> rptr = HEAD; + while(trav -> rptr != HEAD) + { + trav = trav -> rptr; + } + trav -> rptr = newNode; + HEAD = newNode; + } +} + +// Insert node at the end of circular-doubly-linked-list +void insertAtLast() +{ + struct node *newNode; + struct node *trav; + trav = HEAD; + int value; + cout << "Enter the value to be inserted: "; + cin >> value; + newNode = createNode(value); + if(HEAD == NULL) + { + newNode -> lptr = NULL; + HEAD = newNode; + newNode -> rptr = HEAD; + return; + } + else { + while(trav -> rptr != HEAD) + { + trav = trav -> rptr; + } + trav -> rptr = newNode; + newNode -> lptr = trav; + newNode -> rptr = HEAD; + } } - void print() + +// Insert node after a particular node in the circular-doubly-linked-list +void insertAtPosition(int x) +{ + struct node *trav; + struct node *next; + struct node *newNode; + trav = HEAD; + int value; + cout << "Enter the value to be inserted: "; + cin >> value; + newNode = createNode(value); + while(trav -> data != x && trav -> rptr != NULL) { - node *t=head; - do - { - cout<data<<" ->"; - t=t->next; + trav = trav -> rptr; + } + if(trav == NULL) + { + cout << "Desired element not found!" << endl; + } + else + { + next = trav -> rptr; + trav -> rptr = newNode; + newNode -> rptr = next; + newNode -> lptr = trav; + next -> lptr = newNode; + } +} - }while(t!=head); - cout< data << " "; + ptr = ptr -> rptr; } - void insertatK(int d,int k) + while(ptr != HEAD); + cout << endl; +} + +// Delete front node from the list +void deleteAtFront() { - node *n=new node(d); - node *t=head; - node *temp=NULL; - int cnt=1; - while(head==NULL || k==1) + struct node *trav = HEAD; + if(HEAD == NULL) { - insertatbeg(d); + cout << "List is Empty!"; + return; + } + if(HEAD -> rptr == HEAD){ + cout << "Element " << HEAD -> data << " is removed." << endl; + HEAD = NULL; + } + else { + cout << "Element " << HEAD -> data << " is removed." << endl; + while(trav -> rptr != HEAD){ + trav = trav -> rptr; + } + HEAD = HEAD -> rptr; + HEAD -> lptr = NULL; + trav -> rptr = HEAD; + } +} + +// Delete last node from the list +void deleteAtLast() +{ + struct node *trav; + struct node *previous; + trav = HEAD; + if(HEAD == NULL){ + cout << "List is Empty!"; return; } - while(t->next!=NULL && cnt rptr == HEAD) { - temp=t; - t=t->next; - cnt++; - } - n->prev=temp; - n->next=temp->next; - temp->next=n; - t->prev=n; + HEAD = NULL; + } + else { + while(trav -> rptr != HEAD) + { + previous = trav; + trav = trav -> rptr; + } + cout << "Element " << trav -> data << " is removed." << endl; + previous = trav -> lptr; + previous -> rptr = HEAD; + } } -void delatbeg() + +// Delete node from a particular position in the list +void deleteAtPosition(int x) { - node *t=head; - head->prev->next=head->next; - head->next->prev=head->prev; - head=head->next; - t->next=NULL; - delete t; + struct node *trav; + struct node *previous; + struct node *next; + trav = HEAD; + while(trav -> data != x && trav -> rptr != NULL) + { + previous = trav; + trav = trav -> rptr; + } + if(trav == NULL) + { + cout << "Desired element not found!" << endl; + } + else + { + next = trav -> rptr; + previous -> rptr = trav -> rptr; + next -> lptr = previous; + } } -void delatend() + +// Menu driven program +int main() { - node *t; - t=head->prev; - t->prev->next=head; - head->prev=t->prev; - t->next=NULL; - delete t; + int choice, nodes, position, element, i; + cout << "**************************************" << endl; + cout << "* Circular Doubly Linked List *" << endl; + cout << "**************************************\n" << endl; + while(1) + { + cout << "1. Insert node at the beginning" << endl; + cout << "2. Insert node at the end" << endl; + cout << "3. Insert node at given position" << endl; + cout << "4. Delete node at front" << endl; + cout << "5. Delete node at last" << endl; + cout << "6. Delete node at given position" << endl; + cout << "7. Display elements of linked list" << endl; + cout << "8. Exit" << endl; + cout << "\nEnter your choice: "; + cin >> choice; + switch(choice) + { + case 1: + insertAtFront(); + cout << endl; + break; + case 2: + insertAtLast(); + cout << endl; + break; + case 3: + int x; + cout << "Enter the node information: "; + cin >> x; + insertAtPosition(x); + cout << endl; + break; + case 4: + deleteAtFront(); + cout << endl; + break; + + case 5: + deleteAtLast(); + cout << endl; + break; + + case 6: + int y; + cout << "Enter the node information: "; + cin >> y; + deleteAtPosition(y); + cout << endl; + break; + + case 7: + display(); + cout << endl; + break; + + case 8: + cout << "Exit" << endl; + return 0; + break; + + default: + cout << "Invalid Choice!" << endl; + break; + } + } + return 0; } -}; -int main() -{ - Linked_List ll; - int d,c; - char choice; - ll.insertatbeg(1); - ll.insertatbeg(2); - ll.insertatbeg(3); - ll.print(); - ll.insertatend(4); - ll.print(); - // ll.insertatK(10,3); - //ll.print(); - ll.delatend(); - ll.print(); - ll.delatend(); - ll.print(); - // ll.delatend(); - //ll.print(); -} + +/** + +************************************** +* Circular Doubly Linked List * +************************************** + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 1 +Enter the value to be inserted: 21 + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 1 +Enter the value to be inserted: 52 + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 7 +Elements of Doubly Linked List are: 52 21 + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 2 +Enter the value to be inserted: 99 + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 3 +Enter the node information: 21 +Enter the value to be inserted: 45 + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 7 +Elements of Doubly Linked List are: 52 21 45 99 + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 4 +Element 52 is removed. + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 5 +Element 99 is removed. + +1. Insert node at the beginning +2. Insert node at the end +3. Insert node at given position +4. Delete node at front +5. Delete node at last +6. Delete node at given position +7. Display elements of linked list +8. Exit + +Enter your choice: 7 +Elements of Doubly Linked List are: 21 45 + +*/ From af6cc495e5147d3e8281ebb0a7468ea08ffcd50d Mon Sep 17 00:00:00 2001 From: Aman-Codes <54680709+Aman-Codes@users.noreply.github.com> Date: Mon, 16 Mar 2020 15:57:28 +0530 Subject: [PATCH 003/265] Adding ASCII_Subsequence in C, Python and JavaScript (Closes issue #1703) (#2290) * Add files via upload * Improved Indentation Improved Indentation * Update ASCII_Subsequences.c * Update ASCII_Subsequences.c * Update ASCII_Subsequences.js * Update ASCII_Subsequences.py * Update ASCII_Subsequences.js * Update ASCII_Subsequences.py --- Ascii_Subsequences/ASCII_Subsequences.c | 110 +++++++++++++++++++++++ Ascii_Subsequences/ASCII_Subsequences.js | 46 ++++++++++ Ascii_Subsequences/ASCII_Subsequences.py | 36 ++++++++ 3 files changed, 192 insertions(+) create mode 100644 Ascii_Subsequences/ASCII_Subsequences.c create mode 100644 Ascii_Subsequences/ASCII_Subsequences.js create mode 100644 Ascii_Subsequences/ASCII_Subsequences.py diff --git a/Ascii_Subsequences/ASCII_Subsequences.c b/Ascii_Subsequences/ASCII_Subsequences.c new file mode 100644 index 000000000..69d4c5a9e --- /dev/null +++ b/Ascii_Subsequences/ASCII_Subsequences.c @@ -0,0 +1,110 @@ +/*ASCII SUBSEQUENCES PROBLEM +This problem is same as the "Subsequences" question just instead of two function calls, three function calls will be made : +- One with the same string. +- One with a letter added. +- One with the ASCII code of the letter added to the string. +*/ + +#include +#include +#include +#include + +char str[100]; + +void subseq(char s[], int i, char str[]) +{ + if(i == strlen(str)) + { + printf("%s\n", s); + return; + } + + // The 3 function calls in the same order as explained above. + // First function call + subseq(s, i + 1, str); + + int i1; + char s2[strlen(s) + 2]; + + for(i1 = 0; i1 < strlen(s); i1++) + { + // Copy string from s to s2 + s2[i1] = s[i1]; + } + + // Concatinate ith character of string str to s2 + s2[i1++] = str[i]; + s2[i1] = '\0'; + + // Second function call + subseq(s2, i + 1, str); + + // Integer n stores the ASCII value of the ith character of string str + int i2, n = (int)str[i]; + char s3[strlen(s) + 2]; + + // Create AsciiString to store the ASCII value of the ith character of string str + char AsciiString[5]; + + if(n < 10) + { + AsciiString[0] = (char)(n + 48); + AsciiString[1] = '\0'; + } + else if(n<100) + { + AsciiString[0] = (char)(((n - (n % 10)) / 10) + 48); + AsciiString[1] = (char)((n % 10) + 48); + AsciiString[2] = '\0'; + } + else + { + AsciiString[0] = (char)(((n - (n % 100)) / 100) + 48); + AsciiString[1] = (char)((((n - (n % 10)) / 10) % 10) + 48); + AsciiString[2] = (char)((n % 10) + 48); + AsciiString[3] = '\0'; + } + + for(i2 = 0; i2 < strlen(s); i2++) + { + // Copy string from s to s3 + s3[i2] = s[i2]; + } + + int i3 = i2; + + for(; i2 < strlen(AsciiString) + strlen(s); i2++) + { + // Concatinate AsciiString into s3 + s3[i2] = AsciiString[i2 - i3]; + } + + s3[i2] = '\0'; + // Third function call + subseq(s3, i + 1, str); +} + +int main() +{ + printf("Enter the string\n"); + scanf("%s", str); + printf("Number of Subsequences : %d\n", (int)pow(3, strlen(str))); + subseq("", 0, str); + return 0; +} + +/*Sample Input: Enter the string: +ab +Sample Output: +Number of Subsequences : 9 + +b +98 +a +ab +a98 +97 +97b +9798 +*/ diff --git a/Ascii_Subsequences/ASCII_Subsequences.js b/Ascii_Subsequences/ASCII_Subsequences.js new file mode 100644 index 000000000..b3ed3fe56 --- /dev/null +++ b/Ascii_Subsequences/ASCII_Subsequences.js @@ -0,0 +1,46 @@ +/*ASCII SUBSEQUENCES PROBLEM +This problem is same as the "Subsequences" question just instead of two function calls, three function calls will be made : +- One with the same string. +- One with a letter added. +- One with the ascii code of the letter added to the string. +*/ + +function subseq(s, i, str) +{ + if(i === str.length) + { + console.log(s); + return; + } + + // The 3 function calls in the same order as explained above. + // First function call + subseq(s, i + 1, str); + // Second function call + subseq(s + str[i], i + 1, str); + var n = str.charCodeAt(i); + // Third function call with the ASCII value of the ith element of the string + subseq(s + n.toString(), i + 1, str); +} + +( function IIFE() { + var str = prompt("Enter the string"); + console.log( "Number of Subsequences : ", Math.pow(3, str.length)); + subseq("", 0, str); + return 0; +})(); + +/*Sample Input: Enter the string: +ab +Sample Output: +Number of Subsequences : 9 + +b +98 +a +ab +a98 +97 +97b +9798 +*/ diff --git a/Ascii_Subsequences/ASCII_Subsequences.py b/Ascii_Subsequences/ASCII_Subsequences.py new file mode 100644 index 000000000..5981573eb --- /dev/null +++ b/Ascii_Subsequences/ASCII_Subsequences.py @@ -0,0 +1,36 @@ +"""ASCII SUBSEQUENCES PROBLEM +This problem is same as the "Subsequences" question just instead of two function calls, three function calls will be made : +- One with the same string. +- One with a letter added. +- One with the ASCII code of the letter added to the string.""" + +def subseq(s, i, string1): + if (i == len(string1)): + print(s) + return + #The 3 function calls in the same order as explained above. + # First function call + subseq(s, i + 1, string1) + # Second function call + subseq(s + string1[i], i + 1, string1) + #Third function call in which ord(string1[i]) gives the ASCII value which is then converted to string for concatenation + subseq(s + str(ord(string1[i])),i + 1, string1) + +string1 = input("Enter the string") +print("Number of Subsequences :", pow(3, len(string1))) +subseq("", 0, string1) + +"""Sample Input: Enter the string +ab +Sample Output: +Number of Subsequences : 9 + +b +98 +a +ab +a98 +97 +97b +9798 +""" From 9555f9f18bc6eff87a557e17898495994a6484a0 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Mon, 16 Mar 2020 16:13:25 +0530 Subject: [PATCH 004/265] check whether a string is palindrome (#2402) * pallindrome string python * Update and rename pallindrome_string.py to palindrome_string.py Fixed Typo in file name * Update palindrome_string.py --- Palindrome/palindrome_string.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Palindrome/palindrome_string.py diff --git a/Palindrome/palindrome_string.py b/Palindrome/palindrome_string.py new file mode 100644 index 000000000..3aa4aac24 --- /dev/null +++ b/Palindrome/palindrome_string.py @@ -0,0 +1,32 @@ +# Python program to find whether a string is a palindrome or not + +# Function to reverse a String +def reverse(str): + + # Initialize variable + rev = "" + + for i in range (len(str)-1, -1, -1): + rev = rev + str[i] + return rev + + +# --- main --- +string = raw_input(("Enter a string: ")) #User Input + +a = reverse(string) #Function call + +if(a == string): #Comparing the reversed String with original String + print("String entered is palindrome!") +else: + print("String entered is not a palindrome!") + +''' +TEST CASES + +Enter a string: affcffa +String entered is palindrome! + +Enter a string: abbcd +String entered is not a palindrome! +''' From 41591c0ce21c0a3f61b4da969b622ba072a045d3 Mon Sep 17 00:00:00 2001 From: Yashasvi Sinha <59117774+heisastark@users.noreply.github.com> Date: Mon, 16 Mar 2020 16:16:04 +0530 Subject: [PATCH 005/265] added Power_Of_Two in JS (#2362) * added Power_Of_Twoin JS * Added space around minus in line 11 --- Power_Of_Two/Power_Of_Two.js | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 Power_Of_Two/Power_Of_Two.js diff --git a/Power_Of_Two/Power_Of_Two.js b/Power_Of_Two/Power_Of_Two.js new file mode 100644 index 000000000..e74f9922c --- /dev/null +++ b/Power_Of_Two/Power_Of_Two.js @@ -0,0 +1,33 @@ +/* +To check whether a number is a power of two or not, +we do bitwise "and" of number and number - 1, if the +result is zero the number is a power of two. +Example: number = 4, then 4 & 3 i.e 100 && 011 is 0 +16 & 15 i.e 10000 & 01111 = 0 +This is true for all powers of two. +*/ + +function isPowerofTwo(n){ + return n && ( ! ( n & (n - 1) )); +} + +var num = parseInt(prompt("Enter a number to check:")); + +if(isPowerofTwo(num)){ + console.log("The number is a power of two"); +} +else{ + console.log("The number is not a power of two"); +} + + +/* +Input: +64 +Output: +The number is a power of two +Input: +5 +Output: +The number is not a power of two +*/ From 38be455c219b8629fff0f3211e2348fc5540c162 Mon Sep 17 00:00:00 2001 From: Sohel Raja Molla Date: Mon, 16 Mar 2020 20:47:57 +0530 Subject: [PATCH 006/265] Implementation of Pascal Triangle in Java and Python Added --- Pascal_Triangle/Pascal_Triangle.java | 51 ++++++++++++++++++++++++++++ Pascal_Triangle/Pascal_Triangle.py | 30 ++++++++++++++++ 2 files changed, 81 insertions(+) create mode 100644 Pascal_Triangle/Pascal_Triangle.java create mode 100644 Pascal_Triangle/Pascal_Triangle.py diff --git a/Pascal_Triangle/Pascal_Triangle.java b/Pascal_Triangle/Pascal_Triangle.java new file mode 100644 index 000000000..3a0fda487 --- /dev/null +++ b/Pascal_Triangle/Pascal_Triangle.java @@ -0,0 +1,51 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.*; + +class Pascal_Triangle { + public static void main (String[] args) throws IOException{ + // Taking The Input from User + System.out.print("Enter the number of rows to be printed: "); + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + // Converting String Into Integer + int rows = Integer.parseInt(br.readLine()); + // Calling the Pascal Class + new Pascal(rows); + } +} + +class Pascal { + Pascal(int n) + { + for(int row = 1; row <= n; row++) + { + // Initializing the Initial Value of Pascal Value as 1 + int pascal_value = 1; + // For Pring Blank Space + for(int i = 1; i < n - row + 1; i++){ + System.out.print(" "); + } + System.out.print(" "); + // For calculating the Pascal Value + for(int i = 1; i <= row; i++) + { + // Assigning the Printable string to string s and printing the s + String s = " " + pascal_value + " "; + System.out.print(s); + // Calculating the New Pascal Value + pascal_value = pascal_value * (row - i) / i; + } + System.out.println(); + } + } +} + +//Input: +//Enter the number of rows to be printed: 5 + +//Output: +// 1 +// 1 1 +// 1 2 1 +// 1 3 3 1 +// 1 4 6 4 1 diff --git a/Pascal_Triangle/Pascal_Triangle.py b/Pascal_Triangle/Pascal_Triangle.py new file mode 100644 index 000000000..532b64c48 --- /dev/null +++ b/Pascal_Triangle/Pascal_Triangle.py @@ -0,0 +1,30 @@ +def Pascal_Triangle(n): + for row in range(1, n + 1): + # Initializing the Initial Value of Pascal Value as 1 + pascal_value = 1 + # For printing blank spaces + for i in range(1, n - row + 1): + print(' ', end=' ') + # For calculating the pascal value + for i in range(1, row + 1): + # Creating the printable string and printing the string + s = ' ' + str(pascal_value) + ' ' + print(s, end = " ") + # Calculating the new Pascal Value + pascal_value = int(pascal_value * (row - i) / i) + print(end = '\n') + +# Taking the Input from the user +rows = int(input("Enter the number of rows to be printed: ")) +# Calling the Function +Pascal_Triangle(rows) + +# Input: +# Enter the number of rows to be printed: 5 + +# Output: +# 1 +# 1 1 +# 1 2 1 +# 1 3 3 1 +# 1 4 6 4 1 From da2f29155413ebe635bca8994111b1d3dcdb843a Mon Sep 17 00:00:00 2001 From: Sukriti Shah Date: Wed, 18 Mar 2020 14:31:02 +0530 Subject: [PATCH 007/265] Adding Python Implementation for Kosaraju Algorithm (Issue #2246) (#2488) * Adding Python implementation for issue #2246 * Update Kosaraju_Algorithm.py --- Kosaraju_Algorithm/Kosaraju_Algorithm.py | 83 ++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 Kosaraju_Algorithm/Kosaraju_Algorithm.py diff --git a/Kosaraju_Algorithm/Kosaraju_Algorithm.py b/Kosaraju_Algorithm/Kosaraju_Algorithm.py new file mode 100644 index 000000000..a7c0bca7b --- /dev/null +++ b/Kosaraju_Algorithm/Kosaraju_Algorithm.py @@ -0,0 +1,83 @@ +# Python implementation of Kosaraju's Algorithm +# Kosaraju's Algorithm is used to print all Strongly Connected Components (SCCs) in a directed graph +# A component is said to be strongly connected if there is a path between all pairs of vertices in it. + +# Kosaraju’s Algorithm involves two passes of Depth First Search in order to find the number of SCCs + +# defaultdict is a useful technique for building graphs. +from collections import defaultdict + +# Function for first DFS pass and to fill vertices in finishStack +def firstDFS(g, v, visited, finishStack): + visited[v] = True + for i in g[v]: + if visited[i] == False: + firstDFS(g, i, visited, finishStack) + finishStack = finishStack.append(v) + +# Function for second DFS pass +def secondDFS(gt, v, visited): + visited[v] = True + print(v, end = " ") + for i in gt[v]: + if visited[i] == False: + secondDFS(gt, i, visited) + +# Create Graph +v = int(input("Enter number of vertices in the graph: ")) + +# g represents original graph +g = defaultdict(list) + +# gt represents transpose of original graph +gt = defaultdict(list) + +e = int(input("Enter number of edges in the graph: ")) +for i in range(1 , e + 1): + print("Edge no. %d - "%(i), end = "") + num = list(map(int, input(' ').split())) + g[num[0]].append(num[1]) + gt[num[1]].append(num[0]) + +# Stack to be filled according to finishing time +finishStack = [] + +# Maintaining visited array of size v +# All vertices are marked False for first DFS pass +visited = [False] * v + +# First DFS on g +for i in range(v): + if visited[i] == False: + firstDFS(g, i, visited, finishStack) + +print ("Strongly connected components(SCCs) in the graph are: ") + +# Maintaining visited array of size v +# All vertices are marked False for second DFS pass +visited = [False] * v + +# Second DFS on gt +while finishStack: + i = finishStack.pop() + if visited[i] == False: + secondDFS(gt, i, visited) + print() + +''' +Sample Input: +Enter number of vertices in the graph: 6 +Enter number of edges in the graph: 7 +Edge no. 1 - 0 1 +Edge no. 2 - 1 2 +Edge no. 3 - 2 0 +Edge no. 4 - 2 3 +Edge no. 5 - 3 4 +Edge no. 6 - 4 5 +Edge no. 7 - 5 3 + +Sample Output: +Strongly connected components(SCCs) in the graph are: +0 2 1 +3 5 4 +''' From d54e5611b03541e5ddb8f541efe0caa2312724a2 Mon Sep 17 00:00:00 2001 From: Swayamprava Satpathy <43417696+Xxoliaxx@users.noreply.github.com> Date: Wed, 18 Mar 2020 14:39:00 +0530 Subject: [PATCH 008/265] Added code for Round Robin Scheduling (#1928) * Add files via upload * Update Readers_Writers_Problem.cpp * Update Readers_Writers_Problem.cpp * Add files via upload * Update Round_Robin_Scheduling.cpp * Delete Round_Robin_Scheduling.cpp * Add files via upload * Delete Readers_Writers_Problem.cpp * Indentation and space around operators fix * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp --- .../C++/Preemptive/Round_Robin_Scheduling.cpp | 104 ++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 Scheduling_Algorithm/C++/Preemptive/Round_Robin_Scheduling.cpp diff --git a/Scheduling_Algorithm/C++/Preemptive/Round_Robin_Scheduling.cpp b/Scheduling_Algorithm/C++/Preemptive/Round_Robin_Scheduling.cpp new file mode 100644 index 000000000..ae27ba4db --- /dev/null +++ b/Scheduling_Algorithm/C++/Preemptive/Round_Robin_Scheduling.cpp @@ -0,0 +1,104 @@ +/*Round Robin Scheduling is a CPU scheduling algorithm where each process is assigned a fixed time slot in a cyclic way. +It is preemtive in nature. +It is cyclic in nature so starvation doesn’t occur +It is variant of first come, first served scheduling +No priority given to any process or task +It is also known as Time slicing scheduling +-Arrival Time: Time at which the process arrives in the ready queue. +-Burst Time: Time required by a process for CPU execution. +-Turn Around Time: Time Difference between completion time and arrival time. +-Waiting Time: Time Difference between turn around time and burst time. */ + +#include +using namespace std; + +int main() +{        + int i, j, no_of_process, current_time, remaining_time; + int f = 0, time_slice, wait_time = 0, turn_time = 0; +    cout << "Enter number of processes: "; +    cin >> no_of_process; + +    int a[no_of_process]; //Arrival Time + int b[no_of_process]; //Burst Time + int r[no_of_process]; +    remaining_time = no_of_process; + +    for(i = 0; i < no_of_process; i++) +    { + cout << "\nProcess " << i << ": "; +       cout << "Enter Arrival Time: "; +       cin >> a[i]; +       cout << "Enter Burst Time: "; +       cin >> b[i]; +       r[i] = b[i]; +    } + +    cout << "Enter Time slice: "; +    cin >> time_slice; + +    cout << "\nProcess\tTurnaround time\t Waiting Time\n"; + cout << "-------------------------------------------"; +    for(current_time = 0, i = 0; remaining_time != 0;) +    { + //If burst time is less than time slice + if(r[i] <= time_slice && r[i] > 0) +       { + current_time += r[i]; //Increase current time by adding burst time +          r[i] = 0; //Make remaining time zero +            f = 1; +        } + //If required time is more than time slice +        else if(r[i] > 0) +       {        + r[i] -= time_slice; //Reduce remaining time by time slice +            current_time += time_slice; //Increase current time by adding time slice +        } + +        if(r[i] == 0 && f == 1) +        { + remaining_time--; +            cout << "\nProcess " << i << "\t" << current_time - a[i] << "\t\t" << current_time - a[i] - b[i]; +            wait_time += current_time - a[i] - b[i]; +            turn_time += current_time - a[i]; +            f = 0; +        } +        if(i >= no_of_process - 1) +            i = 0; +       else if(a[i+1] <= current_time) +            i++; +       else +            i = 0; +     } +     cout << "\nAverage Waiting Time: " << (wait_time*1.0) / no_of_process; +     cout << "\nAverage Turnaround Time: " << (turn_time*1.0) / no_of_process; +     return 0; +} + +/* +Sample Input/Output: + +Enter number of processes: 4 + +Process 0: Enter Arrival Time: 1 +Enter Burst Time: 5 + +Process 1: Enter Arrival Time: 3 +Enter Burst Time: 7 + +Process 2: Enter Arrival Time: 2 +Enter Burst Time: 5 + +Process 3: Enter Arrival Time: 5 +Enter Burst Time: 8 +Enter Time slice: 3 + +Process Turnaround time Waiting Time +------------------------------------------- +Process 0 13 8 +Process 2 17 12 +Process 1 20 13 +Process 3 20 12 +Average Waiting Time: 11.25 +Average Turnaround Time: 17.5 +*/ From 199ea87e49c6a5d9528b28b8aa015bf5b8599ce3 Mon Sep 17 00:00:00 2001 From: Chanpreet Singh <34856246+chanpreet1999@users.noreply.github.com> Date: Wed, 18 Mar 2020 18:18:11 +0530 Subject: [PATCH 009/265] Closes Issue #1601 (#1744) Added Count Frequency Of Elements In Java For issue #1601 --- .../CountFrequencyOfArrayElements.java | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 Freq_Of_Elements_Of_Array/CountFrequencyOfArrayElements.java diff --git a/Freq_Of_Elements_Of_Array/CountFrequencyOfArrayElements.java b/Freq_Of_Elements_Of_Array/CountFrequencyOfArrayElements.java new file mode 100644 index 000000000..d44303278 --- /dev/null +++ b/Freq_Of_Elements_Of_Array/CountFrequencyOfArrayElements.java @@ -0,0 +1,62 @@ +/*Problem Statement + * Given an array of elements count the frequency of every element in the array. + */ + +import java.util.HashMap; +import java.util.Scanner; + +public class CountFrequencyOfArrayElements +{ + + public static void main(String[] args) + { + Scanner sc = new Scanner(System.in); + + // input size of array + int n = sc.nextInt(); + // input array + int a[] = new int[n]; + for(int i = 0; i < n; i++) + a[i] = sc.nextInt(); + + countFreq(a, n); + + sc.close(); + } + + // function to count frequency + private static void countFreq(int[] a, int n) { + // using hashmap to store the freq + HashMap hm = new HashMap<>(); + for(int i = 0; i < n; i++) + { + if( hm.containsKey(a[i]) ) + hm.put( a[i], hm.get(a[i]) + 1); + else + hm.put(a[i], 1); + } + + //display the frequencies + System.out.println("Element \t Frequency"); + hm.forEach( + (k,v) -> + { + System.out.println(k + " \t\t " + v); + } + ); + } + +} + +/* + * Input : +5 +2 1 1 6 1 + + * Output : +Element Frequency +1 3 +2 1 +6 1 + + * */ From 4b17a3e9b29225931199b56e84757330edae3304 Mon Sep 17 00:00:00 2001 From: parjanyaacoder <46294122+parjanyaacoder@users.noreply.github.com> Date: Wed, 18 Mar 2020 18:20:35 +0530 Subject: [PATCH 010/265] Pancake Sorting in Java (#2022) * Pancake Sorting implemented in Java language For issue #1988 --- Pancake_Sort/Pancake_Sort.java | 73 ++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Pancake_Sort/Pancake_Sort.java diff --git a/Pancake_Sort/Pancake_Sort.java b/Pancake_Sort/Pancake_Sort.java new file mode 100644 index 000000000..c26136fe0 --- /dev/null +++ b/Pancake_Sort/Pancake_Sort.java @@ -0,0 +1,73 @@ +/* Pancake Sorting is a Sorting Technique in which the array of length n can be sorted only by reversing the array upto an index i where i is in range of 0 to n - 1 */ + +import java.util.* ; +class PancakeSorting +{ + + static void reverseArray ( int a [] , int n ) // This functions reverses the array upto index n + { + int temp[] = new int [ n + 1 ] ; // temp is the temporary array + for ( int i = 0 ; i <= n ; i ++ ) + { + temp [ i ] = a [ n - i ] ; + } + for ( int i = 0 ; i <= n ; i ++ ) + a [ i ] = temp [ i ] ; + } + + + static int findMax ( int a [] , int n ) // Function to find index of max element upto index n + { + int max = a [ 0 ] ; int j = 0 ; // j stores the index of max element + for ( int i = 1 ; i <= n ; i ++ ) + { + if ( a [ i ] > max ) + { + max = a [ i ] ; + j = i ; + } + } + + return j ; + + } + + + static void pancakeSort ( int a [ ] , int n ) + { + int currentLength ; + for ( currentLength = n ; currentLength > 0 ; -- currentLength ) + { + int j = findmax ( a , currentLength - 1 ) ; + if ( j != currentLength ) + { + reverseArray ( a , j ) ; + reverseArray ( a , currentLength-1 ) ; + } + } + } + + + public static void main ( String [] args ) + { + Scanner sc = new Scanner ( System.in ) ; + int i , j , k , l , m , n ; + n = sc.nextInt () ; + int array [ ] = new int [ n ] ; + for ( i = 0 ; i < n ;i ++) + array [ i ] = sc.nextInt () ; + pancakesort ( array , n ) ; + for ( i = 0 ; i < n ; i ++) + System.out.print ( array [ i ] + " " ) ; + System.out.println ( ) ; + } + + +} + + +/* Input +n = 5 array = { 5 , 4 , 3 , 2 , 1 } + + Output +1 2 3 4 5 */ From e274d7140445a4e27d70d1551f9de7dd26cc9541 Mon Sep 17 00:00:00 2001 From: "Abhushan A. Joshi" <49617450+abhu-A-J@users.noreply.github.com> Date: Wed, 18 Mar 2020 22:33:29 +0530 Subject: [PATCH 011/265] Implementation of Bucket Sort in JS (#2431) --- Bucket_Sort/Bucket_Sort.js | 64 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 Bucket_Sort/Bucket_Sort.js diff --git a/Bucket_Sort/Bucket_Sort.js b/Bucket_Sort/Bucket_Sort.js new file mode 100644 index 000000000..ee9a8c90e --- /dev/null +++ b/Bucket_Sort/Bucket_Sort.js @@ -0,0 +1,64 @@ +/* + Bucket sort is a comparison sort algorithm that operates on elements by dividing + them into different buckets and then sorting these buckets individually. +*/ + +const insertionSort = arr => { + let i, j; + for (i = 1; i < arr.length; i++) { + let currentVal = arr[i]; + for (j = i - 1; j >= 0; j--) { + if (currentVal > arr[j]) { + break; + } + else { + arr[j + 1] = arr[j]; + } + } + arr[j + 1] = currentVal; + } + return arr; +} + +const bucketSort = arr => { + + if (arr.length === 0) { + return arr; + } + + // finding minimum and maximum value and setting bucket size + let minValue = Math.min(...arr); + let maxValue = Math.max(...arr); + let bucketSize = 10; + + let bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1; + + let buckets = Array.from({ length: bucketCount }, () => []); + + // Pushing values to buckets + for (let i = 0; i < arr.length; i++) { + let index = Math.floor((arr[i] - minValue) / bucketSize); + buckets[index].push(arr[i]); + } + + // reset the input array to store sorted result + arr.length = 0; + + // sort individual buckets and put the elements onto the array + buckets.forEach(function (bucket) { + insertionSort(bucket); + bucket.forEach(function (value) { + arr.push(value) + }); + }); + + return arr; +} + +// I/P and O/P examples + +// [ -11, -10, -1, 2, 4 ] +console.log(bucketSort([-1, 2, 4, -10, -11])); + +// [ -11, -10, 4, 100, 200 ] +console.log(bucketSort([100, 200, 4, -10, -11])); \ No newline at end of file From e8f269283a74b0f4eb2c18075927494b3ac7e52f Mon Sep 17 00:00:00 2001 From: shweta gurnani <43384092+shwetagurnani@users.noreply.github.com> Date: Thu, 19 Mar 2020 00:21:28 +0530 Subject: [PATCH 012/265] Create Readme.md (#2383) * Create Readme.md * Update Readme.md --- Ternary_Search/Readme.md | 46 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Ternary_Search/Readme.md diff --git a/Ternary_Search/Readme.md b/Ternary_Search/Readme.md new file mode 100644 index 000000000..f2f14dfc4 --- /dev/null +++ b/Ternary_Search/Readme.md @@ -0,0 +1,46 @@ +# Ternary Search + +Ternary search is a searching technique that is used to search the position of a specific value in an array. Ternary search is a divide-and-conquer algorithm. It is mandatory for the array to be sorted (in which you will search for an element). + +The array is divided into three parts and then we determine in which part the element exists. In this search, after each iteration it neglects ⅓ part of the array and repeats the same operations on the remaining ⅔. + +## Algorithm + + 1.mid1 = start + (end - start) / 3 and mid2 = mid1 + (end - start) / 3. + + 2.Compare the element to be searched with the element at mid1. If they are equal then return mid1. + + 3.Compare the element to be searched with the element at mid2. If they are equal then return mid2. + + 4.If the element to be searched is less than element at mid1 recur to the first part, otherwise if it is greater than the element at mid2 recur to the third part. If not both, then recur to the second part. + +## Pseudo Code + +``` + ternarySearch(array, start, end, searchKey) + if start <= end then + mid1 = start + (end - start) / 3 + mid2 = mid1 + (end - start) / 3 + if array[mid1] = searchKey then + return mid1 + if array[mid2] = searchKey then + return mid2 + if searchKey < array[mid1] then + call ternarySearch(array, start, mid1 - 1, searchKey) + if searchKey > array[mid2] then + call ternarySearch(array, mid2 + 1, end, searchKey) + else + call ternarySearch(array, mid1 + 1, mid2-1, searchKey) +``` + +## Complexity + Time Complexity: O(log3 n) + Space Complexity: O(1) + + ## Implementation + * [C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ternary_Search/Ternary_Search.c) + * [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ternary_Search/Ternary_Search.cpp) + * [Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ternary_Search/Ternary_Search.java) + * [Coffee Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ternary_Search/Ternary_Search.coffee) + * [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ternary_Search/Ternary_Search.py) + * [JS Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ternary_Search/Ternary_Search.js) From fe80d529dabbccd9b5651549819897811e723bf7 Mon Sep 17 00:00:00 2001 From: Arghadip Chakraborty Date: Thu, 19 Mar 2020 01:26:04 +0530 Subject: [PATCH 013/265] Added KNN algorithm using C (#2074) Fixed indentation Fixed indentation Fixed indentation again Fixed indentation Added more comments in the code Fixed Identaion and few coding conventions Fixed Identaion Fixed Identaion and few coding conventions --- .../K_Nearest_Neighbours.c | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbours.c diff --git a/Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbours.c b/Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbours.c new file mode 100644 index 000000000..ce0f639d3 --- /dev/null +++ b/Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbours.c @@ -0,0 +1,117 @@ +#include +#include +#include + +typedef struct point{ + float w, x, y, z; // features or co-ordinates of the point + float distance; // Distance from test point + int op; // label of the point +}point; + +int main() { + int i, j, n, k; + point p; + point temp; + printf("Number of data points: "); + scanf("%d", &n); + point arr[n]; + printf("\nEnter the dataset values: \n"); + printf("w\tx\ty\tz\top\n"); + + // Taking input data + for (i = 0; i < n; i++) { + scanf("%f%f%f%f%d", &arr[i].w, &arr[i].x, &arr[i].y, &arr[i].z, &arr[i].op); + } + printf("w\tx\ty\tz\top\n"); + for (i = 0; i < n; i++) { + printf("%.2f\t%.2f\t%.2f\t%.2f\t%d\n", arr[i].w, arr[i].x, arr[i].y, arr[i].z, arr[i].op); + } + + // Taking the feature values or co-ordinates of the unknown data point + printf("\nEnter the feature values of the unkown point: \nw\tx\ty\tz\n"); + scanf("%f%f%f%f", &p.w, &p.x, &p.y, &p.z); + + // Measuring the Euclidean distances + for (i = 0; i < n; i++) { + arr[i].distance = sqrt((arr[i].w - p.w) * (arr[i].w - p.w) + (arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y) + (arr[i].z - p.z) * (arr[i].z - p.z)); + } + + //Sorintg the training data with resptect to the Euclidean distances + for (i = 1; i < n; i++) { + for (j = 0; j < n - i; j++) { + if (arr[j].distance > arr[j + 1].distance) { + temp = arr[j]; + arr[j] = arr[j + 1]; + arr[j + 1] = temp; + } + } + } + printf("w\tx\ty\tz\top\tdistance\n"); + for (i = 0; i < n; i++) { + printf("%.2f\t%.2f\t%.2f\t%.2f\t%d\t%.2f\n", arr[i].w, arr[i].x, arr[i].y, arr[i].z, arr[i].op, arr[i].distance); + } + + // Taking the K -nearest neighbors + printf("\nNumber of nearest neighbors(k): "); // Value of K + scanf("%d", &k); + + // Measuring the frequencies of each label in K nearest neighbors' data + int freq1 = 0; // for label 1 + int freq2 = 0; // for label 2 + int freq3 = 0; // for label 3 + int none = 0; + for (i = 0; i < k; i++) { + if (arr[i].op == 1) + freq1++; + else if (arr[i].op == 2) + freq2++; + else if(arr[i].op == 3) + freq3++; + else + none++; + } + + // Printing the label of the unknown data + if(freq1 >= freq2 && freq1 >= freq3) { + printf("\nThe class of unknown point is: 1"); + } + else if(freq2 >= freq1 && freq2 >= freq3 ) { + printf("\nThe class of unknown point is: 2"); + } + else { + printf("\nThe class of unknown point is: 3"); + } +} + +/*Sample Input and Output: +------------------------ +Number of data points: 5 + +Enter the dataset values: +w x y z op +1 2 4 3 1 +1 3 2 1 1 +8 7 6 9 2 +7 8 6 9 2 +6 9 7 5 2 +w x y z op +1.00 2.00 4.00 3.00 1 +1.00 3.00 2.00 1.00 1 +8.00 7.00 6.00 9.00 2 +7.00 8.00 6.00 9.00 2 +6.00 9.00 7.00 5.00 2 + +Enter the feature values of the unkown point: +w x y z +8 7 5 9 +w x y z op distance +8.00 7.00 6.00 9.00 2 1.00 +7.00 8.00 6.00 9.00 2 1.73 +6.00 9.00 7.00 5.00 2 5.29 +1.00 2.00 4.00 3.00 1 10.54 +1.00 3.00 2.00 1.00 1 11.75 + +Number of nearest neighbors(k): 2 + +The class of unknown point is: 2 +*/ From 691b23a4cd549d095179ae2b418e7daa07029a7c Mon Sep 17 00:00:00 2001 From: Nikhil Patro Date: Thu, 19 Mar 2020 20:37:55 +0530 Subject: [PATCH 014/265] Added Bisection_Method.cpp (#2458) --- Bisection_Method/Bisection_Method.cpp | 122 ++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 Bisection_Method/Bisection_Method.cpp diff --git a/Bisection_Method/Bisection_Method.cpp b/Bisection_Method/Bisection_Method.cpp new file mode 100644 index 000000000..92541251d --- /dev/null +++ b/Bisection_Method/Bisection_Method.cpp @@ -0,0 +1,122 @@ +#include +#include +using namespace std; +// approximation limit +#define error 0.0001 + +//function of the polynomial is inputted here say f(x) = x*x - 2*x + 1 +float polynomial(float x) +{ + return x * x - 4 * x + 3; +} + +float mid(float q, float w) +{ + return (q + w) / 2; +} + +int main() +{ + int i; + float lower_bound, upper_bound, a, b; + + cout << "For the interval (a, b) where the root may lie : " << endl; + cout << "Enter the value of a :- " << endl; + cin >> lower_bound; + + a = lower_bound; + + cout << "Enter the value of b :- " << endl; + cin >> upper_bound; + + b = upper_bound; + + if(polynomial(lower_bound) * polynomial(upper_bound) > 0) + { + cout << "Invalid interval" << endl; + } + else + { + // repeat until the required accuracy is obtained + while(abs(polynomial(mid(lower_bound, upper_bound))) > error) + { + cout << "\nIteration_no = " << i << " , First_no = " << lower_bound + << " , Second_no = " << upper_bound << " middle = " + << mid(lower_bound, upper_bound) ; + cout << " , f(middle) = " << polynomial(mid(lower_bound, upper_bound)) + << " , f(first_no)*f(middle) = " + << polynomial(lower_bound)*polynomial(mid(lower_bound, upper_bound)) << endl; + // sign changes in the first interval => root lies in the 1st interval + if(polynomial(lower_bound) * polynomial(mid(lower_bound, upper_bound)) < 0) + { + upper_bound = mid(lower_bound, upper_bound); + } + else + { + lower_bound = mid(lower_bound, upper_bound); + } + i++; + } + cout << "\nIteration_no = " << i << " , First_no = " << lower_bound + << " , Second_no = " << upper_bound << " middle = " << mid(lower_bound, upper_bound) ; + cout << " , f(middle) = " << polynomial(mid(lower_bound, upper_bound)) + << " , f(first_no)*f(middle) = " + << polynomial(lower_bound)*polynomial(mid(lower_bound, upper_bound)) << endl; + cout << "\nThe approximated root of the given polynomial within the specified interval (" + << a << " , " << b << ") = " ; + cout << mid(upper_bound, lower_bound) << endl; + } + return 0; +} + +/* OUTPUT +For the interval (a, b) where the root may lie : +Enter the value of a :- +2.1 +Enter the value of b :- +4.1 + +Iteration_no = 0 , First_no = 2.1 , Second_no = 4.1 middle = 3.1 , f(middle) = 0.21 , +f(first_no)*f(middle) = -0.2079 + +Iteration_no = 1 , First_no = 2.1 , Second_no = 3.1 middle = 2.6 , f(middle) = -0.64 , +f(first_no)*f(middle) = 0.6336 + +Iteration_no = 2 , First_no = 2.6 , Second_no = 3.1 middle = 2.85 , f(middle) = -0.2775 , +f(first_no)*f(middle) = 0.1776 + +Iteration_no = 3 , First_no = 2.85 , Second_no = 3.1 middle = 2.975 , f(middle) = -0.0493755 , +f(first_no)*f(middle) = 0.0137017 + +Iteration_no = 4 , First_no = 2.975 , Second_no = 3.1 middle = 3.0375 , f(middle) = 0.0764065 , +f(first_no)*f(middle) = -0.00377261 + +Iteration_no = 5 , First_no = 2.975 , Second_no = 3.0375 middle = 3.00625 , f(middle) = 0.0125389 , +f(first_no)*f(middle) = -0.000619115 + +Iteration_no = 6 , First_no = 2.975 , Second_no = 3.00625 middle = 2.99062 , f(middle) = -0.0186625 , +f(first_no)*f(middle) = 0.000921469 + +Iteration_no = 7 , First_no = 2.99062 , Second_no = 3.00625 middle = 2.99844 , f(middle) = -0.00312233 , +f(first_no)*f(middle) = 5.82703e-005 + +Iteration_no = 8 , First_no = 2.99844 , Second_no = 3.00625 middle = 3.00234 , f(middle) = 0.00469303 , +f(first_no)*f(middle) = -1.46532e-005 + +Iteration_no = 9 , First_no = 2.99844 , Second_no = 3.00234 middle = 3.00039 , f(middle) = 0.000781059 , +f(first_no)*f(middle) = -2.43872e-006 + +Iteration_no = 10 , First_no = 2.99844 , Second_no = 3.00039 middle = 2.99941 , f(middle) = -0.00117207 , +f(first_no)*f(middle) = 3.65958e-006 + +Iteration_no = 11 , First_no = 2.99941 , Second_no = 3.00039 middle = 2.9999 , f(middle) = -0.000195503 , +f(first_no)*f(middle) = 2.29143e-007 + +Iteration_no = 12 , First_no = 2.9999 , Second_no = 3.00039 middle = 3.00015 , f(middle) = 0.000292778 , +f(first_no)*f(middle) = -5.7239e-008 + +Iteration_no = 13 , First_no = 2.9999 , Second_no = 3.00015 middle = 3.00002 , f(middle) = 4.86374e-005 , +f(first_no)*f(middle) = -9.50877e-009 + +The approximated root of the given polynomial within the specified interval (2.1, 4.1) = 3.00002 +*/ \ No newline at end of file From b4d253ff804166713336d5e162a91b7c2e6e40ac Mon Sep 17 00:00:00 2001 From: PratilipiAich <47985146+PratilipiAich@users.noreply.github.com> Date: Thu, 19 Mar 2020 22:21:42 +0530 Subject: [PATCH 015/265] Circular Queue in JAVA (#2471) * Added Circular_Queue.java * Added Circular_Queue.java Co-authored-by: pratilipi --- Circular_Queue/Circular_Queue.java | 248 +++++++++++++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 Circular_Queue/Circular_Queue.java diff --git a/Circular_Queue/Circular_Queue.java b/Circular_Queue/Circular_Queue.java new file mode 100644 index 000000000..10c736364 --- /dev/null +++ b/Circular_Queue/Circular_Queue.java @@ -0,0 +1,248 @@ +/* Circular Queue works by the process of circular increment +i.e. when we try to increment any variable and we reach the end of queue, +we start from the beginning of queue by modulo division with the queue size.*/ + +import java.util.Scanner; + +public class Circular_Queue { + int front, rear, size; + int[] arr; + + public Circular_Queue(int s) { + size = s; + arr = new int[s]; + front = rear = -1; + } + + public static void main(String[] args) { + int choice, value, s; + Scanner in = new Scanner(System.in); + + System.out.println("Enter the size of queue:"); + s = in.nextInt(); + Circular_Queue q = new Circular_Queue(s); + do { + System.out.println("\n1. Insert"); + System.out.println("2. Delete"); + System.out.println("3. Display"); + System.out.println("4. Exit"); + System.out.println("Enter choice: "); + choice = in.nextInt(); + switch (choice) { + case 1: + System.out.println("\nEnter the value: "); + value = in.nextInt(); + q.enQueue(value); + break; + case 2: + value = q.deQueue(); + if(value == -1) { + System.out.println("\nUNDERFLOW! Queue is Empty."); + break; + } + System.out.println("\n" + value + " Deleted from queue."); + break; + case 3: + q.display(); + break; + case 4: + System.exit(0); + default: + System.out.println("Invalid choice."); + + } + } while (choice != 4); + + } + + /* +Insertion: +1) Check whether queue is Full by (front == 0 && rear == size - 1) || (rear == (front - 1) % (size - 1)). +2) If it is full then display Queue is full. If queue is not full then, check + if (front == -1) then set front = rear = 0 and insert the first element. +3) If (rear == SIZE – 1 && front != 0) if it is true then set rear = 0 and insert element. +4) Otherwise increment rear by 1 and insert an element. +*/ +// Inserting the value in the queue + public void enQueue(int value) { + if ((front == 0 && rear == size - 1) || + (rear == (front - 1) % (size - 1))) { + System.out.println("\nOVERFLOW! Queue is Full."); + return; + } else if (front == -1) /* Insert First Element */ { + front = rear = 0; + arr[rear] = value; + } else if (rear == size - 1 && front != 0) { + rear = 0; + arr[rear] = value; + } else { + rear++; + arr[rear] = value; + } + } + + /* +Deletion: +1) Check whether queue is Empty with (front==-1). +2) If it is empty then display Queue is empty. +3) If queue is not empty then remove the element and Check if (front==rear) + if it is true then set front = rear= -1 else set front = (front + 1) % size and return the element. +*/ +// Deleting from queue + public int deQueue() { + if (front == -1) { + return -1; + + } + int element = arr[front]; + arr[front] = -1; + if (front == rear) { + front = -1; + rear = -1; + } + else { + if (front == size - 1) + front = 0; + else + front = front + 1; + } + return element; + } + + // Displaying the queue + public void display() { + if (front == -1) { + System.out.println("UNDERFLOW! Queue is Empty."); + return; + } + System.out.println("\nElements in Circular Queue are: "); + if (rear >= front) { + for (int i = front; i <= rear; i++) + System.out.print(arr[i] + "\t"); + } else { + for (int i = front; i < size; i++) + System.out.println(arr[i] + "\t"); + + for (int i = 0; i <= rear; i++) + System.out.println(arr[i] + "\t"); + } + } + +} +/* +Enter the size of queue: +4 + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +1 + +Enter the value: +10 + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +1 + +Enter the value: +20 + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +1 + +Enter the value: +30 + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +1 + +Enter the value: +40 + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +1 + +Enter the value: +50 + +OVERFLOW! Queue is Full. + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +3 + +Elements in Circular Queue are: +10 20 30 40 +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +2 + +10 Deleted from queue. + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +2 + +20 Deleted from queue. + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +2 + +30 Deleted from queue. + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +2 + +40 Deleted from queue. + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +2 + +UNDERFLOW! Queue is Empty. + +1. Insert +2. Delete +3. Display +4. Exit +Enter choice: +4 + */ From baa09a61ea51195f9dbc9bbbfa7db926c7e7a7ff Mon Sep 17 00:00:00 2001 From: Ravi Kanth Gojur Date: Thu, 19 Mar 2020 22:45:42 +0530 Subject: [PATCH 016/265] Fibonacci_Number using DP approach added (#2060) * Fibonacci_Number using DP approach added indentation corrected * Indentation Corrected * Fibonacci number using DP Approach added --- .../Fibonacci_Number_Using_DP_Approach.c | 53 ++++++++++++++++ .../Fibonacci_Number_Using_DP_Approach.cpp | 51 ++++++++++++++++ .../Fibonacci_Number_Using_DP_Approach.java | 60 +++++++++++++++++++ 3 files changed, 164 insertions(+) create mode 100644 Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.c create mode 100644 Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.cpp create mode 100644 Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.java diff --git a/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.c b/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.c new file mode 100644 index 000000000..530cb4c1d --- /dev/null +++ b/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.c @@ -0,0 +1,53 @@ +#include +int dp[100005] = {0}; + +int fibDP(int n) +{ + if(n == 0 || n == 1) + { + return n; + } + /* This is used to print the values or series of given fibonacci number + if(dp[n] != 0) + { + return dp[n]; + }*/ + + /* This recursion is to hold the values till cand1 = 1(from 5-4-3-2-1), cand2 = 1(5-3-1) */ + int cand1 = fibDP(n - 1); + int cand2 = fibDP(n - 2); + + /* + Later, it will go back to its previous values(2-3), cand1, cand2 values will be updated. + after, getting values (1,1), those values get added and updated at 5th index. + this will repeat in each iteration, + You can check(print) manually the values of cand1, cand2, n and dp[n] + at multiple instances to get a proper idea of structure of the program + dp[n] = cand1 + cand2; This statement is used to store the fibonacci series in the array + here, we will be returning the final values of cand1, cand2. */ + return (cand1 + cand2); +} + +int main(int argc, char const *argv[]) +{ + int n, result; + + printf("Enter a Number to find the Fibonacci using DP apporach: "); + scanf("%d", &n); + + result = fibDP(n); + printf("\n Fibonacci of %d is: %d", n, result); + + return 0; +} + +/* +TestCase-1: +Sample Input: 6 +Sample Output: 8 + +TestCase-2: +Sample Input: 10 +Sample Output: 55 +*/ + diff --git a/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.cpp b/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.cpp new file mode 100644 index 000000000..c0507595f --- /dev/null +++ b/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.cpp @@ -0,0 +1,51 @@ +#include +using namespace std; +int dp[100005] = {0}; + +int fibDP(int n) +{ + if(n == 0 or n == 1) + { + return n; + } + + /* This is used to print the values or series of given fibonacci number. + if(dp[n] != 0) + { + return dp[n]; + }*/ + + /* This recursion is to hold the values till cand1 = 1(from 5-4-3-2-1), cand2 = 1(5-3-1) */ + int cand1 = fibDP(n - 1); + int cand2 = fibDP(n - 2); + + /* + Later, it will go back to its previous values(2-3), cand1, cand2 values will be updated. + after, getting values (1,1), those values get added and updated at 5th index. + this will repeat in each iteration, + You can check(print) manually the values of cand1, cand2, n and dp[n] + at multiple instances to get a proper idea of structure of the program + dp[n] = cand1 + cand2; This statement is used to store the fibonacci series in the array + here, we will be returning the final values of cand1, cand2. */ + return (cand1 + cand2); +} + +int main(int argc, char const *argv[]) +{ + int n; + cout << "Enter a Number to find the Fibonacci using DP apporach: "; + cin >> n; + cout << "Fibonacci of " << n << " is: " << fibDP(n); + return 0; +} + +/* +TestCase-1: +Sample Input: 6 +Sample Output: 8 + +TestCase-2: +Sample Input: 10 +Sample Output: 55 +*/ + diff --git a/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.java b/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.java new file mode 100644 index 000000000..3029aa51e --- /dev/null +++ b/Fibonacci_Number_Using_DP_Approach/Fibonacci_Number_Using_DP_Approach.java @@ -0,0 +1,60 @@ +import java.util.*; + +class findingFib +{ + int dp[] = new int[100005]; + + int fibDP(int n) + { + if(n == 0 || n == 1) + { + return n; + } + + /* This is used to print the values or series of given fibonacci number. + if(dp[n] != 0) + { + return dp[n]; + }*/ + + /* This recursion is to hold the values till cand1 = 1(from 5-4-3-2-1), cand2 = 1(5-3-1) */ + int cand1 = fibDP(n-1); + int cand2 = fibDP(n-2); + + /* Later, it will go back to its previous values(2-3), cand1, cand2 values will be updated. + after, getting values (1,1), those values get added and updated at 5th index. + this will repeat in each iteration, + You can check(print) manually the values of cand1, cand2, n and dp[n] + at multiple instances to get a proper idea of structure of the program + dp[n] = cand1 + cand2; This statement is used to store the fibonacci series in the array + here, we will be returning the final values of cand1, cand2. */ + return (cand1 + cand2); + } +} + +class Mainer +{ + public static void main(String args[]) + { + findingFib ob1 = new findingFib(); + int n, result; + + Scanner s = new Scanner(System.in); + System.out.print("Enter a Number to find the Fibonacci using DP apporach: "); + n = s.nextInt(); + + result = ob1.fibDP(n); + System.out.println("Fibonacci of " + n + " is: " + result); + } +} + +/* +TestCase-1: +Sample Input: 6 +Sample Output: 8 + +TestCase-2: +Sample Input: 10 +Sample Output: 55 +*/ + From c726b743a5ee99725d804e6187f28d8b35e19682 Mon Sep 17 00:00:00 2001 From: Ravi Kanth Gojur Date: Thu, 19 Mar 2020 23:05:06 +0530 Subject: [PATCH 017/265] Length of Linked List in C, Java Added --- Linked_List/Length_of_Linked_List.c | 71 ++++++++++++++++++++++++ Linked_List/Length_of_Linked_List.java | 74 ++++++++++++++++++++++++++ 2 files changed, 145 insertions(+) create mode 100644 Linked_List/Length_of_Linked_List.c create mode 100644 Linked_List/Length_of_Linked_List.java diff --git a/Linked_List/Length_of_Linked_List.c b/Linked_List/Length_of_Linked_List.c new file mode 100644 index 000000000..ec4fb18d1 --- /dev/null +++ b/Linked_List/Length_of_Linked_List.c @@ -0,0 +1,71 @@ +// Length of Linked List +#include +#include + +/* +This code is written for Char to store in LinkedList, if you want to store numericals or any other datatype, +just replace relevent data type in place of char in class Node. +*/ + +struct Node +{ + char data; + struct Node* next; +}; + +void pushing_data_to_LL(struct Node** headPointer, char newData) +{ + struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); + newNode -> data = newData; + newNode -> next = (*headPointer); + (*headPointer) = newNode; +} + +int gettingLength(struct Node* head) +{ + int count = 0; + struct Node* current = head; + while(current != NULL) + { + count++; + current = current -> next; + } + return count; +} + +int main() +{ + struct Node* head = NULL; + printf("Currently Length of Linkedlist is: %d", gettingLength(head)); + + pushing_data_to_LL(&head, 'G'); + pushing_data_to_LL(&head, 'S'); + pushing_data_to_LL(&head, 'S'); + pushing_data_to_LL(&head, 'O'); + pushing_data_to_LL(&head, 'C'); + + //Intermediate Checking + printf("\n Currently Length of Linkedlist is: %d", gettingLength(head)); + + pushing_data_to_LL(&head, '-'); + printf("\n Currently Length of Linkedlist is: %d", gettingLength(head)); + + pushing_data_to_LL(&head, '2'); + pushing_data_to_LL(&head, '0'); + pushing_data_to_LL(&head, '2'); + pushing_data_to_LL(&head, '0'); + + printf("\n Currently Length of Linkedlist is: %d", gettingLength(head)); + + return 0; +} + +/* +TestCase-1: +Sample Input: G S S O C 2 0 2 0 +Sample Output: 9 //9 letters + +TestCase-2: +Sample Input: O p e n - S o u r c e +Sample Output: 11 //11 letters +*/ diff --git a/Linked_List/Length_of_Linked_List.java b/Linked_List/Length_of_Linked_List.java new file mode 100644 index 000000000..627cf9145 --- /dev/null +++ b/Linked_List/Length_of_Linked_List.java @@ -0,0 +1,74 @@ +import java.util.*; + +/* +This code is written for Strings to store in LinkedList, if you want to store numericals or any other datatype, +just replace relevent data type in place of string in class Node. +*/ + +class Node +{ + String data; + Node next; + Node(String info) + { + data = info; + next = null; + } +} + +class LinkedListLength +{ + Node head; + public void pushing_data_to_LL(String new_data) + { + Node new_node = new Node(new_data); // Creating the node and assign the data. + new_node.next = head; // making the next node as head node + head = new_node; // making head to point to new Node + } + public int gettingLength() + { + Node temp = head; + int count = 0; + while(temp != null) + { + count++; + temp = temp.next; + } + return count; + } +} + +class Mainer +{ + public static void main(String[] args) + { + LinkedListLength thisList = new LinkedListLength(); + + System.out.println("Currently the Length of the LinkedList is: " + thisList.gettingLength()); + + thisList.pushing_data_to_LL("G"); + thisList.pushing_data_to_LL("S"); + thisList.pushing_data_to_LL("S"); + thisList.pushing_data_to_LL("O"); + thisList.pushing_data_to_LL("C"); + + System.out.println("Currently the Length of the LinkedList is: " + thisList.gettingLength()); + + thisList.pushing_data_to_LL("2"); + thisList.pushing_data_to_LL("0"); + thisList.pushing_data_to_LL("2"); + thisList.pushing_data_to_LL("0"); + + System.out.println("Currently the Length of the LinkedList is: " + thisList.gettingLength()); + } +} + +/* +TestCase-1: +Sample Input: G S S O C 2 0 2 0 +Sample Output: 9 //9 letters + +TestCase-2: +Sample Input: O p e n - S o u r c e +Sample Output: 11 //11 letters +*/ \ No newline at end of file From 33a784f57a173b9c7ac176f27c0b83db1d716c40 Mon Sep 17 00:00:00 2001 From: Sri Manikanta Palakollu Date: Thu, 19 Mar 2020 23:08:20 +0530 Subject: [PATCH 018/265] Implemented the Gnome Sort Completely. (#2275) * Implemented the Gnome Sort Completely. * Implemented the requested Changes. * Made the requested changes. * Changes Done. --- Gnome_Sort/Gnome_Sort.c | 62 ++++++++++++++++++++++++++++++++++++++ Gnome_Sort/Gnome_Sort.cpp | 62 ++++++++++++++++++++++++++++++++++++++ Gnome_Sort/Gnome_Sort.java | 61 +++++++++++++++++++++++++++++++++++++ Gnome_Sort/Gnome_Sort.py | 45 +++++++++++++++++++++++++++ 4 files changed, 230 insertions(+) create mode 100644 Gnome_Sort/Gnome_Sort.c create mode 100644 Gnome_Sort/Gnome_Sort.cpp create mode 100644 Gnome_Sort/Gnome_Sort.java create mode 100644 Gnome_Sort/Gnome_Sort.py diff --git a/Gnome_Sort/Gnome_Sort.c b/Gnome_Sort/Gnome_Sort.c new file mode 100644 index 000000000..ee2987699 --- /dev/null +++ b/Gnome_Sort/Gnome_Sort.c @@ -0,0 +1,62 @@ +#include + +// A function which is used to sort the algorithm using gnome sort +void gnome_sort(int arr[], int n) { + + int index = 0; + while (index < n){ + + if (index == 0 || arr[index - 1] <= arr[index]){ + index++; + } + else{ + int temp = arr[index-1]; + arr[index - 1] = arr[index]; + arr[index] = temp; + index = index - 1; + + } + + } + +} + +// Main function. +int main() +{ + int n; + printf("Enter the size of an Array: "); + scanf("%d", &n); + int arr[n]; + + for(int i = 0; i < n; i++){ + scanf("%d", &arr[i]); + } + + gnome_sort(arr, n); + + for(int i = 0; i < n; i++){ + printf("%d\n", arr[i]); + } + + return 0; +} + +/* + Sample Driver Code: + INPUT: + Enter the size of an Array: 5 + 3 + 2 + 1 + -5 + 7 + + OUTPUT: + -5 + 1 + 2 + 3 + 7 + +*/ diff --git a/Gnome_Sort/Gnome_Sort.cpp b/Gnome_Sort/Gnome_Sort.cpp new file mode 100644 index 000000000..9912482c9 --- /dev/null +++ b/Gnome_Sort/Gnome_Sort.cpp @@ -0,0 +1,62 @@ +#include + +using namespace std; + +// A function that is used to sort the algorithm using gnome sort +void gnome_sort(int arr[], int n) { + + // Implementation Logic Begins here + int index = 0; + + while (index < n) { + // Intially Index is set to Zero then It will be incremented to 1 + if (index == 0) + index++; + // Checking the values between the array elements + if (arr[index] >= arr[index - 1]) + index++; + else { + swap(arr[index], arr[index - 1]); + index--; + } + } +} + +// Main function. +int main() +{ + + int n; + cout << "Enter the size of an Array: "; + cin >> n; + int arr[n]; + for(int i = 0; i < n; i++){ + cin >> arr[i]; + } + gnome_sort(arr, n); + + for(int i = 0; i < n; i++){ + cout << arr[i] <= arr[index - 1]) + index++; + else { + int temp = 0; + temp = arr[index]; + arr[index] = arr[index - 1]; + arr[index - 1] = temp; + index--; + } + } + } + + // Sample Input to test above function + public static void main(String[] args) { + + Scanner sc = new Scanner(System.in); + System.out.print("Enter the Size of an Array: "); + int n = sc.nextInt(); + int arr[] = new int[n]; + for(int i=0; i= arr[index - 1]: + index = index + 1 + else: + arr[index], arr[index-1] = arr[index-1], arr[index] + index = index - 1 + + return arr + +# Test Code +n = int(input("Enter the size of an Array: ")) +arr = list() +for i in range(n): + val = int(input()) + arr.append(val) +# Function Call +result = gnome_sort(arr,n) +print(result) + +''' + Sample Driver Code: + INPUT: + Enter the size of an Array: 5 + 3 + 2 + 1 + -5 + 7 + + OUTPUT: + -5 + 1 + 2 + 3 + 7 + +''' From b4e89f398a66955b8ae8473f47d850b30e2387ab Mon Sep 17 00:00:00 2001 From: Muskan Goyal <47412347+goyalmuskan@users.noreply.github.com> Date: Thu, 19 Mar 2020 23:14:24 +0530 Subject: [PATCH 019/265] Merge_Sort.php added (#1820) * Create Fibonacci_Number.php * Delete Fibonacci_Number.php * Create Merge_Sort.php * Update Merge_Sort.php * Updated * Updated --- Merge_Sort/Merge_Sort.php | 44 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Merge_Sort/Merge_Sort.php diff --git a/Merge_Sort/Merge_Sort.php b/Merge_Sort/Merge_Sort.php new file mode 100644 index 000000000..5fada8473 --- /dev/null +++ b/Merge_Sort/Merge_Sort.php @@ -0,0 +1,44 @@ + 0 && count($right) > 0) { + if($left[0] > $right[0]) { + $res[] = $right[0]; + $right = array_slice($right , 1); + } + else{ + $res[] = $left[0]; + $left = array_slice($left, 1); + } + } + while (count($left) > 0) { + $res[] = $left[0]; + $left = array_slice($left, 1); + } + while (count($right) > 0) { + $res[] = $right[0]; + $right = array_slice($right, 1); + } + return $res; +} + +$test_array = array(100, 54, 7, 2, 5, 4, 1); +echo implode(' ', merge_sort($test_array)); + +/* +Output : +1 2 4 5 7 54 100 +*/ +?> From 0b5d39b91d60d9537c3e2a84d38c0433f4106faa Mon Sep 17 00:00:00 2001 From: "Abhushan A. Joshi" <49617450+abhu-A-J@users.noreply.github.com> Date: Thu, 19 Mar 2020 23:36:05 +0530 Subject: [PATCH 020/265] Implementation of Karatsuba Algorithm in JS (#2420) --- Karatsuba_Algorithm/Karatsuba_Algorithm.js | 42 ++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 Karatsuba_Algorithm/Karatsuba_Algorithm.js diff --git a/Karatsuba_Algorithm/Karatsuba_Algorithm.js b/Karatsuba_Algorithm/Karatsuba_Algorithm.js new file mode 100644 index 000000000..be1d99d8b --- /dev/null +++ b/Karatsuba_Algorithm/Karatsuba_Algorithm.js @@ -0,0 +1,42 @@ +/* +The Karatsuba Algorithm implements faster multiplication, +than the traditional approach. +*/ + +const karatSuba = (num1, num2) => { + + // for single digit number multiply directly + if (num1 < 10 || num2 < 10) { + return num1 * num2; + } + + let num1Str = num1.toString(); + let num2Str = num2.toString(); + let n = Math.min(num1Str.length, num2Str.length); + let half = Math.round(n / 2); + + // divide num1 into two halves + let num1_H = parseInt(num1Str.substring(0, num1Str.length - half)); + let num1_L = parseInt(num1Str.substring(num1Str.length - half, num1Str.length)); + + // divide num2 into two halves + let num2_H = parseInt(num2Str.substring(0, num2Str.length - half)); + let num2_L = parseInt(num2Str.substring(num2Str.length - half, num2Str.length)); + + // using the KaratSuba Definition + let s1 = karatSuba(num1_L, num2_L); + let s2 = karatSuba(num1_L + num1_H, num2_L + num2_H); + let s3 = karatSuba(num1_H, num2_H); + let s4 = s2 - s3 - s1; + + // karatsuba formula for finding product + let result = s3 * Math.pow(10, 2 * half) + s4 * Math.pow(10, half) + s1; + + return result; +}; + +// I/O and O/P Examples + +// The result is: 83810205 +console.log(karatSuba(12345, 6789)); +console.log(12345 * 6789); From feb06a5a02fdf7bbf9222f3d0b27da77ec1f64cf Mon Sep 17 00:00:00 2001 From: Hari Krishnan U Date: Thu, 19 Mar 2020 23:45:35 +0530 Subject: [PATCH 021/265] Create Shell_Sort.cs (#2457) Update Shell_Sort.cs Update Shell_Sort.cs Update Shell_Sort.cs --- Shell_Sort/Shell_Sort.cs | 66 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 Shell_Sort/Shell_Sort.cs diff --git a/Shell_Sort/Shell_Sort.cs b/Shell_Sort/Shell_Sort.cs new file mode 100644 index 000000000..b41a7962a --- /dev/null +++ b/Shell_Sort/Shell_Sort.cs @@ -0,0 +1,66 @@ +// C# program implementation of the ShellSort algorithm +using System; + +class ShellSort +{ + //function to implement ShellSort + void shellsort(int []array, int size) + { + // Beginning with a big gap, and then keep on reducing it. + for (int g = size/2; g >= 1; g /= 2) + { + // Performing an insertion sort + for (int i = g; i < size; i += 1) + { + int j, temp = array[i]; + + //Shift other elements until the correct position of a[i] is found + for (j = i; array[j - g] > temp && j >= g ; j -= g) + array[j] = array[j - g]; + + // put the element a[i] in its correct position + array[j] = temp; + } + } + } + + public static void Main() + { + + int size; + Console.Write("How many numbers do you want to sort : "); + size = Convert.ToInt32(Console.ReadLine()); + int[] array = new int[size]; + Console.Write("\nEnter the numbers : "); + for (int i = 0; i < size; i++) + array[i] = Convert.ToInt32(Console.ReadLine()); + ShellSort ob = new ShellSort(); + ob.shellsort(array, size); + Console.Write("\nAfter sorting : "); + for (int i = 0; i < size; i++) + Console.Write(array[i] + " "); + } +} + +/*SAMPLE INPUT AND OUTPUT +SAMPLE 1 +How many numbers do you want to sort : 7 +Enter the numbers : + 4 + 9 + 3 + 9 + 4 + 7 + 5 +After sorting : 3 4 4 5 7 9 9 +SAMPLE 2 +How many numbers do you want to sort : 5 +Enter the numbers : + 5 + 1 + 7 + 3 + 2 +After sorting : 1 2 3 5 7 +*/ From 850074720e2bc39d28cd6f51dfb20519638c71bf Mon Sep 17 00:00:00 2001 From: RedEye00 <55008117+RedEye00@users.noreply.github.com> Date: Thu, 19 Mar 2020 23:50:42 +0530 Subject: [PATCH 022/265] Finding last digit of nth term in squares of fibonacci number (#2285) * Add files via upload * Delete fib.cpp * Create a.txt * Delete a.txt * Issue Resolved and file is added * Issues Resolved please review * Issue of comment resolved * commited changes in issues --- ...igit_of_Square_of_Nth_Fibonacci_Number.cpp | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Last_Digit_of_Square_of_Nth_Fibonacci_Number/Last_Digit_of_Square_of_Nth_Fibonacci_Number.cpp diff --git a/Last_Digit_of_Square_of_Nth_Fibonacci_Number/Last_Digit_of_Square_of_Nth_Fibonacci_Number.cpp b/Last_Digit_of_Square_of_Nth_Fibonacci_Number/Last_Digit_of_Square_of_Nth_Fibonacci_Number.cpp new file mode 100644 index 000000000..e5211db4e --- /dev/null +++ b/Last_Digit_of_Square_of_Nth_Fibonacci_Number/Last_Digit_of_Square_of_Nth_Fibonacci_Number.cpp @@ -0,0 +1,43 @@ +//C++ Program to find last digit of square of nth fibonacci numbers +#include +using namespace std; + +int main(){ + int a[60], n, i, c, b[60], j; + a[0] = 0; + a[1] = 1; + b[0] = 0; + b[1] = 1; + + /*Using the concept that after 60 numbers in a fibonacci + numbers the last digit repeats itself again and again*/ + + /*In this loop we store the last digits of squares of first 60 fibonacci number and + we will store last digits in new array and their index as position in fibonacci series*/ + + for(i = 2 ; i < 60 ; i++){ + a[i] = (a[i - 1] + a[i - 2]) % 10; + c = a[i]; + b[i] = (c * c) % 10; + } + cin>> n ; + + //print the last digit given in that position + + cout<< " \n The Last Digit of Square of this Number : " << b[ n % 60] ; + + return 0; +} +/* +Sample Input 1: +2344 + +Sample Output 1: +The Last Digit of Square of this Number : 9 + +Sample Input 2: +267 + +Sample Output 2: +The Last Digit of Square of this Number : 4 +*/ From 564d1fd09894b96790fea9fadb8139704f9270bc Mon Sep 17 00:00:00 2001 From: Chandrika Deb Date: Fri, 20 Mar 2020 00:27:03 +0530 Subject: [PATCH 023/265] Added minesweeper implementation in C++ (#2541) --- Minesweeper/minesweeper.cpp | 399 ++++++++++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 Minesweeper/minesweeper.cpp diff --git a/Minesweeper/minesweeper.cpp b/Minesweeper/minesweeper.cpp new file mode 100644 index 000000000..5f4265333 --- /dev/null +++ b/Minesweeper/minesweeper.cpp @@ -0,0 +1,399 @@ +#include +using namespace std; + +#define max_mine 99 +#define max_side 25 +#define max_move 526 // 25*25-99 +int SIDE; +int MINES; + +void clrscr() +{ + std::cout << "\33[2J\33[1;1H" << std::flush; +} + +bool isvalid(int row, int col) +{ + return (row >= 0) && (row < SIDE) && (col >= 0) && (col < SIDE); +} + +bool ismine(int row, int col, char board[][max_side]) +{ + if(board[row][col] == 'B') + return (true); + else + return (false); +} + +void move(int *x, int *y) +{ + printf("\nEnter your move as (row col) -> "); + scanf("%d %d", x, y); + return; +} + +void board(char myboard[][max_side]) +{ + clrscr(); + printf("\n\n\t\t\t "); + for(int i = 0; i < SIDE; i++) + { + if (i > 9) + printf(" %d ", i / 10); + else + printf(" "); + } + printf("\n\t\t\t "); + for(int i = 0; i < SIDE; i++) + printf(" %d ", i % 10); + printf("\n\n"); + for(int i = 0; i < SIDE; i++) + { + printf("\t\t\t "); + for(int j = 0; j < SIDE; j++) + { + printf("%c ", myboard[i][j]); + } + printf(" %2d", i); + printf("\n"); + } + return; +} + +int countadjacent(int row, int col, int mines[][2], char realboard[][max_side]) +{ + int count = 0; + if(isvalid(row - 1, col) == true) + { + if(ismine(row - 1, col, realboard) == true) + count++; + } + if(isvalid(row + 1, col) == true) + { + if(ismine(row + 1, col, realboard) == true) + count++; + } + if(isvalid(row, col + 1) == true) + { + if(ismine(row, col + 1, realboard) == true) + count++; + } + if(isvalid(row, col - 1) == true) + { + if(ismine(row, col - 1, realboard) == true) + count++; + } + if(isvalid(row - 1, col - 1) == true) + { + if(ismine(row - 1, col - 1, realboard) == true) + count++; + } + if(isvalid(row - 1, col + 1) == true) + { + if(ismine(row - 1, col + 1, realboard) == true) + count++; + } + if(isvalid(row + 1, col - 1) == true) + { + if(ismine(row + 1, col - 1, realboard) == true) + count++; + } + if(isvalid(row + 1, col + 1) == true) + { + if(ismine(row + 1, col + 1, realboard) == true) + count++; + } + return (count); +} + +bool playuntil(char myboard[][max_side], char realboard[][max_side], int mines[][2], int row, int col, int *moves_left) +{ + if(myboard[row][col] != '-') + return false; + int i, j; + if(realboard[row][col] == 'B') + { + myboard[row][col] = 'B'; + for(i = 0; i < MINES; i++) + myboard[mines[i][0]][mines[i][1]] = 'B'; + board(myboard); + printf ("\nYou lost!\n"); + return (true); + } + else + { + int count = countadjacent(row, col, mines, realboard); + (*moves_left)--; + myboard[row][col] = count + '0'; + if(!count) + { + if(isvalid(row - 1, col) == true) + { + if(ismine(row - 1, col, realboard) == false) + playuntil(myboard, realboard, mines, row - 1, col, moves_left); + } + if (isvalid (row + 1, col) == true) + { + if (ismine (row + 1, col, realboard) == false) + playuntil(myboard, realboard, mines, row + 1, col, moves_left); + } + if (isvalid (row, col + 1) == true) + { + if (ismine (row, col + 1, realboard) == false) + playuntil(myboard, realboard, mines, row, col + 1, moves_left); + } + if (isvalid (row, col - 1) == true) + { + if (ismine (row, col - 1, realboard) == false) + playuntil(myboard, realboard, mines, row, col - 1, moves_left); + } + if (isvalid (row - 1, col + 1) == true) + { + if (ismine (row - 1, col + 1, realboard) == false) + playuntil(myboard, realboard, mines, row - 1, col + 1, moves_left); + } + if (isvalid (row - 1, col - 1) == true) + { + if (ismine (row - 1, col - 1, realboard) == false) + playuntil(myboard, realboard, mines, row - 1, col - 1, moves_left); + } + if (isvalid (row + 1, col + 1) == true) + { + if (ismine (row + 1, col + 1, realboard) == false) + playuntil(myboard, realboard, mines, row + 1, col + 1, moves_left); + } + if (isvalid (row + 1, col - 1) == true) + { + if (ismine (row + 1, col - 1, realboard) == false) + playuntil(myboard, realboard, mines, row + 1, col - 1, moves_left); + } + } + return (false); + } +} + +void placemines(int mines[][2],char realboard[][max_side]) +{ + bool mark[max_side*max_side]; + memset(mark, false, sizeof(mark)); + for(int i = 0; i < MINES;) + { + int random = rand() % (SIDE * SIDE); + int x = random / SIDE; + int y = random % SIDE; + if(mark[random] == false) //add mine if not present at position random + { + mines[i][0] = x; + mines[i][1] = y; + realboard[mines[i][0]][mines[i][1]] = 'B'; + mark[random] = true; + i++; + } + } +} + +void initialise(char realboard[][max_side], char myboard[][max_side]) +{ + srand(time(NULL)); //initalising random so that same config doesn't arise + int i, j; + for(i = 0; i < SIDE; i++) + for(j = 0; j < SIDE; j++) + { + myboard[i][j] = realboard[i][j] = '-'; + } + return; +} + +void cheatmines (char realboard[][max_side]) +{ + printf ("The mines locations are-\n"); + board (realboard); + return; +} + +void replacemine(int row, int col, char board[][max_side]) +{ + for(int i = 0; i < SIDE; i++) + { + for(int j = 0; j < SIDE; j++) + { + if(board[i][j] != 'B') + { + board[i][j] = 'B'; + board[row][col] = '-'; + return; + } + } + } +} + +void play() +{ + bool gameover = false; + char realboard[max_side][max_side],myboard[max_side][max_side]; + int moves_left = SIDE*SIDE-MINES; + int x,y; + int mines[max_mine][2]; //stores (x,y) of all mines + initialise(realboard, myboard); + placemines(mines, realboard); + //if you want cheat and win + //cheatmines(realboard); + int currentmoveindex = 0; + while(gameover == false) + { + printf ("Current Status of Board : \n"); + board(myboard); + move(&x, &y); + //if first move is mine + if(currentmoveindex == 0) + { + if(ismine(x, y, realboard) == true) //first attempt is a mine + replacemine(x, y, realboard); //replace the mine at that location + } + currentmoveindex++; + gameover = playuntil(myboard, realboard, mines, x, y, &moves_left); + if((gameover == false) && (moves_left == 0)) + { + printf ("\nYou won !\n"); + gameover = true; + } + } +} + +void chdiff() +{ + clrscr(); + cout << "\nMINESWEEPER GAME"; + cout << "\n\nCHOOSE YOUR DIFFICULTY LEVEL : "; + cout << "\n\n0.BEGINNER\n1.MEDIUM\n2.HARD"; + cout << "\n\nENTER YOUR LEVEL (0-2) : "; + int ch; + cin >> ch; + if(ch == 0) + { + SIDE = 9; + MINES = 10; + } + else if(ch == 1) + { + SIDE = 16; + MINES = 40; + } + else if(ch == 2) + { + SIDE = 24; + MINES = 99; + } + else + exit(0); +} + +int main() +{ + chdiff(); + play(); + return 0; +} + +/* + Input: + MINESWEEPER GAME +CHOOSE YOUR DIFFICULTY LEVEL : +0.BEGINNER +1.MEDIUM +2.HARD +ENTER YOUR LEVEL (0-2) :0 +Output: + 0 1 2 3 4 5 6 7 8 + + - - - - - - - - - 0 + - - - - - - - - - 1 + - - - - - - - - - 2 + - - - - - - - - - 3 + - - - - - - - - - 4 + - - - - - - - - - 5 + - - - - - - - - - 6 + - - - - - - - - - 7 + - - - - - - - - - 8 + +EnteEnter your move as (row col) -> 4 6 + 0 1 2 3 4 5 6 7 8 + + - - - - 1 0 0 0 0 0 + - - 1 1 2 1 1 0 0 1 + - - 1 0 1 - 1 0 0 2 + - - 1 0 1 1 1 0 0 3 + - - 2 1 0 0 0 1 1 4 + - - - 2 1 1 0 1 - 5 + - - - - - 1 0 1 - 6 + - - - - - 1 1 2 - 7 + - - - - - - - - - 8 + +Enter your move as (row col) -> 7 3 + 0 1 2 3 4 5 6 7 8 + + - - - - 1 0 0 0 0 0 + - - 1 1 2 1 1 0 0 1 + - - 1 0 1 - 1 0 0 2 + - - 1 0 1 1 1 0 0 3 + - - 2 1 0 0 0 1 1 4 + - - - 2 1 1 0 1 - 5 + - - - - - 1 0 1 - 6 + - - - 1 - 1 1 2 - 7 + - - - - - - - - - 8 +Enter your move as (row col) -> 8 6 + 0 1 2 3 4 5 6 7 8 + + - - - - 1 0 0 0 0 0 + - - 1 1 2 1 1 0 0 1 + - - 1 0 1 - 1 0 0 2 + - - 1 0 1 1 1 0 0 3 + - - 2 1 0 0 0 1 1 4 + - - - 2 1 1 0 1 - 5 + - - - - - 1 0 1 - 6 + - - - 1 - 1 1 2 - 7 + - - - - - - 1 - - 8 + +Enter your move as (row col) -> 6 1 + + 0 1 2 3 4 5 6 7 8 + + - - - - 1 0 0 0 0 0 + - - 1 1 2 1 1 0 0 1 + - - 1 0 1 - 1 0 0 2 + - - 1 0 1 1 1 0 0 3 + - - 2 1 0 0 0 1 1 4 + - - - 2 1 1 0 1 - 5 + - 1 - - - 1 0 1 - 6 + - - - 1 - 1 1 2 - 7 + - - - - - - 1 - - 8 + Enter your move as (row col) -> 8 3 + 0 1 2 3 4 5 6 7 8 + + - - - - 1 0 0 0 0 0 + - - 1 1 2 1 1 0 0 1 + - - 1 0 1 - 1 0 0 2 + - - 1 0 1 1 1 0 0 3 + 2 3 2 1 0 0 0 1 1 4 + 0 1 - 2 1 1 0 1 - 5 + 0 1 1 2 - 1 0 1 - 6 + 0 0 0 1 1 1 1 2 - 7 + 0 0 0 0 0 0 1 - - 8 + + + Enter your move as (row col) -> 8 8 + + 0 1 2 3 4 5 6 7 8 + + - - - B 1 0 0 0 0 0 + - - 1 1 2 1 1 0 0 1 + B - 1 0 1 B 1 0 0 2 + B B 1 0 1 1 1 0 0 3 + 2 3 2 1 0 0 0 1 1 4 + 0 1 B 2 1 1 0 1 B 5 + 0 1 1 2 B 1 0 1 - 6 + 0 0 0 1 1 1 1 2 - 7 + 0 0 0 0 0 0 1 B B 8 + +You lost! +*/ From fa99a7809527b0900014dcefdfcdd1d48cc7ba05 Mon Sep 17 00:00:00 2001 From: Ritish Singh <54978105+ritish099@users.noreply.github.com> Date: Fri, 20 Mar 2020 01:18:34 +0530 Subject: [PATCH 024/265] LCM of N elements of an array --- .../Largest_Common_Multiple_1-DArray.c | 47 ++++++++++++++++ .../Largest_Common_Multiple_1-DArray.cpp | 53 ++++++++++++++++++ .../Largest_Common_Multiple_1-DArray.java | 54 +++++++++++++++++++ 3 files changed, 154 insertions(+) create mode 100644 Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.c create mode 100644 Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.cpp create mode 100644 Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.java diff --git a/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.c b/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.c new file mode 100644 index 000000000..e25fcfbc9 --- /dev/null +++ b/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.c @@ -0,0 +1,47 @@ +// C program to find Largest_common_multiple of n elements +#include +#include + +// GCD of 'a' and 'b' +int gcd(int a, int b) +{ + if (b == 0) + return a; + return gcd(b, a % b); +} + +// Returns LCM of array elements +long long int findlcm(int arr[], int n) +{ + // Initialize result + long long int ans = arr[0]; + + // ans contains LCM of arr[0], ..arr[i] + // after i'th iteration, + int i; + for (i = 1; i < n; i++) + ans = (((arr[i] * ans)) / (gcd(arr[i], ans))); + + return ans; +} + +// Driver Code +int main() +{ + int n, i; + printf("Enter the no of elements of the array\n"); + scanf("%d", & n); + int arr[n]; + printf("Enter the elements of the array\n"); + for (i = 0; i < n; i++) { + scanf("%d", & arr[i]); + } + printf("LCM : %lld", findlcm(arr, n)); + return 0; +} + +/*Enter the no of elements of the array +5 +Enter the elements of the array +4 6 12 24 30 +LCM : 120*/ diff --git a/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.cpp b/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.cpp new file mode 100644 index 000000000..f6a75e43b --- /dev/null +++ b/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.cpp @@ -0,0 +1,53 @@ +/*This code is to find the Largest__common_multiple of an given array of elements*/ + +#include + +using namespace std; + +int getLCM(int a, int b) +{ + int m; + m = (a > b) ? a : b; + while (true) { + if (m % a == 0 && m % b == 0) + // returns the value to getLCMArray function + return m; + m++; + } +} + +int getLCMArray(int arr[], int n) +{ + int lcm = getLCM(arr[0], arr[1]); + for (int i = 2; i < n; i++) + { + // calls function getLCM to compute the LCM of two numbers + lcm = getLCM(lcm, arr[i]); + } + // returns LCM to main. + return lcm; +} + +int main() +{ + int n, i; + cout << "Enter the no. of elements of array\n"; + cin >> n; + int a[n]; + cout << "Enter the elements of array\n"; + for (i = 0; i < n; i++) + { + cin >> a[i]; + } + cout << "LCM of array elements: " << getLCMArray(a, n); +} + +/*Enter the no. of elements of array +5 +Enter the elements of array +4 +6 +12 +24 +30 +LCM of array elements: 120*/ diff --git a/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.java b/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.java new file mode 100644 index 000000000..cfc3cc5a4 --- /dev/null +++ b/Largest_Common_Multiple/Largest_Common_Multiple_1-DArray.java @@ -0,0 +1,54 @@ +// JAVA code to find Largest_common_multiple of n elements of the array + +import java.util.Scanner; +import java.util.Arrays; + +class LCM +{ + public static void main(String args[]) + { + int n; + Scanner s = new Scanner(System.in); + System.out.println("Enter no. of elements in array:"); + n = s.nextInt(); + int a[] = new int[n]; + System.out.println("Enter all the elements:"); + for (int i = 0; i < n; i++) + { + // Taking input from the user + a[i] = s.nextInt(); + } + int lcm = 1; + for (int each: a) + { + lcm = calculateLcm(lcm, each); + } + System.out.println("LCM for " + Arrays.toString(a) + " is : " + lcm); + } + + // Calculating LCM by using GCD + private static int calculateLcm(int lcm, int each) + { + return lcm * each / gcd(lcm, each); + } + + // Calculating GCD + private static int gcd(int val1, int val2) + { + if (val1 == 0 || val2 == 0) + return 0; + + if (val1 == val2) + return val1; + + if (val1 > val2) + return gcd(val1 - val2, val2); + return gcd(val1, val2 - val1); + } +} + +/*Enter no. of elements in array: +6 +Enter all the elements: +1 2 3 4 5 6 +LCM for [1, 2, 3, 4, 5, 6] is : 60*/ From b13b244b5a39117af5ed8ef6d55107b1dfe3dda4 Mon Sep 17 00:00:00 2001 From: jedi-starlord <46528937+jedi-starlord@users.noreply.github.com> Date: Fri, 20 Mar 2020 17:18:45 +0530 Subject: [PATCH 025/265] Added Longest Increasing Subsequence code in Go (#2493) * Longest Increasing Subsequence code in Go * Longest Increasing Subsequence code in Go * Updated problem description * No more than 80 chars per line --- Longest_Increasing_Subsequence/LIS.go | 67 +++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 Longest_Increasing_Subsequence/LIS.go diff --git a/Longest_Increasing_Subsequence/LIS.go b/Longest_Increasing_Subsequence/LIS.go new file mode 100644 index 000000000..ee84d0246 --- /dev/null +++ b/Longest_Increasing_Subsequence/LIS.go @@ -0,0 +1,67 @@ +/* Problem Statement : +To find the length of the Longest Increasing +Subsequence of a given sequence, that is all the +elements of the subsequence are in increasing sorted order. +*/ +package main + +import "fmt" + +func Max(lis []int) (max int) { + max = lis[0] + for i := 1; i < len(lis); i++ { + if lis[i] > max { + max = lis[i] + } + } + return +} + +func LIS(arr []int) { + length := len(arr) + + if length == 0 { + return + } + + // Slice to store the length of the LIS til some index + lis_arr := make([]int, length) + lis_arr[0] = 1 + + for i := 1; i < length; i++ { + lis_arr[i] = 1 + + // Computing LIS value in DP Bottom-up + for j := 0; j < i; j++ { + if ( arr[i] > arr[j] && lis_arr[i] < lis_arr[j] + 1) { + lis_arr[i] = lis_arr[j] + 1 + } + } + } + + fmt.Printf("Length of the Longest Increasing Subsequence : %d\n", Max(lis_arr)) +} + +func main() { + var n int + fmt.Println("Enter the size of the array : ") + fmt.Scan(&n) + fmt.Println("Enter the array elements : ") + arr := make([]int, n) + + for i := 0; i < n; i++ { + fmt.Scan(&arr[i]) + } + + LIS(arr) +} + +/* Sample Input : +Enter the size of the array : +8 +Enter the array elements : +15 26 13 38 26 52 43 62 + +Sample Output : +Length of the Longest Increasing Subsequence : 5 +*/ From 6d249f8d93ed85df4d2a01f845d938fd7196a71b Mon Sep 17 00:00:00 2001 From: Debojyoti Chakraborty <50295688+darkdebo@users.noreply.github.com> Date: Fri, 20 Mar 2020 17:26:01 +0530 Subject: [PATCH 026/265] added ruby implementation of Armstrong number (#2501) * this is a ruby implementation of the armstrong number. On branch master Changes to be committed: new file: Armstrong_Number/Armstrong_Number.rb * Update Armstrong_Number.rb ruby implementation of armstrong number. * On branch master Your branch is up to date with 'origin/master'. Changes to be committed: modified: Armstrong_Number.rb checked with 153,370 * Changes to be committed: modified: Armstrong_Number.rb * Added 4 space indent Done with indentation across the file. * Taking input dynamically * Changes to be committed: new file: Bead_Sort.rb * Changes to be committed: new file: Bead_Sort.rb * Revert " Changes to be committed:" * Delete Bead_Sort.rb * Delete Armstrong_Number.rb * Create Armstrong_Number.rb * added Armstrong_Number.rb * Changes to be committed: modified: Armstrong_Number/Armstrong_Number.rb * modified: Armstrong_Number/Armstrong_Number.rb --- Armstrong_Number/Armstrong_Number.rb | 44 ++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Armstrong_Number/Armstrong_Number.rb diff --git a/Armstrong_Number/Armstrong_Number.rb b/Armstrong_Number/Armstrong_Number.rb new file mode 100644 index 000000000..fb0e193e6 --- /dev/null +++ b/Armstrong_Number/Armstrong_Number.rb @@ -0,0 +1,44 @@ +# A positive integer of n digits is called an Armstrong number of order n (order is number of digits) if +# abcd... = pow(a,n) + pow(b,n) + pow(c,n) + pow(d,n) + .... + +# To calculate the order of the number +def order(num) + # variable to store of the number + count = 0 + while (num != 0) + count = count + 1 + num = num / 10 + end + return count +end + +# Function to check whether the given number is +# Armstrong number or not +def Armstrong(num) + count = order(num) + temp = num + sum = 0 + boolean = false + while (temp != 0) + d = temp % 10 + sum = sum + d ** count + temp = temp / 10 + end + return num == sum +end + +# Driver Program +num = gets.chomp.to_i +print(Armstrong(num)) + +#True + +#num = 134 +#print(Armstrong(num)) + +#False + +#num = 370 +#print(Armstrong(num)) + +#True From 81efff3eb365f1b9222928e9b070c4df2bfa36f0 Mon Sep 17 00:00:00 2001 From: HariniJeyaraman <58400069+HariniJeyaraman@users.noreply.github.com> Date: Sat, 21 Mar 2020 02:02:31 +0530 Subject: [PATCH 027/265] Postfix Evaluation in C --- Postfix_Evaluation/Postfix _Evaluation.c | 86 ++++++++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 Postfix_Evaluation/Postfix _Evaluation.c diff --git a/Postfix_Evaluation/Postfix _Evaluation.c b/Postfix_Evaluation/Postfix _Evaluation.c new file mode 100644 index 000000000..c64c510b9 --- /dev/null +++ b/Postfix_Evaluation/Postfix _Evaluation.c @@ -0,0 +1,86 @@ +//Postfix Evaluation +#include +#include +#include + +struct stack +{ + char A[100]; + int Top; +}; + +void push(struct stack *ps, char x) +{ + if(ps -> Top == 99) + printf("\nStack is Full\n"); + else + { + ps -> Top = ps -> Top + 1; + ps -> A[ps -> Top] = x; + } +} + +int evaluate(int op1, int op2, char c) +{ + if(c == '+') + return op1 + op2; + else if(c == '-') + return op1 - op2; + else if(c == '*') + return op1 * op2; + else if(c == '/') + return op1 / op2; +} + +void print(struct stack s) +{ + int i; + for(i = 0 ; i <= s.Top ; i++) + printf("%d\t", s.A[i]); +} + +int pop(struct stack *ps) +{ + int x; + if(ps -> Top == -1) + printf("Stack is empty!Element cant be deleted\n"); + else + { + x = ps -> A[ps -> Top]; + ps -> Top = ps -> Top - 1; + return x; + } +} + +int main() +{ + int op1, op2, x, i; + char optr; + struct stack s; + s.Top = -1; + printf("Enter the postfix exp to be evaluated \n"); + gets(s.A); + for(i = 0; i < strlen(s.A); i++) + { + if(isdigit(s.A[i])) + push(&s, s.A[i] - '0'); + else if(s.A[i] == '+' || s.A[i] == '-' || s.A[i] == '*' || s.A[i] == '/') + { + op1 = pop(&s); + op2 = pop(&s); + optr = s.A[i]; + x = evaluate(op2, op1, optr); + push(&s, x); + } + } + + printf("The result is : "); + print(s); + printf("\n"); +} + +/*Input - Output Sample +Enter the postfix exp to be evaluated +2 3 1 * + 9 - +The result is : -4 +*/ From a771bf161703c49672add6563562eb2ef0801879 Mon Sep 17 00:00:00 2001 From: Md Akdas Ahmad <43089126+MdAkdas@users.noreply.github.com> Date: Sat, 21 Mar 2020 13:04:06 +0530 Subject: [PATCH 028/265] Max_circular_sum_added (#2354) --- .../max_circular_subArray_sum.c | 77 +++++++++++++++++++ .../max_circular_subarray_sum.cpp | 70 +++++++++++++++++ 2 files changed, 147 insertions(+) create mode 100644 Max_Circular_SubArray_Sum/max_circular_subArray_sum.c create mode 100644 Max_Circular_SubArray_Sum/max_circular_subarray_sum.cpp diff --git a/Max_Circular_SubArray_Sum/max_circular_subArray_sum.c b/Max_Circular_SubArray_Sum/max_circular_subArray_sum.c new file mode 100644 index 000000000..fde1120d3 --- /dev/null +++ b/Max_Circular_SubArray_Sum/max_circular_subArray_sum.c @@ -0,0 +1,77 @@ +/* +Question- Given n numbers (both +ve and -ve), arranged in a circle, find the maximum sum of consecutive number. +Solution- There are two cases for this problem +Case-1 The elements that contribute to the maximum sum are arranged such that no wrapping is there.Kadane will simply work. +Case-2 The elements which contribute to the maximum sum are arranged such that wrapping is there. +*/ + +#include + +//Returns maximum of two numbers. +int max(int num1, int num2) +{ + return (num1 > num2 ) ? num1 : num2; +} + +/*Function to find contiguous sub-array with the largest sum +in given set of integers*/ +int kadaneAlgo(int a[], int n) +{ + int max_so_far = 0, max_ending_here = 0; + + for(int i = 0; i < n ; i++) + { + max_ending_here += a[i]; + + if(max_ending_here < 0) + { + max_ending_here = 0; + } + + max_so_far = max(max_ending_here, max_so_far); + } + + return max_so_far; +} + +int circular_subarray_sum(int a[], int n) +{ + //answer for case 1 + int kadane_max = kadaneAlgo(a, n); + + //find total sum and negate all elements of the array + int total_sum = 0; + for(int i = 0; i < n ; i++) + { + total_sum + = a[i]; + a[i] = -a[i]; + + } + +/*find out the sum of non contributing elements and subtract this sum from the +total sum.*/ +total_sum = total_sum + kadaneAlgo(a, n); +return max(kadane_max, total_sum); +} + +int main() +{ + int n; + scanf("%d", &n); + int a[n]; + + for(int i = 0; i < n ; i++) + { + scanf("%d", &a[i]); + } + printf("The sum of subarray with the largest sum is: %d", circular_subarray_sum(a, n)); + return 0; +} + +/* +Input- +9 +2 1 -8 4 -5 1 -7 4 -1 +Output- +The sum of subarray with the largest sum is 6 +*/ \ No newline at end of file diff --git a/Max_Circular_SubArray_Sum/max_circular_subarray_sum.cpp b/Max_Circular_SubArray_Sum/max_circular_subarray_sum.cpp new file mode 100644 index 000000000..3e82c555b --- /dev/null +++ b/Max_Circular_SubArray_Sum/max_circular_subarray_sum.cpp @@ -0,0 +1,70 @@ +/* +Question- Given n numbers (both +ve and -ve), arranged in a circle, find the maximum sum of consecutive number. +Solution- There are two cases for this problem. +Case-1 The elements that contribute to the maximum sum are arranged such that no wrapping is there.Kadane will simply work. +Case-2 The elements which contribute to the maximum sum are arranged such that wrapping is there. +*/ + +#include +using namespace std; + +/* Function to find contiguous sub-array with the largest sum +in given set of integers*/ +int kadaneAlgo(int a[], int n) +{ + int max_so_far=0, max_ending_here = 0; + + for(int i = 0; i < n; i++) + { + max_ending_here += a[i]; + if(max_ending_here < 0) + { + max_ending_here = 0; + } + + max_so_far = max(max_ending_here, max_so_far); + } + return max_so_far; +} + +int circular_subarray_sum(int a[], int n) +{ + //answer for case 1. + int kadane_max = kadaneAlgo(a, n); + + //Find total sum and negate all elements of the array. + int total_sum = 0; + for(int i = 0; i < n; i++) + { + total_sum += a[i]; + a[i] = -a[i]; + + } + /*Ans for test case 2. + Find out the sum of non contributing elements and subtract this sum from the Total sum.*/ + total_sum = total_sum + kadaneAlgo(a, n); + return max(kadane_max, total_sum); +} + +int main() +{ + int n; + cin >> n; + int a[n]; + + for(int i = 0; i < n; i++) + { + cin >> a[i]; + } + + cout << "The sum of subarray with the largest sum is: " << circular_subarray_sum(a, n) << endl; + return 0; +} + +/* +Input- +9 +2 1 -8 4 -5 1 -7 4 -1 +Output- +The sum of subarray with the largest sum is 6 +*/ \ No newline at end of file From 3ec54dbf97e4c123a1a2cee6939d2c94dbdce545 Mon Sep 17 00:00:00 2001 From: Soham Pal <49874099+p-soham11@users.noreply.github.com> Date: Sun, 22 Mar 2020 03:04:16 +0530 Subject: [PATCH 029/265] Ternary Search in C# (#2176) (#2494) --- Ternary_Search/Ternary_Search.cs | 103 +++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 Ternary_Search/Ternary_Search.cs diff --git a/Ternary_Search/Ternary_Search.cs b/Ternary_Search/Ternary_Search.cs new file mode 100644 index 000000000..5d4212197 --- /dev/null +++ b/Ternary_Search/Ternary_Search.cs @@ -0,0 +1,103 @@ +using System; + +public class ternarysrc { + + // Function to perform Ternary Search + static int ternarySearch(int l, int r, int key, int[] ar) + { + while (r >= l) + { + + // Finding the mid1 and mid2 + int mid1 = l + (r - l) / 3; + int mid2 = r - (r - l) / 3; + + // To check if key is present at any mid + if (ar[mid1] == key) + { + return mid1; + } + if (ar[mid2] == key) + { + return mid2; + } + + // Checking region where KEY might be present + if (key < ar[mid1]) + { + r = mid1 - 1; + } + else if (key > ar[mid2]) + { + l = mid2 + 1; + } + else + { + l = mid1 + 1; + r = mid2 - 1; + } + } + + // If the KEY is not found + return -1; + } + + // Main Function to Execute + public static void Main(String[] args) + { + int l, r, p, i, key = 0, len = 0; + + // Taking the input of Array Length from user + Console.WriteLine("Enter Length of Array : "); + len = Convert.ToInt32(Console.ReadLine()); + + int[] ar = new int[len]; + + Console.WriteLine("Enter Array Elements in Ascending Order : "); + + for(i = 0; i < len; i++ ) // Array input + { + ar[i] = Convert.ToInt32(Console.ReadLine()); + } + + // Starting index + l = 0; + + // Ending Index + r = len - 1; + + Console.WriteLine("\nEnter the Number to be Searched : "); + // KEY to be searched in the array + key = Convert.ToInt32(Console.ReadLine()); + + // Searching the KEY using ternarySearch function + p = ternarySearch(l, r, key, ar); + + + // Checking if the KEY is present or not + if(p == -1) + Console.WriteLine("\nNumber Not Found"); + else + Console.WriteLine("\n The Index of " + key + " is " + p); + Console.ReadKey(); + + + } +} + +// Sample Input/Output: +/* + Enter Length of Array : 5 + Enter Array Elements in Ascending Order : + 10 + 20 + 30 + 40 + 50 + + Enter the Number to be Searched : + 50 + + The Index of 50 is 4 + +*/ From 03077e5ac8ce372ecf618f64a3b10a90ac743823 Mon Sep 17 00:00:00 2001 From: Simran Koul Date: Sun, 22 Mar 2020 15:51:24 +0530 Subject: [PATCH 030/265] Create arrayList.java (#2230) Update arrayList.java Modifications after Review Update arrayList.java Made changes as suggested --- Collections/arrayList.java | 228 +++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 Collections/arrayList.java diff --git a/Collections/arrayList.java b/Collections/arrayList.java new file mode 100644 index 000000000..868a686a4 --- /dev/null +++ b/Collections/arrayList.java @@ -0,0 +1,228 @@ +import java.util.*; +public class arrayList { + public static void main(String[] args) { + + // Creating a Scanner Object + Scanner scan = new Scanner(System.in); + + // Creating the ArrayList + List li = new ArrayList(); + + char choice='y'; + int value, index; + System.out.println("Enter 1 to add Objects to the list"); + System.out.println("Enter 2 to add Object at a particular index to a list"); + System.out.println("Enter 3 to check size of the list"); + System.out.println("Enter 4 to remove an element from particular index"); + System.out.println("Enter 5 to get an element at a particular index"); + System.out.println("Enter 6 to replace an element at a particular index"); + System.out.println("Enter 7 to find the index of an element"); + System.out.println("Enter 8 to search for the last occurence index of element in the list"); + System.out.println("Enter 9 to check whether an element exists in the list"); + System.out.println("Enter 10 to clear the list"); + System.out.println("Enter 11 to check whether the list is empty or not"); + System.out.println("Enter 12 to create a sublist from the list"); + System.out.println("Enter 13 to print the list"); + while(choice=='y') + { + System.out.println("Enter your choice"); + int input = scan.nextInt(); + switch(input) + { + case 1: System.out.println("Enter value to be added"); + value=scan.nextInt(); + li.add(value); + break; + case 2: System.out.println("Enter the index and value of element to be added"); + index=scan.nextInt(); + value=scan.nextInt(); + li.add(index,value); + break; + case 3: System.out.println("Size of list: "+li.size()); + break; + case 4: System.out.println("Enter index of element to be removed"); + index=scan.nextInt(); + li.remove(index); + System.out.println("Element removed successfully!"); + System.out.println("After Deletion: "+li); + break; + case 5: System.out.println("Enter index of element"); + index=scan.nextInt(); + System.out.println("Element is: "+li.get(index)); + break; + case 6: System.out.println("Enter index and value of element to be replaced"); + index=scan.nextInt(); + value=scan.nextInt(); + li.set(index,value); + System.out.println("After replacing: "+li); + break; + case 7: System.out.println("Enter value of element whose index to be found"); + value=scan.nextInt(); + System.out.println("Value is: "+li.indexOf(value)); + + break; + case 8: System.out.println("Enter the value of element whose last occurence index is to be found"); + value=scan.nextInt(); + System.out.println("Value is:"+li.lastIndexOf(value)); + break; + case 9: // Check if an element exists in the Array List + System.out.println("Enter value of element"); + value=scan.nextInt(); + boolean find = li.contains(value); + if(find) { + System.out.println("Element is in the list"); + } + else + { + System.out.println("Element is not in the list"); + } + break; + case 10: // To clear all elements in array + li.clear(); + break; + case 11: // To check whether the list is empty or not. + System.out.println("Is the list empty? "+li.isEmpty()); + break; + case 12: // To print sublist + int start,end; + System.out.println("Enter starting and ending index"); + start=scan.nextInt(); + end=scan.nextInt(); + List sublist = new ArrayList(); + sublist = li.subList(start,end); + System.out.println(sublist); + break; + case 13: // Creating an Iterator to traverse the arraylist. + Iterator itr = li.iterator(); + while(itr.hasNext()) + { + System.out.println(itr.next()); + } + break; + default: System.out.println("Invalid option entered"); + break; + + } + System.out.println("Do you want to continue? Enter 'y' for more inputs or 'n' to stop"); + choice=scan.next().charAt(0); + } + } +} + +/* +Sample Input +Enter 1 to add Objects to the list +Enter 2 to add Object at a particular index to a list +Enter 3 to check size of the list +Enter 4 to remove an element from particular index +Enter 5 to get an element at a particular index +Enter 6 to replace an element at a particular index +Enter 7 to find the index of an element +Enter 8 to search for the last occurence index of element in the list +Enter 9 to check whether an element exists in the list +Enter 10 to clear the list +Enter 11 to check whether the list is empty or not +Enter 12 to create a sublist from the list +Enter 13 to print the list +Enter your choice +1 +Enter value to be added +100 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +1 +Enter value to be added +200 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +1 +Enter value to be added +300 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +2 +Enter the index and value of element to be added +2 +1000 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +3 +Size of list: 4 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +4 +Enter index of element to be removed +2 +Element removed successfully! +After Deletion: [100, 200, 300] +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +5 +Enter index of element +2 +Element is: 300 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +6 +Enter index and value of element to be replaced +1 +200 +After replacing: [100, 200, 300] +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +7 +Enter value of element whose index to be found +100 +Value is: 0 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +8 +Enter the value of element whose last occurence index is to be found +200 +Value is:1 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +9 +Enter value of element +100 +Element is in the list +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +11 +Is the list empty? false +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +12 +Enter starting and ending index +1 +2 +[200] +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +13 +100 +200 +300 +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +y +Enter your choice +9 +Enter value of element +12 +Element is not in the list +Do you want to continue? Enter 'y' for more inputs or 'n' to stop +n +*/ \ No newline at end of file From 4d56308e85f7e2d4f34a18eb2c4488cbdebe8b38 Mon Sep 17 00:00:00 2001 From: Md Akdas Ahmad <43089126+MdAkdas@users.noreply.github.com> Date: Mon, 23 Mar 2020 15:40:19 +0530 Subject: [PATCH 031/265] palindromic_string_added 2, indentation fixed C/C++ (#2356) --- palindromic_string/palindromic_string.c | 54 ++++++++++++++++++++++ palindromic_string/palindromic_string.cpp | 55 +++++++++++++++++++++++ 2 files changed, 109 insertions(+) create mode 100644 palindromic_string/palindromic_string.c create mode 100644 palindromic_string/palindromic_string.cpp diff --git a/palindromic_string/palindromic_string.c b/palindromic_string/palindromic_string.c new file mode 100644 index 000000000..1984bbde4 --- /dev/null +++ b/palindromic_string/palindromic_string.c @@ -0,0 +1,54 @@ +/* +C Programme to check palindromic string. +A Palindromic String is a sequence of characters which is +the same when read both forward and backward. +*/ + +#include +#include + +// Driver function +int main() +{ + char string1[20]; + int i, length; + bool flag = false; + + printf("Enter a string: "); + scanf("%s", string1); + + length = strlen(string1); + + for(i = 0; i < length/2; i++) + { + if(string1[i] != string1[length - i - 1]) + { + flag = true; + break; + } + } + + if (flag) + { + printf("%s is not a palindrome", string1); + } + else + { + printf("%s is a palindrome", string1); + } + return 0; +} + +/* +Input: +radar + +Output: +radar is a palindrome + +Input: +Enter a string: india + +Output: +india is not a palindrome +*/ diff --git a/palindromic_string/palindromic_string.cpp b/palindromic_string/palindromic_string.cpp new file mode 100644 index 000000000..11720adbe --- /dev/null +++ b/palindromic_string/palindromic_string.cpp @@ -0,0 +1,55 @@ +/* +C++ Programme to check palindromic string. +A Palindromic String is a sequence of characters which is +the same when read both forward and backward. +*/ + +#include +#include +using namespace std; + +// Driver function +int main() +{ + char string1[20]; + int i, length; + bool flag = false; + + cout << "Enter a string: "; + cin >> string1; + + length = strlen(string1); + + for(i = 0; i < length/2; i++) + { + if(string1[i] != string1[length - i - 1]) + { + flag = true; + break; + } + } + + if (flag) + { + cout << string1 << " is not a palindrome" << endl; + } + else + { + cout << string1 << " is a palindrome" << endl; + } + + return 0; +} + +/*Input: +radar + +Output: +radar is a palindrome + +Input: +Enter a string: india + +Output: +india is not a palindrome +*/ \ No newline at end of file From cda804925c437422227d2752dfe3c23908b1c8d9 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Tue, 24 Mar 2020 22:31:29 +0530 Subject: [PATCH 032/265] check palindrome in a number in Java (#2492) updated with changes updated updated changes --- Palindrome/palindrome_no.java | 47 +++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Palindrome/palindrome_no.java diff --git a/Palindrome/palindrome_no.java b/Palindrome/palindrome_no.java new file mode 100644 index 000000000..b3b5e0e06 --- /dev/null +++ b/Palindrome/palindrome_no.java @@ -0,0 +1,47 @@ +// Java program to check if a number entered is a palindrome + +import java.util.*; + +public class palindrome_no { + + // Find reverse of a number + public static int reverse(int number) { + int reverseno = 0 ; + + while (number > 0) { + reverseno = (int) (reverseno * Math.pow(10, 1) + number % Math.pow(10, 1)); + number = (int) (number / Math.pow(10, 1)); + } + return reverseno; + } + + public static void main(String[] args) { + Scanner s = new Scanner(System.in); + System.out.println(" Hey, Enter any number "); + int enter_number = s.nextInt(); + int reverseno = reverse(enter_number); + + // Check whether the number entered is equal to reversed number or not + if (reverseno == enter_number) { + System.out.println("Number is a PALINDROME"); + return ; + } + System.out.println("Number is not a PALINDROME"); + return; + } +} + +/* +Test cases +INPUT + Hey, Enter any number +1223 +OUTPUT +Number is not a PALINDROME + +INPUT + Hey, Enter any number +1223221 +OUTPUT +Number is a PALINDROME +*/ From b02279f7cfe58e0de64b76fd3aa91de50e560f0e Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Tue, 24 Mar 2020 22:34:05 +0530 Subject: [PATCH 033/265] check palindrome in a string in Java (#2491) updated --- Palindrome/palindrome_string.java | 50 +++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 Palindrome/palindrome_string.java diff --git a/Palindrome/palindrome_string.java b/Palindrome/palindrome_string.java new file mode 100644 index 000000000..175e380e1 --- /dev/null +++ b/Palindrome/palindrome_string.java @@ -0,0 +1,50 @@ +//Java program to check if a string is a Palindrome + +import java.util.*; + +public class reverse_string { + + // Reverse a given string + public static String palindrome(String string_entered) { + String str_reversed = ""; + int length_of_String = string_entered.length()-1; + int len = 0; + + for (len = length_of_String; len >= 0 ; len --) + str_reversed = str_reversed + string_entered.charAt(len); + return str_reversed; + } + + public static void main(String[] args) { + + Scanner s = new Scanner(System.in); + System.out.println(" Hey,Enter any string "); + String string_entered = s.nextLine(); + String str_reversed = palindrome(string_entered); + + // Comparing 2 strings to find if input string is palindrome or not + if(string_entered.equals(str_reversed)) { + System.out.println(" String is a PALINDROME "); + } + else { + System.out.println(" String is not a PALINDROME "); + } + } +} + +/* +Test cases + +INPUT + Hey,Enter any string +hello +OUTPUT + String is not a PALINDROME + +INPUT + Hey,Enter any string +metem +OUTPUT + String is a PALINDROME +*/ + From c91c9a89f86b13e391e35673c50e838c279947af Mon Sep 17 00:00:00 2001 From: Ramchandra Joshi <60807704+rbjoshi1309@users.noreply.github.com> Date: Wed, 25 Mar 2020 12:20:54 +0530 Subject: [PATCH 034/265] Added code for Tower Of Hanoi in Go language (#2562) Added code for Tower Of Hanoi in Go language --- Tower_Of_Hanoi/Tower_Of_Hanoi.go | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_Of_Hanoi.go diff --git a/Tower_Of_Hanoi/Tower_Of_Hanoi.go b/Tower_Of_Hanoi/Tower_Of_Hanoi.go new file mode 100644 index 000000000..939013a59 --- /dev/null +++ b/Tower_Of_Hanoi/Tower_Of_Hanoi.go @@ -0,0 +1,36 @@ +// Tower of Hanoi problem using recursion + +package main +import "fmt" + +func TowerOfHanoi(n int, source byte, destination byte, auxillary byte) { + if (n == 1) { + fmt.Printf("Move disk 1 from rod %c to rod %c \n", source, destination) + return + } + TowerOfHanoi(n - 1, source, auxillary, destination) + fmt.Printf("Move disk %d from rod %c to rod %c \n", n, source, destination) + TowerOfHanoi(n - 1, auxillary, destination, source) +} + +func main() { + var n int + fmt.Print("Enter number of disks: ") + fmt.Scan(&n) + // n = Number of disks + + TowerOfHanoi(n, 'A', 'C', 'B') + // A, B and C are names of rods + // A is source rod, B is auxillary rod, C is destination rod +} + +/* +Enter number of disks: 3 +Move disk 1 from rod A to rod C +Move disk 2 from rod A to rod B +Move disk 1 from rod C to rod B +Move disk 3 from rod A to rod C +Move disk 1 from rod B to rod A +Move disk 2 from rod B to rod C +Move disk 1 from rod A to rod C +*/ From 1a7ceec1fe07ea03f4daecf61df8a42b57393338 Mon Sep 17 00:00:00 2001 From: abhinash_giri <56127409+abhinashgiri@users.noreply.github.com> Date: Wed, 25 Mar 2020 12:25:17 +0530 Subject: [PATCH 035/265] Merge-sort-3-way-with-reuested-changes (#2505) --- Merge_Sort_3_Way/Merge_Sort_3_Way.cpp | 204 ++++++++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 Merge_Sort_3_Way/Merge_Sort_3_Way.cpp diff --git a/Merge_Sort_3_Way/Merge_Sort_3_Way.cpp b/Merge_Sort_3_Way/Merge_Sort_3_Way.cpp new file mode 100644 index 000000000..b1092a74e --- /dev/null +++ b/Merge_Sort_3_Way/Merge_Sort_3_Way.cpp @@ -0,0 +1,204 @@ +#include "iostream" +#include +using namespace std; + +//function for storing elements from three vectors(left,mid,right) in sorted manner in vector named sorted +// sorted vector must be passed by reference to see the effect of changes made by the function +// other vectors are passed as reference to avoid copying of elements repeatedly + +void mergeVersion3(vector &sorted,vector &left,vector &mid,vector &right) +{ + int i = 0; //index pointer variable for left vector + int j = 0; //index pointer variable for mid vector + int k = 0; //index pointer variable for right vector + int l = 0; //index pointer variable for sorted vector + // selecting the minimum element of from the three vectors when all are non-empty + while( (i < left.size()) && (j mergeSort3ways(vector &input) +{ + if( input.size() == 1 ) + { + return input; + } + else if( input.size() == 2 ) + { + + //two different vectors (element1 and element2) of size 1 to store one element each and no_element vector of size 0 + + vectorelement1,element2,no_element(0); + element1.emplace_back(input.at(0)); + element2.emplace_back(input.at(1)); + + //call merging of three vectors and then return sorted vector + + mergeVersion3(input,element1,element2,no_element); + return input; + } + else + { int left_size {0}, right_size {0}, mid_size {0}; + if( input.size() % 3 == 0 ) + { + left_size = int(input.size() / 3); + mid_size = int(input.size() / 3); + right_size = int(input.size() / 3); + } + else if( input.size() % 3 == 1 ) + { + left_size = int(input.size() / 3) + 1; + mid_size = int(input.size() / 3); + right_size = int(input.size() / 3); + } + else if( input.size() % 3 == 2 ) + { + left_size = int(input.size() / 3) + 1; + mid_size = int(input.size() / 3); + right_size = int(input.size() / 3) + 1; + } + + // dividing original vector into three vectors left_vec,mid_vec,right_vec + + vector left_vec,right_vec,mid_vec; + for (int i = 0; i < left_size ; ++i) + { + left_vec.emplace_back(input[i]); + } + for (int i = 0; i < mid_size ; ++i) + { + mid_vec.emplace_back(input[i + left_size]); + } + for (int i = 0; i < right_size ; ++i) + { + right_vec.emplace_back(input[i + left_size + mid_size]); + } + + //dividing the three vectors recursively + + mergeSort3ways(left_vec); + mergeSort3ways(mid_vec); + mergeSort3ways(right_vec); + + // sorting the vector + + mergeVersion3(input,left_vec,mid_vec,right_vec); + return input; + } + +} + +// Driver Code + +int main() +{ + int n {0} , temp {0}; //initializes the variables n and temp to zero just after creation , it is not assignment + cin >> n; //input for number of elements in input array/vector + vector input , result; //vector to take input of all elements + + // taking input of n elements in a vector + + for (int i = 0; i < n ; ++i) { + cin >> temp; + input.emplace_back(temp); //emplace_back is more efficient than push_back + } + + // sorted vector is returned to result vector + + result = mergeSort3ways(input); + + // Displaying the sorted Vector + + for(auto c : result) + { + cout << c << " "; + } + return 0; +} +// Sample Test Cases +// Input +// 5 +// 78 8 6 5 7 +// Output +// 5 6 7 8 78 +// input +// 10 +// -8 45 -9 47 34 2 5 21 987 -3 +// Output +// -9 -8 -3 2 5 21 34 45 47 987 From 3bb864cc7503482ce456c0d40b76409a4dd994f7 Mon Sep 17 00:00:00 2001 From: Ishaan Ahuja <59371101+ishaan2908@users.noreply.github.com> Date: Wed, 25 Mar 2020 23:59:11 +0530 Subject: [PATCH 036/265] Created Count_Rotations.java (#1804) Added method to find how many times a sorted array is rotated using Binary Search --- Count_Rotations/Count_Rotations.java | 70 ++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Count_Rotations/Count_Rotations.java diff --git a/Count_Rotations/Count_Rotations.java b/Count_Rotations/Count_Rotations.java new file mode 100644 index 000000000..6b1accc83 --- /dev/null +++ b/Count_Rotations/Count_Rotations.java @@ -0,0 +1,70 @@ +/** + * A sorted array has been rotated in clockwise direction. + * Find how many times it was rotated. + */ + +import java.util.Scanner; + +class CountRotations +{ + static int findRotations(int[] arr) + { + /** + * returns no. of times a sorted array was rotated. + */ + int size = arr.length; + int left = 0, right = size - 1; + + while(left <= right) + { + int middle = (right + left) / 2; + int previous = (middle + size - 1) % size, next = (middle + 1) % size; + + // next is index of element after middle + // previous is index of element before middle + + if(arr[left] <= arr[right]) + return left; + + if(arr[middle] <= arr[next] && arr[middle] <= arr[previous]) + return middle; + + if(arr[middle] <= arr[right]) + right = middle - 1; + + else if(arr[middle] >= arr[left]) + left = middle + 1; + } + return 0; + } + + public static void main(String[] args) + { + Scanner scan = new Scanner(System.in); + + System.out.println("Enter size of the array: "); + int size = scan.nextInt(); + + int[] arr = new int[size]; + + System.out.println("Enter " + size + " elements: "); + for(int i = 0; i < size; i++) + arr[i] = scan.nextInt(); + + int count = findRotations(arr); + // count variable stores no. of rotations in the array. + + System.out.println("The array is rotated " + count + " times."); + } +} + +/** + * Sample Input + * size = 6 + * arr = 5, 6, 1, 2, 3, 4 + */ + +/** + * Sample Output + * The array is rotated 2 times. + */ From b5a3f734ef0da069d1380dfa1c6f865d1bc8552b Mon Sep 17 00:00:00 2001 From: jalajdorai <53962833+jalajdorai@users.noreply.github.com> Date: Thu, 26 Mar 2020 00:22:06 +0530 Subject: [PATCH 037/265] Integer to Roman Program (#2216) --- Integer_to_Roman/Integer_to_Roman.cpp | 67 +++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 Integer_to_Roman/Integer_to_Roman.cpp diff --git a/Integer_to_Roman/Integer_to_Roman.cpp b/Integer_to_Roman/Integer_to_Roman.cpp new file mode 100644 index 000000000..2b08ff0af --- /dev/null +++ b/Integer_to_Roman/Integer_to_Roman.cpp @@ -0,0 +1,67 @@ +/* +Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M. +Symbol Value +I 1 +V 5 +X 10 +L 50 +C 100 +D 500 +M 1000 +For example, two is written as II in Roman numeral, just two one's added together. +Twelve is written as, XII, which is simply X + II. +The number twenty seven is written as XXVII, which is XX + V + II. +Roman numerals are usually written largest to smallest from left to right. +However, the numeral for four is not IIII. Instead, the number four is written as IV. +Because the one is before the five we subtract it making four. +The same principle applies to the number nine, which is written as IX. +There are six instances where subtraction is used: +I can be placed before V (5) and X (10) to make 4 and 9. +X can be placed before L (50) and C (100) to make 40 and 90. +C can be placed before D (500) and M (1000) to make 400 and 900. +Given an integer, convert it to a roman numeral. + Input is guaranteed to be within the range from 1 to 3999. +*/ + +#include +using namespace std; +class Solution { +public: + string intToRoman(int num) { + int a[] = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000}; + string s[] = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"}; + string ans = ""; + int i = 12; + while(num > 0) + { + int d = num / a[i]; + num = num % a[i]; + while(d--) + { + ans = ans + s[i]; + } + i--; + } + return ans; + } +}; + +int stringToInteger(string input) { + return stoi(input); +} + +int main() { + string line; + while (getline(cin, line)) { + int num = stringToInteger(line); + string ret = Solution().intToRoman(num); + string out = (ret); + cout << out << endl; + } + return 0; +} +/* +Input: 58 +Output: "LVIII" +Explanation: L = 50, V = 5, III = 3. +*/ From 0cfac2b7503607b22aacdfdda7f172abcf7d3a94 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Fri, 27 Mar 2020 13:13:13 +0530 Subject: [PATCH 038/265] Depth First Search in Dart (#2561) --- Depth_First_Search/Depth_First_Search.dart | 100 +++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 Depth_First_Search/Depth_First_Search.dart diff --git a/Depth_First_Search/Depth_First_Search.dart b/Depth_First_Search/Depth_First_Search.dart new file mode 100644 index 000000000..c5224896f --- /dev/null +++ b/Depth_First_Search/Depth_First_Search.dart @@ -0,0 +1,100 @@ +// Required library to use inbuilt queue in LIFO manner in Dart +import 'dart:collection'; +// Required library to use standard output facility of dart +import 'dart:io'; + +// Function to find the depth first search of a graph +void Depth_First_Search ( var graph, int source, int no_vertices ) { + // Queue is used in LIFO manner to obtain stack functionality. + var queue = Queue(); + // A list to keep track of visited nodes + var visited = new List(no_vertices); + // Initializing the list + for(int i = 0; i < no_vertices; i ++ ) { + visited[i] = 0; + } + // Adding the source node to LIFO queue ( stack ) + queue.add(source); + // Marking the node visited + visited[source] = 1; + int val; + + while(queue.isNotEmpty){ + val = queue.removeLast(); + stdout.write("$val "); + + //Visiting neighbours of the popped node + for(int i = 0; i < no_vertices; i ++ ){ + if(graph[val][i] == 1 && visited[i] == 0){ + queue.add(i); + visited[i] = 1; + } + } + } +} + +// Driver method of the program +void main(){ + + // Reading from the standard input + print("Which graph do you want to enter ( directed/ undirected ):"); + String mode = stdin.readLineSync().toString(); + + print("Enter number of vertices:"); + var input = stdin.readLineSync(); + int no_vertices = int.parse(input); + + // Graph is implemented as adjacency matrix. + var graph = new List.generate(no_vertices, (_) => new List(no_vertices)); + for(int i = 0; i < no_vertices; i++){ + for(int j = 0; j < no_vertices; j++){ + graph[i][j] = 0; + } + } + + print("Enter number of edges:"); + var input1 = stdin.readLineSync(); + int no_edges = int.parse(input); + print("Enter source and destination vertices of edges:\n"); + print("Note: Enter source and destination vertices as 0,1,2,..."); + + for(int i = 1; i <= no_edges; i++){ + + print("Edge #$i:"); + + print("Enter source vertex:"); + int source = int.parse(stdin.readLineSync()); + + print("Enter destination vertex:"); + int destination = int.parse(stdin.readLineSync()); + + if(mode == "undirected"){ + graph[source][destination] = 1; + graph[destination][source] = 1; + } + else{ + graph[source][destination] = 1; + } + + } + + print("Enter the source vertex from which DFS should begin:"); + int source1 = int.parse(stdin.readLineSync()); + + // Sample input graph + // 0 - 1 - 2 + // | / + // 3 - 4 + + print("Vertices in Depth First Search of the graph in sample input is: "); + + // Depth First Search of the above graph + Depth_First_Search(graph,source1,no_vertices); + + // Sample Output + // Vertices in Depth First Search of the graph in sample input is: + // 0 3 4 2 1 + +} + + From d3a2320a5025b9e3df714c0d288e892b81e607fe Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Fri, 27 Mar 2020 13:13:33 +0530 Subject: [PATCH 039/265] Breadth first search using dart (#2560) --- .../Breadth_First_Search.dart | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 Breadth_First_Search/Breadth_First_Search.dart diff --git a/Breadth_First_Search/Breadth_First_Search.dart b/Breadth_First_Search/Breadth_First_Search.dart new file mode 100644 index 000000000..895b1f5f3 --- /dev/null +++ b/Breadth_First_Search/Breadth_First_Search.dart @@ -0,0 +1,99 @@ +// Required library to use inbuilt queues in Dart +import 'dart:collection'; +// Required library to use standard output facility of dart +import 'dart:io'; + +// Function to find the breadth first search of a graph +void Breadth_First_Search( var graph, int source, int no_vertices ) { + // Queue to order nodes levelwise or breadthwise + var queue = Queue(); + // A list to keep track of visited nodes + var visited = new List(no_vertices); + // Initializing the list + for(int i = 0; i < no_vertices; i++){ + visited[i] = 0; + } + // Adding the source node to queue + queue.add(source); + // Marking the node visited + visited[source] = 1; + int val; + + while(queue.isNotEmpty){ + val = queue.removeFirst(); + stdout.write("$val "); + + //Visiting neighbours of the dequed node + for(int i = 0; i < no_vertices; i++){ + if(graph[val][i] == 1 && visited[i] == 0){ + queue.add(i); + visited[i] = 1; + } + } + } +} + +// Driver method of the program +void main() { + + // Reading from the standard input + print("Which graph do you want to enter ( directed/ undirected ):"); + String mode = stdin.readLineSync().toString(); + + print("Enter number of vertices:"); + var input = stdin.readLineSync(); + int no_vertices = int.parse(input); + + // Graph is implemented as adjacency matrix. + var graph = new List.generate(no_vertices, (_) => new List(no_vertices)); + for(int i = 0; i < no_vertices; i++){ + for(int j = 0; j < no_vertices; j++){ + graph[i][j] = 0; + } + } + + print("Enter number of edges:"); + var input1 = stdin.readLineSync(); + int no_edges = int.parse(input); + print("Enter source and destination vertices of edges:\n"); + print("Note: Enter source and destination vertices as 0,1,2,..."); + + for(int i = 1; i <= no_edges; i++){ + + print("Edge #$i:"); + + print("Enter source vertex:"); + int source = int.parse(stdin.readLineSync()); + + print("Enter destination vertex:"); + int destination = int.parse(stdin.readLineSync()); + + if(mode == "undirected"){ + graph[source][destination] = 1; + graph[destination][source] = 1; + } + else { + graph[source][destination] = 1; + } + + } + + print("Enter the source vertex from which BFS should begin:"); + int source1 = int.parse(stdin.readLineSync()); + + // Sample input graph + // 0 - 1 - 2 + // | / + // 3 - 4 + + print("Vertices in Breadth First Search of the graph in sample input is: "); + + // Breadth First Search of the above graph + Breadth_First_Search(graph,source1,no_vertices); + + // Sample Output + // 0 1 3 2 4 + +} + + From e492e1adab74c05ea4380975362256a5fd291ae5 Mon Sep 17 00:00:00 2001 From: Ritish Singh <54978105+ritish099@users.noreply.github.com> Date: Fri, 27 Mar 2020 13:55:05 +0530 Subject: [PATCH 040/265] Postman Sort in C# (#2511) --- Postman_Sort/Postman_Sort.cs | 112 +++++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 Postman_Sort/Postman_Sort.cs diff --git a/Postman_Sort/Postman_Sort.cs b/Postman_Sort/Postman_Sort.cs new file mode 100644 index 000000000..e44363c54 --- /dev/null +++ b/Postman_Sort/Postman_Sort.cs @@ -0,0 +1,112 @@ +//Program to Sort the array using Postman Sort + +using System; +namespace Declaring_Method +{ + public class Postman_Sort + { + public static int[] arr = new int[100]; + public static int[] arr1 = new int[100]; + public int temp, max, count, maxdigits = 0, c = 0; + public static void Main(string[] args) + { + + Postman_Sort p = new Postman_Sort(); + int t1, t, n = 1, i, j; + Console.WriteLine("Enter the Size of the array "); + p.count = Convert.ToInt32(Console.ReadLine()); + Console.WriteLine("Enter the elements of the array :-"); + for (i = 0; i < p.count; i++) + { + Console.Write("Element - {0} : ", i); + arr[i] = Convert.ToInt32(Console.ReadLine()); + arr1[i] = arr[i]; + } + + //Finding the longest digits in the array and no of elements in that digit + for (i = 0; i < p.count; i++) + { + t = arr[i]; + while (t > 0) + { + p.c++; //Counting the no of elements of a digit + t = t / 10; + } + if (p.maxdigits < p.c) + p.maxdigits = p.c; //Storing the length of longest digit + p.c = 0; + } + for (i = 1; i < p.maxdigits; i++) + { + n = n * 10; + } + + for (i = 0; i < p.count; i++) + { + p.max = arr[i] / n; //Dividing by a particular base + t = i; + for (j = i + 1; j < p.count; j++) + { + if (p.max > (arr[j] / n)) + { + p.max = arr[j] / n; + t = j; + } + } + p.temp = arr1[t]; + arr1[t] = arr1[i]; + arr1[i] = p.temp; + p.temp = arr[t]; + arr[t] = arr[i]; + arr[i] = p.temp; + } + while (n >= 1) + { + for (i = 0; i < p.count;) + { + t1 = arr[i] / n; + for (j = i + 1; t1 == (arr[j] / n); j++); + arrange(i, j); + i = j; + } + n = n / 10; + } + Console.WriteLine("Sorted Array"); + for (i = 0; i < p.count; i++) + Console.Write("{0} ", arr1[i]); //Displaying the Sorted array + } + + //Arranging the elements + public static void arrange(int k, int n) + { + Postman_Sort p = new Postman_Sort(); + int i, j; + for (i = k; i < (n - 1); i++) + { + for (j = i + 1; j < n; j++) + { + if (arr1[i] > arr1[j]) + { + p.temp = arr1[i]; + arr1[i] = arr1[j]; + arr1[j] = p.temp; + p.temp = (arr[i] % 10); + arr[i] = (arr[j] % 10); + arr[j] = p.temp; + } + } + } + } + } +} +/* Enter the Size of the array +6 +Enter the elements of the array :- +Element - 0 : 43 +Element - 1 : 35 +Element - 2 : 75 +Element - 3 : 1 +Element - 4 : 68 +Element - 5 : 453 +Sorted Array +1 35 43 68 75 453 */ From 5730c44353f43c16ad2dd1d47a29059c6f3f1d09 Mon Sep 17 00:00:00 2001 From: Anuj Singh <43649349+myselfanuj@users.noreply.github.com> Date: Fri, 27 Mar 2020 23:35:30 +0530 Subject: [PATCH 041/265] CircleSort Algo in Kotlin (#2460) * CircleSort in Kotlin * Arranged Code * Update Circle_Sort.kts --- Circle_Sort/Circle_Sort.kts | 55 +++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 Circle_Sort/Circle_Sort.kts diff --git a/Circle_Sort/Circle_Sort.kts b/Circle_Sort/Circle_Sort.kts new file mode 100644 index 000000000..382c01749 --- /dev/null +++ b/Circle_Sort/Circle_Sort.kts @@ -0,0 +1,55 @@ +fun> circleSort(array: Array, lo: Int, hi: Int, nSwaps: Int): Int { + if (lo == hi) return nSwaps + + fun swap(array: Array, i: Int, j: Int) { + val temp = array[i] + array[i] = array[j] + array[j] = temp + } + + var high = hi + var low = lo + val mid = (hi - lo) / 2 + var swaps = nSwaps + + while (low < high) { + if (array[low] > array[high]) { + swap(array, low, high) + swaps++ + } + low++ + high-- + } + if (low == high) + if (array[low] > array[high + 1]) { + swap(array, low, high + 1) + swaps++ + } + + swaps = circleSort(array, lo, lo + mid, swaps) + swaps = circleSort(array, lo + mid + 1, hi, swaps) + return swaps +} + +fun main(args: Array) { + // -- ExampleArray1 -- + val array = arrayOf(6, 7, 8, 9, 2, 5, 3, 4, 1) + println("Unsorted Array: ${array.asList()}") + while (circleSort(array, 0, array.size - 1, 0) != 0) ; + println("Sorted Array : ${array.asList()}") //Sorted Array + println() + + // -- ExampleArray2 -- + val array2 = arrayOf("the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog") + println("Unsorted Array : ${array2.asList()}") + while (circleSort(array2, 0, array2.size - 1, 0) != 0) ; + println("Sorted Array : ${array2.asList()}") //Sorted Array +} + + +//output +Unsorted Array: [6, 7, 8, 9, 2, 5, 3, 4, 1] +Sorted Array : [1, 2, 3, 4, 5, 6, 7, 8, 9] + +Unsorted Array : [the, quick, brown, fox, jumps, over, the, lazy, dog] +Sorted Array : [brown, dog, fox, jumps, lazy, over, quick, the, the] From 8c338af13daeec1317945a4502a15910afc67a84 Mon Sep 17 00:00:00 2001 From: Bishal Kumar Chanda <60260604+BishalKrChanda@users.noreply.github.com> Date: Fri, 27 Mar 2020 23:39:58 +0530 Subject: [PATCH 042/265] added armstrong in c# added armstrong in c# --- Armstrong_Number/Armstrong_Number.cs | 38 ++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Armstrong_Number/Armstrong_Number.cs diff --git a/Armstrong_Number/Armstrong_Number.cs b/Armstrong_Number/Armstrong_Number.cs new file mode 100644 index 000000000..4ba4bed30 --- /dev/null +++ b/Armstrong_Number/Armstrong_Number.cs @@ -0,0 +1,38 @@ +using System; +public class Armstrong +{ + public static void Main(string[] args) + { + // initialising variables + int n, r, sum = 0, temp; + // asking for user input for the number to be checked + Console.Write("Enter the Number = "); + // storing the number in variable n + n = int.Parse(Console.ReadLine()); + // storing the number in a temporary variable + temp = n; + // running while loop to get the condition number + while(n > 0) + { + r = n % 10; + sum = sum + (r * r * r); + n = n / 10; + } + // checking if the number found using the condition of finding armstrong number is equal to the given number + // printing the statement according to the result of the condition + if(temp == sum) + Console.Write("The Entered Number is an Armstrong Number."); + else + Console.Write("The Entered number is not an Armstrong Number."); + } +} + +/* +Sample inputs and outputs: + +Enter the Number = 153 +The Entered Number is an Armstrong Number. + +Enter the Number = 121 +The Entered number is not an Armstrong Number. +*/ From 32a22374add884d44f0f2abf67193a197b2e860d Mon Sep 17 00:00:00 2001 From: Aman-Codes <54680709+Aman-Codes@users.noreply.github.com> Date: Fri, 27 Mar 2020 23:41:05 +0530 Subject: [PATCH 043/265] Implemented KNN algorithm using C++ (Closes issue #1789) (#2546) * Added the KNN Algorithm implemented using C++ * Added Tree_Inorder_Traversal.js * Delete Tree_Inorder_Traversal.js --- .../K_Nearest_Neighbors.cpp | 111 ++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbors.cpp diff --git a/Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbors.cpp b/Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbors.cpp new file mode 100644 index 000000000..296a0ed85 --- /dev/null +++ b/Machine_Learning/K_Nearest_Neighbours/K_Nearest_Neighbors.cpp @@ -0,0 +1,111 @@ +#include +using namespace std; + +struct point { + float w, x, y, z; // w, x, y and z are the values of the dataset + float distance; // distance will store the distance of dataset point from the unknown test point + int op; // op will store the class of the point +}; + +int main() { + int i, j, n, k; + struct point p; + struct point temp; + cout << "Number of data points: "; + cin >> n; + struct point arr[n]; + cout << "\nEnter the dataset values: \n"; + cout << "w\tx\ty\tz\top\n"; + + // Taking dataset + for (i = 0; i < n; i++) { + cin >> arr[i].w >> arr[i].x >> arr[i].y >> arr[i].z >> arr[i].op; + } + + cout << "\nw\tx\ty\tz\top\n"; + + for (i = 0; i < n; i++) { + cout << fixed << setprecision(2) << arr[i].w << '\t' << arr[i].x << '\t' << arr[i].y << '\t' << arr[i].z << '\t' << arr[i].op << '\n'; + } + + cout << "\nEnter the feature values of the unknown point: \nw\tx\ty\tz\n"; + cin >> p.w >> p.x >> p.y >> p.z; + + // Measuring the Euclidean distance + for (i = 0; i < n; i++) { + arr[i].distance = sqrt(((arr[i].w - p.w) * (arr[i].w - p.w)) + ((arr[i].x - p.x) * (arr[i].x - p.x)) + ((arr[i].y - p.y) * (arr[i].y - p.y)) + ((arr[i].z - p.z) * (arr[i].z - p.z))); + } + + // Sorting the training data with respect to distance + for (i = 1; i < n; i++) { + for (j = 0; j < n - i; j++) { + if (arr[j].distance > arr[j + 1].distance) { + temp = arr[j]; + arr[j] = arr[j + 1]; + arr[j + 1] = temp; + } + } + } + + cout << "\nw\tx\ty\tz\top\tdistance\n"; + for (i = 0; i < n; i++) { + cout << fixed << setprecision(2) << arr[i].w << '\t' << arr[i].x << '\t' << arr[i].y << '\t' << arr[i].z << '\t' << arr[i].op << '\t' << arr[i].distance << '\n'; + } + + // Taking the K nearest neighbors + cout << "\nNumber of nearest neighbors(k): "; + cin >> k; + + int freq[1000] = {0}; + int index = 0, maxfreq = 0; + + // Creating frequency array of the class of k nearest neighbors + for (int i = 0; i < k; i++) { + freq[arr[i].op]++; + } + + // Finding the most frequent occurring class + for (int i = 0; i < 1000; i++) { + if(freq[i] > maxfreq) { + maxfreq = freq[i]; + index = i; + } + } + + cout << "The class of unknown point is " << index; + return 0; +} + +// Sample Output +/* +Number of data points: 5 + +Enter the dataset values: +w x y z op +1 2 3 4 5 +10 20 30 40 50 +5 2 40 7 10 +40 30 100 28 3 +20 57 98 46 8 + +w x y z op +1.00 2.00 3.00 4.00 5 +10.00 20.00 30.00 40.00 50 +5.00 2.00 40.00 7.00 10 +40.00 30.00 100.00 28.00 3 +20.00 57.00 98.00 46.00 8 + +Enter the feature values of the unknown point: +w x y z +40 30 80 30 + +w x y z op distance +40.00 30.00 100.00 28.00 3 20.10 +20.00 57.00 98.00 46.00 8 41.34 +10.00 20.00 30.00 40.00 50 60.00 +5.00 2.00 40.00 7.00 10 64.33 +1.00 2.00 3.00 4.00 5 94.39 + +Number of nearest neighbors(k): 3 +The class of unknown point is 3 +*/ From db7a66f2ac601d73cab2ee538cb69c5a425f8256 Mon Sep 17 00:00:00 2001 From: AkanshaKamboj <42874293+AkanshaKamboj@users.noreply.github.com> Date: Sat, 28 Mar 2020 00:01:06 +0530 Subject: [PATCH 044/265] Binary Tree Bottom View, Top View and Right View in C #1577 (#2396) * Binary Tree Bottom View in C * Update BinaryTree_Bottom_View.c * Update BinaryTree_Bottom_View.c * Create Binary_Tree_Right_View.c * Create Binary_Tree_Top_View.c * Rename BinaryTree_Bottom_View.c to Binary_Tree_Bottom_View.c * Update Binary_Tree_Bottom_View.c * Update Binary_Tree_Right_View.c * Update Binary_Tree_Top_View.c --- .../Binary_Tree_Bottom_View.c | 124 ++++++++++++++++++ .../Binary_Tree_Right_View.c | 105 +++++++++++++++ Binary_Tree_Top_View/Binary_Tree_Top_View.c | 124 ++++++++++++++++++ 3 files changed, 353 insertions(+) create mode 100644 Binary_Tree_Bottom_View/Binary_Tree_Bottom_View.c create mode 100644 Binary_Tree_Right_View/Binary_Tree_Right_View.c create mode 100644 Binary_Tree_Top_View/Binary_Tree_Top_View.c diff --git a/Binary_Tree_Bottom_View/Binary_Tree_Bottom_View.c b/Binary_Tree_Bottom_View/Binary_Tree_Bottom_View.c new file mode 100644 index 000000000..18e63540e --- /dev/null +++ b/Binary_Tree_Bottom_View/Binary_Tree_Bottom_View.c @@ -0,0 +1,124 @@ +/* C program to print bottom view of the binary tree*/ + +#include +#include +#include + +// A binary tree node has data, pointer to left child and a pointer to right child +struct Node +{ + int data; + struct Node* left; + struct Node* right; +}; + +/* Inserting elements into Binary Tree*/ +struct Node *create() +{ + Node *ptr; + int x; + printf("Enter data(-1 for no node):"); + scanf("%d", &x); + + if(x == -1) + return NULL; + + ptr = (struct Node*)malloc(sizeof(struct Node)); + ptr -> data = x; + + printf("Enter left child of %d:\n", x); + ptr -> left = create(); + + printf("Enter right child of %d:\n", x); + ptr -> right = create(); + + return ptr; +} + +// Calculating the level and the vertical distance of the node and finding the nodes that appear as the top view +void findBottomView(struct Node *root, int *a, int *b, int level, int dist) +{ + if(root == NULL) + return; + + if(level > a[50 + dist]) + { + a[50 + dist] = level; + b[50 + dist] = root -> data; + } + + # Recursively calling the right and the left child to get the bottom view + + findBottomView(root -> right, a, b, level + 1, dist + 1); + findBottomView(root -> left, a, b, level + 1, dist - 1); +} + +int *bottomView(struct Node* root, int *len) { + + int i, o = 0; + + // a stores level of the node + // b stores vertical distance of the node from root + + int *a = (int *)calloc(100, sizeof(int)); + int *b = (int *)calloc(100, sizeof(int)); + int *c = (int *)calloc(100, sizeof(int)); + + // Initialising a and b as INT_MIN as we need to print bottom most elements + for(i = 0; i < 100; i++) + { + a[i] = INT_MIN; + b[i] = INT_MIN; + } + + findBottomView(root, a, b, 0, 0); + + for(i = 0; i < 100; i++) + { + if(b[i] != INT_MIN) + c[o++] = b[i]; + } + + *len = o; + return c; +} + +int main() +{ + struct Node *root = create(); + int len = 0; + int *res = bottomView(root, &len); + + for(int i = 0; i < len; i++) + printf("%d ", res[i]); +} + + +/* Sample Input +Enter data(-1 for no node: 1 +Enter left child of 1: +Enter data(-1 for no node: 2 +Enter left child of 2: +Enter data(-1 for no node: 6 +Enter left child of 6: +Enter data(-1 for no node: -1 +Enter right child of 6: +Enter data(-1 for no node: -1 +Enter right child of 2: +Enter data(-1 for no node: -1 +Enter right child of 1: +Enter data(-1 for no node: 3 +Enter left child of 3: +Enter data(-1 for no node: -1 +Enter right child of 3: +Enter data(-1 for no node: -1 + + 1 + / \ + 2 3 + / + 6 + +Output :- 6 2 1 3 +*/ + diff --git a/Binary_Tree_Right_View/Binary_Tree_Right_View.c b/Binary_Tree_Right_View/Binary_Tree_Right_View.c new file mode 100644 index 000000000..5f58ab287 --- /dev/null +++ b/Binary_Tree_Right_View/Binary_Tree_Right_View.c @@ -0,0 +1,105 @@ +/* C program to print right view of the binary tree*/ + +#include +#include + +/* A binary tree node has data, pointer to left child and a pointer to right child */ +struct Node +{ + int data; + struct Node* left; + struct Node* right; +}; + +/* Inserting elements into Binary Tree*/ +struct Node *create() +{ + Node *ptr; + int x; + + printf("Enter data(-1 for no node):"); + scanf("%d", &x); + + if(x == -1) + return NULL; + + ptr = (struct Node*)malloc(sizeof(struct Node)); + ptr -> data = x; + + printf("Enter left child of %d:\n",x); + ptr -> left = create(); + + printf("Enter right child of %d:\n",x); + ptr -> right = create(); + + return ptr; +} + +/*Recursive solution for priniting right view of Binary Tree*/ +void findRightView(struct Node *root, int *ans, int *size, int index) +{ + if(root == NULL) + return; + + index++; + + // Increasing the level of the tree every time a node with the same level appears + if(index > *size) + ans[(*size)++] = root -> data; + + // Recursively calling the nodes down the tree + findRightView(root -> right, ans, size, index); + + findRightView(root -> left, and, size, index); +} + +// Function for intializing the level of the root node and size of the array +int *rightView(struct Node *root, int *size) +{ + int *ans = malloc(sizeof(int) * 100); + *size = 0; + + findRightView(root, ans, size, 0); + + return ans; +} + +int main() +{ + struct Node *root = create(); + + int size = 0; + int *res = rightView(root, &size); + + for(int i = 0; i < size; i++) + printf("%d", res[i]); +} + +/* Sample Input +Enter data(-1 for no node: 1 +Enter left child of 1: +Enter data(-1 for no node: 2 +Enter left child of 2: +Enter data(-1 for no node: 6 +Enter left child of 6: +Enter data(-1 for no node: -1 +Enter right child of 6: +Enter data(-1 for no node: -1 +Enter right child of 2: +Enter data(-1 for no node: -1 +Enter right child of 1: +Enter data(-1 for no node: 3 +Enter left child of 3: +Enter data(-1 for no node: -1 +Enter right child of 3: +Enter data(-1 for no node: -1 + + 1 + / \ + 2 3 + / + 6 + +Output :- 1 3 6 +*/ + diff --git a/Binary_Tree_Top_View/Binary_Tree_Top_View.c b/Binary_Tree_Top_View/Binary_Tree_Top_View.c new file mode 100644 index 000000000..be8940cbd --- /dev/null +++ b/Binary_Tree_Top_View/Binary_Tree_Top_View.c @@ -0,0 +1,124 @@ + +/* C program to print top view of Binary tree*/ + +#include +#include +#include + +/* A binary tree node has data, pointer to left child and a pointer to right child */ +struct Node +{ + int data; + struct Node* left; + struct Node* right; +}; + +// Inserting elements into Binary Tree +struct Node *create() +{ + Node *ptr; + int x; + + printf("Enter data(-1 for no node):"); + scanf("%d",&x); + + if(x == -1) + return NULL; + + ptr = (struct Node*)malloc(sizeof(struct Node)); + ptr -> data = x; + + printf("Enter left child of %d:\n",x); + ptr -> left = create(); + + printf("Enter right child of %d:\n",x); + ptr -> right = create(); + + return ptr; +} + +// Calculating the level and the vertical distance of the node and finding the nodes that appear as the top view +void findTopView(struct Node *root, int *a, int *b, int level, int dist) +{ + if(root == NULL) + return; + + if(level < a[50 + dist]) + { + a[50 + dist] = level; + b[50 + dist] = root->data; + } + + # Recursively calling the left and the right child to get the bottom view + findTopView(root->left, a, b, level+1, dist-1); + + findTopView(root->right, a, b, level+1, dist+1); +} + +int *topView(struct Node* root, int *len) { + + int i,o = 0; + + // a stores the level of the node + // b stores the Vertical distance of the node from root + int *a = (int *)calloc(100, sizeof(int)); + int *b = (int *)calloc(100, sizeof(int)); + int *c = (int *)calloc(100, sizeof(int)); + + // Initialising a and b as INT_MAX as we need to print top most elements + for(i = 0; i < 100; i++) + { + a[i] = INT_MAX; + b[i] = INT_MAX; + } + + findTopView(root, a, b, 0, 0); + + for(i = 0; i < 100; i++) + { + if(b[i] != INT_MAX) + c[o++] = b[i]; + } + + *len = o; + return c; +} + +int main() +{ + struct Node *root = create(); + int len = 0; + int *res = topView(root, &len); + + for(int i = 0; i < len; i++) + printf("%d ", res[i]); +} + +/* Sample Input +Enter data(-1 for no node: 1 +Enter left child of 1: +Enter data(-1 for no node: 2 +Enter left child of 2: +Enter data(-1 for no node: 6 +Enter left child of 6: +Enter data(-1 for no node: -1 +Enter right child of 6: +Enter data(-1 for no node: -1 +Enter right child of 2: +Enter data(-1 for no node: -1 +Enter right child of 1: +Enter data(-1 for no node: 3 +Enter left child of 3: +Enter data(-1 for no node: -1 +Enter right child of 3: +Enter data(-1 for no node: -1 + + 1 + / \ + 2 3 + / + 6 + +Output :- 6 2 1 3 +*/ + From e3e7af5642f7886247345ae7ecae834ab1c3ba2e Mon Sep 17 00:00:00 2001 From: Chand Bud <47664980+chandbud5@users.noreply.github.com> Date: Sat, 28 Mar 2020 16:26:59 +0530 Subject: [PATCH 045/265] Tower of Hanoi in Kotlin (#2531) * Add files via upload * Update Tower_Of_Hanoi.kt * Update Tower_Of_Hanoi.kt * Update Tower_Of_Hanoi.kt * Update Tower_Of_Hanoi.kt --- Tower_Of_Hanoi/Tower_Of_Hanoi.kt | 44 ++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_Of_Hanoi.kt diff --git a/Tower_Of_Hanoi/Tower_Of_Hanoi.kt b/Tower_Of_Hanoi/Tower_Of_Hanoi.kt new file mode 100644 index 000000000..cd1422331 --- /dev/null +++ b/Tower_Of_Hanoi/Tower_Of_Hanoi.kt @@ -0,0 +1,44 @@ +/* + This is the solution for tower of hanoi problem using recursion implemented in Kotlin + Tower of Hanoi is an application of recursion + In this our aim is to shift n disks from source tower(peg) to destination tower(peg) + We can use third tower as auxilary tower. In it's solution we first try to shift n-1 disks. + Minimum number of steps required for this are 2^n-1 where n is number of disks. +*/ +import java.util.Scanner + +fun main() { + + val reader = Scanner(System.`in`) + var n:Int = reader.nextInt() + solveHanoi(n, 'A', 'C', 'B') +} + +/* + n - Number of disks + src - Source pole + dest - Destination pole + aux - Auxiliary pole +*/ + +fun solveHanoi(n: Int,src: Char, dest: Char, aux: Char) +{ + if(n >= 1) + { + solveHanoi(n - 1, src, dest, aux) + println("Move disk $n from $src to $dest") + solveHanoi(n - 1, aux, dest, src) + } +} + +/* +Output: + for 3 disks + Move disk 1 from A to C + Move disk 2 from A to C + Move disk 1 from B to C + Move disk 3 from A to C + Move disk 1 from B to C + Move disk 2 from B to C + Move disk 1 from A to C +*/ From a9e22d6f8d8a2b408a82eb4098e6c56a8dcac50b Mon Sep 17 00:00:00 2001 From: Chandrika Deb Date: Sat, 28 Mar 2020 16:29:37 +0530 Subject: [PATCH 046/265] Added Tower Of Hanoi in PHP (#2577) * Added Tower Of Hanoi in PHP * Update Tower_Of_Hanoi.php --- Tower_Of_Hanoi/Tower_Of_Hanoi.php | 43 +++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_Of_Hanoi.php diff --git a/Tower_Of_Hanoi/Tower_Of_Hanoi.php b/Tower_Of_Hanoi/Tower_Of_Hanoi.php new file mode 100644 index 000000000..4a28a5272 --- /dev/null +++ b/Tower_Of_Hanoi/Tower_Of_Hanoi.php @@ -0,0 +1,43 @@ +/* This is an implementation of Tower Of Hanoi problem in PHP. + We have considered 4 disks in this case. +*/ + + + +/* Sample Output + +Move disk 1 from rod A to rod B +Move disk 2 from rod A to rod C +Move disk 1 from rod B to rod C +Move disk 3 from rod A to rod B +Move disk 1 from rod C to rod A +Move disk 2 from rod C to rod B +Move disk 1 from rod A to rod B +Move disk 4 from rod A to rod C +Move disk 1 from rod B to rod C +Move disk 2 from rod B to rod A +Move disk 1 from rod C to rod A +Move disk 3 from rod B to rod C +Move disk 1 from rod A to rod B +Move disk 2 from rod A to rod C +Move disk 1 from rod B to rod C + +*/ From 51b497cf277fc7f5e68605c2f7d46306805c3034 Mon Sep 17 00:00:00 2001 From: Disha Sinha <42354197+disha2sinha@users.noreply.github.com> Date: Sat, 28 Mar 2020 16:32:21 +0530 Subject: [PATCH 047/265] Tower of Hanoi in Dart (#2513) * Tower of Hanoi in Dart * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart * Add files via upload * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart --- Tower_Of_Hanoi/Tower_of_Hanoi.dart | 49 ++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_of_Hanoi.dart diff --git a/Tower_Of_Hanoi/Tower_of_Hanoi.dart b/Tower_Of_Hanoi/Tower_of_Hanoi.dart new file mode 100644 index 000000000..03a2085e1 --- /dev/null +++ b/Tower_Of_Hanoi/Tower_of_Hanoi.dart @@ -0,0 +1,49 @@ +/* Tower of Hanoi is a mathematical problem where we have three rods A, B and C and n +number of disks where n is taken from user in this code. +The goal of the problem is to transfer the entire stack of disks to another rod, +obeying the conditions as follows: +1) Only one disk can be moved at a time. +2) Each move consists of taking the top disk from one of the stacks and placing +it on top of another stack. +3) No disk can be placed on top of a smaller disk. */ + +import 'dart:io'; + +void tower (int disks, String beg, String aux, String end) +{ + if (disks == 1) + { + print ("\nMove disk 1 from $beg ---> $end \n") ; + return ; + } + tower (disks - 1, beg, end, aux) ; + print ("\nMove disk $disks from $beg ---> $end \n") ; + tower (disks - 1, aux, beg, end) ; + return ; +} + +main() +{ + print ("ENTER NUMBER OF DISCS :\n") ; + int disks = int.parse (stdin.readLineSync()) ; + tower (disks, "A", "B", "C") ; +} + +/*OUTPUT: +ENTER NUMBER OF DISCS: +4 +Move disk 1 from A ---> B +Move disk 2 from A ---> C +Move disk 1 from B ---> C +Move disk 3 from A ---> B +Move disk 1 from C ---> A +Move disk 2 from C ---> B +Move disk 1 from A ---> B +Move disk 4 from A ---> C +Move disk 1 from B ---> C +Move disk 2 from B ---> A +Move disk 1 from C ---> A +Move disk 3 from B ---> C +Move disk 1 from A ---> B +Move disk 2 from A ---> C +Move disk 1 from B ---> C */ From 775b4ae122c77584f21fc0800b8f15b3d96d9d67 Mon Sep 17 00:00:00 2001 From: Yashasvi Sinha <59117774+heisastark@users.noreply.github.com> Date: Sat, 28 Mar 2020 16:35:17 +0530 Subject: [PATCH 048/265] added kadane algo in dart (#2517) * added kadane algo in dart * Dynamic Inputs, Comments position changed 1. Code changed to take dynamic inputs 2. Added comments before the code * Added sample input/output at the end of the file * Indented return statements properly * Added Karatsuba Algo in Dart * Added spaces between operators and Sample I/O * Deleting mistakenly added file Karatsuba_Algorithm.dart was accidentally pushed to the my branch that sent for PR. I have removed it now. --- Kadane_Algorithm/Kandane_Algorithm.dart | 85 +++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100755 Kadane_Algorithm/Kandane_Algorithm.dart diff --git a/Kadane_Algorithm/Kandane_Algorithm.dart b/Kadane_Algorithm/Kandane_Algorithm.dart new file mode 100755 index 000000000..bda39c82e --- /dev/null +++ b/Kadane_Algorithm/Kandane_Algorithm.dart @@ -0,0 +1,85 @@ +/* Dart implementation of Kadane's Algorithm to find the Maximum Subarray Sum +including the extra phase required when all the numbers in array are negative */ + +import 'dart:io'; + +// Function that returns maximum between Two Numbers +int max(a, b){ + if(a > b) + return a; + else + return b; +} + + +// Function implementing Kadane's Algorithm (array contains at least one positive number) +int kadane( input , n ){ + int currentmax = 0, maxsofar = 0; + + for( int i = 0; i < n; i++ ) + { + currentmax = max( 0 , currentmax + input[i] ); + maxsofar = max( maxsofar, currentmax ); + } + return maxsofar; +} + +void main() { + + int maxsubarraysum, size; + + // Input array + stdout.write("Enter the number of elements in the array:"); + String input = stdin.readLineSync(); + size = int.parse(input); + List array = []; + for( int i = 0; i < size; i++ ) + { + String x1 = stdin.readLineSync(); + int x2 = int.parse(x1); + array.add(x2); + } + + // Size of array + int n = array.length; + + // Flag variable to check if all the numbers in array are negative or not + int flag = 0; + + // Smallest_negative variable will store the maximum subarray sum if all the numbers are negative in array + int largestinnegative = array[0]; + + // Scanning each element in array + for( int i = 0; i < n; i++ ) + { + // If any element is positive, kadane's algo can be applied + if(array[i] >= 0) + { + flag = 1; + break; + } + else + { // If all the elements are negative, find the largest in them + if( array[i] > largestinnegative ) + { + largestinnegative = array[i]; + } + } + } + + // Kadane's algo applicable + if(flag == 1) + { + maxsubarraysum = kadane( array , n ); + } + else + { // Kadane 's algo not applicable, + maxsubarraysum = largestinnegative; + } + + // hence the max_subarray_sum will be the largest number in array itself + print("Maximum Subarray Sum is: $maxsubarraysum"); +} + +// sample input = [-2, 1, -6, 4, -1, 2, 1, -5, 4] +// sample output = Maximum Subarray Sum is: 6 From c2aa357b88156fe35238e66dcb355077cc0f4836 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sat, 28 Mar 2020 22:31:41 +0530 Subject: [PATCH 049/265] Find whether a number is Palindrome or not (#2327) * EvenOdd Python * EvenODD python * pallindrome of string in python * pallindrome number in python * Update and rename pallindrome_no.py to palindrome_no.py Fixed the all the typos * Delete EvenOdd.py * Delete pallindrome_string.py * Update palindrome_no.py * Update palindrome_no.py * Update palindrome_no.py Co-authored-by: samjain2001 --- Palindrome/palindrome_no.py | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Palindrome/palindrome_no.py diff --git a/Palindrome/palindrome_no.py b/Palindrome/palindrome_no.py new file mode 100644 index 000000000..0f341d47c --- /dev/null +++ b/Palindrome/palindrome_no.py @@ -0,0 +1,34 @@ +# Python program to find whether a number is a palindrome or not + +# Function to reverse a number +def reverse(num): + # Initialize variable + rev = 0 + + while ( num > 0 ) : + dig = num % 10 + rev = rev * 10 + dig + num = num // 10 + # Returning reversed number + return rev + +# --- main --- +num = int(input("Enter a number:")) +a = reverse(num) + +# Comparing the reversed number with original number +if(a == num): + print("Number entered is palindrome!") +else: + print("Number entered is not a palindrome!") + +''' +TEST CASES +INPUT +Enter a number:3445443 +Number entered is palindrome! + +OUTPUT +Enter a number:234 +Number entered is not a palindrome! +''' From 8f170a6b38ae7b19a1a409b46d004c89d59a509d Mon Sep 17 00:00:00 2001 From: Ritish Singh <54978105+ritish099@users.noreply.github.com> Date: Sun, 29 Mar 2020 15:03:46 +0530 Subject: [PATCH 050/265] Jhonson Algorithm in C# (#2626) * Jhonson Algorithm in C# * Update Jhonson.cs --- Jhonson_Algoritm/Jhonson.cs | 76 +++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Jhonson_Algoritm/Jhonson.cs diff --git a/Jhonson_Algoritm/Jhonson.cs b/Jhonson_Algoritm/Jhonson.cs new file mode 100644 index 000000000..b5a41b194 --- /dev/null +++ b/Jhonson_Algoritm/Jhonson.cs @@ -0,0 +1,76 @@ +// C# Program Implementing Jhonson Algorithm. + +using System; + +namespace ConsoleApp1 +{ + class Jhonson_Algorithm + { + public static void Main(String[] args) + { + int vert, edge, i, j, k, c; + int INF = 999999; + int[,] cost = new int[10, 10]; + int[,] adj = new int[10, 10]; + + Console.WriteLine("Enter no of vertices: "); + vert = Convert.ToInt32(Console.ReadLine()); + Console.WriteLine("Enter no of Edges: "); + edge = Convert.ToInt32(Console.ReadLine()); + Console.WriteLine("Enter the EDGE cost: "); + + for (k = 1; k <= edge; k++) + { + //take the input and store it into adj and cost matrix + i = Convert.ToInt32(Console.ReadLine()); + j = Convert.ToInt32(Console.ReadLine()); + c = Convert.ToInt32(Console.ReadLine()); + adj[i, j] = cost[i, j] = c; + } + + for (i = 1; i <= vert; i++) + for (j = 1; j <= vert; j++) + { + if (adj[i, j] == 0 && i != j) + //If its not a edge put infinity + adj[i, j] = INF; + } + for (k = 1; k <= vert; k++) + for (i = 1; i <= vert; i++) + for (j = 1; j <= vert; j++) + //Finding the minimum + //find minimum path from i to j through k + adj[i, j] = (adj[i, k] + adj[k, j]) > adj[i, j] ? adj[i, j] : (adj[i, k] + adj[k, j]) ; + Console.WriteLine("The distance matrix of the graph.\n"); + // Output the resultant matrix + for (i = 1; i <= vert; i++) + { + for (j = 1; j <= vert; j++) + { + if (adj[i, j] != INF) + Console.Write("{0} ", adj[i,j]); + } + Console.WriteLine(" "); + } + } + } +} +/*Enter no of vertices: +3 +Enter no of Edges: +5 +Enter the EDGE cost: +1 2 8 + +2 1 12 + +1 3 22 + +3 1 6 + +2 3 4 +The distance matrix of the graph. + +0 8 12 +10 0 4 +6 14 0*/ From df04554ca1e8a7347218a521cb09db73bb05ebb2 Mon Sep 17 00:00:00 2001 From: Sabuj Jana Date: Sun, 29 Mar 2020 15:21:13 +0530 Subject: [PATCH 051/265] Added Topological_Sort.js (Fixes #2159) (#2369) * Added Topological_Sort.js * Added Topological_Sort.js --- Topological_Sort/Topological_Sort.js | 92 ++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 Topological_Sort/Topological_Sort.js diff --git a/Topological_Sort/Topological_Sort.js b/Topological_Sort/Topological_Sort.js new file mode 100644 index 000000000..b76dfcc1f --- /dev/null +++ b/Topological_Sort/Topological_Sort.js @@ -0,0 +1,92 @@ +// Program to implement Topological Sort +class Graph { + constructor(nodes) { + //2 class variables + this.nodes = nodes; // no of vertices + this.adj = new Array(nodes); // adjacency list + for (let i = 0; i < nodes; i++) { + this.adj[i] = new Array(); + } + this.stack = []; // a stack for storing the ending times of dfs + } + + showGraph = () => { + const { + nodes, + adj + } = this; // destructuring for clarity + + for (let i = 0; i < nodes; i++) { + // show graph in readable format + console.log(`Vertex ${i} is connected to verices `, adj[i]); + } + }; + + addEdge = (x, y) => { + const { + nodes, + adj + } = this; + // x is connected to y + adj[x].push(y); + }; + + topoSort = () => { + const { + nodes, + adj + } = this; + + let visited = new Array(nodes); // visited array + for (let i = 0; i < nodes; i++) visited[i] = false; + + for (let i = 0; i < nodes; i++) + if (!visited[i]) this.topoUtil(i, visited); + }; + + topoUtil = (start, visited) => { + // utility function of topoSort + const { + nodes, + adj + } = this; + + visited[start] = true; + + for (let x of adj[start]) { + if (!visited[x]) { + this.topoUtil(x, visited); + } + } + + this.stack.push(start); // push the node when we have completed it + }; +} + +// implement +let n = 6; // 6 vertices +let graph = new Graph(n); // initialise the graph + +// add edges +graph.addEdge(5, 2); +graph.addEdge(5, 0); +graph.addEdge(4, 0); +graph.addEdge(4, 1); +graph.addEdge(2, 3); +graph.addEdge(3, 1); + +console.log("The Graph is:"); +graph.showGraph(); + +graph.topoSort(); +console.log(`The Topological sort is `, graph.stack.reverse()); + +// Output: +// The Graph is: +// Vertex 0 is connected to verices [] +// Vertex 1 is connected to verices [] +// Vertex 2 is connected to verices [ 3 ] +// Vertex 3 is connected to verices [ 1 ] +// Vertex 4 is connected to verices [ 0, 1 ] +// Vertex 5 is connected to verices [ 2, 0 ] +// The topological sort is [ 5, 4, 2, 3, 1, 0 ] From 49d53689f40edc8d26c5ac9694311b8525c4c947 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sun, 29 Mar 2020 17:42:22 +0530 Subject: [PATCH 052/265] Addition of matrix in java (#2527) updated --- Matrix_Operations/Java/Matrix_Addition.java | 108 ++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 Matrix_Operations/Java/Matrix_Addition.java diff --git a/Matrix_Operations/Java/Matrix_Addition.java b/Matrix_Operations/Java/Matrix_Addition.java new file mode 100644 index 000000000..63c9d71ed --- /dev/null +++ b/Matrix_Operations/Java/Matrix_Addition.java @@ -0,0 +1,108 @@ +// Java Program to calculation sum of 2 matrices (2D Array) +import java.util.*; + +public class Matrix_Addition { + // Find sum of 2 Matrices and store it in matrix3 + public static void add_matrices(int[][] matrix1, int[][] matrix2) { + + int index1, index2 = 0; + int[][] matrix3 = new int[matrix1.length][matrix1[0].length]; + + for ( index1 = 0; index1 < matrix1.length ; index1 ++) { + for ( index2 = 0; index2 < matrix1[0].length; index2++ ) { + matrix3[index1][index2] = matrix1[index1][index2] + matrix2[index1][index2]; + } + } + + // Print the calculated matrix + for ( index1 = 0; index1 < matrix3.length ; index1 ++) { + for ( index2 = 0; index2 < matrix3[0].length; index2++ ) { + System.out.print( matrix3[index1][index2] + " "); + } + System.out.println(); + } + } + + public static void main(String args[]) { + Scanner s = new Scanner(System.in); + + System.out.println("Of First Matrix"); + System.out.println(" Enter number of rows "); + int rows_first = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_first = s.nextInt(); + int[][] matrix1 = new int[rows_first][columns_first]; + + System.out.println("Of Second Matrix"); + System.out.println(" Enter number of rows "); + int rows_second = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_second = s.nextInt(); + int[][] matrix2 = new int[rows_second][columns_second]; + + if (columns_first != columns_second || rows_first != rows_second) { + System.out.println(" Addition of matrix is not possible "); + } + else { + + System.out.println(" Enter elements of 1st matrix "); + for (int i = 0 ; i < rows_first; i++) { + for (int j = 0 ; j< columns_first; j++) { + matrix1[i][j] = s.nextInt(); + } + } + + System.out.println(" Enter elements of 2nd matrix "); + for (int i = 0 ; i < rows_first; i++) { + for (int j = 0 ; j< columns_first; j++) { + matrix2[i][j] = s.nextInt(); + } + } + add_matrices(matrix1, matrix2); + } + } +} + +/* +TEST CASES +INPUT +Of First Matrix +Enter number of rows +2 +Enter number of columns +3 +Of Second Matrix +Enter number of rows +2 +Enter number of columns +4 +OUTPUT +Addition of matrix is not possible +INPUT +Of First Matrix +Enter number of rows +2 +Enter number of columns +2 +Of Second Matrix +Enter number of rows +2 +Enter number of columns +2 +Enter elements of 1st matrix +1 +2 +3 +4 +Enter elements of 2nd matrix +1 +1 +1 +1 +OUTPUT +2 3 +4 5 +*/ + From 39bbc04246cc62e5ce6f3f6bc229c14afd9587f7 Mon Sep 17 00:00:00 2001 From: VIJAY07102 <44638395+VIJAY07102@users.noreply.github.com> Date: Mon, 30 Mar 2020 19:45:04 +0530 Subject: [PATCH 053/265] Priority_Queue.py Priority_Queue --- Priority_Queue/Priority_Queue.py | 65 ++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Priority_Queue/Priority_Queue.py diff --git a/Priority_Queue/Priority_Queue.py b/Priority_Queue/Priority_Queue.py new file mode 100644 index 000000000..eff1b80fd --- /dev/null +++ b/Priority_Queue/Priority_Queue.py @@ -0,0 +1,65 @@ +queue = [] + +def insert(data): # To insert values into the Queue + queue.append(data) + +def delete(): # TO remove value from the Priority Queue + try: # Here highest value will be deleted first + max = 0 + for i in range(len(queue)): + if queue[i] > queue[max]: + max = i + + item = queue[max] + del queue[max] + + return item + + except IndexError: # Instead of giving error for empty queue + print("Queue is empty!!") # Displays that 'Queue is empty' + +while 1: + + print("\t1. Insert value in queue\n\t2. Delete value in queue\n\t3. Print Queue\n\t4. Exit") + + opt = int(input("Enter your option:")) + + if opt == 1: + value = int(input("Enter the value:")) + insert(value) + + elif opt == 2: + del_value = delete() + print("\n" + str(del_value) + " is deleted") + + elif opt == 3: + print(queue) + + elif opt == 4: + break + + else: + print("\tInvalid option!\n\tTry Again!!") + +# The program is made of user choice +''' +Example: + 1. Insert value in queue + 2. Delete value in queue + 3. Print Queue + 4. Exit +Enter your option: 1 # Here you have to give value to be inserted in the queue +Enter the value: 12 + 1. Insert value in queue + 2. Delete value in queue + 3. Print Queue + 4. Exit +Enter your option:2 # To delete the value of highest priority(here highest value) +14 is deleted +Enter your option:3 # display the queue +[12, 1, 7] +Enter your option:4 #to exit +If you enter any other value other than (1,2,3,4), You will be shown: + Invalid option! + Try Again!! +''' From f47d1b73611295bd2727a978d3078a194855a0fb Mon Sep 17 00:00:00 2001 From: "Abhushan A. Joshi" <49617450+abhu-A-J@users.noreply.github.com> Date: Wed, 1 Apr 2020 00:26:18 +0530 Subject: [PATCH 054/265] Added implementation of Z-Algorithm in JS (#2607) --- Z_Algorithm/Z_Algorithm.js | 102 +++++++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 Z_Algorithm/Z_Algorithm.js diff --git a/Z_Algorithm/Z_Algorithm.js b/Z_Algorithm/Z_Algorithm.js new file mode 100644 index 000000000..351dca2a5 --- /dev/null +++ b/Z_Algorithm/Z_Algorithm.js @@ -0,0 +1,102 @@ +/* +Z algorithm is a linear time string matching algorithm which runs in complexity. +It is used to find all occurrence of a pattern in a string , which is common +string searching problem. +*/ + +const setZArray = combined => { + + // Initiate zArray and fill it with zeros. + const zArray = Array.from({ length: combined.length }, () => 0); + + // Z box boundaries. + let leftIndex = 0, rightIndex = 0, shift = 0; + + // Go through all characters of the zString. + for (let i = 1; i < combined.length; i += 1) { + + if (i > rightIndex) { + + leftIndex = i; + rightIndex = i; + + while ( + rightIndex < combined.length + && combined[rightIndex - leftIndex] === combined[rightIndex] + ) { + + // Expanding Z box right boundary. + rightIndex += 1; + } + + + zArray[i] = rightIndex - leftIndex; + rightIndex -= 1; + + } + + else { + + // Calculate corresponding Z box shift. + shift = i - leftIndex; + + // Check if the value that has been already calculated before + if (zArray[shift] < (rightIndex - i) + 1) { + + zArray[i] = zArray[shift]; + } + else { + + // shift left boundary of Z box to current position. + leftIndex = i; + + // And start comparing characters one by one as we normally do for the case + while ( + rightIndex < combined.length + && combined[rightIndex - leftIndex] === combined[rightIndex] + ) { + rightIndex += 1; + } + + zArray[i] = rightIndex - leftIndex; + + rightIndex -= 1; + } + } + } + + // Return generated zArray. + return zArray; +} + + +zAlgorithm = (text, word) => { + + const wordPositions = []; + + // Concatenate word and text. Word will be a prefix to a text. + const zString = `${word}$${text}`; + + // Generate Z-array for concatenated string. + const zArray = setZArray(zString); + + for (let i = 1; i < zArray.length; i += 1) { + if (zArray[i] === word.length) { + + const wordPosition = i - word.length - 1; + wordPositions.push(wordPosition); + } + } + + // Return the list of word positions. + return wordPositions; +} + + +// I/O and O/P Examples: + +// The postions are: [0,10,16] +console.log(zAlgorithm("omgawesomeomgsftomg", "omg")); + +// The positions are: [3,12] +console.log(zAlgorithm("ohelloworldello", "llo")); From faf814b4081e7aaba2ab884464bdbcb521410cae Mon Sep 17 00:00:00 2001 From: HIMANSHU SHARMA Date: Wed, 1 Apr 2020 22:04:44 +0530 Subject: [PATCH 055/265] Created Pancake Sort in C# (#2309) * Create Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs --- Pancake_Sort/Pancake_Sort.cs | 78 ++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Pancake_Sort/Pancake_Sort.cs diff --git a/Pancake_Sort/Pancake_Sort.cs b/Pancake_Sort/Pancake_Sort.cs new file mode 100644 index 000000000..14fcf9212 --- /dev/null +++ b/Pancake_Sort/Pancake_Sort.cs @@ -0,0 +1,78 @@ +using System; + +class pancakeSortProgram { + // function swapping adjacent integer in array till from index 0 toindex i + static void flip(int []arr, int i) + { + int temp, start = 0; + while (start < i) + { + temp = arr[start]; + arr[start] = arr[i]; + arr[i] = temp; + start++; + i--; + } + } + // function returning index of max value till index curr_size + static int findMax(int []arr, int n) + { + int mi, i; + for (mi = 0, i = 0; i < n; ++i) + if (arr[i] > arr[mi]) + mi = i; + return mi; + } + + static int pancakeSort(int []arr, int n) + { + for (int curr_size = n; curr_size > 1; --curr_size) + { + // function calling for finding index of max integer + // till the index curr_size + int mi = findMax(arr, curr_size); + // call function flip for swapping if index of max integer + // till the index curr_size is not equal to curr_size-1 + if (mi != curr_size - 1) + { + flip(arr, mi); + flip(arr, curr_size - 1); + } + } + return 0; + } + // function for printing sorted array + static void printArray(int []arr, int arr_size) + { + for (int i = 0; i < arr_size; i++) + Console.Write(arr[i] + " "); + Console.Write(""); + } + + public static void Main (string [] args) + { + int n = Convert.ToInt32(Console.ReadLine());//input size of array + int []arr = new int[n];//initializing array of size n + + for(int i = 0; i < n; i++) + arr[i] = Convert.ToInt32(Console.ReadLine());//input value in array + + pancakeSort(arr, n);// call function which is sorting the input array + Console.Write("Sorted Array: "); + printArray(arr, n);// call fubction which print the sorted array + } +} +/* +Input: +6 +23 +10 +20 +11 +12 +6 +7 + +Output: +Sorted Array: 6 7 10 11 12 20 23 +*/ From 23261ceda1e6c15dd947b201a795d025c54d687e Mon Sep 17 00:00:00 2001 From: PrachieNaik <42534757+PrachieNaik@users.noreply.github.com> Date: Wed, 1 Apr 2020 22:27:45 +0530 Subject: [PATCH 056/265] Create Tree_Preorder_Traversal.kt (#2585) * Create Tree_Preorder_Traversal.kt * Update Tree_Preorder_Traversal.kt Taking dynamic input --- .../Tree_Preorder_Traversal.kt | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 Tree_Preorder_Traversal/Tree_Preorder_Traversal.kt diff --git a/Tree_Preorder_Traversal/Tree_Preorder_Traversal.kt b/Tree_Preorder_Traversal/Tree_Preorder_Traversal.kt new file mode 100644 index 000000000..18bef0bd6 --- /dev/null +++ b/Tree_Preorder_Traversal/Tree_Preorder_Traversal.kt @@ -0,0 +1,50 @@ +import java.util.* +class Node( + var key:Int, + var left:Node? = null, + var right:Node? = null +) +{ + fun preorderTraversal() + { + print("$key ") + left?.preorderTraversal() + right?.preorderTraversal() + } +} + +fun main() { + var read = Scanner(System.`in`) + println("Enter the size of Array:") + val arrSize = read.nextLine().toInt() + var arr = IntArray(arrSize) + val nodes = mutableListOf>() + println("Enter the array respresentaion of binary tree") + for(i in 0 until arrSize) + { + arr[i] = read.nextLine().toInt() + nodes.add(Node(arr[i])) + } + for(i in 0..arrSize-2) + { + if((i*2)+1 Date: Wed, 1 Apr 2020 22:52:02 +0530 Subject: [PATCH 057/265] add kosaraju algorithm in cpp (#2672) * add kosaraju algorithm in cpp * Update kosaraju_algorithm.cpp --- kosaraju_algorithm/kosaraju_algorithm.cpp | 105 ++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 kosaraju_algorithm/kosaraju_algorithm.cpp diff --git a/kosaraju_algorithm/kosaraju_algorithm.cpp b/kosaraju_algorithm/kosaraju_algorithm.cpp new file mode 100644 index 000000000..8b969d461 --- /dev/null +++ b/kosaraju_algorithm/kosaraju_algorithm.cpp @@ -0,0 +1,105 @@ +//Strongly connected components(KOSARAJU ALGORITHM) +#include +#include +#include +#include +using namespace std; + +//dfs to store vertices in a stack as per their finish time +void dfs(vector* edges, int start, unordered_set &visited, stack &finishStack) { + visited.insert(start); + for (int i = 0; i < edges[start].size(); i++) { + int adjacent = edges[start][i]; + if (visited.count(adjacent) == 0) { + dfs(edges, adjacent, visited, finishStack); + } + } + finishStack.push(start); +} + +//dfs of a transpose graph +void dfs2(vector* edges, int start, unordered_set* component, unordered_set & visited) { + visited.insert(start); + component->insert(start); + for (int i = 0; i < edges[start].size(); i++) { + int adjacent = edges[start][i]; + if (visited.count(adjacent) == 0) { + dfs2(edges, adjacent, component, visited); + } + } +} + +unordered_set*>* getSCC(vector* edges, vector* edgesT, int n) { + unordered_set visited; + stack finishedVertices; + for (int i = 0; i < n; i++) { + if (visited.count(i) == 0) { + dfs(edges, i, visited, finishedVertices); + } + } + unordered_set*>* output = new unordered_set*>(); + visited.clear(); + while (finishedVertices.size() != 0) { + int element = finishedVertices.top(); + finishedVertices.pop(); + if (visited.count(element) != 0) { + continue; + } + unordered_set* component = new unordered_set(); + dfs2(edgesT, element, component, visited); + output->insert(component); + } + return output; +} + +int main() { + int n; //no.of vertices + cout<<"Enter the no. of vertices : "<> n; + vector* edges = new vector[n]; //using a adjacency list to implement + vector* edgesT = new vector[n]; //transpose of a graph + int m; // no.of edges + cout<<"Enter the no. of edges : "<> m; + + for (int i = 0; i < m; i++) { + int j, k; + cin >> j >> k; + edges[j - 1].push_back(k - 1); + edgesT[k - 1].push_back(j - 1); + } + + unordered_set*>* components = getSCC(edges, edgesT, n); + unordered_set*>::iterator it = components->begin(); + + while (it != components->end()) { + unordered_set* component = *it; + unordered_set::iterator it2 = component->begin(); + while (it2 != component->end()) { + cout <<*it2 + 1<< " "; + it2++; + } + cout << endl; + delete component; + it++; + } + + delete components; + delete [] edges; + delete [] edgesT; +} + +/*INPUTS +Enter the no. of vertices : 6 +Enter the no. of edges :7 +1 2 +2 3 +3 4 +4 1 +3 5 +5 6 +6 5 + +OUTPUT +6 5 +2 3 4 1 */ From 2e9f2ac3386740ef3693cae6211e9a9f81adb526 Mon Sep 17 00:00:00 2001 From: j-shreya <53999364+j-shreya@users.noreply.github.com> Date: Wed, 1 Apr 2020 23:28:08 +0530 Subject: [PATCH 058/265] Aggressive cows (#2543) * Create GENERIC_TREE_LOTRAVERSAL.java * Update GENERIC_TREE_LOTRAVERSAL.java * Revert "Update GENERIC_TREE_LOTRAVERSAL.java" This reverts commit dfdd3095201cbf35c1ee673a6332a0eaf4960a88. * Revert "Create GENERIC_TREE_LOTRAVERSAL.java" This reverts commit 2c87bbb08c1e7f312d3e9410b7ff5423d25f1458. * Create Aggressive_Cows.java * Update Aggressive_Cows.java 1. Multi comments made 2. Extra spaces and lines removed 3. Indentation corrected --- Aggressive_Cows/Aggressive_Cows.java | 76 ++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Aggressive_Cows/Aggressive_Cows.java diff --git a/Aggressive_Cows/Aggressive_Cows.java b/Aggressive_Cows/Aggressive_Cows.java new file mode 100644 index 000000000..1cdb49723 --- /dev/null +++ b/Aggressive_Cows/Aggressive_Cows.java @@ -0,0 +1,76 @@ +import java.util.Arrays; +import java.util.Scanner; + +public class Aggressive_Cows { + + public static void main(String[] args) { + + /* in this problem we have to maximise the minimum distance between the + * cows since minimum distance is being linearly checked we apply + * binary search on minimum distance */ + + Scanner scn = new Scanner(System.in); + int nos = scn.nextInt(); // input for no. of stalls + int noc = scn.nextInt(); // input for no. of cows + + int[] arr = new int[nos]; // storing the position of stalls in an array + + for (int i = 0; i < arr.length; i++) { + arr[i] = scn.nextInt(); + } + + Arrays.sort(arr); // to sort the positions of stalls in ascending order + + int finalAns = 0; + + int lo = 0; + int hi = arr[arr.length - 1] - arr[0]; + + while (lo <= hi) { + + int mid = (lo + hi) / 2; + + if (isItPossible(nos, noc, arr, mid)) { + + finalAns = mid; + lo = mid + 1; + + }else{ + hi = mid - 1; + } + } + + System.out.println(finalAns); + + } + + // function to check if a particular arrangement of cows is possible or not + private static boolean isItPossible(int nos, int noc, int[] arr, int mid) { + + int cowsPlaced = 1; + int lastCowPos = arr[0]; // position at which cow is placed + + for (int i = 1; i < arr.length; i++) { + + if (arr[i] - lastCowPos >= mid) { + cowsPlaced++; + lastCowPos = arr[i]; + + if (cowsPlaced == noc) { + return true; + } + } + } + return false; + } +} + +// SAMPLE INPUT: 5 3 +// 1 +// 2 +// 8 +// 4 +// 9 +// +// Output: +// 3 From 4a4737dd8a6ecb9301fb2394b6b6a588e46c7949 Mon Sep 17 00:00:00 2001 From: shreya kapoor <31164665+shreyakapoor08@users.noreply.github.com> Date: Thu, 2 Apr 2020 16:40:17 +0530 Subject: [PATCH 059/265] Logistic Regression in Python (#2636) --- .../Logistic_Regression.ipynb | 418 ++++++++++++++++++ 1 file changed, 418 insertions(+) create mode 100644 Machine_Learning/Logistic_Regression/Logistic_Regression.ipynb diff --git a/Machine_Learning/Logistic_Regression/Logistic_Regression.ipynb b/Machine_Learning/Logistic_Regression/Logistic_Regression.ipynb new file mode 100644 index 000000000..669cfdb7f --- /dev/null +++ b/Machine_Learning/Logistic_Regression/Logistic_Regression.ipynb @@ -0,0 +1,418 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "plt.style.use('seaborn')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 2)\n", + "(500, 2)\n" + ] + } + ], + "source": [ + "mean_01 = np.array([1,0.5])\n", + "cov_01 = np.array([[1,0.1],[0.1,1.2]])\n", + "\n", + "mean_02 = np.array([4,5])\n", + "cov_02 = np.array([[1.21,0.1],[0.1,1.3]])\n", + "\n", + "\n", + "# Normal Distribution\n", + "dist_01 = np.random.multivariate_normal(mean_01,cov_01,500)\n", + "dist_02 = np.random.multivariate_normal(mean_02,cov_02,500)\n", + "\n", + "print(dist_01.shape)\n", + "print(dist_02.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(0)\n", + "\n", + "plt.scatter(dist_01[:,0],dist_01[:,1],label='Class 0')\n", + "plt.scatter(dist_02[:,0],dist_02[:,1],color='r',marker='^',label='Class 1')\n", + "plt.xlim(-5,10)\n", + "plt.ylim(-5,10)\n", + "plt.xlabel('x1')\n", + "plt.ylabel('x2')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 1)\n", + "(500, 1)\n", + "(1000, 3)\n" + ] + } + ], + "source": [ + "y1 = np.zeros((500,1))\n", + "print(y1.shape)\n", + "\n", + "y2 = np.ones((500,1))\n", + "print(y2.shape)\n", + "\n", + "data1 = np.hstack((dist_01,y1))\n", + "data2 = np.hstack((dist_02,y2))\n", + "data = np.vstack((data1,data2))\n", + "\n", + "print(data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 4.61546313 2.66193635 1. ]\n", + " [ 4.14312954 4.21854945 1. ]\n", + " [ 3.5360558 5.44785463 1. ]\n", + " [-0.30283189 1.49333376 0. ]\n", + " [ 3.78745303 6.42600424 1. ]\n", + " [ 1.88347777 4.75120101 1. ]\n", + " [ 4.62331128 4.57041199 1. ]\n", + " [ 3.25889833 6.95708425 1. ]\n", + " [ 0.8891156 -1.34359916 0. ]\n", + " [ 3.17329477 3.51864788 1. ]]\n" + ] + } + ], + "source": [ + "np.random.shuffle(data)\n", + "print(data[:10])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "split = int(0.8*data.shape[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(800, 2) (200, 2)\n", + "(800,) (200,)\n" + ] + } + ], + "source": [ + "X_train = data[:split,:-1]\n", + "X_test = data[split:,:-1]\n", + "\n", + "Y_train = data[:split,-1]\n", + "Y_test = data[split:,-1]\n", + "\n", + "print(X_train.shape,X_test.shape)\n", + "print(Y_train.shape,Y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def hypothesis(x,w,b):\n", + " '''accepts input vector x, input weight vector w and bias b'''\n", + " \n", + " h = np.dot(x,w) + b\n", + " return sigmoid(h)\n", + "\n", + "def sigmoid(z):\n", + " return 1.0/(1.0 + np.exp(-1.0*z))\n", + "\n", + "def error(y_true,x,w,b):\n", + " \n", + " m = x.shape[0]\n", + " \n", + " err = 0.0\n", + " \n", + " for i in range(m):\n", + " hx = hypothesis(x[i],w,b) \n", + " err += y_true[i]*np.log2(hx) + (1-y_true[i])*np.log2(1-hx)\n", + " \n", + " \n", + " return -err/m\n", + "\n", + "\n", + "def get_grads(y_true,x,w,b):\n", + " \n", + " grad_w = np.zeros(w.shape)\n", + " grad_b = 0.0\n", + " \n", + " m = x.shape[0]\n", + " \n", + " for i in range(m):\n", + " hx = hypothesis(x[i],w,b)\n", + " \n", + " grad_w += -1*(y_true[i] - hx)*x[i]\n", + " grad_b += -1*(y_true[i]-hx)\n", + " \n", + " \n", + " grad_w /= m\n", + " grad_b /= m\n", + " \n", + " return [grad_w,grad_b] #returning python list\n", + "\n", + "\n", + "# One Iteration of Gradient Descent\n", + "def grad_descent(x,y_true,w,b,learning_rate=0.1):\n", + " \n", + " err = error(y_true,x,w,b)\n", + " [grad_w,grad_b] = get_grads(y_true,x,w,b)\n", + " \n", + " w = w - learning_rate*grad_w\n", + " b = b - learning_rate*grad_b\n", + " \n", + " return err,w,b\n", + " \n", + "def predict(x,w,b):\n", + " \n", + " confidence = hypothesis(x,w,b)\n", + " if confidence<0.5:\n", + " return 0\n", + " else:\n", + " return 1\n", + " \n", + "def accuracy(x_tst,y_tst,w,b):\n", + " \n", + " y_pred = []\n", + " \n", + " for i in range(y_tst.shape[0]):\n", + " p = predict(x_tst[i],w,b)\n", + " y_pred.append(p)\n", + " \n", + " y_pred = np.array(y_pred)\n", + " \n", + " return float((y_pred==y_tst).sum())/y_tst.shape[0]\n", + " \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "loss = []\n", + "acc = []\n", + "\n", + "W = 2*np.random.random((X_train.shape[1],))\n", + "b = 5*np.random.random()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(300):\n", + " l,W,b = grad_descent(X_train,Y_train,W,b,learning_rate=0.5)\n", + " acc.append(accuracy(X_test,Y_test,W,b))\n", + " loss.append(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(loss)\n", + "plt.ylabel(\"negative of log likelihood\")\n", + "plt.xlabel(\"epoch\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.98\n" + ] + } + ], + "source": [ + "plt.plot(acc)\n", + "plt.ylabel(\"accuracy\")\n", + "plt.xlabel(\"epoch\")\n", + "plt.show()\n", + "print(acc[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(0)\n", + "\n", + "plt.scatter(dist_01[:,0],dist_01[:,1],label='Class 0')\n", + "plt.scatter(dist_02[:,0],dist_02[:,1],color='r',marker='^',label='Class 1')\n", + "plt.xlim(-5,10)\n", + "plt.ylim(-5,10)\n", + "plt.xlabel('x1')\n", + "plt.ylabel('x2')\n", + "\n", + "x = np.linspace(-4,8,10)\n", + "y = -(W[0]*x + b)/W[1]\n", + "plt.plot(x,y,color='k')\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.76604691 1.49267387]\n", + "-5.424920453033558\n" + ] + } + ], + "source": [ + "print(W)\n", + "print(b)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From fb37ab4be2ad207dbd1a115d65127f6f561f9422 Mon Sep 17 00:00:00 2001 From: SWARNIMA SHUKLA Date: Fri, 3 Apr 2020 00:13:00 +0530 Subject: [PATCH 060/265] Johnson Algorithm Implementation in Dart (#2567) --- Johnson_Algorithm/Johnson_Algorithm.dart | 180 +++++++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 Johnson_Algorithm/Johnson_Algorithm.dart diff --git a/Johnson_Algorithm/Johnson_Algorithm.dart b/Johnson_Algorithm/Johnson_Algorithm.dart new file mode 100644 index 000000000..e1cbc70f9 --- /dev/null +++ b/Johnson_Algorithm/Johnson_Algorithm.dart @@ -0,0 +1,180 @@ +/* +Johnson’s algorithm for All-pairs shortest paths + +Given a weighted Directed Graph where the weights may be negative, +find the shortest path between every pair of vertices in the Graph using +Johnson’s Algorithm. + */ + +int MAX_INT = 9223372036854775807; + +int minDistance(distance, visited) +{ + var minimum = MAX_INT; + var minVertex = 0; + + var v = distance.length; + + for(var vertex = 0; vertex < v; vertex++) + { + if( (minimum > distance[vertex]) && (visited[vertex] == false) ) + { + minimum = distance[vertex]; + minVertex = vertex; + } + } + return minVertex; +} + +void Dijkstra(graph, modified, src) +{ + var num_vertices = graph.length; + var distance = new List(num_vertices); + + var visited = new List(num_vertices); + + for (var i = 0; i < num_vertices; i++) + { + distance[i] = MAX_INT; + visited[i] = false; + } + + distance[src] = 0; + + for(var count = 0; count < num_vertices; count++) + { + var curVertex = minDistance(distance, visited); + visited[curVertex] = true; + for(var vertex = 0; vertex < num_vertices; vertex++) + { + if ((visited[vertex] == false) && (distance[vertex] > (distance[curVertex] + + modified[curVertex][vertex])) && (graph[curVertex][vertex] != 0)) + { + distance[vertex] = (distance[curVertex] + modified[curVertex][vertex]); + } + } + } + + for(var vertex = 0; vertex < num_vertices; vertex++) + { + print('Vertex ${vertex} : ${distance[vertex]}'); + } +} + +List BellmanFord(edges, graph, num_vertices) +{ + var distance = new List(num_vertices+1); + + for(var i = 0; i <= num_vertices; i++) + { + distance[i]=MAX_INT; + } + + distance[num_vertices] = 0; + + for(var i = 0; i < num_vertices; i++) + { + edges.add([num_vertices, i, 0]); + } + + for(var i = 0; i < num_vertices; i++) + { + for(var j in edges) + { + + if((distance[j[0]] != MAX_INT) && (distance[j[0]] + j[2] < distance[j[1]]) ) + { + distance[j[1]] = distance[j[0]] + j[2]; + } + } + } + + return distance; +} + + +void JohnsonAlgorithm(graph) +{ + var edges = new List(); + + for(var i = 0; i < graph.length ; i++) + { + for(var j = 0; j < graph[i].length; j++) + { + if(graph[i][j] != 0) + { + edges.add([i, j, graph[i][j]]); + } + } + } + + var modifiedwei = BellmanFord(edges, graph, graph.length); + + var modified = [[0,0,0,0], + [0,0,0,0], + [0,0,0,0], + [0,0,0,0]]; + + for(var i = 0; i < graph.length; i++) + { + for(var j = 0; j < graph[i].length; j++) + { + if(graph[i][j] != 0) + { + modified[i][j] = (graph[i][j] + + modifiedwei[i] - modifiedwei[j]); + } + } + } + + print ('Modified Graph: ${modified}'); + + for(var src = 0; src < graph.length; src++) + { + print ('\nShortest Distance with vertex ${src} as the source:\n'); + Dijkstra(graph, modified, src); + } +} + +void main() { + + var graph = [[0, -8, 2, 4], + [0, 0, 2, 6], + [0, 0, 0, 2], + [0, 0, 0, 0]]; + + JohnsonAlgorithm(graph); +} + +/* +Modified Graph: [[0, 0, 8, 8], [0, 0, 0, 2], [0, 0, 0, 0], [0, 0, 0, 0]] + +Shortest Distance with vertex 0 as the source: + +Vertex 0 : 0 +Vertex 1 : 0 +Vertex 2 : 0 +Vertex 3 : 0 + +Shortest Distance with vertex 1 as the source: + +Vertex 0 : 9223372036854775807 +Vertex 1 : 0 +Vertex 2 : 0 +Vertex 3 : 0 + +Shortest Distance with vertex 2 as the source: + +Vertex 0 : 9223372036854775807 +Vertex 1 : 9223372036854775807 +Vertex 2 : 0 +Vertex 3 : 0 + +Shortest Distance with vertex 3 as the source: + +Vertex 0 : 9223372036854775807 +Vertex 1 : 9223372036854775807 +Vertex 2 : -9223372036854775801 +Vertex 3 : 0 + + */ From 4e6909438b449fa055040539a288f7dfb178133b Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Fri, 3 Apr 2020 00:34:45 +0530 Subject: [PATCH 061/265] Boyer Moore Algorithm in C# (#2604) * Boyer Moore Algorithm in C# * Updated Changes --- Boyer_Moore_Algorithm/Boyer_Moore.cs | 110 +++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 Boyer_Moore_Algorithm/Boyer_Moore.cs diff --git a/Boyer_Moore_Algorithm/Boyer_Moore.cs b/Boyer_Moore_Algorithm/Boyer_Moore.cs new file mode 100644 index 000000000..391afe81a --- /dev/null +++ b/Boyer_Moore_Algorithm/Boyer_Moore.cs @@ -0,0 +1,110 @@ +// C# Program for Boyer Moore String Matching Algorithm + +using System; + +public class Algorithm +{ + static int CHARACTERS = 256; + + // Getting maximum of two integers + static int max (int a, int b) { return (a > b)? a: b; } + + // Bad Character Pre-Processing Function + static void badChar( char []str, int size,int []badCharacter) + { + int i; + + // Initializing all occurences to -1 + for (i = 0; i < CHARACTERS; i++) + badCharacter[i] = -1; + + // Filling the Actual Value + for (i = 0; i < size; i++) + badCharacter[(int) str[i]] = i; + } + + // Pattern Searching Function + static void search( char []txt, char []pat) + { + int m = pat.Length; + int n = txt.Length; + + int []Character = new int[CHARACTERS]; + badChar(pat, m, Character); + + /* + s is used to keep track of + pattern shifting with respect to text + */ + + int s = 0; + + while(s <= (n - m)) + { + int j = m - 1; + + while(j >= 0 && pat[j] == txt[s+j]) + j--; + + /* + If the pattern is present at current + shift, then index j will become -1 after + the above loop + */ + + if (j < 0) + { + Console.WriteLine("Pattern occurs at index: " + s); + s += (s+m < n)? m-Character[txt[s+m]] : 1; + } + + else + s += max(1, j - Character[txt[s+j]]); + + } + } + + public static void Main() + { + Console.WriteLine("Enter The String Value: "); + String valueEntered = Console.ReadLine(); + Console.WriteLine("Enter The Pattern To Search: "); + String pattern = Console.ReadLine(); + Console.WriteLine(); + + char []txt = valueEntered.ToCharArray(); + char []pat = pattern.ToCharArray(); + search(txt, pat); + } +} + +/** + +Enter The String Value: +ABAAABCD +Enter The Pattern To Search: +ABC + +Pattern occurs at index: 4 + +-------------------------------------------------- + +Enter The String Value: +AABAACAADAABAABA +Enter The Pattern To Search: +AABA + +Pattern occurs at index: 0 +Pattern occurs at index: 9 +Pattern occurs at index: 12 + +-------------------------------------------------- + +Enter The String Value: +THIS IS A TEST TEXT +Enter The Pattern To Search: +TEST + +Pattern occurs at index: 10 + +*/ From f231d7fba6dcdfb9a9612c1206a5431782f3b19d Mon Sep 17 00:00:00 2001 From: Sukriti Shah Date: Fri, 3 Apr 2020 16:38:33 +0530 Subject: [PATCH 062/265] Adding PHP Implementation for Chinese Rem. Th. (#2685) --- .../Chinese_Remainder_Theorem.php | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.php diff --git a/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.php b/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.php new file mode 100644 index 000000000..0275718e9 --- /dev/null +++ b/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.php @@ -0,0 +1,57 @@ + + From 50193d01daaaba6477d881911c7089a594fa22a7 Mon Sep 17 00:00:00 2001 From: Apoorva <51367534+apoorvam25@users.noreply.github.com> Date: Fri, 3 Apr 2020 22:35:53 +0530 Subject: [PATCH 063/265] Added Minimum Absolute Difference in Array Problem[C and C++] (#1845) --- .../Minimum_Absolute_Difference_In_Array.c | 42 +++++++++++++++++++ .../Minimum_Absolute_Difference_In_Array.cpp | 38 +++++++++++++++++ 2 files changed, 80 insertions(+) create mode 100644 Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.c create mode 100644 Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.cpp diff --git a/Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.c b/Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.c new file mode 100644 index 000000000..8739a9751 --- /dev/null +++ b/Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.c @@ -0,0 +1,42 @@ +/*Given an integer array A of size N, find and return +the minimum absolute difference between any two elements in the array. +The absolute difference between two elements ai, and aj (where i != j ) is |ai - aj|*/ + +#include +#include +#include + +int cmpfunc (const void * a, const void * b) +{ + return (*(int*)a - *(int*)b); +} + +int minAbsoluteDiff(int arr[], int n) +{ + qsort(arr, n, sizeof(int), cmpfunc); + int mindiff = INT_MAX; + for(int i = 0; i < n - 1; i++) + { + if(abs(arr[i] - arr[i + 1]) < mindiff) + mindiff = abs(arr[i] - arr[i + 1]); + } + return mindiff; +} + +int main() +{ + int size, i; + scanf("%d", &size); + int input[size]; + for(i = 0; i < size; i++) + scanf("%d", &input[i]); + + printf("%d", minAbsoluteDiff(input,size)); + return 0; +} + +/* Input : 12 + 922 192 651 200 865 174 798 481 510 863 150 520 + + Output : 2 +*/ diff --git a/Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.cpp b/Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.cpp new file mode 100644 index 000000000..ab13f120d --- /dev/null +++ b/Minimum_Absolute_Difference_In_Array/Minimum_Absolute_Difference_In_Array.cpp @@ -0,0 +1,38 @@ +/*Given an integer array A of size N,find and return +the minimum absolute difference between any two elements in the array. +The absolute difference between two elements ai, and aj (where i != j ) is |ai - aj|*/ + +#include +#include +#include +using namespace std; + +int minAbsoluteDiff(int arr[], int n) +{ + std::sort(arr, arr + n); + int mindiff = INT_MAX; + for(int i = 0; i < n - 1; i++) + { + if(abs(arr[i] - arr[i + 1] ) < mindiff) + mindiff = abs(arr[i] - arr[i + 1]); + } + return mindiff; +} + +int main() +{ + int size; + cin >> size; + int *input = new int[1 + size]; + + for(int i = 0; i < size; i++) + cin >> input[i]; + cout << minAbsoluteDiff(input, size) << endl; + return 0; +} + +/* Input : 5 + 2 9 0 4 5 + + Output : 1 +*/ From 67a6b6bc9bf2306c837189616c563f0e6819d99c Mon Sep 17 00:00:00 2001 From: Mansi Agrawal <46123053+mansikagrawal@users.noreply.github.com> Date: Fri, 3 Apr 2020 22:59:12 +0530 Subject: [PATCH 064/265] Count_Inversion.cpp (#2625) --- Count_Inversion/Count_Inversion.cpp | 85 +++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 Count_Inversion/Count_Inversion.cpp diff --git a/Count_Inversion/Count_Inversion.cpp b/Count_Inversion/Count_Inversion.cpp new file mode 100644 index 000000000..3f4c1601e --- /dev/null +++ b/Count_Inversion/Count_Inversion.cpp @@ -0,0 +1,85 @@ +// Count inversion using merge sort + +#include +using namespace std; + +//merge two sorted arrays such that resultant array is also sorted +int merge(int array[], int aux[], int low, int mid, int high) +{ + int x = low, y = mid, z = low, count = 0; + + // checking till left and right half of merge sort + while ((x <= mid-1) && (y <= high)) + { + if (array[x] <= array[y]) + { + aux[z++] = array[x++]; + } + else + { + aux[z++] = array[y++]; + count += mid-x; + } + } + + // Copy remaining elements + while (x <= mid-1) + { + aux[z++] = array[x++]; + } + + while (y <= high) + { + aux[z++] = array[y++]; + } + + // Sorting the original array with the help of aux array + for (int i = low; i <= high; i++) + { + array[i] = aux[i]; + } + return count; +} + +//merge sort to find inversion count +int mergeSort(int array[], int aux[], int low, int high) +{ + int count = 0; + if (high > low) + { + int mid = (low + high) / 2; + + // merge sort on Left half of the array + count = mergeSort(array, aux, low, mid); + // merge sort on Right half of the array + count += mergeSort(array, aux, mid + 1, high); + // Merge the two half + count += merge(array, aux, low, mid + 1, high); + } + return count; +} + +//wrapper function that returns number of inversions +int inversions_count(int array[], int n) +{ + int aux[n]; + return mergeSort(array, aux, 0, n-1); +} + +int main () +{ + int n; + cin >> n; + int arr[n]; + for(int i = 0; i < n; i++) + cin >> arr[i]; + cout << (inversions_count(arr, n)) << endl; + return 0; +} + +/* Sample input +5 +1 20 6 4 5 + +Sample Output +5 */ From 34d8d3b7b3aaa518751bb053eb314d844c381ba0 Mon Sep 17 00:00:00 2001 From: Aman-Codes <54680709+Aman-Codes@users.noreply.github.com> Date: Sun, 5 Apr 2020 16:38:02 +0530 Subject: [PATCH 065/265] Added Tree Inorder Traversal in JS (#2586) * Create Tree_Inorder_Traversal.js * Update Tree_Inorder_Traversal.js --- .../Tree_Inorder_Traversal.js | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Tree_Inorder_Traversal/Tree_Inorder_Traversal.js diff --git a/Tree_Inorder_Traversal/Tree_Inorder_Traversal.js b/Tree_Inorder_Traversal/Tree_Inorder_Traversal.js new file mode 100644 index 000000000..37ea90ebd --- /dev/null +++ b/Tree_Inorder_Traversal/Tree_Inorder_Traversal.js @@ -0,0 +1,38 @@ +/* + * Program to traverse a tree in Inorder. + */ + +// Creates a Tree Node with input value +class Node { + constructor(value) { + this.value = value; + this.left = null; + this.right = null; + } +} + +// Function for In Order Tree Transversal +function InOrder(root) { + if (root) { + InOrder(root.left); + console.log(root.value); + InOrder(root.right); + } +} + +// Sample Input +var root = new Node(1); +root.left = new Node(2); +root.right = new Node(3); +root.left.left = new Node(4); +root.left.right = new Node(5); +root.right.left = new Node(6); +root.right.right = new Node(7); + +// Sample Output +console.log("In Order traversal of tree is:-"); +InOrder(root); + +/* Output +In Order traversal of tree is:- 4 2 5 1 6 3 7 + */ From 3aa645770be5789598b671bc820791a80c2fa1e0 Mon Sep 17 00:00:00 2001 From: prince-09 <52371330+prince-09@users.noreply.github.com> Date: Sun, 5 Apr 2020 16:45:00 +0530 Subject: [PATCH 066/265] Floyd warshal js (#2468) * floyd Warshall in javascript * floyd warshall in java script * floyd warshall in java script * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js --- Floyd_Warshall_Algorithm/Floyd_Warshall.js | 88 ++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 Floyd_Warshall_Algorithm/Floyd_Warshall.js diff --git a/Floyd_Warshall_Algorithm/Floyd_Warshall.js b/Floyd_Warshall_Algorithm/Floyd_Warshall.js new file mode 100644 index 000000000..5af0847ed --- /dev/null +++ b/Floyd_Warshall_Algorithm/Floyd_Warshall.js @@ -0,0 +1,88 @@ +/*The Floyd Warshall Algorithm is for solving the All Pairs Shortest Path problem. +The problem is to find shortest distances between every pair of vertices in a given +edge weighted directed Graph.This is Floyd Warshall algorithm in java script.*/ + +class Graph { + constructor() { + this.edges = {}; + this.nodes = []; + } + + addNode(node) { + this.nodes.push(node); + this.edges[node] = []; + } + + addEdge(node1, node2, weight =1) { + this.edges[node1].push({node:node2, weight:weight }); + this.edges[node2].push({node:node1, weight:weight }); + } + + floydWarshallAlgorithm() { + let dist = {}; + for (let i = 0; i < this.nodes.length; i++) { + dist[this.nodes[i]] = {}; + + // For existing edges assign the dist to be same as weight + this.edges[this.nodes[i]].forEach(e = > (dist[this.nodes[i]][e.node] = e.weight)); + + this.nodes.forEach(n = > { + // For all other nodes assign it to infinity + if (dist[this.nodes[i]][n] == undefined) + dist[this.nodes[i]][n] = Infinity; + // For self edge assign dist to be 0 + if (this.nodes[i] == = n) dist[this.nodes[i]][n] = 0; + }); + } + + this.nodes.forEach(i = > { + this.nodes.forEach(j = > { + this.nodes.forEach(k = > { + // Check if going from i to k then from k to j is better + // than directly going from i to j. If yes then update + // i to j value to the new value + if (dist[i][k] + dist[k][j] < dist[i][j]) + dist[i][j] = dist[i][k] + dist[k][j]; + }); + }); + }); + return dist; + } +} + + let g = new Graph(); + + var edges = prompt("Please enter number of edges", "5"); + + var vertices = prompt("Please enter number of vertices", "5"); + + for(let i=0;i Date: Mon, 6 Apr 2020 03:19:36 +0530 Subject: [PATCH 067/265] Added a Number conversion(Decimal to Binary) code in java (#2524) Number conversion (decimal to binary) --- Number_Conversion/Java/Decimal_to_binary.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Number_Conversion/Java/Decimal_to_binary.java diff --git a/Number_Conversion/Java/Decimal_to_binary.java b/Number_Conversion/Java/Decimal_to_binary.java new file mode 100644 index 000000000..24a179f0b --- /dev/null +++ b/Number_Conversion/Java/Decimal_to_binary.java @@ -0,0 +1,30 @@ +//JAVA program to convert Decimal integer to it's Binary form + +import java.util.Scanner; + +public class Decimal_to_binary { + + //Driver Code + public static void main(String[] args){ + int n, rem; + String Bin = ""; //String to store the binary number + Scanner sc = new Scanner(System.in); + System.out.println("Enter any decimal number:"); + n = sc.nextInt(); //Taking the decimal input + + if (n == 0){ + Bin = "0"; + } + + //Simultaneously storing the remainder when number divided by 2 in the string in reverse order + while (n > 0){ + rem = n % 2; + Bin = rem + Bin; + n = n / 2; + } + System.out.println("Binary number:"+Bin); //output + } +} +//Input : 10 +//Output : 1010 + From 51ad0a118a32aa7cea0cad0846d3c007bf5880b0 Mon Sep 17 00:00:00 2001 From: AkanshaKamboj <42874293+AkanshaKamboj@users.noreply.github.com> Date: Mon, 6 Apr 2020 03:21:05 +0530 Subject: [PATCH 068/265] Linked list merge sort in C, C++, Java, Python #1578 (#2395) * Create Linked_List_Merge_Sort.c * Add files via upload * Update Linked_List_Merge_Sort.c * Update Linked_List_Merge_Sort.c * Update Linked_List_MergeSort.cpp * Update Linked_List_MergeSort.java * Update Linked_List_MergeSort.java * Update Linked_List_MergeSort.py * Update Linked_List_MergeSort.cpp * Update Linked_List_MergeSort.java * Update Linked_List_Merge_Sort.c * Rename Linked_List_MergeSort.cpp to Linked_List_Merge_Sort.cpp * Rename Linked_List_MergeSort.py to Linked_List_Merge_Sort.py * Rename Linked_List_MergeSort.java to Linked_List_Merge_Sort.java --- .../Linked_List_Merge_Sort.c | 157 +++++++++++++++++ .../Linked_List_Merge_Sort.cpp | 156 +++++++++++++++++ .../Linked_List_Merge_Sort.java | 165 ++++++++++++++++++ .../Linked_List_Merge_Sort.py | 149 ++++++++++++++++ 4 files changed, 627 insertions(+) create mode 100644 Linked_List_Merge_Sort/Linked_List_Merge_Sort.c create mode 100644 Linked_List_Merge_Sort/Linked_List_Merge_Sort.cpp create mode 100644 Linked_List_Merge_Sort/Linked_List_Merge_Sort.java create mode 100644 Linked_List_Merge_Sort/Linked_List_Merge_Sort.py diff --git a/Linked_List_Merge_Sort/Linked_List_Merge_Sort.c b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.c new file mode 100644 index 000000000..fa759d249 --- /dev/null +++ b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.c @@ -0,0 +1,157 @@ +/*C program for sorting a Single Linked List using Merge Sort technique. Merge Sort uses divide and conquer technique i.e. it + divides the input array into two halves, calls itself recursively for the two halves until one element remains and then merges + the two halves + + | 6 | 5 | 4 | 3 | 2 | 1 | * + / \ * + / \ * + | 6 | 5 | 4 | | 3 | 2 | 1 | * + / \ / \ * DIVIDE + / \ / \ * + | 6 | 5 | | 4 | | 3 | 2 | | 1 | * + / \ | / \ | * + |6| |5| | |3| |2| | * + \ / | \ / | + \ / | \ / | + | 5 | 6 | | | 2 | 3 | | * + \ | \ | * + \ | \ | * + | 4 | 5 | 6 | | 1 | 2 | 3 | * MERGE + \ / * + \ / * + | 1 | 2 | 3 | 4 | 5 | 6 | * + */ +#include +#include + +struct Node { + int data; + struct Node* next; +}; + +/*Merging the contents of the two linked list*/ +struct Node *merge(struct Node *l1, struct Node *l2) +{ + if(!l1) + return l2; + + if(!l2) + return l1; + + struct Node *head=NULL; + + if(l1->data < l2->data) + { + head = l1; + l1 = l1->next; + } + else + { + head = l2; + l2 = l2->next; + } + + struct Node *ptr = head; + + while(l1 && l2) + { + if(l1->data < l2->data) + { + ptr->next = l1; + l1 = l1->next; + } + else + { + ptr->next = l2; + l2 = l2->next; + } + ptr = ptr->next; + } + + if(l1) + ptr->next = l1; + else + ptr->next = l2; + + return head; +} + +/*Dividing the linked list*/ +struct Node* mergeSort(struct Node* head) { + + if(head==NULL || head->next==NULL) + return head; + + /*Dividing the linked list into two equal parts as done in merge sort*/ + struct Node *ptr1 = head; + struct Node *ptr2 = head->next; + + while(ptr2 && ptr2->next) + { + ptr1 = ptr1->next; + if(ptr2->next) + ptr2 = ptr2->next->next; + } + + ptr2 = ptr1->next; + ptr1->next = NULL; + + return merge(mergeSort(head),mergeSort(ptr2)); +} + +/* Function for printing the Single Linked List*/ +void printList(struct Node* head) { + + while (head != NULL) { + printf("%d-->", head->data); + head = head->next; + } + + printf("NULL"); +} + +int main() +{ + int test,n,ele; + scanf("%d", &test); + + /* Inserting elements into linked list*/ + while (test--) + { + struct Node* head = NULL; + struct Node *temp = NULL; + scanf("%d", &n); + + while(n--) + { + scanf("%d", &ele); + + struct Node *ptr = (struct Node*)malloc(sizeof(struct Node)); + ptr->data = ele; + ptr->next = NULL; + + if(head==NULL) + head = ptr; + else + temp->next = ptr; + + temp = ptr; + } + + head = mergeSort(head); + printList(head); + } + return 0; +} + +/* +Sample Input +1 - Test cases +5 - Total number of elements to be inserted in linked list +23 2 34 5 1 - Adding the contents of the linked list + +Sample Output +1-->2-->5-->23-->34-->NULL +*/ + + diff --git a/Linked_List_Merge_Sort/Linked_List_Merge_Sort.cpp b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.cpp new file mode 100644 index 000000000..a5ddf503f --- /dev/null +++ b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.cpp @@ -0,0 +1,156 @@ +/*C++ program for sorting a Single Linked List using Merge Sort technique. Merge Sort uses divide and conquer technique i.e. it + divides the input array into two halves, calls itself recursively for the two halves until one element remains and then merges + the two halves + | 6 | 5 | 4 | 3 | 2 | 1 | * + / \ * + / \ * + | 6 | 5 | 4 | | 3 | 2 | 1 | * + / \ / \ * DIVIDE + / \ / \ * + | 6 | 5 | | 4 | | 3 | 2 | | 1 | * + / \ | / \ | * + |6| |5| | |3| |2| | * + \ / | \ / | + \ / | \ / | + | 5 | 6 | | | 2 | 3 | | * + \ | \ | * + \ | \ | * + | 4 | 5 | 6 | | 1 | 2 | 3 | * MERGE + \ / * + \ / * + | 1 | 2 | 3 | 4 | 5 | 6 | * + */ + +#include +using namespace std; + +struct Node { + int data; + struct Node* next; + Node(int x) { + data = x; + next = NULL; + } +}; + +/*Merging the contents of the two linked list*/ +struct Node *merge(struct Node *l1, struct Node *l2) +{ + if(!l1) + return l2; + + if(!l2) + return l1; + + struct Node *head = NULL; + + if(l1->data < l2->data) + { + head = l1; + l1 = l1->next; + } + else + { + head = l2; + l2 = l2->next; + } + + struct Node *ptr = head; + + while(l1 && l2) + { + if(l1->data < l2->data) + { + ptr->next = l1; + l1 = l1->next; + } + else + { + ptr->next = l2; + l2 = l2->next; + } + ptr = ptr->next; + } + + if(l1) + ptr->next = l1; + else + ptr->next = l2; + + return head; +} + +/*Dividing the linked list*/ +struct Node* mergeSort(struct Node* head) { + + if(head == NULL || head->next == NULL) + return head; + + /*Dividing the linked list into two equal parts as done in merge sort*/ + struct Node *ptr1 = head; + struct Node *ptr2 = head->next; + + while(ptr2 && ptr2->next) + { + ptr1 = ptr1->next; + if(ptr2->next) + ptr2 = ptr2->next->next; + } + + ptr2 = ptr1->next; + ptr1->next = NULL; + + return merge(mergeSort(head),mergeSort(ptr2)); +} + +void printList(struct Node* head) { + + while (head != NULL) { + printf("%d-->", head->data); + head = head->next; + } + + printf("NULL"); +} + +int main() { + int test,n,ele; + cin >> test; + + while (test--) + { + struct Node *head = NULL; + struct Node *temp = NULL; + cin>>n; + + while(n--) + { + cin>>ele; + + struct Node *ptr = new Node(ele); + + if(head == NULL) + head = ptr; + else + temp->next = ptr; + + temp = ptr; + } + + head = mergeSort(head); + printList(head); + } + return 0; +} + +/* +Sample Input +1 - Test cases +5 - Total number of elements to be inserted in linked list +23 2 34 5 1 - Adding the contents of the linked list + +Sample Output +1-->2-->5-->23-->34-->NULL +*/ + + diff --git a/Linked_List_Merge_Sort/Linked_List_Merge_Sort.java b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.java new file mode 100644 index 000000000..1021a2c0d --- /dev/null +++ b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.java @@ -0,0 +1,165 @@ +/*JAVA program for sorting a Single Linked List using Merge Sort technique. Merge Sort uses divide and conquer technique i.e. + it divides the input array into two halves, calls itself recursively for the two halves until one element remains and then + merges the two halves + + | 6 | 5 | 4 | 3 | 2 | 1 | * + / \ * + / \ * + | 6 | 5 | 4 | | 3 | 2 | 1 | * + / \ / \ * DIVIDE + / \ / \ * + | 6 | 5 | | 4 | | 3 | 2 | | 1 | * + / \ | / \ | * + |6| |5| | |3| |2| | * + \ / | \ / | + \ / | \ / | + | 5 | 6 | | | 2 | 3 | | * + \ | \ | * + \ | \ | * + | 4 | 5 | 6 | | 1 | 2 | 3 | * MERGE + \ / * + \ / * + | 1 | 2 | 3 | 4 | 5 | 6 | * + */ + +import java.util.*; +import java.lang.*; +import java.io.*; + +class Node +{ + int data; + Node next; + Node(int key) + { + data = key; + next = null; + } +} + +class LinkedList +{ + /*Merging the contents of the two linked list*/ + + public static Node merge(Node l1, Node l2) + { + if(l1 == null) + return l2; + + if(l2 == null) + return l1; + + Node head = null; + + if(l1.data < l2.data) + { + head = l1; + l1 = l1.next; + } + else + { + head = l2; + l2 = l2.next; + } + + Node ptr = head; + + while(l1 != null && l2 != null) + { + if(l1.data < l2.data) + { + ptr.next = l1; + l1 = l1.next; + } + else + { + ptr.next = l2; + l2 = l2.next; + } + ptr = ptr.next; + } + + if(l1 != null) + ptr.next = l1; + else + ptr.next = l2; + + return head; + } + + /*Dividing the linked list*/ + public static Node mergeSort(Node head) + { + + if(head == null || head.next == null) + return head; + + Node ptr1 = head; + Node ptr2 = head.next; + + /*Dividing the linked list into two equal parts as done in merge sort*/ + while(ptr2 !=null && ptr2.next != null) + { + ptr1 = ptr1.next; + if(ptr2.next != null) + ptr2 = ptr2.next.next; + } + + ptr2 = ptr1.next; + ptr1.next = null; + + return merge(mergeSort(head),mergeSort(ptr2)); + } + + public static void printList(Node head) + { + if(head == null) + return; + + Node temp = head; + while(temp != null) + { + System.out.print(temp.data + "-->"); + temp = temp.next; + } + System.out.print("NULL"); + } + + public static void main (String[] args) + { + Scanner sc= new Scanner(System.in); + int t = sc.nextInt(); + + LinkedList l = new LinkedList(); + + while(t!=0) + { + int n = sc.nextInt(); + Node head = new Node(sc.nextInt()); + Node temp = head; + + n--; + + while(n!=0){ + temp.next = new Node(sc.nextInt()); + temp = temp.next; + n--; + } + + head = l.mergeSort(head); + l.printList(head); + t--; + } + } +} + +/* + Sample Input + 1 - Test cases + 5 - Total number of elements to be inserted in linked list + 23 2 34 5 1 - Adding the contents of the linked list + + Sample Output + 1-->2-->5-->23-->34-->NULL +*/ + diff --git a/Linked_List_Merge_Sort/Linked_List_Merge_Sort.py b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.py new file mode 100644 index 000000000..5ed23598f --- /dev/null +++ b/Linked_List_Merge_Sort/Linked_List_Merge_Sort.py @@ -0,0 +1,149 @@ +''' + PYTHON program for sorting a Single Linked List using Merge Sort technique. Merge Sort uses divide and conquer technique i.e. + it divides the input array into two halves, calls itself recursively for the two halves until one element remains and then + merges the two halves + + | 6 | 5 | 4 | 3 | 2 | 1 | * + / \ * + / \ * + | 6 | 5 | 4 | | 3 | 2 | 1 | * + / \ / \ * DIVIDE + / \ / \ * + | 6 | 5 | | 4 | | 3 | 2 | | 1 | * + / \ | / \ | * + |6| |5| | |3| |2| | * + \ / | \ / | + \ / | \ / | + | 5 | 6 | | | 2 | 3 | | * + \ | \ | * + \ | \ | * + | 4 | 5 | 6 | | 1 | 2 | 3 | * MERGE + \ / * + \ / * + | 1 | 2 | 3 | 4 | 5 | 6 | * +''' + +import atexit +import io +import sys + +class Node: + + def __init__(self, data): + self.data = data + self.next = None + +# Linked List Class +class LinkedList: + def __init__(self): + self.head = None + + # creates a new node with given value and appends it at the end of the linked list + + def merge(self, l1, l2): + head = None + + # Base cases + if l1 == None: + return l2 + + if l2 == None: + return l1 + + # pick either l1 or l2 and recurse + if l1.data <= l2.data: + head = l1 + l1 = l1.next + else: + head = l2 + l2 = l2.next + + ptr=head + + while l1!=None and l2!=None: + + if l1.data < l2.data: + ptr.next = l1 + l1 = l1.next + else: + ptr.next = l2 + l2 = l2.next + + ptr = ptr.next + + if l1 != None: + ptr.next = l1 + else: + ptr.next = l2 + + return head + + + def mergeSort(self, head): + + if head == None or head.next == None: + return head + + ptr1 = head + ptr2 = head.next + + while(ptr2 != None and ptr2.next != None): + ptr1 = ptr1.next + if ptr2.next != None: + ptr2 = ptr2.next.next + + ptr2 = ptr1.next + ptr1.next = None + + return self.merge(self.mergeSort(head), self.mergeSort(ptr2)) + + +# prints the elements of linked list starting with head +def printList(head): + + if head is None: + return + + temp = head + + while temp: + print(temp.data,end="-->") + temp = temp.next + + print("NULL") + + +if __name__ == '__main__': + t=int(input()) + + for cases in range(t): + n = int(input()) + li = LinkedList() + + temp = li.head + + while n!=0: + ele = int(input()) + ptr = Node(ele) + + if li.head is None: + li.head = ptr + else + temp.next = ptr + + temp = ptr + n -= 1 + + li.head = li.mergeSort(li.head) + printList(li.head) + + ''' + Sample Input + 1 - Test cases + 5 - Total number of elements to be inserted in linked list + 23 2 34 5 1 - Adding the contents of the linked list + + Sample Output + 1-->2-->5-->23-->34-->NULL +''' + From b973bac2270615b9f0007828449b91a38a10997c Mon Sep 17 00:00:00 2001 From: jedicakelord <46528937+jedicakelord@users.noreply.github.com> Date: Mon, 6 Apr 2020 03:26:55 +0530 Subject: [PATCH 069/265] Chinese Remainder Theorem in Go (#2675) * Chinese Remainder Theorem in Go * Added comments --- .../Chinese_Remainder_Theorem.go | 93 +++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.go diff --git a/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.go b/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.go new file mode 100644 index 000000000..389734a93 --- /dev/null +++ b/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.go @@ -0,0 +1,93 @@ +/* Chinese Remainder Theorem : +* Given two arrays number[0..n-1] and remainder[0..n-1] +* Find the minimum possible value of x +* that produces given remainders, i.e +* x % number[0] = remainder[0] +* x % number[1] = remainder[1] and so on. +*/ + +package main + +import "fmt" + +//Extended Euclid Algorithm +func inverse(a int, m int) (x1 int) { + var m0 int = m + x0 := 0 + x1 = 1 + var quotient int + var next int + + if m == 1 { + return 0 + } + + // while the number is greater than 1 + // keep on making (a,m) = (m,a%m) + // Go on reverse to find out x0 and x1 from there. + // where x1 will be the inverse modulo + for a > 1 { + quotient = a / m; next = m + m = a % m + a = next; next = x0 + x0 = x1 - quotient * x0 + x1 = next + } + + if x1 < 0 { + x1 = x1 + m0 + } + + return x1 +} + +func CRT(number []int, rem []int, k int) int { + var prod int = 1 + var prod_exp int + + for i := 0; i < k; i++ { + prod = prod * number[i] + } + + var result int = 0 + + // Optimized CRT formula + for i := 0; i < k; i++ { + prod_exp = prod / number[i] + result = result + rem[i] * inverse(prod_exp, number[i]) * prod_exp + } + + return result % prod +} + +func main() { + var n int + fmt.Println("Enter the size of the array : ") + fmt.Scan(&n) + fmt.Println("Enter the number array : ") + num := make([]int, n) + + for i := 0; i < n; i++ { + fmt.Scan(&num[i]) + } + + fmt.Println("Enter the remainder array : ") + rem := make([]int, n) + + for i := 0; i < n; i++ { + fmt.Scan(&rem[i]) + } + + fmt.Printf("Minimum positive number x is : %d\n", CRT(num, rem, n)) +} + +/* Input : +Enter the size of the array : +3 +Enter the number array : +4 11 9 +Enter the remainder array : +1 2 4 +Output : +Minimum positive number x is : 13 +*/ From 16da63304c5080f5310d391b95510fe41ba50da6 Mon Sep 17 00:00:00 2001 From: HariniJeyaraman <58400069+HariniJeyaraman@users.noreply.github.com> Date: Mon, 6 Apr 2020 21:06:06 +0530 Subject: [PATCH 070/265] 1st commit (#2605) --- Quicksort_3_way/quick_sort_3_way.rb | 71 +++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 Quicksort_3_way/quick_sort_3_way.rb diff --git a/Quicksort_3_way/quick_sort_3_way.rb b/Quicksort_3_way/quick_sort_3_way.rb new file mode 100644 index 000000000..ce52deb6f --- /dev/null +++ b/Quicksort_3_way/quick_sort_3_way.rb @@ -0,0 +1,71 @@ +#3 way Quick Sort in Ruby + +def quick_sort(a, lo, hi) + if lo < hi + temp = partition(a, lo, hi) + l = temp[0] + r = temp[1] + quick_sort(a, lo, l - 1) + quick_sort(a, r + 1, hi) + end +end + +def partition(a, lo, hi) + pivot = a[lo] + i = lo + 1 + lt = lo + gt = hi + + while(i <= gt) + + if a[i] < pivot + temp = a[lt] + a[lt] = a[i] + a[i] = temp + lt += 1 + i += 1 + elsif a[i] > pivot + temp = a[i] + a[i] = a[gt] + a[gt] = temp + gt -= 1 + else + i += 1 + end + end + return lt, gt +end + +puts "Enter the size of array : " +n = gets +puts "Enter the values for the array : " +$i = 0 +$num = Integer(n) +arr = Array.new + +while $i < $num do + + arr[$i] = gets + $i +=1 +end +$num2 = Integer(n) - 1 +puts quick_sort(arr, 0, $num2) +puts "After sorting : " +puts arr + +=begin +Sample Input-Output +Enter the size of array : +4 +Enter the values for the array : +10 +14 +12 +13 + +After sorting : +10 +12 +13 +14 +=end From 983c5d3364928dc38feafe2a83ec8578311485fd Mon Sep 17 00:00:00 2001 From: SWARNIMA SHUKLA Date: Mon, 6 Apr 2020 22:58:00 +0530 Subject: [PATCH 071/265] Dijkstra Algorithm implementation in dart (#2617) Update Dijkstra_Algorithm.dart --- Dijkstra_Algorithm/Dijkstra_Algorithm.dart | 152 +++++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 Dijkstra_Algorithm/Dijkstra_Algorithm.dart diff --git a/Dijkstra_Algorithm/Dijkstra_Algorithm.dart b/Dijkstra_Algorithm/Dijkstra_Algorithm.dart new file mode 100644 index 000000000..283a735be --- /dev/null +++ b/Dijkstra_Algorithm/Dijkstra_Algorithm.dart @@ -0,0 +1,152 @@ +/* + Djikstra's algorithm (named after its discover, E.W. Dijkstra) solves the + problem of finding the shortest path from a point in a graph (the source) + to a destination. + It turns out that one can find the shortest paths from a given source to all + points in a graph in the same time, hence this problem is sometimes called + the single-source shortest paths problem. +*/ +import 'dart:io'; + +var INT_MAX = 9223372036854775807; + +int minDistance(dist, visited, n) +{ + int min = INT_MAX, min_index; + + for (var v = 0; v < n + 1; v++) + { + if (( visited[v] == false ) && ( dist[v] <= min )) + { + min = dist[v]; + min_index = v; + } + } + + return min_index; +} + +void printsol(dist, n) +{ + print('Vertex \t\t Distance from Source\n'); + + for (var i = 0; i < n + 1; i++) + { + print('${i} \t\t ${dist[i]}\n'); + } +} + +void dijkstra(graph, src, n) +{ + var dist = new List(n + 1); + + var visited = new List(n + 1); + + for (var i = 0; i < n + 1; i++) + { + dist[i] = INT_MAX; + visited[i] = false; + } + + dist[src] = 0; + + for (var count = 0; count < n; count++) + { + var u = minDistance(dist, visited, n); + + visited[u] = true; + + for (var v = 0; v < n + 1; v++) + { + if ( !visited[v] && graph[u][v] > 0 && dist[u] != INT_MAX + && dist[u] + graph[u][v] < dist[v] ) + { + dist[v] = dist[u] + graph[u][v]; + } + } + } + + printsol(dist, n); +} + +void main() +{ + print('Enter number of nodes 0 to ?'); + + int n = int.parse(stdin.readLineSync()); + + var max_edges = (n + 1) * (n); + + var adjmat = new List.generate(n + 1, (_) => new List(n + 1)); + + for(var i = 0; i <= n; i++) + { + for(var j = 0; j <= n; j++) + { + adjmat[i][j] = 0; + } + } + + print('Enter in the following format\nsrc\ndest\nweight\n'); + for(var i = 0; i < max_edges; i++) + { + var src = int.parse(stdin.readLineSync()); + var dest = int.parse(stdin.readLineSync()); + var weight = int.parse(stdin.readLineSync()); + + print('*' * 20); + + if( (src == -1) && (dest == -1) ) + { + break; + } + + if( src > n || dest > n || src < 0 || dest < 0 ) + { + print('Invalid edge!\n'); + i--; + } + else + { + adjmat[src][dest] = weight; + } + } + + dijkstra(adjmat, 0, n); +} + +/* +Input: +Enter number of nodes 0 to ? +9 +Enter in the following format +Source +Destination +Weight +******************************************************* +The adjacency matrix will look like this +admat=[[0, 14, 0, 7, 0, 0, 0, 8, 0, 10], + [14, 0, 8, 0, 0, 0, 0, 11, 0, 0], + [0, 8, 0, 7, 0, 4, 0, 0, 2, 0], + [7, 0, 7, 0, 9, 12, 0, 0, 0, 5], + [0, 0, 0, 9, 0, 0, 0, 0, 0, 0], + [0, 0, 4, 0, 0, 0, 2, 0, 0, 11], + [0, 0, 0, 12, 0, 2, 0, 1, 6, 15], + [8, 11, 0, 0, 0, 0, 1, 0, 7, 0], + [0, 0, 2, 0, 0, 0, 6, 7, 0, 0], + [10, 0, 0, 5, 0, 11, 15, 0, 0, 0]]; +******************************************************* +Output: +Distance from Source: +Vertex Distance +0 0 +1 14 +2 14 +3 7 +4 16 +5 11 +6 9 +7 8 +8 15 +9 10 +*/ From c45f20be73e5dba0d36fe491dc5f03c7e5d4dd5f Mon Sep 17 00:00:00 2001 From: Lakshyajit Laxmikant <30868587+lakshyajit165@users.noreply.github.com> Date: Mon, 6 Apr 2020 23:02:10 +0530 Subject: [PATCH 072/265] added selection sort logic in typescript (#2693) --- Selection_Sort/Selection_Sort.ts | 35 ++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Selection_Sort/Selection_Sort.ts diff --git a/Selection_Sort/Selection_Sort.ts b/Selection_Sort/Selection_Sort.ts new file mode 100644 index 000000000..1c77907e8 --- /dev/null +++ b/Selection_Sort/Selection_Sort.ts @@ -0,0 +1,35 @@ +// function for selection sort logic +function Selection_Sort(numbers: number[]) : number[]{ + + let i: number; + let j: number; + let min: number; + let temp: number; + + // outer loop to traverse through each element + for(i = 0; i < numbers.length - 1; i++){ + min = i; + + // inner loop finds the minimum element and puts it in the beginning. + for(j = i + 1; j < numbers.length; j++){ + if(numbers[j] < numbers[min]){ + min = j; + } + } // inner loop ends + + if(i !== min){ + temp = numbers[i]; + numbers[i] = numbers[min]; + numbers[min] = temp; + } + } // outer loop ends + + return numbers; +} + +const numbers: number[] = [10, 9, 8, 1, 5, 2, 4, 7, 3]; + +console.log(Selection_Sort(numbers)); + +// INPUT [10, 9, 8, 1, 5, 2, 4, 7, 3] +// OUTPUT [ 1, 2, 3, 4, 5, 7, 8, 9, 10 ] From 3140991882297f12f0592c8f0a48e9bc97e62d92 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Tue, 7 Apr 2020 11:16:36 +0530 Subject: [PATCH 073/265] Tower Of Hanoi In Ruby (#2701) --- Tower_Of_Hanoi/Tower_Of_Hanoi.rb | 37 ++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_Of_Hanoi.rb diff --git a/Tower_Of_Hanoi/Tower_Of_Hanoi.rb b/Tower_Of_Hanoi/Tower_Of_Hanoi.rb new file mode 100644 index 000000000..1165b804c --- /dev/null +++ b/Tower_Of_Hanoi/Tower_Of_Hanoi.rb @@ -0,0 +1,37 @@ +## Tower Of Hanoi In Ruby + +## Recursive Function +def tower(disk, source, auxilary, destination) + if disk == 1 + puts "Disk #{disk} moves from #{source} to #{destination}" + return + end + + tower(disk - 1, source, destination, auxilary) + puts "Disk #{disk} moves from #{source} to #{destination}" + tower(disk - 1, auxilary, source, destination) + nil + +end + +## Taking User Input For Number Of disks +puts "Enter the number of disks: " +disk = gets.to_i +puts + +## Fucntion Call +tower(disk, 'source', 'auxiliary', 'destination') + +=begin + +Enter the number of disks: 3 + +Disk 1 moves from Source to Destination +Disk 2 moves from Source to Auxiliary +Disk 1 moves from Destination to Auxiliary +Disk 3 moves from Source to Destination +Disk 1 moves from Auxiliary to Source +Disk 2 moves from Auxiliary to Destination +Disk 1 moves from Source to Destination + +=end From 971acfb0d7b75c433dbaed6b4b6b1c49c0af588a Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Thu, 9 Apr 2020 15:08:15 +0530 Subject: [PATCH 074/265] Add Inorder Traversal in Kotlin (#2657) Updated inorder --- Tree_Inorder_Traversal/Inorder_Traversal.kt | 62 +++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 Tree_Inorder_Traversal/Inorder_Traversal.kt diff --git a/Tree_Inorder_Traversal/Inorder_Traversal.kt b/Tree_Inorder_Traversal/Inorder_Traversal.kt new file mode 100644 index 000000000..5acd29580 --- /dev/null +++ b/Tree_Inorder_Traversal/Inorder_Traversal.kt @@ -0,0 +1,62 @@ +//Code for printing inorder traversal in kotlin + +class Node +{ + //Structure of Binary tree node + int num; + Node left, right; + public node(int num) + { + key = item; + left = right = null; + } +} + +class BinaryTree +{ + Node root; + BinaryTree() + { + root = null; + } + //function to print inorder traversal + fun printInorder(Node: node):void + { + if (node == null) + return; + printInorder(node.left); + //printing val of node + println(node.num); + printInorder(node.right); + } + + fun printInorder():void + { + printInorder(root); + } +} + + //Main function +fun main() +{ + BinaryTree tree = new BinaryTree(); + var read = Scanner(System.`in`) + println("Enter the size of Array:") + val arrSize = read.nextLine().toInt() + var arr = IntArray(arrSize) + println("Enter data of binary tree") + + for(i in 0 until arrSize) + { + arr[i] = read.nextLine().toInt() + tree.root = new Node(arr[i]); + } + + println("Inorder traversal of binary tree is"); + tree.printInorder();//function call +} + +/* +Input: 10 8 3 30 5 19 4 5 1 +Output:5 3 1 2 8 10 19 30 4 +*/ From 6019d81ec1c2daff0257428d42479eb28863daa5 Mon Sep 17 00:00:00 2001 From: reeha <56428237+syedareehaquasar@users.noreply.github.com> Date: Thu, 9 Apr 2020 19:39:59 +0530 Subject: [PATCH 075/265] README FOR FORD FULKERSON METHOD (#2589) --- Ford_Fulkerson_Method/README.md | 70 +++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Ford_Fulkerson_Method/README.md diff --git a/Ford_Fulkerson_Method/README.md b/Ford_Fulkerson_Method/README.md new file mode 100644 index 000000000..74c1fddd7 --- /dev/null +++ b/Ford_Fulkerson_Method/README.md @@ -0,0 +1,70 @@ +# Ford-Fulkerson Algorithm + +The Ford-Fulkerson algorithm is an algorithm that tackles the max-flow min-cut problem. That is, given a network with vertices and edges between those vertices that have certain weights, how much "flow" can the network process at a time? Flow can mean anything, but typically it means data through a computer network. + +It was discovered in 1956 by Ford and Fulkerson. This algorithm is sometimes referred to as a method because parts of its protocol are not fully specified and can vary from implementation to implementation. An algorithm typically refers to a specific protocol for solving a problem, whereas a method is a more general approach to a problem. + +The Ford-Fulkerson algorithm assumes that the input will be a graph, GG, along with a source vertex, ss, and a sink vertex, tt. The graph is any representation of a weighted graph where vertices are connected by edges of specified weights. There must also be a source vertex and sink vertex to understand the beginning and end of the flow network. + +Ford-Fulkerson has a complexity of O\big(|E| \cdot f^{*}\big),O(∣E∣⋅f +∗ + ), where f^{*}f +∗ + is the maximum flow of the network. The Ford-Fulkerson algorithm was eventually improved upon by the Edmonds-Karp algorithm, which does the same thing in O\big(V^2 \cdot E\big)O(V +2 + ⋅E) time, independent of the maximum flow value. + +## ALGORITHM +Follow 3 basic steps: +1. Find augmented path +2. Complete the bottle neck capacity +3. Augment each edge and total flow +Repeat these steps until the augmented path is reached + +### Example: +![step1](https://github.com/syedareehaquasar/hello-world/blob/master/e.PNG) +here only 2 spaces are there in DT so taking 2 +![step2](https://github.com/syedareehaquasar/hello-world/blob/master/ee.PNG) +Similarly another path +![step3](https://github.com/syedareehaquasar/hello-world/blob/master/eee.PNG) +Similarly another path +![step5](https://github.com/syedareehaquasar/hello-world/blob/master/eeeee.PNG) +Similarly another path +![step6](https://github.com/syedareehaquasar/hello-world/blob/master/eeeeeeeeeee.PNG) +Here paths SA and CD are full but we require 2 in AC but place of only 1 in CD so we have reached our answer ->19 +![final answer](https://github.com/syedareehaquasar/hello-world/blob/master/eeeeeeeeeeeeeee.PNG) + +## PSEUDOCODE + +The pseudo-code for this method is quite short; however, there are some functions that bear further discussion. The simple pseudo-code is below. +This pseudo-code is not written in any specific computer language. Instead, it is an informal, high-level description of the algorithm. + +Ford-Fulkerson Algorithm ((Graph GG, source ss, sink t):t): +``` +initialize flow to 0 +path = findAugmentingPath(G, s, t) +while path exists: + augment flow along path #This is purposefully ambiguous for now + G_f = createResidualGraph() + path = findAugmentingPath(G_f, s, t) +return flow +``` + +# Time Complexity +O(max_flow * E) +Time complexity of the above algorithm is O(max_flow * E). We run a loop while there is an augmenting path. In worst case, we may add 1 unit flow in every iteration. Therefore the time complexity becomes O(max_flow * E) +![tc](https://github.com/syedareehaquasar/hello-world/blob/master/h.PNG) + +# Implementation + + - [c code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ford_Fulkerson_Method/Ford_Fulkerson_Method.c) + - [coffee code] + - [cpp code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ford_Fulkerson_Method/Ford-Fulkerson.cpp) + - [c# code] + - [go code] + - [java code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ford_Fulkerson_Method/Ford_Fulkerson_Method.java) + - [javaScript code] + - [kotlin code] + - [python code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Ford_Fulkerson_Method/Ford_Fulkerson_Method.py) + - [ruby code] + - [dart code] From 8d30245d30d75f888614623ef88b8f9cecaf608f Mon Sep 17 00:00:00 2001 From: kushagra-anand <52084821+kushagra-anand@users.noreply.github.com> Date: Fri, 10 Apr 2020 15:02:42 +0530 Subject: [PATCH 076/265] Kadane Algorithm (#2534) * Create Kadane Algorithm in GO --- Kadane_Algorithm/Kadane_Algorithm.go | 55 ++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 Kadane_Algorithm/Kadane_Algorithm.go diff --git a/Kadane_Algorithm/Kadane_Algorithm.go b/Kadane_Algorithm/Kadane_Algorithm.go new file mode 100644 index 000000000..d9bf09646 --- /dev/null +++ b/Kadane_Algorithm/Kadane_Algorithm.go @@ -0,0 +1,55 @@ +// Go program to print largest contiguous array sum + +package main + +import "fmt" + +func KAlgo(a []int, n int) int { + var max int + var check_max int + max = 0 + check_max = 0 + + for i := 0; i < n; i++ { + check_max = check_max + a[i] + + // Minimum sum will be 0 + if check_max < 0 { + check_max = 0 + } + if max < check_max { + max = check_max + } + } + return max +} + +//Main Function +func main() { + var n int + fmt.Print("Enter number of Elements ") + fmt.Scan(&n) + ope(n) +} + +func ope(n int) { + fmt.Print("\nEnter Elements ") + a := make([]int, n) + + // Array input + for i := 0; i < n; i++ { + fmt.Scan(&a[i]) + } + + var output int + + // Function Calling for the Algo + output = KAlgo(a, n) + fmt.Println("\nSum of the sub array: ", output) +} + +/* +Enter Number of Elements 6 +Enter Elements 2 -4 -5 -6 8 10 +Sum of the sub array: 18 +*/ From d3d50a9e92669ae4af0d027c1e72e5ba09e8ca73 Mon Sep 17 00:00:00 2001 From: Ravi Kanth Gojur Date: Fri, 10 Apr 2020 22:01:49 +0530 Subject: [PATCH 077/265] Boyer Moore Algo in c added (#2644) --- Boyer_Moore_Algorithm/Boyer_Moore.c | 63 +++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Boyer_Moore_Algorithm/Boyer_Moore.c diff --git a/Boyer_Moore_Algorithm/Boyer_Moore.c b/Boyer_Moore_Algorithm/Boyer_Moore.c new file mode 100644 index 000000000..ec88ef89d --- /dev/null +++ b/Boyer_Moore_Algorithm/Boyer_Moore.c @@ -0,0 +1,63 @@ +#include +#define MAX 256 + +int findmax(int a, int b) +{ + return (a > b) ? a : b; +} + +void searchwrongchar(char *str, int size, int extra[MAX]) +{ + for (int i = 0; i < MAX; ++i) + extra[i] = -1; + + for (int i = 0; i < size; ++i) + extra[(int)str[i]] = i; +} + +void search(char *text, char *pattern) +{ + int patLen = strlen(pattern); + int txtLen = strlen(text); + + int extra[MAX]; + + searchwrongchar(pattern, patLen, extra); + + int s = 0; + while (s <= (txtLen - patLen)) + { + int j = patLen - 1; + + while (j >= 0 && pattern[j] == text[s + j]) + j--; + + if (j < 0) + { + printf("\n\nPattern Matches at shift of = %d.", s); + s += (s + patLen < txtLen) ? patLen - extra[text[s + patLen]] : 1; + } + else + s += findmax(1, j - extra[text[s + j]]); + } +} + +int main() +{ + char text[MAX], pattern[MAX]; + printf("Enter the Text: "); + scanf("%s", &text); + printf("\nEnter the Pattern to Match: "); + scanf("%s", &pattern); + search(text, pattern); + return 0; +} + +/* +INPUT: +Enter the Text: ABAAABCD +Enter the Pattern to Match: ABC + +OUTPUT: +Pattern match at shift = 4 +*/ From fe9be768da741dd8f0d1edd68f8d996c9b308300 Mon Sep 17 00:00:00 2001 From: jedicakelord <46528937+jedicakelord@users.noreply.github.com> Date: Fri, 10 Apr 2020 23:10:12 +0530 Subject: [PATCH 078/265] Boyer Moore in Go (#2687) --- Boyer_Moore_Algorithm/Boyer_Moore.go | 78 ++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Boyer_Moore_Algorithm/Boyer_Moore.go diff --git a/Boyer_Moore_Algorithm/Boyer_Moore.go b/Boyer_Moore_Algorithm/Boyer_Moore.go new file mode 100644 index 000000000..092766194 --- /dev/null +++ b/Boyer_Moore_Algorithm/Boyer_Moore.go @@ -0,0 +1,78 @@ +/*Boyer Moore Algorithm for Pattern Search*/ +package main + +import "fmt" + +func max(a, b int) int { + if a > b { + return a + } + return b +} + +//Using Bad Character Heuristic method +func preprocess(str string, length int, chars []int) { + + for i,_:=range(chars) {chars[i] = 1} + + //The last occurrence of the char + for k := 0; k < length; k++ { + chars[int(str[k])] = k; + } +} + +func boyreMoore(text string, pattern string) { + var lenStr int = len(text) + var lenPattern int = len(pattern) + + chars := make([]int, 128) + + preprocess(pattern, lenPattern, chars) + + //shift of the pattern with respect to text + var shift int = 0 + + for shift <= lenStr - lenPattern { + match := lenPattern - 1 + + for (match >= 0 && pattern[match] == text[shift + match]) { + match = match - 1 + } + + // If pattern found, match = -1 + if match < 0 { + fmt.Printf("Pattern found at : %d\n", shift) + + // Shift the pattern so that the next character in text + //aligns with the last occurrence of it in pattern. + if shift + lenPattern < lenStr { + shift = shift + lenPattern - chars[text[shift + lenPattern]] + } else { + shift = 1 + } + } else { + shift = shift + max(1, match - chars[text[shift + match]]); + } + } +} + +func main() { + var text string + var pattern string + fmt.Println("Enter the text : ") + fmt.Scan(&text) + fmt.Println("Enter the pattern to search : ") + fmt.Scan(&pattern) + + boyreMoore(text, pattern) + +} + +/*Input : +* Enter the text : +* therethenthat +* Enter the pattern : +* the +* Pattern found at : 0 +* Pattern found at : 8 +*/ From 7e653099d6b670124e6238c4c6e494e1c0b5f6a0 Mon Sep 17 00:00:00 2001 From: coderprasukj <60914425+coderprasukj@users.noreply.github.com> Date: Sun, 12 Apr 2020 20:30:20 +0530 Subject: [PATCH 079/265] Kruskal Algo in C (#2255) --- Kruskal_Algorithm/Kruskal_Algorithm.c | 153 ++++++++++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 Kruskal_Algorithm/Kruskal_Algorithm.c diff --git a/Kruskal_Algorithm/Kruskal_Algorithm.c b/Kruskal_Algorithm/Kruskal_Algorithm.c new file mode 100644 index 000000000..4f7692296 --- /dev/null +++ b/Kruskal_Algorithm/Kruskal_Algorithm.c @@ -0,0 +1,153 @@ +// Kruskal Algorithm in C +#include +#define NUM 20 + +// Creating the edge +typedef struct edge +{ + int p; // Variable to contain all the first node of the edge + int q; // Variable to contain all the second node of the edge + int weight; // Variable to contain the weight of the edge +} edge; + +// Creating the Edgelist +typedef struct edgelist +{ + edge data[NUM]; + int n; +} edgelist; + +edgelist list; +int weights[NUM][NUM]; // Array for weights in the graph +int n; +edgelist listSpan; + +void kruskal_algo(); +void print(); +int find(int contain[], int vertexno); +void union1(int contain[], int c1, int c2); +void sort(); + +// Driver Program +int main() +{ + int total_cost; + printf("\nEnter number of vertices : "); + scanf("%d", &n); // Number of Vertices + + printf("\nEnter the adjacency matrix : \n"); + + for(int i = 0; i < n; i++) // Enter the Adjacency Matrix + for(int j = 0; j < n; j++) + scanf("%d", &weights[i][j]); + + kruskal_algo(); + print(); + return 0; +} + +// Function performing Kruskal's algorithm +void kruskal_algo() +{ + int contain[NUM], x, y; + list.n = 0; + + for(int i = 1; i < n; i++) + for(int j = 0; j < i; j++) + { + if(weights[i][j] != 0) + { + // Containing all the first node of the edges + list.data[list.n].p = i; + // Containing all the second node of the edges + list.data[list.n].q = j; + // Containing the weight of the edges + list.data[list.n].weight = weights[i][j]; + list.n++; + } + } + + // Sorting the edges according to their weight. + sort(); + + for(int i = 0; i < n; i++) + contain[i] = i; // Intializing the array with first node + + listSpan.n = 0; + + for(int i = 0; i < list.n; i++) + { + x = find(contain, list.data[i].p); // x is the first node of the edge + y = find(contain, list.data[i].q); // y is the second node of the edge + if(x != y) + { + listSpan.data[listSpan.n] = list.data[i]; + listSpan.n = listSpan.n+1; + union1(contain, x, y); + } + } +} + +// Returns the value present at k[vertex_number] +int find(int contain[], int vertex_number) +{ + return(contain[vertex_number]); +} + +void union1(int contain[], int c1, int c2) +{ + for(int i = 0; i < n; i++) + if(contain[i] == c2) + contain[i] = c1; +} + +// Sorting all the edges in increasing order +// according to their weight. +void sort() +{ + edge temp; + for(int i = 1; i < list.n; i++) + { + for(int j = 0; j < list.n-1; j++) + { + if(list.data[j].weight > list.data[j+1].weight) + { + temp = list.data[j]; + list.data[j] = list.data[j+1]; + list.data[j+1] = temp; + } + } + } +} + +// Printing the Output +void print() +{ + int cost = 0; + for(int i = 0; i < listSpan.n; i++) + { + printf("\n%d\t%d\t%d", listSpan.data[i].p, listSpan.data[i].q, listSpan.data[i].weight); + cost = cost + listSpan.data[i].weight; + } + printf("\nCost of the spanning tree = %d\n", cost); +} + +/* +INPUT : +Enter number of vertices : 6 +Enter the Adjacency Matrix : + 0 3 0 0 6 5 + 3 0 1 0 0 4 + 0 1 0 6 0 4 + 0 0 6 0 8 5 + 6 0 0 8 0 2 + 5 4 4 5 2 0 + +OUTPUT : + + 2 1 1 + 5 4 2 + 1 0 3 + 5 1 4 +Cost of the spanning tree = 15 +*/ From 0f3e0fbbef557c44cfba9c229f688a5a315bf7b4 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 13 Apr 2020 01:39:25 +0530 Subject: [PATCH 080/265] Breadth First Search in Ruby (#2635) * BFS in Ruby * Updated Changes --- Breadth_First_Search/Breadth_First_Search.rb | 92 ++++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 Breadth_First_Search/Breadth_First_Search.rb diff --git a/Breadth_First_Search/Breadth_First_Search.rb b/Breadth_First_Search/Breadth_First_Search.rb new file mode 100644 index 000000000..e2548423c --- /dev/null +++ b/Breadth_First_Search/Breadth_First_Search.rb @@ -0,0 +1,92 @@ +## Breadth First Search algorithm in Ruby. + +def breadth_first_search(adj_matrix, source, destination) + node_array = [source] + path = [] + ## puts "\nThe initial NODE ARRAY is #{node_array}." + + loop do + curr_node = node_array.pop + path << curr_node + ## puts "The next node to be checked is #{curr_node}." + + if curr_node.nil? + puts 'Destination Node Not Found!' + return false + + elsif curr_node == destination + puts "\nDestination Node #{curr_node} Found!" + puts "\nThe path between Source Node #{source} and Destination Node #{destination} is:\n #{path}." + return true + + end + + ## puts "\nIterating through the following array:\n #{adj_matrix[curr_node]}" + children = (0..adj_matrix.length - 1).to_a.select do |i| + ## puts "Checking index #{i} whose value is #{adj_matrix[curr_node][i]}" + adj_matrix[curr_node][i] == 1 + + end + + ## puts "\nCHILD ARRAY returned: #{children}" + node_array = children + node_array + ## puts "\nAfter appending CHILD ARRAY, NODE ARRAY is: #{node_array}" + + end + +end + +## Defining Adjacency Matrix by taking user input + +puts "Enter Size of Adjacency Matrix: " +size = gets.to_i + +adj_matrix = Array.new(size) { [] } + +i = 0 +counter = 0 + +while(counter != size) + i = 0 + puts "\nEnter the values of row #{counter + 1}: " + while(i != size) + adj_matrix[counter][i] = gets.to_i + i += 1 + end + counter += 1 +end + +## User input for Source Node and Destination Node + +puts "\nEnter Source Node: " +source = gets.to_i + +puts "\nEnter Destination Node: " +destination = gets.to_i + +## Passing the adjacent matrix, source and destination as arguments to the algorithm. + +breadth_first_search(adj_matrix, source, destination) + +=begin + +Enter Size of Adjacency Matrix: 4 + +Enter the values of row 1: 0 1 1 0 + +Enter the values of row 2: 1 0 0 0 + +Enter the values of row 3: 1 0 1 0 + +Enter the values of row 4: 0 1 0 0 + +Enter Source Node: 0 + +Enter Destination Node: 2 + +Destination Node 2 Found! + +The path between Source Node 0 and Destination Node 2 is: + [0, 2]. + +=end From b21a0eaebdf2362cb8077456c794c17a603e76ae Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 13 Apr 2020 23:13:22 +0530 Subject: [PATCH 081/265] Tree Inorder Traversal In C# (#2723) --- .../Tree_Inorder_Traversal.cs | 173 ++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 Tree_Inorder_Traversal/Tree_Inorder_Traversal.cs diff --git a/Tree_Inorder_Traversal/Tree_Inorder_Traversal.cs b/Tree_Inorder_Traversal/Tree_Inorder_Traversal.cs new file mode 100644 index 000000000..0ef48879e --- /dev/null +++ b/Tree_Inorder_Traversal/Tree_Inorder_Traversal.cs @@ -0,0 +1,173 @@ +/** + Tree Inorder Traversal In C# +*/ + +using System; + +// Node Class To Declare Nodes Of The Tree +class Node +{ + public int data; + public Node left; + public Node right; + + public void display() + { + Console.Write(" ["); + Console.Write(data); + Console.Write("] "); + } +} + +// Tree Class To Declare Binary Search Tree +class Tree +{ + public Node root; + + // Constructor + public Tree() + { + root = null; + } + + public Node ReturnRoot() + { + return root; + } + + // Function To Insert Node Into BST + public void Insert(int id) + { + Node newNode = new Node(); + newNode.data = id; + + if (root == null) + root = newNode; + else + { + Node current = root; + Node parent; + + while (true) + { + parent = current; + if (id < current.data) + { + current = current.left; + if (current == null) + { + parent.left = newNode; + return; + } + } + + else + { + current = current.right; + if (current == null) + { + parent.right = newNode; + return; + } + } + } + } + } + + // Inorder Traversal Function + public void Inorder(Node Root) + { + if (Root != null) + { + Inorder(Root.left); + Console.Write(Root.data + " "); + Inorder(Root.right); + } + } +} + +class InorderTreeProgram +{ + public static void Main(string[] args) + { + // Declaring the Object Of Tree Class + Tree BST = new Tree(); + Console.WriteLine("1. Insert Node"); + Console.WriteLine("2. Display InOrder Traversal"); + Console.WriteLine("3. Exit"); + + while(true) + { + Console.WriteLine("\nEnter your choice: "); + String choice = Console.ReadLine(); + int Choice = int.Parse(choice); + + switch(Choice) + { + case 1: + { + Console.WriteLine("Enter the value to insert node: "); + String val = Console.ReadLine(); + int data = int.Parse(val); + BST.Insert(data); + break; + } + + case 2: + { + Console.WriteLine("\nTree Inorder Traversal: "); + BST.Inorder(BST.ReturnRoot()); + Console.WriteLine(" "); + break; + } + + case 3: + { + Console.WriteLine("Exit"); + System.Environment.Exit(0); + break; + } + } + } + } +} + +/** + +1. Insert Node +2. Display InOrder Traversal +3. Exit + +Enter your choice: 1 +Enter the value to insert node: 30 + +Enter your choice: 1 +Enter the value to insert node: 35 + +Enter your choice: 1 +Enter the value to insert node: 57 + +Enter your choice: 1 +Enter the value to insert node: 15 + +Enter your choice: 1 +Enter the value to insert node: 63 + +Enter your choice: 1 +Enter the value to insert node: 49 + +Enter your choice: 1 +Enter the value to insert node: 77 + +Enter your choice: 1 +Enter the value to insert node: 98 + +Enter your choice: 2 + +Tree Inorder Traversal: +15 30 35 49 57 63 77 98 + +Enter your choice: 3 +Exit + +*/ From 5f10bda91547599631ab7c9fc248f6e8b7d8e756 Mon Sep 17 00:00:00 2001 From: riajha02 <32812168+RiaJha02@users.noreply.github.com> Date: Mon, 13 Apr 2020 11:14:13 -0700 Subject: [PATCH 082/265] Adding Backtracking Using Bitmasking (#2583) Squashing Files --- .../Backtrack_using_bitmask.cpp | 48 +++++++++++++++ .../Backtrack_using_bitmask.java | 59 +++++++++++++++++++ .../Backtrack_using_bitmask.py | 46 +++++++++++++++ 3 files changed, 153 insertions(+) create mode 100644 Backtracking_using_bitmask/Backtrack_using_bitmask.cpp create mode 100644 Backtracking_using_bitmask/Backtrack_using_bitmask.java create mode 100644 Backtracking_using_bitmask/Backtrack_using_bitmask.py diff --git a/Backtracking_using_bitmask/Backtrack_using_bitmask.cpp b/Backtracking_using_bitmask/Backtrack_using_bitmask.cpp new file mode 100644 index 000000000..430594811 --- /dev/null +++ b/Backtracking_using_bitmask/Backtrack_using_bitmask.cpp @@ -0,0 +1,48 @@ +#include +using namespace std; + +#define d (1 << n) - 1 +int cnt = 0; + +/*This is an optimised approach than the normal backtracking approach. +Here we don’t need to write is Safe Position Function +which works in linear time instead we use bitsets which work in O(1) time.*/ + +void solve(int row, int left, int right, int n) +{ + //All rows are occupied,so the solution must be complete + if(row == d) + { + cnt++; + return; + } + + //Gets a bit sequence with "1"s whereever there is an open "slot" + int pos = d & ~(left | row | right); + + //Loops as long as there is a valid place to put another queen. + while(pos > 0) + { + int bit = pos & (-pos); + pos -= bit; + solve(row | bit, (left | bit) << 1, (right | bit) >> 1, n); + } +} + +int main() { + int n; + cin >> n; + solve(0, 0, 0, n); + cout << cnt; +} + +/* +Sample Input: +4 +Sample Output: +2 +Sample Input: +5 +Sample Output: +10 +*/ \ No newline at end of file diff --git a/Backtracking_using_bitmask/Backtrack_using_bitmask.java b/Backtracking_using_bitmask/Backtrack_using_bitmask.java new file mode 100644 index 000000000..20c064bfb --- /dev/null +++ b/Backtracking_using_bitmask/Backtrack_using_bitmask.java @@ -0,0 +1,59 @@ +import java.util.*; +class Solution +{ + //Keeps track of the # of valid solutions + static int ans = 0; + + public static int power(int x, int y) + { + if(y == 0) + return 1; + int result = power(x,y / 2); + if(y % 2 == 0) + return result * result; + else + return x * result * result; + } + //Checks all possible board configurations + public static void solveNQueens(int left, int col, int right, int n, int done) + { + //All columns are occupied, so the solution must be complete + if(col == done) + { + ans++; + return; + } + + //Gets a bit sequence with "1"s where ever there is an open "slot" + int pos = ~(left | col | right) & done; + + //Loops as long as there is a valid place to put another queen. + while(pos > 0) + { + int bit = pos & (-pos); + pos = pos - bit; + solveNQueens((left | bit) >> 1, col | bit, (right | bit) << 1, n, done); + } + } + public static void main(String[] args) + { + Scanner input = new Scanner(System.in); + int n = input.nextInt(); + //Helps identify valid solutions + int done = power(2, n) - 1; + solveNQueens(0, 0, 0, n, done); + System.out.print(ans); + input.close(); + } +}; + +/* +Sample Input: +4 +Sample Output: +2 +Sample Input: +5 +Sample Output: +10 +*/ \ No newline at end of file diff --git a/Backtracking_using_bitmask/Backtrack_using_bitmask.py b/Backtracking_using_bitmask/Backtrack_using_bitmask.py new file mode 100644 index 000000000..c43de7811 --- /dev/null +++ b/Backtracking_using_bitmask/Backtrack_using_bitmask.py @@ -0,0 +1,46 @@ +# Here we use bit patterns to keep track of queen placements +# for the columns, left diagonals and right diagonals. + +def totalNQueens(n): + #Helps identify valid solutions + all_ones = 2 ** n - 1 + + #Keeps track of the # of valid solutions + count = 0 + + #Checks all possible board configurations + def helper(ld, column, rd): + nonlocal count + #All columns are occupied,so the solution must be complete + if column == all_ones: + count += 1 + return + + #Gets a bit sequence with "1"s whereever there is an open "slot" + possible_slots = ~(ld | column | rd) & all_ones + + #Loops as long as there is a valid place to put another queen. + while possible_slots: + current_bit = possible_slots & -possible_slots + possible_slots -= current_bit + helper( (ld | current_bit) >> 1, column | current_bit, (rd | current_bit) << 1) + + helper(0, 0, 0) + return count + +if __name__ == '__main__': + n = int(input()) + d = (1 << n) - 1 + cnt = totalNQueens(n) + print(cnt) + +''' +Sample Input: +4 +Sample Output: +2 +Sample Input: +5 +Sample Output: +10 +''' \ No newline at end of file From 9dbe42b4989276a7285d430a3d8d6fc89ae540e3 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Tue, 14 Apr 2020 21:52:54 +0530 Subject: [PATCH 083/265] Transpose of matrix in java (#2529) changes made --- Matrix_Operations/Java/Matrix_transpose.java | 63 ++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Matrix_Operations/Java/Matrix_transpose.java diff --git a/Matrix_Operations/Java/Matrix_transpose.java b/Matrix_Operations/Java/Matrix_transpose.java new file mode 100644 index 000000000..f24dacd1d --- /dev/null +++ b/Matrix_Operations/Java/Matrix_transpose.java @@ -0,0 +1,63 @@ +// Java Program to calculation transpose of a matrix (2D Array) +import java.util.Scanner; + +public class Matrix_transpose { + + // Find transpose of matrix + public static void transpose_matrices(int[][] matrix) { + + int index1, index2; + int[][] matrix_ans = new int[matrix.length][matrix[0].length]; + for ( index1 = 0; index1 < matrix.length; index1 ++) { + for ( index2 = 0; index2 < matrix[0].length; index2++ ) { + matrix_ans[index2][index1] = matrix[index1][index2]; + } + } + + // Print the calculated matrix + for ( index1 = 0; index1 < matrix_ans.length; index1 ++) { + for ( index2 = 0; index2 < matrix_ans[0].length; index2++ ) { + System.out.print( matrix_ans[index1][index2] + " "); + } + System.out.println(); + } + } + + public static void main(String args[]) { + Scanner s = new Scanner(System.in); + + System.out.println(" Enter number of rows "); + int rows = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns = s.nextInt(); + int[][] matrix = new int[rows][columns]; + + + System.out.println(" Enter elements of matrix "); + for (int i = 0; i < rows; i++) { + for (int j = 0 ; j < columns; j++) { + matrix[i][j] = s.nextInt(); + } + } + transpose_matrices(matrix); + } +} +/* +TEST CASES + +INPUT + Enter number of rows +2 + Enter number of columns +2 + Enter elements of matrix +2 3 +4 5 + +OUTPUT +2 4 +3 5 + +*/ + From 335ca72ad25fb16d86d02b933b5417b63835ffc0 Mon Sep 17 00:00:00 2001 From: Manish Choudhary <53442020+Manish-cloud@users.noreply.github.com> Date: Tue, 14 Apr 2020 21:58:22 +0530 Subject: [PATCH 084/265] Kruskal Algorithm Implementation in python (#2682) Used disjoint set data structure for Algorithm implementation. --- Kruskal_Algorithm/Kruskal_Algorithm.py | 93 ++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 Kruskal_Algorithm/Kruskal_Algorithm.py diff --git a/Kruskal_Algorithm/Kruskal_Algorithm.py b/Kruskal_Algorithm/Kruskal_Algorithm.py new file mode 100644 index 000000000..973909899 --- /dev/null +++ b/Kruskal_Algorithm/Kruskal_Algorithm.py @@ -0,0 +1,93 @@ +#Implementation of Kruskal Algorithm using Disjoint + +graphData = [] +vertices = [] + +class Disjoint: + def __init__(self): + self.sets = [] + + def createSet(self, val): + self.sets.append([val]) + + def getSets(self): + return self.sets + + def findSet(self, val): + for oneSet in self.sets: + if val in oneSet: + return oneSet + + def mergeSets(self, val1, val2): + set1 = self.findSet(val1) + set2 = self.findSet(val2) + if set1 != set2: + set1.extend(set2) + self.sets.remove(set2) + +def kruskalAlgorithm(vertices, graphData): + MST = [] + minimumWeight = 0 + + adisjointSet = Disjoint() # Creating object of disjoint set + for vertex in vertices: + adisjointSet.createSet(vertex) + + graphData.sort() # Sort weights in increasing order + + for weight, vertex1, vertex2 in graphData: + if (adisjointSet.findSet(vertex1) != adisjointSet.findSet(vertex2)): + minimumWeight += weight + MST.append((weight, vertex1, vertex2)) + adisjointSet.mergeSets(vertex1, vertex2) + # To improve efficiency + # when length of disjoint set becomes 1 we can break loop + if (len(adisjointSet.sets) == 1): + break + + print("Minimum Weight : ", minimumWeight) + # To display in which order edges are added + for path in MST: + print((path[1], path[2]), "=>", path[0]) + +if __name__ == "__main__": + numberOfVertices = int(input("Enter number of vertices in graph : ")) + print("Enter vertices") + for _ in range(numberOfVertices): + vertex = input() + vertices.append(vertex) + + numberOfEdges = int(input("Enter number of edges in graph : ")) + print("Note :=> Enter graph data in following format weight vertex1 vertex2") + for _ in range(numberOfEdges): + weights, vertex1, vertex2 = input().split() + weights = int(weights) + graphData.append((weights, vertex1, vertex2)) + + kruskalAlgorithm(vertices, graphData) + +""" +Input/Output + +Enter number of vertices in graph : 5 +Enter vertices +a +b +c +d +e +Enter number of edges in graph : 7 +Note :=> Enter graph data in following format weight vertex1 vertex2 +1 a c +4 a b +2 c b +3 b d +7 c d +5 c e +6 d e +Minimum Weight : 11 +('a', 'c') => 1 +('c', 'b') => 2 +('b', 'd') => 3 +('c', 'e') => 5 +""" From 1d8912a78ac23096a948407ba3dd3bdf6bc364cf Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Tue, 14 Apr 2020 22:03:55 +0530 Subject: [PATCH 085/265] Tree Preorder Traversal in Dart (#2720) --- .../Tree_Preorder_Traversal.dart | 139 ++++++++++++++++++ 1 file changed, 139 insertions(+) create mode 100644 Tree_Preorder_Traversal/Tree_Preorder_Traversal.dart diff --git a/Tree_Preorder_Traversal/Tree_Preorder_Traversal.dart b/Tree_Preorder_Traversal/Tree_Preorder_Traversal.dart new file mode 100644 index 000000000..81898f6cf --- /dev/null +++ b/Tree_Preorder_Traversal/Tree_Preorder_Traversal.dart @@ -0,0 +1,139 @@ +import 'dart:io'; + +// Class to define the node of a binary tree. +class Node { + + int value; + Node left; + Node right; + + Node(int value) { + + this.value = value; + this.left = null; + this.right = null; + + } + +} + +// Class to define a binary tree. +class Tree { + + // The tree's root. + Node root; + + // Constructor + Tree(Node root) { + this.root = root; + } + + // Insert method to build the tree using recursion. + Node insert(Node root, int val) { + + if (root != null){ + + // Inserting in the left side if value is less than root. + if (val < root.value) { + root.left = insert(root.left, val); + } + else { + // Inserting in the right side if value is greater than root. + if (val > root.value) { + root.right = insert(root.right, val); + } + // Informing user that the value is already present. + else{ + print("Value is already present in the tree."); + } + } + } + else{ + // Insertion + root = Node(val); + } + + return root; + + } + + // Utility method used to print the preorder traversal using recursion. + void preorder_utility(Node node) { + + if (node != null) { + print(node.value); + + // Recursion + preorder_utility(node.left); + preorder_utility(node.right); + } + + } + + // Method to print the preorder traversal of the binary tree. + void tree_preorder_traversal(){ + + print("The preorder traversal of the tree in the given input is follows:"); + preorder_utility(this.root); + + } + +} + +// Driver method of the program +void main(){ + + // Reading user input + print("Enter root of the tree:"); + var input = stdin.readLineSync(); + int root_val = int.parse(input); + + // Root node + Node root_node = Node(root_val); + + // Binary Tree + Tree tree = Tree(root_node); + + String choice = "y"; + + while (choice == "y") { + + print("Enter number to insert:"); + var input3 = stdin.readLineSync(); + int insert_val = int.parse(input3); + tree.insert(root_node, insert_val); + + print("Do you want to insert another number into the tree? (y/n)"); + var input2 = stdin.readLineSync(); + choice = input2; + + } + + /* Sample Input tree + 8 + / \ + 3 12 + / \ / \ + 2 6 9 15 + / \ + 5 7 + */ + + // Calling method to print preorder traversal of the tree. + tree.tree_preorder_traversal(); + + /* Sample Output + The preorder traversal of the tree in the given input is follows: + 8 + 3 + 2 + 6 + 5 + 7 + 12 + 9 + 15 + */ + +} + From 007b6f94a16253d162f9b5b00989d1ebadbf25bf Mon Sep 17 00:00:00 2001 From: Yashasvi Sinha <59117774+heisastark@users.noreply.github.com> Date: Tue, 14 Apr 2020 23:17:57 +0530 Subject: [PATCH 086/265] Added Karatsuba Algo in Dart (#2616) * Sqashing 6 commits * deleting accidentally added file * deleting accidentally added file * deleting accidentally added file * deleting accidentally added file * deleting accidentally added file * deleting accidentally added file * Karatsuba_Algorithm.dart added (accidently deleted while squashing commits) --- Karatsuba_Algorithm/Karatsuba_Algorithm.dart | 57 ++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 Karatsuba_Algorithm/Karatsuba_Algorithm.dart diff --git a/Karatsuba_Algorithm/Karatsuba_Algorithm.dart b/Karatsuba_Algorithm/Karatsuba_Algorithm.dart new file mode 100644 index 000000000..6fa0b0b3c --- /dev/null +++ b/Karatsuba_Algorithm/Karatsuba_Algorithm.dart @@ -0,0 +1,57 @@ +import 'dart:io'; +import 'dart:math'; + +// function to find minimun of two integers +int minof(a, b){ + if(a < b) + return a; + else return b; +} + +int karatSuba(num1, num2){ + + // for single digit number multiply directly + if (num1 < 10 || num2 < 10) { + return num1 * num2; + } + + String num1Str = num1.toString(); + String num2Str = num2.toString(); + int n = minof(num1Str.length, num2Str.length); + int half = (n / 2).round(); + + // divide num1 into two halves + int num1_H = int.parse(num1Str.substring(0, num1Str.length - half)); + int num1_L = int.parse(num1Str.substring(num1Str.length - half, num1Str.length)); + + // divide num2 into two halves + int num2_H = int.parse(num2Str.substring(0, num2Str.length - half)); + int num2_L = int.parse(num2Str.substring(num2Str.length - half, num2Str.length)); + + // using the KaratSuba Definition + int s1 = karatSuba(num1_L, num2_L); + int s2 = karatSuba(num1_L + num1_H, num2_L + num2_H); + int s3 = karatSuba(num1_H, num2_H); + int s4 = s2 - s3 - s1; + + // karatsuba formula for finding product + int result = s3 * pow(10, 2 * half) + s4 * pow(10, half) + s1; + + return result; +} + +void main(){ + String a, b; + a = stdin.readLineSync(); + b = stdin.readLineSync(); + print(karatSuba(int.parse(a), int.parse(b))); +} + +/* +Sample input: +12345 +6789 + +Sample Output: +83810205 +*/ From 8f5692eae049825c98c8b92c826711b5463fb2b6 Mon Sep 17 00:00:00 2001 From: Lakshyajit Laxmikant <30868587+lakshyajit165@users.noreply.github.com> Date: Tue, 14 Apr 2020 23:54:47 +0530 Subject: [PATCH 087/265] corrected indentation in shell sort using go (#2683) --- Shell_Sort/Shell_Sort.go | 80 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 Shell_Sort/Shell_Sort.go diff --git a/Shell_Sort/Shell_Sort.go b/Shell_Sort/Shell_Sort.go new file mode 100644 index 000000000..aafea87fa --- /dev/null +++ b/Shell_Sort/Shell_Sort.go @@ -0,0 +1,80 @@ +package main + +import ( + "fmt" + "strconv" +) + +func main() { + var n int + fmt.Scanf("%d", &n) + + // input the size of the array + var arr = make([]int, n) + + // input the elements of the array + for i := 0; i < n; i++ { + if _, err := fmt.Scan(&arr[i]); err != nil { + panic(err) + } + } + + // calling the shellsort function to sort the array + shellsort(arr) + + // printing the sorted array + for i := 0; i < n; i++ { + fmt.Print(strconv.Itoa(arr[i])+" ") + } +} + +func shellsort(items []int) { + var ( + n = len(items) + gaps = []int{1} + k = 1 + + ) + + // start with a bigger gap and then gradually reduce the gaps + for { + gap := element(2, k) + 1 + if gap > n-1 { + break + } + gaps = append([]int{gap}, gaps...) + k++ + } + + // shell sort logic + for _, gap := range gaps { + for i := gap; i < n; i += gap { + j := i + for j > 0 { + if items[j-gap] > items[j] { + items[j-gap], items[j] = items[j], items[j-gap] + } + j = j - gap + } + } + } +} + +// function to help calculate number of gaps +func element(a, b int) int { + e := 1 + for b > 0 { + if b&1 != 0 { + e *= a + } + b >>= 1 + a *= a + } + return e +} + +/* + SAMPLE INPUT: 5 + 5 4 1 2 3 + SAMPLE OUTPUT: 1 2 3 4 5 +*/ \ No newline at end of file From 3188f22aa4672776066a52d2d111a90d1d1c63ed Mon Sep 17 00:00:00 2001 From: reeha <56428237+syedareehaquasar@users.noreply.github.com> Date: Wed, 15 Apr 2020 23:33:52 +0530 Subject: [PATCH 088/265] README.md for Z-ALGORITHM (#2594) --- Z_Algorithm/README.md | 95 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 Z_Algorithm/README.md diff --git a/Z_Algorithm/README.md b/Z_Algorithm/README.md new file mode 100644 index 000000000..d069a4a97 --- /dev/null +++ b/Z_Algorithm/README.md @@ -0,0 +1,95 @@ +# Z ALGORITHM +This algorithm finds all occurrences of a pattern in a text in linear time. Let length of text be n and of pattern be m, then total time taken is O(m + n) with linear space complexity. Now we can see that both time and space complexity is same as KMP algorithm but this algorithm is Simpler to understand. +Z algorithm is a linear time string matching algorithm which runs in complexity. It is used to find all occurrence of a pattern in a string , which is common string searching problem. +In this algorithm, we construct a Z array. + +### What is Z Array? +For a string str[0..n-1], Z array is of same length as string. An element Z[i] of Z array stores length of the longest substring starting from str[i] which is also a prefix of str[0..n-1]. The first entry of Z array is meaning less as complete string is always prefix of itself. + +``` +Example: + +Index 0 1 2 3 4 5 6 7 8 9 10 11 +Text a a b c a a b x a a a z +Z values X 1 0 0 3 1 0 0 2 2 1 0 + +str = "aaaaaa" +Z[] = {x, 5, 4, 3, 2, 1} + +str = "aabaacd" +Z[] = {x, 1, 0, 2, 1, 0, 0} + +str = "abababab" +Z[] = {x, 0, 6, 0, 4, 0, 2, 0} +``` + +### How is Z array helpful in Searching Pattern in Linear time? +The idea is to concatenate pattern and text, and create a string “P$T” where P is pattern, $ is a special character should not be present in pattern and text, and T is text. Build the Z array for concatenated string. In Z array, if Z value at any point is equal to pattern length, then pattern is present at that point. +``` +Example: +Pattern P = "aab", Text T = "baabaa" +The concatenated string is = "aab$baabaa" +Z array for above concatenated string is {x, 1, 0, 0, 0, + 3, 1, 0, 2, 1}. +Since length of pattern is 3, the value 3 in Z array +indicates presence of pattern. +``` + +### How to construct Z array? +A Simple Solution is two run two nested loops, the outer loop goes to every index and the inner loop finds length of the longest prefix that matches substring starting at current index. + +## ALGORITHM +![algo](https://github.com/syedareehaquasar/reeha/blob/master/1.PNG) + +## Pseudocode +Simple and short. Note that the optimization L = R = i is used when S[0] ≠ S[i] (it doesn't affect the algorithm since at the next iteration i > R regardless). + +``` +int L = 0, R = 0; +for (int i = 1; i < n; i++) { + if (i > R) { + L = R = i; + while (R < n && s[R-L] == s[R]){ + R++; + z[i] = R-L; + R--; + } + } + else { + int k = i-L; + if (z[k] < R-i+1) { + z[i] = z[k]; + } + else { + L = i; + while (R < n && s[R-L] == s[R]){ + R++; + z[i] = R-L; R--; + } + } +} +``` +## Example: +S = “abc”, T = “abcdabaabc” +L = “abc$abcdabaabc” +Compute Z values. +Z[1] = 0, Z[2] = 0, Z[3] = 0, Z[4] = 3, Z[5] = 0, Z[6] = 0, Z[7] = 0, Z[8] = 2, Z[9] = 0, Z[10] = 1, Z[11] = 3, Z[12] = 0, Z[13] = 0 +Look at values of Z[4] and Z[11] +hence string S matches at index 4 (abc$abcdabaabc) and index 11 (abc$abcdabaabc) + +## Time Complexity +O(n) +The algorithm runs in O(n) time. Characters are never compared at positions less than , and every time a match is found, is increased by one, so there are at most n comparisons + +## Implementation + - [c code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.c) + - [coffee code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.coffee) + - [cpp code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.cpp) + - [c# code] + - [go code] + - [java code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.java) + - [javaScript code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.js) + - [kotlin code] + - [python code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.py) + - [ruby code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Z_Algorithm/Z_Algorithm.rb) + - [dart code] From 4386283b09c0a23f090a8cfcf3d7d50f73000433 Mon Sep 17 00:00:00 2001 From: Ashish Nagpal <36301481+ashishnagpal2498@users.noreply.github.com> Date: Thu, 16 Apr 2020 00:06:04 +0530 Subject: [PATCH 089/265] :star: add median of two sorted arrays (#2463) :up: unequal arrays check --- Median_Sorted_Arrays/Median_Sorted_Arrays.cpp | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 Median_Sorted_Arrays/Median_Sorted_Arrays.cpp diff --git a/Median_Sorted_Arrays/Median_Sorted_Arrays.cpp b/Median_Sorted_Arrays/Median_Sorted_Arrays.cpp new file mode 100644 index 000000000..d4b121bfb --- /dev/null +++ b/Median_Sorted_Arrays/Median_Sorted_Arrays.cpp @@ -0,0 +1,74 @@ +//median of two sorted arrays - +#include +#include +using namespace std; + +float median(int *arr1, int * arr2, int n, int m) +{ + int low1 = 0, + hi1 = n - 1, + low2 = 0, + hi2 = m - 1; + while (true) + { + int m1 = (hi1 - low1) / 2, + m2 = (hi2 - low2) / 2, + median1 = arr1[m1], + median2 = arr2[m2]; + if (hi1 - low1 <= 1 || hi2 - low1 <= 1) + { + //calculate the median + float leftVal = max(arr1[low1], arr2[low2]); + float rightVal = min(arr1[hi1], arr2[low2]); + float ans = (abs(n-m) >= 1) ? ceil((leftVal + rightVal)/2) : (leftVal + rightVal)/2; + return (float) ans; + } + if (median1 == median2) + { + return median1; + } + else if (median2 > median1) + { //Shift the lower pointer of array 1 to median 1 + low1 = m1; + //Shift the Higher pointer of array 2 to median 2 + hi2 = m2; + } + else { + //Shift the Higher pointer of array 1 to median 1 + hi1 = m1; + //Shift the Lower pointer of array 2 to median 2 + low2 = m2; + } + + } +} + +int main() +{ + int n, m, arr1[100005], arr2[100005]; + cout << "Enter size of Array 1 \n"; + cin >> n; + cout << "Enter size of Array 2 \n"; + cin >> m; + cout << "Enter Elements of Array 1 \n"; + for (int i = 0; i < n; i++) cin >> arr1[i]; + cout << "Enter Elements of Array 2 \n"; + for (int i = 0; i < m; i++) cin >> arr2[i]; + cout << "Median of Combined Sorted Array is " << median(arr1, arr2, n, m); + cout << endl; + return 0; +} + +/* Sample Input + Enter size of Array 1 + 3 + Enter size of Array 2 + 3 +Enter Elements of Array 1 + 1 2 3 +Enter Elements of Array 1 + 4 5 6 + +Sample Output +Median of Combined Sorted Array is - 3.5 + */ \ No newline at end of file From ae9770f592eaf3c3f62d9653e4ddaac3a590fb7e Mon Sep 17 00:00:00 2001 From: Md Akdas Ahmad <43089126+MdAkdas@users.noreply.github.com> Date: Fri, 17 Apr 2020 01:04:43 +0530 Subject: [PATCH 090/265] Segment tree RMQ in C added. (#2676) --- Segment_Tree_RMQ/Segement_Tree_RMQ.c | 91 ++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 Segment_Tree_RMQ/Segement_Tree_RMQ.c diff --git a/Segment_Tree_RMQ/Segement_Tree_RMQ.c b/Segment_Tree_RMQ/Segement_Tree_RMQ.c new file mode 100644 index 000000000..dc5609cba --- /dev/null +++ b/Segment_Tree_RMQ/Segement_Tree_RMQ.c @@ -0,0 +1,91 @@ +#include +#include +#include + +int min(int x, int y) +{ + return (x < y) ? x : y; +} + +void build(int *a, int *tree, int start, int end, int treenode) +{ + if (start == end) + { + tree[treenode] = a[start]; + return; + } + + int mid; + mid = (start + end) / 2; + + //compute the values in the left and right subtrees + build(a, tree, start, mid, 2 * treenode); + build(a, tree, mid + 1, end, 2 * treenode + 1); + + /*store the minimum value in the first and + second half of the interval*/ + tree[treenode] = min(tree[2 * treenode], tree[2 * treenode + 1]); + return; +} + +int query(int *tree, int start, int end, int l, int r, int treenode) +{ + /* if the current interval doesn’t intersect + the query interval return INT_MAX*/ + if (start > r || end < l) + { + return INT_MAX; + } + + /*if the current interval is included in + the query interval return tree[treenode]*/ + if (start >= l && end <= r) + { + return tree[treenode]; + } + + int mid; + mid = (start + end) / 2; + + //return the minimum value + int e = query(tree, start, mid, l, r, 2 * treenode); + int f = query(tree, mid + 1, end, l, r, 2 * treenode + 1); + + return min(e, f); +} + +int main() +{ + int size; + printf("Enter the size of the array: "); + scanf("%d", &size); + int array[size]; + int *segTree = (int *)malloc(sizeof(4 * size)); + + printf("Enter the elements.\n"); + for(int i = 0; i < size; i++) + { + scanf("%d", &array[i]); + } + + build(array, segTree, 0, size - 1, 1); + + int start, end; + printf("Enter the range of the query: "); + scanf("%d %d", &start, &end); + int result = query(segTree, 0, size - 1, start - 1, end - 1, 1); + + printf("Minimum value in index range %d to %d is: %d\n", start, end, result); + + return 0; +} + +/* +Input: +Enter the size of the array.: 5 +-7 3 -1 8 1 +Enter the range of the query.: 2 5 + +Output: +Minimum value in index range 2 to 5 is: -1 +*/ From 9ebc24f5d305e3aa18bc880e88a8cb7306ba942b Mon Sep 17 00:00:00 2001 From: shreya kapoor <31164665+shreyakapoor08@users.noreply.github.com> Date: Fri, 17 Apr 2020 12:23:08 +0530 Subject: [PATCH 091/265] Depth First Search in C# (#2674) * Depth First Search in C# --- Depth_First_Search/Depth_First_Search.cs | 69 ++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 Depth_First_Search/Depth_First_Search.cs diff --git a/Depth_First_Search/Depth_First_Search.cs b/Depth_First_Search/Depth_First_Search.cs new file mode 100644 index 000000000..f1e65a25d --- /dev/null +++ b/Depth_First_Search/Depth_First_Search.cs @@ -0,0 +1,69 @@ +/// C# program for Depth First Search Traversal + +using System; +using System.Collections.Generic; //used for including List + +class DirectedGraph +{ + List[] adjacencylist; + int vertix; + + DirectedGraph(int newv) //Constructor with same name as that of class + { + vertix = newv; + adjacencylist = new List[newv]; + for (int i = 0; i < newv; ++i) + adjacencylist[i] = new List(); + } + + void DFSFunction(int newv, bool[] traversed) + { + traversed[newv] = true; + Console.Write(newv + " "); + List vList = adjacencylist[newv]; + foreach (var n in vList) + { + if (!traversed[n]) + DFSFunction(n, traversed); + } + } + + void Addition_of_Edge(int newv, int var) + { + adjacencylist[newv].Add(var); + } + + void Depth_First_Search(int newv) + { + bool[] traversed = new bool[vertix]; + + DFSFunction(newv, traversed); + } + + public static void Main(String[] args) + { + DirectedGraph newgraph = new DirectedGraph(4); // Number of vertices is 4 + Console.WriteLine("Number of edges between the vertices to enter"); + int n = Convert.ToInt32(Console.ReadLine()); + for (int i=0;i Date: Fri, 17 Apr 2020 12:50:40 +0530 Subject: [PATCH 092/265] Added code of Longest Increasing Subsequence in Java (#2598) * Added code of Longest Increasing Subsequence in Java --- Longest_Increasing_Subsequence/LIS.java | 54 +++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Longest_Increasing_Subsequence/LIS.java diff --git a/Longest_Increasing_Subsequence/LIS.java b/Longest_Increasing_Subsequence/LIS.java new file mode 100644 index 000000000..fb525d0a2 --- /dev/null +++ b/Longest_Increasing_Subsequence/LIS.java @@ -0,0 +1,54 @@ +/* +Problem Statement : +To find the length of the Longest Increasing +Subsequence of a given sequence, that is all the +elements of the subsequence are in increasing sorted order. +*/ + +import java.util.*; + +class LIS +{ + static int lis(int arr[], int n) + { + int lis[] = new int[n]; + int result = Integer.MIN_VALUE; + + for (int i = 0; i < n; ++i) + lis[i] = 1; + + for (int i = 1; i < n; ++i) + { + for (int j = 0; j < i; ++j) + { + if (arr[i] > arr[j] && lis[i] < lis[j] + 1) + lis[i] = lis[j] + 1; + } + result = Math.max(result, lis[i]); + } + + return result; + } + + public static void main(String args[]) + { + Scanner sc = new Scanner(System.in); + + System.out.print("Enter the size of array : "); + int n = sc.nextInt(); + + int[] arr = new int[n]; + System.out.print("Enter the array elements : "); + for (int i = 0; i < n; ++i) + arr[i] = sc.nextInt(); + + System.out.println("\nLength of the Longest Increasing Subsequence : " + lis(arr, n)); + } +} + +/* +Enter the size of the array : 8 +Enter the array elements : 15 26 13 38 26 52 43 62 + +Length of the Longest Increasing Subsequence : 5 +*/ From aa64927aca354810547f4c33a0090dd944c4bf1a Mon Sep 17 00:00:00 2001 From: Manish Choudhary <53442020+Manish-cloud@users.noreply.github.com> Date: Fri, 17 Apr 2020 13:41:36 +0530 Subject: [PATCH 093/265] AVL Tree implementation in C++ (#2679) --- AVL_Tree/AVL_Tree.cpp | 202 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 202 insertions(+) create mode 100644 AVL_Tree/AVL_Tree.cpp diff --git a/AVL_Tree/AVL_Tree.cpp b/AVL_Tree/AVL_Tree.cpp new file mode 100644 index 000000000..3c68347ee --- /dev/null +++ b/AVL_Tree/AVL_Tree.cpp @@ -0,0 +1,202 @@ +#include +using namespace std; + +struct tnode +{ + int data; + tnode * L, * R; + tnode() + { + L = R = NULL; + } +}; + +class AVL +{ + private: + tnode * root; + public: + AVL() { root = NULL; } + tnode * LL(tnode *); + tnode * RR(tnode *); + tnode * LR(tnode *); + tnode * RL(tnode *); + + int height(tnode *); + int MAX(int, int); + + void create(); + tnode * insert(tnode *, int); + void display(); + void inorder(tnode *); + void preorder(tnode *); +}; + +tnode * AVL :: LL(tnode * parent) +{ + tnode * temp; + temp = parent -> L; + parent -> L = temp -> R; + temp -> R = parent; + return temp; +} + +tnode * AVL :: RR(tnode * parent) +{ + tnode * temp; + temp = parent -> R; + parent -> R = temp -> L; + temp -> L = parent; + return temp; +} + +tnode * AVL :: LR(tnode * parent) +{ + parent -> L = RR(parent -> L); + parent = LL(parent); + return parent; +} + +tnode * AVL :: RL(tnode * parent) +{ + parent -> R = LL(parent -> R); + parent = RR(parent); + return parent; +} + +int AVL :: MAX(int a, int b) +{ + if(a > b) + return a; + else + return b; +} + +int AVL :: height(tnode * temp ) +{ + if(temp == NULL) //height of empty node(subtree) + return -1; + + if(temp -> L == NULL and temp -> R == NULL) //height of leaf node + return 0; + + return (1 + MAX( height(temp -> L), height(temp -> R))); +} + +void AVL :: create() +{ + int val; + char ch; + do + { + cout << "Enter Number : "; + cin >> val; + root = insert(root, val); + cout << "Continue : "; + cin >> ch; + }while(ch == 'y'); +} + +tnode * AVL :: insert(tnode * temp, int val) +{ + if(temp == NULL) + { + temp = new tnode; + temp -> data = val; + } + else + { + if(val < temp -> data) + { + temp -> L = insert(temp -> L, val); + if( ( height(temp -> L) - height(temp -> R) == 2 ) ) + { + if(val < temp -> L -> data) + temp = LL(temp); + else + temp = LR(temp); + } + } + else + { + temp -> R = insert(temp -> R, val); + if( ( height(temp -> L) - height(temp -> R)== -2 ) ) + { + if(val > temp -> R -> data) + temp = RR(temp); + else + temp = RL(temp); + } + } + } + return temp; +} + +void AVL :: inorder(tnode * temp) +{ + if(temp != NULL) + { + inorder(temp -> L); + cout << "\n" << temp -> data; + inorder(temp -> R); + } +} + +void AVL :: preorder(tnode * temp) +{ + if(temp != NULL) + { + cout << "\n"< data; + preorder(temp -> L); + preorder(temp -> R); + } +} + +void AVL :: display() +{ + cout << "\n Data in Sorted way : "; + inorder(root); + cout << "\n Preorder : "; + preorder(root); +} + +int main() +{ + AVL t; + t.create(); + t.display(); + cout << endl; + return 0; +} + +/* + Initially putting data in increasing order to form right skewed tree + +Enter Number : 5 +Continue : y +Enter Number : 6 +Continue : y +Enter Number : 7 +Continue : y +Enter Number : 8 +Continue : y +Enter Number : 9 +Continue : y +Enter Number : 10 +Continue : n + + Data in Sorted way : +5 +6 +7 +8 +9 +10 + Preorder : +8 +6 +5 +7 +9 +10 + */ From 83c8169bdc60aa4dcc1c4f59cf0b7f1bcea857fe Mon Sep 17 00:00:00 2001 From: Sukriti Shah Date: Sat, 18 Apr 2020 00:32:24 +0530 Subject: [PATCH 094/265] PHP implementation for LIS (#2669) Update LIS.php --- Longest_Increasing_Subsequence/LIS.php | 43 ++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Longest_Increasing_Subsequence/LIS.php diff --git a/Longest_Increasing_Subsequence/LIS.php b/Longest_Increasing_Subsequence/LIS.php new file mode 100644 index 000000000..2554faaf1 --- /dev/null +++ b/Longest_Increasing_Subsequence/LIS.php @@ -0,0 +1,43 @@ + $arr[$j] && $dp[$i] < $dp[$j] + 1) + $dp[$i] = $dp[$j] + 1; + } + + // find the max out of computed lengths of LIS + // ending at different indices + $max = PHP_INT_MIN; + for($i = 0; $i < $n; $i++){ + if($max < $dp[$i]) + $max = $dp[$i]; + } + + return $max; +} + +// Sample test case +$arr = array(3, 10, 2, 1, 20, 40, 60, 7); +$n = sizeof($arr); + +echo "Length of LIS is " , lisLen($arr, $n); + +/* +Sample Input as specified in the code: +3, 10, 2, 1, 20, 40, 60, 7 + +Sample Output: +Length of LIS is 5 +*/ + +?> From f68d36e4704fbad621983d50338f616ff677e774 Mon Sep 17 00:00:00 2001 From: Ritish Singh <54978105+ritish099@users.noreply.github.com> Date: Sat, 18 Apr 2020 01:01:50 +0530 Subject: [PATCH 095/265] Prims Algorithm in C (#2684) --- Prims_Algorithm/Prims_Algorithm.cs | 77 ++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 Prims_Algorithm/Prims_Algorithm.cs diff --git a/Prims_Algorithm/Prims_Algorithm.cs b/Prims_Algorithm/Prims_Algorithm.cs new file mode 100644 index 000000000..76e955f74 --- /dev/null +++ b/Prims_Algorithm/Prims_Algorithm.cs @@ -0,0 +1,77 @@ +using System; + +namespace Declaring_Method +{ + public class Prim_Algorithm + { + public static void Main(string[] args) + { + int a = 0, b = 0, u = 0, v = 0, n, i, j, edge_no = 1; + int min, mincost = 0; + int[] visited = new int[100]; + int[, ] cost = new int[10, 10]; + + Console.WriteLine("Enter the number of Nodes"); + n = Convert.ToInt32(Console.ReadLine()); + Console.WriteLine("Enter the adjency matrix"); + + //Intilize all visited elements to 0 + for (i = 0; i < 100; i++) + { + visited[i] = 0; + } + + //Taking Matrix Input from the User + for (i = 1; i <= n; i++) + { + for (j = 1; j <= n; j++) + { + cost[i, j] = Convert.ToInt32(Console.ReadLine()); + //Initialize Cost Matrix to Infintiy if user input is 0 + if (cost[i, j] == 0) + cost[i, j] = 999; + } + } + visited[1] = 1; + Console.WriteLine(" "); + + while (edge_no < 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]; + //Storing Position + a = u = i; + b = v = j; + } + // Print the Edge Number with its Cost + if (visited[u] == 0 || visited[v] == 0) + { + Console.WriteLine("Edge {0} : ({1} {2}) cost:{3} ", edge_no++, a, b, min); + mincost += min; // Calculating minimum Cost + visited[b] = 1; + } + cost[a, b] = cost[b, a] = 999; + } + Console.WriteLine("Minimum Cost : {0}", mincost); + } + } +} + +/*Enter the number of Nodes +5 +Enter the adjency matrix +0 2 0 6 0 +2 0 3 8 5 +0 3 0 0 7 +6 8 0 0 9 +0 5 7 9 0 + +Edge 1 : (1 2) cost:2 +Edge 2 : (2 3) cost:3 +Edge 3 : (2 5) cost:5 +Edge 4 : (1 4) cost:6 +Minimum Cost : 16 */ From 0e73cbf2e51c2009fa948c9606aaa9224e41f00e Mon Sep 17 00:00:00 2001 From: Ritish Singh <54978105+ritish099@users.noreply.github.com> Date: Sat, 18 Apr 2020 01:02:55 +0530 Subject: [PATCH 096/265] Jhonson Algorithm in PHP (#2696) --- Jhonson_Algoritm/Jhonson_Algorithm.php | 62 ++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 Jhonson_Algoritm/Jhonson_Algorithm.php diff --git a/Jhonson_Algoritm/Jhonson_Algorithm.php b/Jhonson_Algoritm/Jhonson_Algorithm.php new file mode 100644 index 000000000..59a2d1885 --- /dev/null +++ b/Jhonson_Algoritm/Jhonson_Algorithm.php @@ -0,0 +1,62 @@ + From 329ca741f4355d53dfc7f0330e66ce47f3510563 Mon Sep 17 00:00:00 2001 From: Muskan Goyal Date: Sat, 18 Apr 2020 14:46:01 +0530 Subject: [PATCH 097/265] Fenwick_Tree.php Added (#2689) Update Fenwick_Tree.php Updated Done --- Fenwick_Tree/Fenwick_Tree.php | 105 ++++++++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 Fenwick_Tree/Fenwick_Tree.php diff --git a/Fenwick_Tree/Fenwick_Tree.php b/Fenwick_Tree/Fenwick_Tree.php new file mode 100644 index 000000000..71801c8ca --- /dev/null +++ b/Fenwick_Tree/Fenwick_Tree.php @@ -0,0 +1,105 @@ + 0){ + // Adding tree node to sum + $s = $s + $ft[$index]; + // Update tree node + $index -= $index & (-$index); + } + // Return total sum + return $s; +} + +// Update function +function update ($ft, $size, $index, $val) { + /* + Arguments + ft : Fenwick Tree + index : Index of ft to be updated + size : Length of the original array + val : Add val to the index "index" + Traverse all ancestors and add 'val'. + Add 'val' to current node of Fenwick Tree. + Update index to that of parent in update. + */ + $index += 1; + while( $index <= $size){ + // Update tree node value + $ft[$index] = $ft[$index] + $val; + // Update node index + $index += $index and (-$index); + } + } + + +// Build function +function construct($array, $size) { + /* + Argument + array : The original array + size : The length of the given array + This function will construct the Fenwick Tree + from the given array of length "size" + + Return : Fenwick Tree array ft[] + */ + // Init ft array of length 1000 with zero value initially + $ft = array(); + // Constructing Fenwick Tree by Update operation + for( $i = 0; $i < $size; $i++) { + // Update operation + update($ft, $size, $i, $array[$i]); + } + // Return Fenwick Tree array + return $ft; +} + +//Driver code to test above methods +function main() { + $array = array(2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9); + $n = construct($freq, sizeof($array)); + echo implode(sum($n, 5)); + $array[3] = $array[3] + 6; + update($n, sizeof($array), 3, 6) ; + echo implode(sum($n, 5)); +} + +/* +INPUT +------- +array : [2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9] +Sum of elements in array[0..5] is 12 +Sum of elements in array[0..5] after update is 18 + +OUTPUT +------ +12 +18 +*/ + +?> From 85f7d36624717ed76af33f0c732d528ebe7618bf Mon Sep 17 00:00:00 2001 From: Ashish Nagpal <36301481+ashishnagpal2498@users.noreply.github.com> Date: Sun, 19 Apr 2020 16:38:18 +0530 Subject: [PATCH 098/265] Tree Level order Traversal Tree (#2642) :star: Tree Level order traversal :up: Input Output addition :bug: single node print :up: indentation correction :star: description added --- .../Tree_Levelorder_Traversal.js | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.js diff --git a/Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.js b/Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.js new file mode 100644 index 000000000..0d546041a --- /dev/null +++ b/Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.js @@ -0,0 +1,59 @@ +/*Description - Level order traveral of a tree is a traversal in which all the nodes which are at same +level are explored and then we move to another level. It is implemented using a queue. The root node +is pushed into queue intially and loops run till queue is not empty. The node at front is poped out +and if child of that node exist then those are pushed into queue. +Implementing Level Order Traversal in graph is also called Breath First Search. +*/ + +// Creates a Tree Node with input value +class Node { + constructor(value) { + this.value = value; + this.left = null; + this.right = null; + } +} + +//Level Order Traversal +var traversal = function (root) { + if (root === null) return root; + if (root.left === null && root.right === null) { + console.log(root.value); + return root; + } + const queue = []; + queue.push(root); + while (queue.length > 0) { + const node = queue.splice(0, 1)[0]; + console.log(node.value); + if (node.left) queue.push(node.left); + if (node.right) queue.push(node.right); + } + return root; +}; + +// Sample Input +var root = new Node(1); +root.left = new Node(2); +root.right = new Node(3); +root.left.left = new Node(4); +root.left.right = new Node(5); +root.right.left = new Node(6); +root.right.right = new Node(7); + +// Sample Output +console.log("Level Order traversal of tree is:-"); +traversal(root); + +/* +* Output +* +* Level Order traversal of tree is +1 +2 +3 +4 +5 +6 +7 +*/ From b5e7b15e29086a1657b144fd9d5d89c75d3eba8b Mon Sep 17 00:00:00 2001 From: prashansag62 <43422124+prashansag62@users.noreply.github.com> Date: Sun, 19 Apr 2020 16:41:10 +0530 Subject: [PATCH 099/265] bfs in Csharp added (#2514) --- Breadth_First_Search/BFS_in_Csharp.cs | 133 ++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 Breadth_First_Search/BFS_in_Csharp.cs diff --git a/Breadth_First_Search/BFS_in_Csharp.cs b/Breadth_First_Search/BFS_in_Csharp.cs new file mode 100644 index 000000000..aa25d7319 --- /dev/null +++ b/Breadth_First_Search/BFS_in_Csharp.cs @@ -0,0 +1,133 @@ +//Breadth First Search ALgorithm implemented using queue in C# + +using System; +// for generic data structures +using System.Collections.Generic; + +namespace GraphBfs +{ + class graph + { //no of vertices in a graph + private int vertices; + //declaraing list + private List[] adj; + public graph(int v) + { + //initialising Adjacency List with number of vertices + vertices = v; + adj = new List[v]; + for(int i = 0; i < v; i++) + { + adj[i] = new List(); + } + } + + public void addedge(int c,int v) + { + adj[c].Add(v); + adj[v].Add(c); + } + + // function for Breadth First Search ,starting node as parameter + public void BFS(int v) + { + bool[] visited = new bool[vertices]; + Queue queue = new Queue(); + visited[v] = true; + // enqueuing first node in queue + queue.Enqueue(v); + while(queue.Count != 0) + { + // dequeue node from beginning of queue + v = queue.Dequeue(); + Console.Write(v + " "); + foreach(int i in adj[v]) + { + //only unvisited node pushed into queue + if( !visited[i]) + { + visited[i] = true; + queue.Enqueue(i); + } + } + } + } + } + + class program + { + static void Main(string[] args) + { //Taking input number of vertices + Console.WriteLine("Enter number of vertices in a graph"); + int v = Convert.ToInt32(Console.ReadLine()); + + graph g = new graph(v); + + //Taking input number of edges + Console.WriteLine("Enter number of edge in a graph"); + int e = Convert.ToInt32(Console.ReadLine()); + + for(int i = 0; i < e; i++) + { + Console.WriteLine("Enter nodes of " + (i+1) +" edge"); + string s = Console.ReadLine(); + + int e1 = Convert.ToInt32(s.Split(" ")[0]); + int e2 = Convert.ToInt32(s.Split(" ")[1]); + + g.addedge(e1, e2); + } + Console.WriteLine("Breadth First Search of Graph :-"); + //calling BFS function with starting node provided + g.BFS(0); + } + } +} + +/*Sample Input and Output + +Enter number of vertices in a graph +10 +Enter number of edge in a graph +12 +Enter nodes of 1 edge +0 1 +Enter nodes of 2 edge +0 2 +Enter nodes of 3 edge +1 3 +Enter nodes of 4 edge +2 4 +Enter nodes of 5 edge +2 5 +Enter nodes of 6 edge +3 6 +Enter nodes of 7 edge +6 4 +Enter nodes of 8 edge +4 5 +Enter nodes of 9 edge +4 7 +Enter nodes of 10 edge +7 8 +Enter nodes of 11 edge +7 9 +Enter nodes of 12 edge +8 9 +Breadth First Search of Graph :- +0 1 2 3 4 5 6 7 8 9 + +Adjacency List of Sample Input + +0 -> 1,2 +1 -> 0,3 +2 -> 0,4,5 +3 -> 1,6 +4 -> 2,6,5,7, +5 -> 2,4 +6 -> 3,4 +7 -> 4,8,9 +8 -> 7,9 +9 -> 7,8 + +*/ From ffa64bfbc031137c24172b55d676b5921266c12a Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Mon, 20 Apr 2020 17:16:52 +0530 Subject: [PATCH 100/265] Chinese Remainder Theorem in Dart (#2763) --- .../Chinese_Remainder_Theorem.dart | 119 ++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.dart diff --git a/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.dart b/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.dart new file mode 100644 index 000000000..ec990892c --- /dev/null +++ b/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.dart @@ -0,0 +1,119 @@ +/* + Dart program to implement Chinese Remainder Theorem (CRT) + --------------------------------------------------------------------- + + Chinese Remainder Theorem + --------------------------------------------------------------------- + + The Chinese Remainder Theorem ( based on Extended Euclid's algorithm ) states that a set of 'k' congruency equations with a single variable + as follows + + x % num[0] = rem[0] + x % num[1] = rem[1] + . + . + . + x % num[k] = rem[k] + + can be solved by using the formula, x = ( sum(rem[i]*pd[i]*inv[i]) for all i ) % product where + + product is the product of all numbers in num array + rem[i] is the i'th remainder in the given input, + pd[i] is the value of product divided by num[i], + inv[i] is the modulo inverse of pd[i] and num[i], + sum() is a function that sums up the values. + + Here, the obtained solution is minimum possible x. + +*/ + +// Importing required libraries. +import 'dart:io'; + +// Function to calculate modulo inverse. +int modular_inverse(int a, int m){ + + // Temporary variable to store m to use later. + int temp = m; + + if (m == 1){ + return 0; + } + + int y = 0, x = 1, temp2, quotient, remainder; + + // Calculating x and y based on Euclid's algorithm + while (a > 1){ + quotient = (a / m).floor(); + remainder = a % m; + a = m; + m = remainder; + temp2 = y; + y = x - quotient * y; + x = temp2; + } + + // Making x positive if found negative + if (x < 0){ + x += temp; + } + + return x; +} + +// Driver function of the program +void main(){ + + // Taking input of the number array (num[i]). + print("Enter array of pairwise co-prime numbers:"); + + var input = stdin.readLineSync(); + var lis = input.split(' '); + List numbers = lis.map(int.parse).toList(); + + // Taking input of remainder array (rem[i]). + print("Enter remainders:"); + + input = stdin.readLineSync(); + lis = input.split(' '); + List remainders = lis.map(int.parse).toList(); + + int product = 1; + + // Length of the 'numbers' list. + int length = numbers.length; + + // Finding product of all the numbers. + for (int i = 0; i < length; i ++){ + product *= numbers[i]; + } + + int temp, result = 0; + + // Summing the required values for all i according to the formula. + for (int i = 0; i < length; i ++){ + temp = (product / numbers[i]).floor(); + result += temp * (remainders[i]) * modular_inverse(temp,numbers[i]); + } + + result = result % product; + + // Printing result + print("The value of 'x' by Chinese Remainder Theorem is $result."); + +} + +/* + Sample Input + + Enter array of pairwise co-prime numbers: + 9 8 5 7 1 + Enter remainders: + 1 2 3 4 5 + + Sample Output + + The value of 'x' by Chinese Remainder Theorem is 298. + +*/ + From 7cd7f84b17cc70dd28513f28bf22ed26f8533d56 Mon Sep 17 00:00:00 2001 From: ka1shi <44312733+ka1shi@users.noreply.github.com> Date: Wed, 22 Apr 2020 02:48:33 +0530 Subject: [PATCH 101/265] Johnson Algorithm implementation in C (#2334) --- Johnson_Algorithm/Johnson_Algorithm.c | 359 ++++++++++++++++++++++++++ 1 file changed, 359 insertions(+) create mode 100644 Johnson_Algorithm/Johnson_Algorithm.c diff --git a/Johnson_Algorithm/Johnson_Algorithm.c b/Johnson_Algorithm/Johnson_Algorithm.c new file mode 100644 index 000000000..e68aeac41 --- /dev/null +++ b/Johnson_Algorithm/Johnson_Algorithm.c @@ -0,0 +1,359 @@ +// Implementation of Johnson's algorithm in C + +#include +#include +#include +#include + +// Structure to represent Edge of graph +struct Edge { + // Edge with a source and destination and weight as distance between source and destination + int source, destination, weight; +}; + +// Structure to represent a connected, weighted and directed graph +struct Graph { + // V is number of vertices + // E is Number of Edges + int V, E; + + // Array of Edge structure + struct Edge* edge; +}; + +struct Graph* createGraph(int V, int E) +{ + // Allocate memory to V vertices of graph + struct Graph* graph = malloc(V * sizeof(int)); + graph -> V = V; + graph -> E = E; + + // Allocate memory to E Edges of graph + graph -> edge = malloc(E * sizeof(int)); + + // Information Message + // printf("The graph is created with %d vertices and %d edges.\n", V, E); + return graph; +} + +struct Graph* addEdge(struct Graph* graph, int src, int des, int wt, int i) +{ + graph -> edge[i].source = src; + graph -> edge[i].destination = des; + graph -> edge[i].weight = wt; + + return graph; +} + +void printGraph(struct Graph* graph) +{ + int E = graph -> E; + + for(int i = 0; i < E; i++) + { + printf("The distance from %d to %d is: %d\n", graph -> edge[i].source, graph -> edge[i].destination, graph -> edge[i].weight); + } + printf("\n"); +} + +int* BellmanFord(struct Graph* graph, int extra, int* dist) +{ + int V = graph -> V; + int E = graph -> E; + + // Initialize distance from extra vertex to all vertices as Infinite(INT_MAX) + for(int i = 0; i < V + 1; i++) + { + dist[i] = INT_MAX; + } + + // Distance from extra vertex to itself is zero + dist[extra] = 0; + + // Shortest path from any vertex can have atmost V-1 edges + for(int i = 1; i <= V; i++) + { + for(int j = 0; j < E + V; j++) + { + int u = graph -> edge[j].source; + int v = graph -> edge[j].destination; + int w = graph -> edge[j].weight; + + // Check if old distance is greater than new distance + if(dist[u] != INT_MAX && dist[v] > dist[u] + w) + { + // Update old distance with new distance + dist[v] = dist[u] + w; + } + } + } + + return dist; +} + +struct Graph* updateEdge(struct Graph* graph, int dist[], int E) +{ + // Update Edge after getting distance from extra vertex to each original vertex + // To make distance between all vertices poitive + for(int i = 0; i < E; i++) + { + int u = graph -> edge[i].source; + int v = graph -> edge[i].destination; + + // Update distance between from vertex u to v as => distance of u from extra vertex - distance of v from extra vertex + original distance from u to v + graph -> edge[i].weight = dist[u] - dist[v] + graph -> edge[i].weight; + } + + return graph; +} + +int minDistance(int dist[], bool visited[], int V) +{ + // Find closest vertex from source vertex that has not been visited + + // Initialize as min as INFINITY(INT_MAX) + int min = INT_MAX, min_index; + + for(int v = 0; v < V; v++) + { + // If vertex is not visited and is smaller than current min + if(!visited[v] && dist[v] <= min) + { + min = dist[v]; + min_index = v; + } + } + return min_index; +} + +int askGraph(struct Graph* graph, int u, int v, int E) +{ + // Return distance from vertex u to vertex v + + for(int i = 0; i < E; i++) + { + if(graph -> edge[i].source == u && graph -> edge[i].destination == v) + { + return graph -> edge[i].weight; + } + } + // return INT_MIN if edge from u to v does not exist + return INT_MIN; +} + +int* Dijsktra(struct Graph* graph, int V, int E, int src, int* dist) +{ + // Calculate shortest path from source vertex to all other vertices + + // checks if vertex i is visited and is finalized + bool visited[V]; + + // Initialize all distances as INT_MAX and visited[] as false + for(int i = 0; i < V; i++) + { + dist[i] = INT_MAX; + visited[i] = false; + } + + // Distance of source vertex from itself is zero + dist[src] = 0; + + // Shortest path from any vertex can have atmost V-1 edges + for(int i = 0; i < V - 1; i++) + { + // Pick the minimum distance vertex from all vertices + int u = minDistance(dist, visited, V); + + // Picked vertex is visited + visited[u] = true; + + // Update distance of adjacent vertices from picked vertex + for(int v = 0; v < V; v++) + { + // Update dist[v] only if it is not in visited, + // Distance from src to v is smaller through src to u to v + + // Distance from u to v + int temp = askGraph(graph, u, v, E); + + if(!visited[v] && dist[u] != INT_MAX && temp != INT_MIN && dist[v] > dist[u] + temp) + { + // Update old distance + dist[v] = dist[u] + temp; + } + } + + } + + return dist; +} + +int main(){ + + // V is number of vertices and E is number of Edges in graph + int V, E; + + scanf("%d %d", &V, &E); + + // Information Message + // printf("%d\n",V); + // printf("%d\n",E); + + // Declaring source, destination and weight for edges + int src, des, wt; + + // One Extra vertex (V+1) is considered for calculating distance with each vertex present in original graph + // Additional V edges (E+V) from extra vertex to all original vertices is considered + + struct Graph* graph = createGraph(V + 1, E + V); + + // Add each edge to graph with source, destination and weight + for(int i = 0; i < E + V; i++) + { + if(i < E) // Original E Edges + { + scanf("%d %d %d", &src, &des, &wt); + // printf("%d %d %d %d\n",src,des,wt, i); + graph = addEdge(graph, src, des, wt, i); + } + else // Extra V edges from one extra vertex to original vertices with 0 weight + { + // printf("%d %d %d %d\n",V,i-E,0, i); + graph = addEdge(graph, V, i - E, 0, i); + } + } + + // printf("\n"); + + // Print graph + // printf("Original Graph:\n\n"); + // printGraph(graph); + + // Store distance of each original vertex from extra vertex(including itself) + int _dist[V + 1]; + + // BellmanFord Algorithm to calculate distance of all original vertices with negative edges from extra vertex + int* dist = BellmanFord(graph, V, _dist); + + // Update new edge weights between vertices + graph = updateEdge(graph, dist, E); + + // Now will consider original E Edges only, rest V will be ignored from extra vertex total of E+V + // Also extra vertex will be ignored + // As was required only to convert negative weight distance between vertices to positive weight distance + + // New graph with all positive weight distance + // printf("Updated Graph:\n\n"); + // printGraph(graph); + + // Matrix to store distance of every vertex with every other vertex + int distance[V][V]; + // Running Dijsktra for every vertex as source + for(int i = 0; i < V; i++) + { + int __dist[V]; + + // Calculating shortest distance from source i to every other vertices using Dijsktra + int* dist_final = Dijsktra(graph, V, E, i, __dist); + + // Update the final matrix distance + for(int j = 0; j < V; j++) + { + distance[i][j] = dist_final[j]; + } + } + + printf("Final Result\n"); + printf("(Value 2147483648 indicates vertex v is not reachable from vertex u)\n\n"); + for(int i = 0; i < V; i++) + { + for(int j = 0; j < V; j++) + { + if(distance[i][j] == INT_MAX) + { + distance[i][j] = INT_MAX; + // To indicate that j vertex is not reachable from i vertex + // No Edge from i to j + } + printf("Distance from %d to %d is :%d\n", i, j, distance[i][j]); + } + printf("\n"); + } +} + +/* + INPUT: + + 7 9 + 0 1 -1 + 0 2 0 + 3 0 12 + 3 2 5 + 2 5 -6 + 5 4 3 + 4 1 4 + 6 5 8 + 1 6 -7 + + OUTPUT: + + Final Result +(Value -2147483648 indicates vertex v is not reachable from vertex u) + +Distance from 0 to 0 is :0 +Distance from 0 to 1 is :0 +Distance from 0 to 2 is :0 +Distance from 0 to 3 is :-2147483648 +Distance from 0 to 4 is :0 +Distance from 0 to 5 is :0 +Distance from 0 to 6 is :0 + +Distance from 1 to 0 is :-2147483648 +Distance from 1 to 1 is :0 +Distance from 1 to 2 is :-2147483648 +Distance from 1 to 3 is :-2147483648 +Distance from 1 to 4 is :6 +Distance from 1 to 5 is :6 +Distance from 1 to 6 is :0 + +Distance from 2 to 0 is :-2147483648 +Distance from 2 to 1 is :2 +Distance from 2 to 2 is :0 +Distance from 2 to 3 is :-2147483648 +Distance from 2 to 4 is :0 +Distance from 2 to 5 is :0 +Distance from 2 to 6 is :2 + +Distance from 3 to 0 is :12 +Distance from 3 to 1 is :7 +Distance from 3 to 2 is :5 +Distance from 3 to 3 is :0 +Distance from 3 to 4 is :5 +Distance from 3 to 5 is :5 +Distance from 3 to 6 is :7 + +Distance from 4 to 0 is :-2147483648 +Distance from 4 to 1 is :2 +Distance from 4 to 2 is :-2147483648 +Distance from 4 to 3 is :-2147483648 +Distance from 4 to 4 is :0 +Distance from 4 to 5 is :8 +Distance from 4 to 6 is :2 + +Distance from 5 to 0 is :-2147483648 +Distance from 5 to 1 is :2 +Distance from 5 to 2 is :-2147483648 +Distance from 5 to 3 is :-2147483648 +Distance from 5 to 4 is :0 +Distance from 5 to 5 is :0 +Distance from 5 to 6 is :2 + +Distance from 6 to 0 is :-2147483648 +Distance from 6 to 1 is :8 +Distance from 6 to 2 is :-2147483648 +Distance from 6 to 3 is :-2147483648 +Distance from 6 to 4 is :6 +Distance from 6 to 5 is :6 +Distance from 6 to 6 is :0 + + */ From d07d86eeb261ca2fe76c5b2a24ca83e5c85ac95c Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Thu, 23 Apr 2020 15:23:33 +0530 Subject: [PATCH 102/265] Add Level Order Traversal in Kotlin (#2757) --- .../Tree_Levelorder_Traversal.kt | 104 ++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.kt diff --git a/Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.kt b/Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.kt new file mode 100644 index 000000000..43ec8d992 --- /dev/null +++ b/Tree_Levelorder_Traversal/Tree_Levelorder_Traversal.kt @@ -0,0 +1,104 @@ +// Code for printing Level Order of Tree in Kotlin + +class Node +{ + //Structure of Binary tree node + int num; + Node left, right; + public Node(int num) + { + key = item; + left = right = null; + } +} + +class BinaryTree +{ + Node root; + BinaryTree() + { + root = null; + } + + //function to print level order traversal + fun printLevelOrder():void + { + int h = height(root); + int i; + // To Print nodes at each level + for (i = 1; i <= h; i++) + { + printGivenLevel(root, i); + } + + } + + //Function to calculate height of Tree + fun height(Node: root):void + { + if (root == null) + { + return 0; + } + else + { + // compute height of each subtree + int lheight = height(root.left); + int rheight = height(root.right); + // use the larger one + if (lheight > rheight) + { + return(lheight + 1); + } + else + { + return(rheight + 1); + } + } + } + + fun printGivenLevel(Node:root ,int: level):void + { + if (root == null) + { + return; + } + //Print data + if (level == 1) + { + println(root.data); + } + else if (level > 1) + { + printGivenLevel(root.left, level-1); + printGivenLevel(root.right, level-1); + } + } + + fun main() + { + BinaryTree tree = new BinaryTree(); + var read = Scanner(System.`in`) + println("Enter the size of Array:") + val arrSize = read.nextLine().toInt() + var arr = IntArray(arrSize) + println("Enter data of binary tree") + + for(i in 0 until arrSize) + { + arr[i] = read.nextLine().toInt() + tree.root = new Node(arr[i]); + } + + println("Level order traversal of binary tree is "); + tree.printLevelOrder(); + } +} + +/* +Input: +1 2 3 4 5 6 7 8 9 +Output: +Level order traversal of binary tree is +1 2 3 4 5 6 7 8 9 +*/ From a4052fbf160d1de39f8e413b43366c16260d2e94 Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Fri, 24 Apr 2020 00:32:26 +0530 Subject: [PATCH 103/265] Add spiral array in C (#2322) --- Spiral_Array/SpiralArray.c | 96 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 Spiral_Array/SpiralArray.c diff --git a/Spiral_Array/SpiralArray.c b/Spiral_Array/SpiralArray.c new file mode 100644 index 000000000..ef1da21b5 --- /dev/null +++ b/Spiral_Array/SpiralArray.c @@ -0,0 +1,96 @@ +#include +int main() +{ + int a[20][20], int d, int i, int j, int ra, int ca, int r, int c, int k; + //accepting number of rows + do + { + printf("enter number of rows:"); + scanf("%d", &ra); + }while(ra < 1); + //accepting number of columns + do + { + printf("enter number of columns:"); + scanf("%d", &ca); + }while(ca < 1); + printf("\n\t enter elements:"); + printf("\n"); + //accepting matrix + for(i = 0; i < ra; i++) + { + for(j = 0; j < ca; j++) + { + scanf("%d", &a[i][j]); + } + } + printf(" INTIAL MATRIX = "); + for(i = 0; i < ra; i++) + { + printf("\n"); + + for(j = 0; j < ca; j++) + { + printf("%d" , a[i][j]); + } + } + printf("\n"); + printf("spiral form = "); + printf("\n"); + r = ra - 1; + c = ca - 1; + i = 0; + j = 0; + //printing each side so as to get spiral form + while(i <= c && j <= r) + { + if(d == 0) + { + for(k = i; k <= c; k++) + { + printf("%d", a[j][k]); + } + j++; + d = 1; + } + else if(d == 1) + { + for(k = j; k <= r; k++) + { + printf("%d", a[k][c]); + } + c--; + d = 2; + } + else if(d == 2) + { + for(k = c; k >= i; k--) + { + printf("%d", a[r][k]); + } + r--; + d = 3; + } + else if(d == 3) + { + for(k = r; k >= j; k--) + { + printf("%d", a[k][i]); + } + i++; + d = 0; + } + } +return 0; +} +/* Test Cases + +Input: + 1 2 3 4 + 5 6 7 8 + 9 10 11 12 + 13 14 15 16 +Output: +1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10 + +*/ From 3d4de052f8a5266b9848bcddc6aa472d1fba23df Mon Sep 17 00:00:00 2001 From: Tahanima Chowdhury Date: Sat, 25 Apr 2020 13:25:28 +0600 Subject: [PATCH 104/265] Added LCS implementation in Ruby (#2252) (#2766) --- .../Longest_Common_Subsequence.rb | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 Longest_Common_Subsequence/Longest_Common_Subsequence.rb diff --git a/Longest_Common_Subsequence/Longest_Common_Subsequence.rb b/Longest_Common_Subsequence/Longest_Common_Subsequence.rb new file mode 100644 index 000000000..27e5aa5ec --- /dev/null +++ b/Longest_Common_Subsequence/Longest_Common_Subsequence.rb @@ -0,0 +1,58 @@ +=begin +Problem Statement- Given two sequences, find +the length of longest subsequence present in both of them. +A subsequence is a sequence that can be derived +from another sequence by deleting some or +no elements without changing the order of the remaining elements. +=end + +def longest_common_subsequence(arr1, arr2, size1, size2) + lcs = Array.new(size1 + 1){Array.new(size2 + 1)} + + for i in 0..size1 + for j in 0..size2 + if (i == 0 || j == 0) + lcs[i][j] = 0 + # when the last character of both subsequences match, + # increase length of lcs by 1 + elsif (arr1[i - 1] == arr2[j - 1]) + lcs[i][j] = lcs[i - 1][j - 1] + 1 + # when the last character is not same, + # take maximum obtained by adding + # one character to one of the subsequences + else + lcs[i][j] = [lcs[i - 1][j], lcs[i][j - 1]].max + end + end + end + + lcs[size1][size2] +end + +# Driver Code +puts "Enter the size of first array:" +size1 = gets.to_i + +puts "Enter the first array elements:" +arr1 = gets.split(" ").map(&:to_i) + +puts "Enter the size of second array:" +size2 = gets.to_i + +puts "Enter the second array elements:" +arr2 = gets.split(" ").map(&:to_i) + +len = longest_common_subsequence(arr1, arr2, size1, size2) +puts "Length of Longest Common Subsequence is: #{len}" + +=begin +Enter the size of first array: +7 +Enter the first array elements: +10 15 20 25 30 35 40 +Enter the size of second array: +8 +Enter the second array elements: +10 12 23 25 28 30 32 40 +Length of Longest Common Subsequence is: 4 +=end From 6a9acfeda16594973221056e4611bbcf4b25eeeb Mon Sep 17 00:00:00 2001 From: monikajha <53649201+m-code12@users.noreply.github.com> Date: Sun, 26 Apr 2020 01:18:13 +0530 Subject: [PATCH 105/265] Merge Sort in Rust (#2760) * Merge Sort in Rust * Update Merge_Sort.rs --- Merge_Sort/Merge_Sort.rs | 97 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 Merge_Sort/Merge_Sort.rs diff --git a/Merge_Sort/Merge_Sort.rs b/Merge_Sort/Merge_Sort.rs new file mode 100644 index 000000000..4ee67d93f --- /dev/null +++ b/Merge_Sort/Merge_Sort.rs @@ -0,0 +1,97 @@ +/* + Rust Program to implement Merge Sort + -------------------------------------------------------- + Merge Sort + -------------------------------------------------------- +Merge sort is a divide-conquer-combine algorithm based on the idea of breaking down a list into several sub-lists . +The list is broken into sublists until each sublist consists of a single element and merging those sublists in a +manner that results into a sorted list. + +The idea is : + -> Divide the unsorted list into N sublists, each containing 1 element. + -> Take adjacent pairs of two singleton lists and merge them to form a list of 2 elements.N will now convert + into N/2 lists of size 2. + -> Repeat the process till a single sorted list of size N is obtained. + +Complexity Analysis : + +The list of size N is divided into a max of logN parts, and the merging of all sublists into a single list takes O(N) time. +The worst case run time of this algorithm is O(NlogN) . +The average and best case run time of this algorithm is N(logN) . +The space complexity of this algorithm is N . +*/ + + +use std::io; +use std::str::FromStr; + +fn main() { + println!("Enter the numbers to be sorted (separated by space) : "); + let mut i = read_values::().unwrap(); + merge_sort(&mut i); + println!("Sorted array: {:?}", i) + } + +fn merge_sort(a: &mut Vec) { + let size = a.len(); + let mut buffer = vec![0; size]; + merge_split(a, 0, size, &mut buffer); +} + +fn merge_split(a: &mut Vec, start: usize, end: usize, buffer: &mut Vec) { + if end - start > 1 { + // Determine the split index + let split = (start + end) / 2; + + // Split and merge sort + merge_split(a, start, split, buffer); + merge_split(a, split, end, buffer); + merge(a, buffer, start, split, end); + merge_copy(buffer, a, start, end); + } +} + +fn merge(src: &Vec, dest: &mut Vec, start: usize, split: usize, end: usize) { + // Define cursor indices for the left and right part that will be merged + let mut left = start; + let mut right = split; + + // Merge the parts into the destination in the correct order + for i in start..end { + if left < split && (right >= end || src[left] <= src[right]) { + dest[i] = src[left]; + left += 1; + } else { + dest[i] = src[right]; + right += 1; + } + } +} + +fn merge_copy(src: &Vec, dest: &mut Vec, start: usize, end: usize) { + (start..end).for_each(|i| dest[i] = src[i]); +} + +fn read_values() -> Result, T::Err> { + let mut s = String::new(); + io::stdin() + .read_line(&mut s) + .expect("could not read from stdin"); + s.trim() + .split_whitespace() + .map(|word| word.parse()) + .collect() +} + +/* + + Sample Input : + + Enter the numbers to be sorted (separated by space) : + 76 56 45 3 1 4 + + Sample Output : + + Sorted array: [1, 3, 4, 45, 56, 76] +*/ + From 30a9f398e67f828d6ae50cfe721b31bfd662f741 Mon Sep 17 00:00:00 2001 From: Ankita Saloni Date: Sun, 26 Apr 2020 01:50:52 +0530 Subject: [PATCH 106/265] Created Ternary_Search.kt (#2745) Co-authored-by: Ankita Saloni <56873389+saloniankita23@users.noreply.github.com> --- Ternary_Search/Ternary_Search.kt | 77 ++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 Ternary_Search/Ternary_Search.kt diff --git a/Ternary_Search/Ternary_Search.kt b/Ternary_Search/Ternary_Search.kt new file mode 100644 index 000000000..65b82347a --- /dev/null +++ b/Ternary_Search/Ternary_Search.kt @@ -0,0 +1,77 @@ + import java.util.* + import kotlin.collections.ArrayList + + //Ternary Search begins + public fun ternarySearch(l:Int, r:Int, key:Int, ar:ArrayList): Int { + if(r>=1){ + var mid1 = l + (r - l) / 3 + var mid2 = r - (r - l) / 3 + + //Searching for the key element + if (ar[mid1] == key) { + return mid1 + } + + if (ar[mid2] == key) { + return mid2 + } + + if (key < ar[mid1]) { + return ternarySearch(l, mid1 - 1, key, ar) + } + + else if (key > ar[mid2]) { + return ternarySearch(mid2 + 1, r, key, ar) + } + + else { + return ternarySearch(mid1 + 1, mid2 - 1, key, ar) + } + } + return -1; +} + + //Main function + fun main() { + var l:Int = 0 + var r:Int + var p:Int + var key:Int + var scan1: Scanner = Scanner(System.`in`) + + //var ar = arrayOf(1,2,3,4,5,6,7,8,9,10) + var ar = ArrayList() + + //Taking input from user + println("Enter the number of elements: ") + var n:Int = scan1.nextInt() + var temp:Int + for (i in 1..n) { + temp = scan1.nextInt() + ar.add(temp) + } + + //Sorting the array + println("Sorting the array in ascending order...") + ar.sort() + r = ar.count() + println("Enter the key element to search for:") + key = scan1.nextInt() + p = ternarySearch(l, r, key, ar) + //Printing the key element with its position + print("Index of $key is $p \n") + + + /*Sample Input and Output + Enter the number of elements : + 6 + 5 + 4 + 3 + 2 + 1 + Sorting the array in ascending order... + Enter the key element to search for: + 5 + Index of 5 is 4 + */ From e43cc39e99e9855ff214659d1df9681709a5d7eb Mon Sep 17 00:00:00 2001 From: Anmol Kaur Date: Sun, 26 Apr 2020 14:11:51 +0530 Subject: [PATCH 107/265] added PHP/Heap sort (#2147) (#2737) --- Heap_Sort/heap_sort.php | 74 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 Heap_Sort/heap_sort.php diff --git a/Heap_Sort/heap_sort.php b/Heap_Sort/heap_sort.php new file mode 100644 index 000000000..f16b141cc --- /dev/null +++ b/Heap_Sort/heap_sort.php @@ -0,0 +1,74 @@ + $data[$index]) // If left child is larger than root + $largest = $left; + else + $largest = $index; + + if ($right < $heapSize && $data[$right] > $data[$largest]) // If right child is larger than largest so far + $largest = $right; + + if ($largest != $index) // If largest is not root + { + $temp = $data[$index]; + $data[$index] = $data[$largest]; + $data[$largest] = $temp; + + //Recursively heapify the affected sub-tree + MaxHeapify($data, $heapSize, $largest); + } +} + +function HeapSort(&$data, $count) { + $heapSize = $count; + + // Build heap (rearrange array) + for ($p = ($heapSize - 1) / 2; $p >= 0; $p--) + MaxHeapify($data, $heapSize, $p); + + // One by one extract an element from heap + for ($i = $count - 1; $i > 0; $i--) + { + $temp = $data[$i]; + $data[$i] = $data[0]; + $data[0] = $temp; + + $heapSize--; + MaxHeapify($data, $heapSize, 0); + } +} + +// example of driver function +$array = array(20 , 43 , 65 , 88 , 11 , 33 , 56 , 74); +HeapSort($array , 8); +print_r($array); + + // output + /*Array + ( + [0] => 11 + [1] => 20 + [2] => 33 + [3] => 65 + [4] => 43 + [5] => 56 + [6] => 74 + [7] => 88 + ) + +*/ + +?> From 85d70e506a8d4bd6d9d67c09d0aaca0f9517f93a Mon Sep 17 00:00:00 2001 From: monikajha <53649201+m-code12@users.noreply.github.com> Date: Tue, 28 Apr 2020 08:26:16 +0530 Subject: [PATCH 108/265] Bucket Sort in Ruby (#2759) --- Bucket_Sort/Bucket_Sort.rb | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Bucket_Sort/Bucket_Sort.rb diff --git a/Bucket_Sort/Bucket_Sort.rb b/Bucket_Sort/Bucket_Sort.rb new file mode 100644 index 000000000..92c906c86 --- /dev/null +++ b/Bucket_Sort/Bucket_Sort.rb @@ -0,0 +1,36 @@ +DEFAULT_BUCKET_SIZE = 5 + +def bucket_sort(input, bucket_size = DEFAULT_BUCKET_SIZE) + print 'Array is empty' if input.empty? + + array = input.split(' ').map(&:to_i) + + bucket_count = ((array.max - array.min) / bucket_size).floor + 1 + + # create buckets + buckets = [] + bucket_count.times { buckets.push [] } + + # fill buckets + array.each do |item| + buckets[((item - array.min) / bucket_size).floor].push(item) + end + + # sort buckets + buckets.each(&:sort!) + + buckets.flatten.join(' ') +end + +puts 'Enter a list of numbers (separated by space) : ' +list = gets +puts 'The sorted list is : ' +print bucket_sort(list) + + +# Output : +# Enter a list of numbers (separated by space) : +# 7 9 5 4 1 +# The sorted list is : +# 1 4 5 7 9 + From 8ca15ba84cf9391c82f163fd0e98ab5a1c74f6a2 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Tue, 28 Apr 2020 11:37:00 +0530 Subject: [PATCH 109/265] Topological Sort implemented in Dart (#2812) --- Topological_Sort/Topological_Sort.dart | 181 +++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 Topological_Sort/Topological_Sort.dart diff --git a/Topological_Sort/Topological_Sort.dart b/Topological_Sort/Topological_Sort.dart new file mode 100644 index 000000000..88d35a0b7 --- /dev/null +++ b/Topological_Sort/Topological_Sort.dart @@ -0,0 +1,181 @@ +/** + * Topological Sort implementation in Dart + * ------------------------------------------------------- + * + * In a directed acyclic graph, if there is an edge from u to v. Then, u comes before v. + * This observation has many real life application like scheduling tasks, ordering things etc.,. + * + * Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that + * for every directed edge uv, vertex u comes before v in the ordering. + * + * Topological sorting is an application of Depth First Search. + * + */ + + +// Importing required libraries +import 'dart:io'; +import 'dart:core'; + +// Class for a graph +class Graph{ + + // Number of vertices in a graph. + int vertices; + + // Adjacency list to store the graph. + List< List< int > > adjlist; + + // Constructor + Graph(int v){ + + // Assigning number of vertices + this.vertices = v; + + // Initializing the graph + this.adjlist = new List< List< int > >(vertices); + + for (int i = 0 ; i < vertices ; i ++){ + + this.adjlist[i] = new List< int >(); + + } + + } + + // Method to add an edge + void add_edge(int source , int destination){ + + this.adjlist[source].add(destination); + + } + + + // Utility method for Topological Sort + void topologicalSortUtil(int source , List< int > stack , List< bool > visited){ + + // Marking source vertex visited + visited[source] = true; + + int len = this.adjlist[source].length; + + // Recursively visiting it's neighbours + for (int i = 0 ; i < len ; i ++){ + + if (visited[adjlist[source][i]] == false){ + + // Recursive call + topologicalSortUtil(adjlist[source][i] , stack , visited); + + } + } + + // Adding to stack + stack.add(source); + + } + + // Method to find the topological sort + void topologicalSort(){ + + // Stack required to print the topological sort + List< int > stack = new List< int >(); + + // Initializing the visited list. + List< bool > visited = new List< bool >.generate(this.vertices , ( i ) => false); + + // Running the utility on all vertices to cover the entire graph. + for (int i = 0 ; i < this.vertices ; i ++){ + + if (visited[i] == false){ + + topologicalSortUtil(i , stack , visited); + + } + + } + + // Converting the elements in the stack into a string and printing them. + String s; + + List temp = new List< int >(); + + while ( ! stack.isEmpty ){ + + temp.add(stack.removeLast()); + + } + + s = temp.join(" "); + + // Printing the result + print(s); + + } + +} + +// Driver function of the program +void main(){ + + // Taking input of number of vertices + print("Enter number of vertices:"); + + var input = stdin.readLineSync(); + + int n = int.parse(input); + + Graph g = new Graph(n); + + // Taking input of number of edges + print("Enter number of edges:"); + + input = stdin.readLineSync(); + + int m = int.parse(input); + + // Taking input of edges + print("Enter edges for vertices in 0 - n range:"); + + for(int i = 0 ; i < m ; i ++){ + + input = stdin.readLineSync(); + + var lis = input.split(" "); + + List list1 = lis.map(int.parse).toList(); + + g.add_edge(list1[0] , list1[1]); + + } + + // Printing the result + print("Following is the topological sort of the input graph: "); + + g.topologicalSort(); + +} + +/* + + Sample Input + ---------------------- + Enter number of vertices: + 8 + Enter number of edges: + 7 + Enter edges for vertices in 0 - n range: + 0 1 + 0 4 + 1 7 + 1 2 + 2 3 + 4 5 + 5 6 + + Sample Output + ----------------------- + Following is the topological sort of the input graph: + 0 4 5 6 1 2 3 7 + +*/ From 19c851e5b62d7c998fff5c5e3c50c8a7424aa482 Mon Sep 17 00:00:00 2001 From: Bieky Mahato <60212331+biekymahato@users.noreply.github.com> Date: Wed, 29 Apr 2020 13:13:03 +0530 Subject: [PATCH 110/265] Implementation Of Tower of Hanoi in C# (#2599) Implementation Tower_Of_Hanoi in C# Tower Of Hanoi (c#) Modified the Tower of hanoi in C# Changes the folder Implementation of Tower of Hanoi in C# after required changes --- Tower_Of_Hanoi/Tower_of_Hanoi.cs | 93 ++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_of_Hanoi.cs diff --git a/Tower_Of_Hanoi/Tower_of_Hanoi.cs b/Tower_Of_Hanoi/Tower_of_Hanoi.cs new file mode 100644 index 000000000..8e190dfc0 --- /dev/null +++ b/Tower_Of_Hanoi/Tower_of_Hanoi.cs @@ -0,0 +1,93 @@ +/* +C# recursive program to solve +tower of hanoi puzzle */ +using System; + +class geek +{ + + // C# recursive function to solve Tower of Hanoi puzzle + static void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) + { + if (n == 1) + { + Console.WriteLine("Move disk 1 from rod " + from_rod + " to rod " + to_rod); + return; + } + towerOfHanoi(n-1, from_rod, aux_rod, to_rod); + Console.WriteLine("Move disk " + n + " from rod "+ from_rod + " to rod " + to_rod); + towerOfHanoi(n-1, aux_rod, to_rod, from_rod); + } + + // Driver method + public static void Main() + { + // Number of disks + int n; + String val; + + //Input taken + val = Console.ReadLine(); + n = Convert.ToInt32(val); + + // A, B and C are names of rods + towerOfHanoi(n, 'A', 'C', 'B'); + } +} + +/* +Input for Test Case 1: +4 //n = 4 +Output for Test Case 1: +Move disk 1 from rod A to rod B +Move disk 2 from rod A to rod C +Move disk 1 from rod B to rod C +Move disk 3 from rod A to rod B +Move disk 1 from rod C to rod A +Move disk 2 from rod C to rod B +Move disk 1 from rod A to rod B +Move disk 4 from rod A to rod C +Move disk 1 from rod B to rod C +Move disk 2 from rod B to rod A +Move disk 1 from rod C to rod A +Move disk 3 from rod B to rod C +Move disk 1 from rod A to rod B +Move disk 2 from rod A to rod C +Move disk 1 from rod B to rod C +*/ +/* +Input for Test Case 2: +5 //n = 5 +Output for Test case 2: +Move disk 1 from rod A to rod C +Move disk 2 from rod A to rod B +Move disk 1 from rod C to rod B +Move disk 3 from rod A to rod C +Move disk 1 from rod B to rod A +Move disk 2 from rod B to rod C +Move disk 1 from rod A to rod C +Move disk 4 from rod A to rod B +Move disk 1 from rod C to rod B +Move disk 2 from rod C to rod A +Move disk 1 from rod B to rod A +Move disk 3 from rod C to rod B +Move disk 1 from rod A to rod C +Move disk 2 from rod A to rod B +Move disk 1 from rod C to rod B +Move disk 5 from rod A to rod C +Move disk 1 from rod B to rod A +Move disk 2 from rod B to rod C +Move disk 1 from rod A to rod C +Move disk 3 from rod B to rod A +Move disk 1 from rod C to rod B +Move disk 2 from rod C to rod A +Move disk 1 from rod B to rod A +Move disk 4 from rod B to rod C +Move disk 1 from rod A to rod C +Move disk 2 from rod A to rod B +Move disk 1 from rod C to rod B +Move disk 3 from rod A to rod C +Move disk 1 from rod B to rod A +Move disk 2 from rod B to rod C +Move disk 1 from rod A to rod C +*/ From e6e79ba6f319e98fab4607f0e1d606e0d035d94b Mon Sep 17 00:00:00 2001 From: Debdut Goswami Date: Wed, 29 Apr 2020 14:42:26 +0530 Subject: [PATCH 111/265] Insertion Sort #2148 (#2806) --- Insertion_Sort/README.md | 130 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 Insertion_Sort/README.md diff --git a/Insertion_Sort/README.md b/Insertion_Sort/README.md new file mode 100644 index 000000000..d1add4837 --- /dev/null +++ b/Insertion_Sort/README.md @@ -0,0 +1,130 @@ +# INSERTION SORT + +[Insertion Sort](https://en.wikipedia.org/wiki/Insertion_Sort) is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. + +## EXAMPLE + +Given below is an unsorted array. `Insertion sort` takes O(n) time in Best Case and Ο(n2) time for Average and Worst Case. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/unsorted_array.jpg) + +`Insertion sort` compares the first two elements + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_1.jpg) + +It finds that both 14 and 33 are already in ascending order. For now, 14 is in sorted sub-list. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_2.jpg) + +Insertion sort moves ahead and compares 33 with 27. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_3.jpg) + +And finds that 33 is not in the correct position. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_4.jpg) + +It swaps 33 with 27. It also checks with all the elements of sorted sub-list. Here we see that the sorted sub-list has only one element 14, and 27 is greater than 14. Hence, the sorted sub-list remains sorted after swapping. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_5.jpg) + +By now we have 14 and 27 in the sorted sub-list. Next, it compares 33 with 10. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_6.jpg) + +These values are not in a sorted order. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_7.jpg) + +So we swap them. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_8.jpg) + +However, swapping makes 27 and 10 unsorted. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_9.jpg) + +Hence, we swap them too. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_10.jpg) + +Again we find 14 and 10 in an unsorted order. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_11.jpg) + +We swap them again. By the end of third iteration, we have a sorted sub-list of 4 items. + +![Insertion Sort](https://www.tutorialspoint.com/data_structures_algorithms/images/insertion_sort_12.jpg) + +This process goes on until all the unsorted values are covered in a sorted sub-list. Now we shall see some programming aspects of insertion sort. + +## ALGORITHM + +``` +Step 1 − If it is the first element, it is already sorted. return 1; +Step 2 − Pick next element +Step 3 − Compare with all elements in the sorted sub-list +Step 4 − Shift all the elements in the sorted sub-list that is greater than the value to be sorted +Step 5 − Insert the value +Step 6 − Repeat until list is sorted +``` + +## PSEUDOCODE + +Pseudocode of InsertionSort algorithm can be expressed as − + +``` +procedure insertionSort( A : array of items ) + int holePosition + int valueToInsert + + for i = 1 to length(A) inclusive do: + + /* select value to be inserted */ + valueToInsert = A[i] + holePosition = i + + /*locate hole position for the element to be inserted */ + + while holePosition > 0 and A[holePosition-1] > valueToInsert do: + A[holePosition] = A[holePosition-1] + holePosition = holePosition -1 + end while + + /* insert the number at hole position */ + A[holePosition] = valueToInsert + + end for + +end procedure +``` + +## COMPLEXITY + +**Time complexity** + +_Best Case_: O(n) + +_Average and Worst Case_: О(n2) + +where _n_ is the number of items being sorted. + +**Space complexity** - O(1), due to auxillary space only. + +## Implementation + +- [C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.c) + +- [CoffeeScript Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.coffee) + +- [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.cpp) + +- [C# Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.cs) + +- [Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.java) + +- [JavaScript Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.js) + +- [PHP Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.php) + +- [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Insertion_Sort/Insertion_Sort.py) From f6ca8c26197ceda9653eb8fa06745177066b514d Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Wed, 29 Apr 2020 16:48:47 +0530 Subject: [PATCH 112/265] Segment Tree RMQ implemented in Dart (#2799) --- Segment_Tree_RMQ/Segment_Tree_RMQ.dart | 230 +++++++++++++++++++++++++ 1 file changed, 230 insertions(+) create mode 100644 Segment_Tree_RMQ/Segment_Tree_RMQ.dart diff --git a/Segment_Tree_RMQ/Segment_Tree_RMQ.dart b/Segment_Tree_RMQ/Segment_Tree_RMQ.dart new file mode 100644 index 000000000..8aa67af20 --- /dev/null +++ b/Segment_Tree_RMQ/Segment_Tree_RMQ.dart @@ -0,0 +1,230 @@ +/** + * Dart implementation of Segment Tree for Range Minimum Query + * ------------------------------------------------------------------------- + * Segment Tree is a binary tree whose nodes are ranges of an interval. + * Each node has a value corresponding to it's interval. + * Construction of a Segment Tree takes O(n) time. + * Querying on the same takes O(logn) time. + * Hence, many queries can be answered efficiently in time using Segment Tree. + * + * +*/ + +// Importing required libraries +import 'dart:io'; +import 'dart:math'; + +// Maximum range of int of 64 bits. +const int int64MaxValue = 9223372036854775807; + +// Function to find logarithm to base 2. +double logtobase2(int n){ + + return log(n) / log(2); + +} + +// Function to update value at a particular position in the tree +void updateNode(List tree , int treestart , int treeend , int nodeindex , int position , int newval){ + + if (treestart == treeend){ + + tree[nodeindex] = newval; + + } + else{ + + int mid = (treestart + ((treeend - treestart) / 2)).floor(); + + if (position < mid){ + + updateNode(tree , treestart , mid , 2 * nodeindex , position , newval); + + } + else{ + + updateNode(tree , mid + 1 , treeend, 2 * nodeindex + 1 , position, newval); + + } + + tree[nodeindex] = min(tree[2 * nodeindex] , tree[2 * nodeindex + 1]); + + } + +} + +// Function to query on a Segment Tree +int queryonSegmentTree(List tree , int start , int end , int treestart , int treeend , int nodeindex){ + + if (start > end){ + + return int64MaxValue; + + } + + // Base Case + if (start == treestart && end == treeend){ + + return tree[nodeindex]; + + } + + // Finding the index of midpoint + int mid = (treestart + (treeend - treestart) / 2).floor(); + + int value1 , value2; + + + // Recursion to find the minimum. + value1 = queryonSegmentTree(tree , start , min(end,mid) , treestart , mid , 2 * nodeindex ); + + value2 = queryonSegmentTree(tree , max(start , mid + 1) , end , mid + 1 , treeend , 2 * nodeindex + 1 ); + + // Returning minimum. + return min(value1 , value2); + +} + +// Function to construct the Segment Tree. +void constructSegmentTree(List tree , List numbers , int start , int end , int nodeindex){ + + // Base Case + if (start == end){ + + tree[nodeindex] = numbers[start]; + return; + + } + + // Finding index of the midpoint. + int mid = (start + ((end - start) / 2)).floor(); + + // Recursion to find minimum. + constructSegmentTree(tree , numbers , start , mid , 2 * nodeindex); + + constructSegmentTree(tree , numbers , mid + 1 , end , 2 * nodeindex + 1); + + // Finding minimum of the parent from its children. + tree[nodeindex] = min(tree[2 * nodeindex],tree[2 * nodeindex + 1]); + +} + +// Driver function of the program. +void main(){ + + // Taking input of number of array elements. + print("Enter number of elements: "); + + var input = stdin.readLineSync(); + + int n = int.parse(input); + + // Taking input of the number array (num[i]). + print("Enter array of numbers:"); + + input = stdin.readLineSync(); + + var lis = input.split(' '); + + List numbers = lis.map(int.parse).toList(); + + // Calculating the depth of the possible binary tree. + int depth = logtobase2(n).ceil(); + // Finding the maximum number of nodes in the binary tree. + int num_nodes = 2 * pow(2 , depth) - 1; + + // Initializing the Segment tree. + List tree = List.generate(num_nodes + 1 , (i) => 0); + + // Constructing the Segment Tree. + constructSegmentTree(tree , numbers , 0 , n - 1 , 1); + + // Taking input of number of queries. + print("Enter number of queries: "); + + input = stdin.readLineSync(); + + int q = int.parse(input); + + List queries = List(2); + + int flag; + + + // Taking input of queries. + print("Enter queries: "); + + for (int i = 0 ; i < q ; i ++){ + + print("Enter 1 to retrieve minimum in a range or 2 to update a value: "); + + input = stdin.readLineSync(); + + flag = int.parse(input); + + print("Enter corresponding query: "); + + input = stdin.readLineSync(); + + lis = input.split(' '); + + queries = lis.map(int.parse).toList(); + + if (flag == 2){ + + numbers[queries[0]] = queries[1]; + updateNode(tree , 0 , n - 1 , 1 , queries[0] , queries[1]); + + } + else{ + + // Printing output of each query. + print(queryonSegmentTree(tree , queries[0] , queries[1] , 0 , n - 1 , 1)); + + } + + } + +} + +/** + * + * Sample Input & Output + * --------------------------- + * Enter number of elements: + * 10 + * Enter array of numbers: + * 12 43 9 -2 1 8 6 5 10 23 + * Enter number of queries: + * 6 + * Enter queries: + * Enter 1 to retrieve minimum in a range or 2 to update a value: + * 1 + * Enter corresponding query: + * 1 2 + * 9 (Output) + * Enter 1 to retrieve minimum in a range or 2 to update a value: + * 2 + * Enter corresponding query: + * 0 -12 + * Enter 1 to retrieve minimum in a range or 2 to update a value: + * 1 + * Enter corresponding query: + * 1 2 + * -12 (Output) + * Enter 1 to retrieve minimum in a range or 2 to update a value: + * 2 + * Enter corresponding query: + * 7 -100 + * Enter 1 to retrieve minimum in a range or 2 to update a value: + * 1 + * Enter corresponding query: + * 4 9 + * -100 (Output) + * Enter 1 to retrieve minimum in a range or 2 to update a value: + * 1 + * Enter corresponding query: + * 2 6 + * -2 (Output) + * + */ From 35880677b465d602e63d58bb8104c2cecd2def29 Mon Sep 17 00:00:00 2001 From: Anushka-Rajvanshi <60550664+Anushka-Rajvanshi@users.noreply.github.com> Date: Thu, 30 Apr 2020 14:59:18 +0530 Subject: [PATCH 113/265] Added Chinese remainder theorem in C. (#2832) --- .../Chinese_remainder_theorem.c | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 Chinese_Remainder_Theorem/Chinese_remainder_theorem.c diff --git a/Chinese_Remainder_Theorem/Chinese_remainder_theorem.c b/Chinese_Remainder_Theorem/Chinese_remainder_theorem.c new file mode 100644 index 000000000..0ace268c5 --- /dev/null +++ b/Chinese_Remainder_Theorem/Chinese_remainder_theorem.c @@ -0,0 +1,64 @@ +#include + +//function to find minimum number such that num%divisor[i] gives corresponding remainder[i] +int minresult( int divisor[], int rem[], int size) +{ + int m = 1, M[size], inv[size], i, k, count, x = 0; + for (i = 0; i < size; i++) + { + m = m * divisor[i]; + } + for (i = 0; i < size; i++) + { + M[i] = m / divisor[i]; + } + for (i = 0; i < size; i++) + { + count = 0; + k = 1; + do + { + if(((M[i] % divisor[i]) * k) % divisor[i] == 1) + { + inv[i] = k; + count++; + } + k++; + }while(count == 0); + } + for (i = 0; i < size; i++) + { + x = x + (rem[i] * M[i] * inv[i]); //according to CRT + } + x = x % m; + return x; +} + +int main() +{ + int size, i, divisor[100], rem[100]; + //input size of array in variable size + printf("Enter size of array:"); + scanf("%d", &size); + //input divisor values and then remainder values + printf("Enter value of coprime divisors:"); + for (i = 0; i < size; i++ ) + { + scanf("%d", &divisor[i]); + } + printf("Enter value of remainders:"); + for (i = 0; i < size; i++ ) + { + scanf("%d", &rem[i]); + } + //function call to find result. + printf("Answer is: %d ", minresult( divisor, rem, size)); + return 0; +} + +/* Sample input-output: +Enter size of array:3 +Enter value of coprime divisors:2 3 5 +Enter value of remainders:1 2 4 +Answer is: 29 +*/ From 1457fe4cc45fe81e42d4cb7b988eb7b141c4bc53 Mon Sep 17 00:00:00 2001 From: Subhradeep Saha Date: Fri, 1 May 2020 15:02:42 +0530 Subject: [PATCH 114/265] Gray Code generation of any input bit length (#2005) --- Gray_Code/Gray_Code.cpp | 53 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 Gray_Code/Gray_Code.cpp diff --git a/Gray_Code/Gray_Code.cpp b/Gray_Code/Gray_Code.cpp new file mode 100644 index 000000000..2c349500b --- /dev/null +++ b/Gray_Code/Gray_Code.cpp @@ -0,0 +1,53 @@ +//C++ program to generate the Gray Code for any input bit length + +#include +#define pb push_back +using namespace std; + +// Function to generate the Gray Code sequence +void Gray(int n){ + //If input size is less than or equal to 0 + if(n <= 0){ + cout << "Invalid input"; + return; + } + + vector v; + v.pb("0"); + v.pb("1"); + + for(int i = 2; i < (1 << n); i <<= 1){ + for(int j = i - 1; j >= 0; j--) + v.pb(v[j]); + + for(int j = 0; j < i; j++) + v[j] = "0" + v[j]; + + for(int j = i; j < 2 * i; j++) + v[j] = "1" + v[j]; + } + + cout << "Gray Code for bit length = " << n << " : " << endl; + + for(int i = 0; i < v.size(); i++) + cout << v[i] << endl; +} + +int main(){ + int n; + cout << "Enter the bit length for Gray Code generation : "; + cin >> n; + Gray(n); +} + +/* Sample input-output +Enter the bit length for Gray Code generation : 3 +Gray Code for bit length = 3 : +000 +001 +011 +010 +110 +111 +101 +100 */ From bcccc63f22d43c47690c170d0a0fc560477bde97 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Fri, 1 May 2020 15:28:56 +0530 Subject: [PATCH 115/265] Karatsuba Algorithm In GO (#2817) Updated Changes --- Karatsuba_Algorithm/Karatsuba_Algorithm.go | 136 +++++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 Karatsuba_Algorithm/Karatsuba_Algorithm.go diff --git a/Karatsuba_Algorithm/Karatsuba_Algorithm.go b/Karatsuba_Algorithm/Karatsuba_Algorithm.go new file mode 100644 index 000000000..19f3ceba6 --- /dev/null +++ b/Karatsuba_Algorithm/Karatsuba_Algorithm.go @@ -0,0 +1,136 @@ +// Karatsuba Algorithm In GO + +/** + +The Karatsuba Algorithm is a fast multiplication algorithm. +It was discovered by Anatoly Karatsuba in 1960. It reduces +the multiplication of two n-digit numbers to at most single +digit multiplications in general. It is therefore faster +than classical multiplication operation. + +*/ + +package main + +// Importing Necessary Packages +import +( + "fmt" + "math" +) + +// Input Function To Get The Digits +func getDigits(number int64) uint { + + var ans uint + + if number == 0 { + return 1 + } + + if number < 0 { + number = -number + } + + for number > 0 { + ans++ + number = number / 10 + } + + return ans +} + +func getHighAndLowDigits(num int64, digits uint) (int64, int64) { + + divisor := int64(math.Pow(10, float64(digits))) + + if num >= divisor { + return num / divisor, num % divisor + } + else { + return 0, num + } +} + +// Karatsuba Algorithm Function +func karatsuba(x int64, y int64) int64 { + + var max_digits uint + positive := true + + if x == 0 || y == 0 { + return 0 + } + + if (x > 0 && y < 0) || (x < 0 && y > 0) { + positive = false + } + + if x < 0 { + x = -x + } + + if y < 0 { + y = -y + } + + if x < 10 || y < 10 { + return x * y + } + + x_digits := getDigits(x) + y_digits := getDigits(y) + + if x_digits >= y_digits { + max_digits = x_digits / 2 + } + else { + max_digits = y_digits / 2 + } + + x_high, x_low := getHighAndLowDigits(x, max_digits) + y_high, y_low := getHighAndLowDigits(y, max_digits) + + z0 := karatsuba(x_low, y_low) + z1 := karatsuba((x_low + x_high), (y_low + y_high)) + z2 := karatsuba(x_high, y_high) + + if positive { + return (z2 * int64(math.Pow(10, float64(2 * max_digits)))) + + (z1 - z2 - z0) * int64(math.Pow(10, float64(max_digits))) + z0 + } + else { + return -((z2 * int64(math.Pow(10, float64(2 * max_digits)))) + + (z1 - z2 - z0) * int64(math.Pow(10, float64(max_digits))) + z0) + } +} + +// Main Function & Taking User Inputs +func main() { + + fmt.Println("Enter the first number: ") + var first int64 + fmt.Scanln(&first) + + fmt.Println("Enter the second number: ") + var second int64 + fmt.Scanln(&second) + fmt.Println() + + fmt.Print("Result: ") + fmt.Println(karatsuba(first, second)) +} + +/** + +Enter the first number: 121547 +Enter the second number: 1855324 + +Result: 225509066228 + +Enter the first number: -8859460 +Enter the second number: 1154486 + +Result: -10228122537560 + +*/ From 565a6e8c43fd7e33204fa1d0ad5ffdfb4c8a7a55 Mon Sep 17 00:00:00 2001 From: shweta gurnani <43384092+shwetagurnani@users.noreply.github.com> Date: Sat, 2 May 2020 17:09:27 +0530 Subject: [PATCH 116/265] Postman sort readme added (#2829) --- Postman_Sort/readme.md | 104 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 Postman_Sort/readme.md diff --git a/Postman_Sort/readme.md b/Postman_Sort/readme.md new file mode 100644 index 000000000..fc4ef136d --- /dev/null +++ b/Postman_Sort/readme.md @@ -0,0 +1,104 @@ +# Postman Sort + +Postman sort works by sorting the integers of an array from their most significant digits to their least +significant digits. In the Postman sort the integer having most significant digits and the number of +elements in that integer is determined, the length of the longest integer is stored. All the elements in the +array are divided by a particular base. The elements of the array are sorted on the basis of the most significant +digit to the least significant digit i.e. from leftmost to rightmost digit. + +## Example + +Let's arrange the numbers in ascending order using postman sort. + +- Unsorted List + +The input array contains 7 elements which are {25, 432, 788, 130, 23, 121, 564} + +- Iteration 1 + +The elements of the array being sorted on the basis of the most significant digit, *it becomes {25, 23, 130, 121, 432, 564, 788}* + +- Iteration 2 + +The elements of the array being sorted on the basis of the second most significant digit, *it becomes {25, 23, 121, 130, 432, 564, 788}* + +- Iteration 3 + +At last those elements of the array are compared which have same value of significant digit and if they are not in correct +order, the elements gets swapped and are arranged in desired order. The array after getting sorted *becomes +{23, 25, 121, 130, 432, 564, 788}* + +*In this way the elements of the array are sorted on the basis of their significant digits.* + +## Algorithm + +1.Compare the leftmost digit of the elements of the array then the next to it and so on.
+ +2.If the elements are not in correct order swap them according to their significant digit.
+ +3.The function recurses which compares the elements having same value of significant digit and arranges the elements in correct order.
+ +## Pseudocode +``` +declare temp, max, count, maxdigits = 0, c = 0 +declare t1, t ,i, j +Initialise n = 1 +Input the number of elements in the array and store their values in arr[], arr1[] +for(i = 0; i < count; i++) + t = arr[i] + while(t > 0) + c++ + t = t/10 + if(maxdigits < c) + maxdigits = c + c = 0 + +for(i = 0; i < maxdigits; i++) + n = n * 10 +for(i = 0; i < count; i++) + max = arr[i] / n + t = i + for(j = i + 1; j < count; j++) + if(max > (arr[j] / n)) + max = arr[j] / n + t = j + temp = arr1[t] + arr1[t] = arr1[i] + arr1[i] = temp + temp = arr[t] + arr[t] = arr[i] + arr[i] = temp +while(n >= 1) + for(i = 0; i < count;) + t1 = arr[i] / n + for(j = i + 1; t1 == (arr[j]/n); j++); + arrange(i, j) + i = j + n = n / 10 + +void arrange(int k, int n) + for(i = k; i < n - 1; i++) + for(j = i + 1; j < n; j++) + if(arr1[i] > arr[j]) + temp = arr1[i] + arr1[i] = arr1[j] + arr1[j] = temp + temp = arr[i] % 10 + arr[i] = arr[j] % 10 + arr[j] = temp + +``` + +## Complexity + + Time Complexity = d * (n + k) + Space Complexity = n + 2^d + +where +>d = number of digits
+>n = number of keys
+>k = size of bucket + +## Implementation +* [C# Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Postman_Sort/Postman_Sort.cs) + From 8f33b4e6b565827a15d54e2bf8cc52e784e7456f Mon Sep 17 00:00:00 2001 From: Arkadip Bhattacharya Date: Sat, 2 May 2020 20:23:38 +0530 Subject: [PATCH 117/265] Added Boyer_Moore_Algorithm in Kotlin (#2813) --- Boyer_Moore_Algorithm/Boyer_Moore.kt | 78 ++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Boyer_Moore_Algorithm/Boyer_Moore.kt diff --git a/Boyer_Moore_Algorithm/Boyer_Moore.kt b/Boyer_Moore_Algorithm/Boyer_Moore.kt new file mode 100644 index 000000000..5bc69cb02 --- /dev/null +++ b/Boyer_Moore_Algorithm/Boyer_Moore.kt @@ -0,0 +1,78 @@ +/* +Boyer Moore String Matching Algorithm in Kotlin +Author: Arkadip Bhattacharya (@darkmatter18) + */ +import java.util.* + +internal object Main { + private var NO_OF_CHARACTERS = 256 + private fun maxOfAAndB(a: Int, b: Int): Int { + return a.coerceAtLeast(b) + } + + private fun badCharacterHeuristic(str: CharArray, size: Int, badcharacter: IntArray) { + + // Initialize all elements of bad character as -1 + var i = 0 + while (i < NO_OF_CHARACTERS) { + badcharacter[i] = -1 + i++ + } + // Fill the actual value of last occurrence of a character + i = 0 + while (i < size) { + badcharacter[str[i].toInt()] = i + i++ + } + } + + // A pattern searching function + private fun search(text: CharArray, pattern: CharArray) { + val m = pattern.size + val n = text.size + val badCharacterHeuristic = IntArray(NO_OF_CHARACTERS) + + // Fill the bad character array by calling the preprocessing function + badCharacterHeuristic(pattern, m, badCharacterHeuristic) + + // s is shift of the pattern with respect to text + var s = 0 + while (s <= n - m) { + var j = m - 1 + + // Keep reducing index j of pattern while characters of pattern and text are matching at this shift s + while (j >= 0 && pattern[j] == text[s + j]) j-- + + // If the pattern is present at current shift, then index j will become -1 after the above loop + s += if (j < 0) { + println("Patterns occur at shift = $s") + + // Shift the pattern so that the next character in text aligns with the last occurrence of it in pattern. + // The condition s+m < n is necessary for the case when pattern occurs at the end of text + if (s + m < n) m - badCharacterHeuristic[text[s + m].toInt()] else 1 + } else maxOfAAndB(1, j - badCharacterHeuristic[text[s + j].toInt()]) + } + } + + /* Driver program*/ + @JvmStatic + fun main(args: Array) { + val sc = Scanner(System.`in`) + var s = sc.nextLine() + val text = s.toCharArray() + s = sc.nextLine() + val pattern = s.toCharArray() + search(text, pattern) + } +} + +/* +Sample Input: +AABAACAADAABAABA +AABA + +Sample Output: +Patterns occur at shift = 0 +Patterns occur at shift = 9 +Patterns occur at shift = 12 + */ From 1e9cf085d8ba896c6d7f07955842e9f40b41f04e Mon Sep 17 00:00:00 2001 From: Muskan Jaiswal <60754388+codermuskanj@users.noreply.github.com> Date: Sat, 2 May 2020 21:10:50 +0530 Subject: [PATCH 118/265] 'c++_implementation_of_RSA_CRT' (#2724) 'modified' 'modified0' 'update11' Co-authored-by: abc --- RSA_CRT/RSA_CRT.cpp | 90 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 RSA_CRT/RSA_CRT.cpp diff --git a/RSA_CRT/RSA_CRT.cpp b/RSA_CRT/RSA_CRT.cpp new file mode 100644 index 000000000..7518643d4 --- /dev/null +++ b/RSA_CRT/RSA_CRT.cpp @@ -0,0 +1,90 @@ +#include +using namespace std; + +// gcd function +long long int egcd (long long int a, long long int b) { + int rem; + + while (b != 0) { + rem = a % b; + a = b; + b = rem; + } + return a; +} + +// modular inversion function +long long int findInv (long long int x, long long int y, long long int n) { + long long int d = 2, temp; + + while (d < n) { + temp = ((d * x) - 1) % y; + if (temp == 0) + break; + d ++; + } + return d; +} + +// m is message to be encrypted, 1 < m < n +int main() { + long long int m, p, q, n, e, c, m1 = 1, m2 = 1, c11; + long long int phi, dP, dQ, qInv, h, message; + + cout << "Enter the message \n"; + cin >> m; + + // p and q are two random prime numbers + cout << "Enter two prime numbers"; + cin >> p; + cin >> q; + n = p * q; + + // eulers toitent function + phi = (p - 1) * (q - 1); + + // (n, e) forms our public key , 1 < e < phi + e = 2; + while ( e < phi) { + if (egcd (e, phi) == 1) + break; + e ++; + } + + //calculating CRT exponents dP, dQ and qInv to make calculations shorter and faster + dP = findInv (e , p - 1, n); + dQ = findInv (e , q - 1 , n); + qInv = findInv (q, p, n); + + //printing ciper text + c11 = pow (m, e); + c = c11 % n; + cout << "Cipher = " << c << "\n"; + + //printing original message + for (int i = 1; i <= dP; i++) { + m1 = ( m1 * c) % p; + } + + for(int i = 1; i <= dQ; i++) { + m2 = (m2 * c) % q; + } + h = (qInv * (m1 + p - m2)) % p; + message = m2 + (h * q); + cout << "Orignal message = " << message << "\n"; + + return 0; +} + +/* +Input : +Enter the message +1331 +Enter two prime numbers +131 +137 +Output : +Cipher = 16990 +Orignal Message = 1331 +*/ + From e5f9fda3ca3ea90857f3e2e2676a8c9d94535d55 Mon Sep 17 00:00:00 2001 From: Muskan Jaiswal <60754388+codermuskanj@users.noreply.github.com> Date: Sat, 2 May 2020 21:14:37 +0530 Subject: [PATCH 119/265] 'Python_Implementation_of_Rabin_Karp' (#2728) 'updated0' 'updated1' 'modified11' Co-authored-by: abc --- Rabin_Karp/Rabin_Karp.py | 57 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 Rabin_Karp/Rabin_Karp.py diff --git a/Rabin_Karp/Rabin_Karp.py b/Rabin_Karp/Rabin_Karp.py new file mode 100644 index 000000000..5eaa02854 --- /dev/null +++ b/Rabin_Karp/Rabin_Karp.py @@ -0,0 +1,57 @@ +# Rabin Karp Algorithm + +# AN : range or No of alphabets +# val : AN ^ patlen-1 +# patlen : pattern length +# PN: any prime no given input from main +# Time-Complexity:- +# The average case running time of the Rabin-Karp algorithm = O(n + m). +# The best case running time of the Rabin-Karp algorithm = O(n + m). +# The worst-case running time of the Rabin-Karp algorithm = O(n * m). + +AN = 256 + +def search (pattern, text, PN ) : + + patlen = len(pattern) # pattern length + txtlen = len(text) # text length + val = 1 + hpat = 0 # pattern hash value + htxt = 0 # text hash value + i = 0 + j = 0 + + for i in range (patlen - 1) : + val = (val * AN) % PN # PN is a prime number + + for i in range (patlen) : + hpat = (AN * hpat + ord(pattern[i])) % PN + htxt = (AN * htxt + ord(text[i])) % PN + + for i in range (txtlen - patlen + 1) : + if hpat == htxt : + for j in range (patlen) : + if text[i + j] != pattern[j]: + break + j += 1 + if j == patlen : + print( "Found at index starting from " + str(i)) + + # calculate the new position including i + m + if i < txtlen - patlen : + htxt = (AN * (htxt - ord(text[i]) * val) + ord(text[i + patlen])) % PN + + if htxt < 0 : + htxt = htxt + PN + +# Driver program +text = input() +pattern = input() +PN = 101 # Prime number +search (pattern, text, PN) + +# Input:-XWINGO XOR WINGO +# WINGO +# 101 +# OUTPUT:-Found at index starting from 1 +# Found at index starting from 11 From 1f212dd5d6541f6cad4bd8421957cbb526c15e4f Mon Sep 17 00:00:00 2001 From: Bhuwan Chandra Date: Sat, 2 May 2020 21:21:52 +0530 Subject: [PATCH 120/265] implementation dijkstra algo in ts (#2732) --- Dijkstra_Algorithm/Dijkstra_Algorithm.ts | 173 +++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 Dijkstra_Algorithm/Dijkstra_Algorithm.ts diff --git a/Dijkstra_Algorithm/Dijkstra_Algorithm.ts b/Dijkstra_Algorithm/Dijkstra_Algorithm.ts new file mode 100644 index 000000000..61b630b60 --- /dev/null +++ b/Dijkstra_Algorithm/Dijkstra_Algorithm.ts @@ -0,0 +1,173 @@ +// Description: Function to perform the Dijkstra algorithm on a weighted graph +// Expected Output: returns the shorted path + +// class for new node +class NewNode { + val: string; + priority: number; + constructor(val: string, priority: number) { + this.val = val; + this.priority = priority; + } +} + +// class for graph +class WeightedGraph { + adjacencyList: {}; + constructor() { + this.adjacencyList = {}; + } + // function to add vertex on graph + addVertex = (vertex: string) => { + if (!this.adjacencyList[vertex]) this.adjacencyList[vertex] = []; + }; + + // function to add weight of the edge between two vertices + addEdge = (vertex1: string, vertex2: string, weight: number) => { + this.adjacencyList[vertex1].push({ node: vertex2, weight }); + this.adjacencyList[vertex2].push({ node: vertex1, weight }); + }; + + // main function to implement Dijkstra Algorithm from start to end node + DijkstraFunction = (start: string, finish: string) => { + const nodes: PriorityQueue = new PriorityQueue(); + const distances = {}; + const previous = {}; + // to return at end + let path = []; + let smallest; + + // build up initial state + for (let vertex in this.adjacencyList) { + if (vertex === start) { + distances[vertex] = 0; + nodes.enqueue(vertex, 0); + } else { + distances[vertex] = Infinity; + nodes.enqueue(vertex, Infinity); + } + previous[vertex] = null; + } + + // as long as there is something to visit, visit the node + while (nodes.values.length) { + smallest = nodes.dequeue().val; + if (smallest === finish) { + // reached the end , need to form the path now and return + while (previous[smallest]) { + path.push(smallest); + smallest = previous[smallest]; + } + break; + } + + if (smallest || distances[smallest] !== Infinity) { + for (let neighbor in this.adjacencyList[smallest]) { + // find neighboring node + let nextNode = this.adjacencyList[smallest][neighbor]; + // calculate new distance to neighboring node + let candidate = distances[smallest] + nextNode.weight; + let nextNeighbor = nextNode.node; + if (candidate < distances[nextNeighbor]) { + // updating new smallest distance to neighbor + distances[nextNeighbor] = candidate; + // updating previous - How we got to neighbor + previous[nextNeighbor] = smallest; + // enqueue in priority queue with new priority + nodes.enqueue(nextNeighbor, candidate); + } + } + } + } + return path.concat(smallest).reverse(); + }; +} + +// class defnition for Priority Queue +class PriorityQueue { + values: NewNode[]; + constructor() { + this.values = []; + } + enqueue = (val: string, priority: number) => { + let newNode = new NewNode(val, priority); + this.values.push(newNode); + this.bubbleUp(); + }; + bubbleUp = () => { + let idx: number = this.values.length - 1; + const element: NewNode = this.values[idx]; + while (idx > 0) { + let parentIdx: number = Math.floor((idx - 1) / 2); + let parent: NewNode = this.values[parentIdx]; + if (element.priority >= parent.priority) break; + this.values[parentIdx] = element; + this.values[idx] = parent; + idx = parentIdx; + } + }; + dequeue = () => { + const min: NewNode = this.values[0]; + const end: NewNode = this.values.pop(); + if (this.values.length > 0) { + this.values[0] = end; + this.sinkDown(); + } + return min; + }; + sinkDown = () => { + let idx: number = 0; + const length: number = this.values.length; + const element: NewNode = this.values[0]; + while (true) { + let leftChildIdx: number = 2 * idx + 1; + let rightChildIdx: number = 2 * idx + 2; + let leftChild: NewNode, rightChild: NewNode; + let swap: number = null; + if (leftChildIdx < length) { + leftChild = this.values[leftChildIdx]; + if (leftChild.priority < element.priority) swap = leftChildIdx; + } + if (rightChildIdx < length) { + rightChild = this.values[rightChildIdx]; + if ( + (swap === null && rightChild.priority < element.priority) || + (swap !== null && rightChild.priority < leftChild.priority) + ) + swap = rightChildIdx; + } + if (swap === null) break; + this.values[idx] = this.values[swap]; + this.values[swap] = element; + idx = swap; + } + }; +} + +function main() { + const wtdGraph = new WeightedGraph(); + // INPUT WEIGHTED GRAPH + // adding vertices of the graph + wtdGraph.addVertex("A"); + wtdGraph.addVertex("B"); + wtdGraph.addVertex("C"); + wtdGraph.addVertex("D"); + wtdGraph.addVertex("E"); + wtdGraph.addVertex("F"); + // addition weight of the edges + wtdGraph.addEdge("A", "B", 1); + wtdGraph.addEdge("A", "C", 3); + wtdGraph.addEdge("B", "E", 2); + wtdGraph.addEdge("C", "D", 4); + wtdGraph.addEdge("C", "F", 5); + wtdGraph.addEdge("D", "E", 3); + wtdGraph.addEdge("D", "F", 1); + wtdGraph.addEdge("E", "F", 2); + + // running the algorithm for the ghraph + const output = wtdGraph.DijkstraFunction("A", "F"); + // OUTPUT OF wtdGraph + console.log(output); //[ 'A', 'B', 'E', 'F'] +} + +main(); From df1e034cb211758f0af5474f55d1d2ee6b3720ab Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Sat, 2 May 2020 21:27:14 +0530 Subject: [PATCH 121/265] Floyd Warshall Algorithm In Ruby (#2758) Updated Changes Updated Minor Changes Updated Changes Final Changes --- .../Floyd_Warshall_Algorithm.rb | 96 +++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.rb diff --git a/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.rb b/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.rb new file mode 100644 index 000000000..c416f3b36 --- /dev/null +++ b/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.rb @@ -0,0 +1,96 @@ +## Floyd Warshall Algorithm In Ruby + +def floyd_warshall(node, edge) + dist = Array.new(node){|i| Array.new(node){|j| i == j ? 0 : Float::INFINITY}} + next_node = Array.new(node){Array.new(node)} + edge.each do |u, v, w| + dist[u - 1][v - 1] = w + next_node[u - 1][v - 1] = v - 1 + end + + node.times do |k| + node.times do |i| + node.times do |j| + if dist[i][j] > dist[i][k] + dist[k][j] + dist[i][j] = dist[i][k] + dist[k][j] + next_node[i][j] = next_node[i][k] + end + end + end + end + + ## Displaying The Output + puts "Pair Distance Path" + node.times do |i| + node.times do |j| + next if i == j + u = i + path = [u] + path << (u = next_node[u][j]) while u != j + path = path.map{|u| u + 1}.join(" -> ") + puts "%d -> %d %6d %s" % [i + 1, j + 1, dist[i][j], path] + end + end +end + +## User Input For Number Of Nodes +puts "Enter the number of Nodes: " +nodes = gets.to_i + +## User Input For Number Of Edge Pairs +puts "Enter number of Edge Pairs: " +pair = gets.to_i + +puts "\nFor Edge Matrix, Enter Starting Node, Ending Node & Distance Between Them..." + +edge_matrix = Array.new(pair) { Array.new(3) } + +i = 0 +counter = 0 + +while(counter != pair) + i = 0 + puts "\nEnter the values of row #{counter + 1}: " + while(i != 3) + edge_matrix[counter][i] = gets.to_i + i += 1 + end + counter += 1 +end + +puts + +floyd_warshall(nodes, edge_matrix) + += begin + +Enter the number of Nodes: 4 +Enter number of Edge Pairs: 5 + +For Edge Matrix, Enter Starting Node, Ending Node & Distance Between Them... + +Enter the values of row 1: 1 3 -2 + +Enter the values of row 2: 2 1 4 + +Enter the values of row 3: 2 3 3 + +Enter the values of row 4: 3 4 2 + +Enter the values of row 5: 4 2 -1 + +Pair Distance Path +1 -> 2 -1 1 -> 3 -> 4 -> 2 +1 -> 3 -2 1 -> 3 +1 -> 4 0 1 -> 3 -> 4 +2 -> 1 4 2 -> 1 +2 -> 3 2 2 -> 1 -> 3 +2 -> 4 4 2 -> 1 -> 3 -> 4 +3 -> 1 5 3 -> 4 -> 2 -> 1 +3 -> 2 1 3 -> 4 -> 2 +3 -> 4 2 3 -> 4 +4 -> 1 3 4 -> 2 -> 1 +4 -> 2 -1 4 -> 2 +4 -> 3 1 4 -> 2 -> 1 -> 3 + += end From 99c78512ec2f4e37ad0c752b4544ba2b9027f164 Mon Sep 17 00:00:00 2001 From: "Kesha K. Kaneria" <46588494+keshakaneria@users.noreply.github.com> Date: Sat, 2 May 2020 21:48:36 +0530 Subject: [PATCH 122/265] Linear Search in dart language (#2838) linear search algorithm in dart Binary search in dart language Binary search algorithm in dart language deleting file to create same in new branch deleting binary search from master branch Binary Search in Dart language Binary search algorithm in dart Deleting this irrelevant file of linear search Change in deleting file as requested binary search code with dynamic user values dynamic values taken with sample input and output deleting irrelevant file deleting unused file Binary search tree in dart language binary search tree to search element and insert and display in pre/in/post order Renamed Binary_Search_Tree to BinarySearchTree renamed corrected indentation and removed spaces changes requested are corrected to remove spaces after brackets and changed indentation Indentation changed from tabs to spaces Indentation changed from tabs to spaces, as requested added space after comma --- Binary_Search_Trees/BinarySearchTree.dart | 291 ++++++++++++++++++++++ 1 file changed, 291 insertions(+) create mode 100644 Binary_Search_Trees/BinarySearchTree.dart diff --git a/Binary_Search_Trees/BinarySearchTree.dart b/Binary_Search_Trees/BinarySearchTree.dart new file mode 100644 index 000000000..ed9f7f25e --- /dev/null +++ b/Binary_Search_Trees/BinarySearchTree.dart @@ -0,0 +1,291 @@ +import 'dart:io'; + +class Node{ + int value; + Node leftNode; + Node rightNode; + + Node(int val){ + this.value = val; + this.leftNode = null; + this.rightNode = null; + } + + Node get left{ + return this.leftNode; + } + + Node get right{ + return this.rightNode; + } + + int get val{ + return this. value; + } + + void set val(int x){ + this.value = x; + } + + void set left(Node x){ + this.leftNode = x; + } + + void set right(Node x){ + this.rightNode = x; + } +} + +Node root; + +preOrderTraversal(Node x){ + if(x == null) return; + print(x.val); + preOrderTraversal(x.left); + preOrderTraversal(x.right); +} + +inOrderTraversal(Node x){ + if(x == null) return; + inOrderTraversal(x.left); + print(x.val); + inOrderTraversal(x.right); +} + +postOrderTraversal(Node x){ + if(x == null) return; + postOrderTraversal(x.left); + print(x.val); + postOrderTraversal(x.right); +} + +insertElement(Node x, int val){ + if(root == null){ + root == new Node(val); + print(root.val); + return; + } + if(x.val == val) return; + if(x.val > val){ + if(x.left == null){ + Node newNode = new Node(val); + x.left = newNode; + return; + } + insertElement(x.left, val); + return; + } + if(x.right == null){ + Node newNode = new Node(val); + x.right = newNode; + return; + } + insertElement(x.right, val); + return; +} + +searchTree(Node x, int val){ + if(x == null){ + print('Did not find $val in Tree!'); + return; + } + if(x.val == val){ + print('Found $val in Tree!'); + return; + } + if(x.val > val){ + searchTree(x.left, val); + return; + } + if(x.val < val){ + searchTree(x.right, val); + return; + } +} + +main() { + int task = 0; + print('Binary Search Tree Program'); + while(task != 3){ + print('0 - Display Tree\n1 - Insert Element in Tree \n2 - Search element in Tree\n3 - Quit\nSelect task:-'); + try{ + task = int.parse(stdin.readLineSync()); + } on Exception{ + print('Please enter valid Integer value!'); + continue; + } + switch(task){ + case 0: + if(root == null){ + print('Empty Tree!'); + } + else{ + print('Traversal Order:-\n1 - Preorder \n2 - Inorder \n3 - Postorder'); + int val; + try{ + val = int.parse(stdin.readLineSync()); + } on Exception{ + print('Please enter valid Integer value!'); + continue; + } + switch(val){ + case 1: + print('PreOrder Traversal'); + preOrderTraversal(root); + break; + case 2: + print('InOrder Traversal'); + inOrderTraversal(root); + break; + case 3: + print('PostOrder Traversal'); + postOrderTraversal(root); + break; + default: + print('Please enter valid Integer value!'); + } + } + break; + + case 1: + int val = null; + print('Enter value that needs to be inserted in Tree:-'); + try{ + val = int.parse(stdin.readLineSync()); + } on Exception{ + print('Please enter valid Integer value!'); + continue; + } + if(val == null){ + print('Failed to insert element in Tree!'); + continue; + } + insertElement(root, val); + print('Successfully inserted $val in Tree!'); + break; + + case 2: + int val = null; + print('Enter value that needs to be searched in Tree:-'); + try{ + val = int.parse(stdin.readLineSync()); + } on Exception{ + print('Failed to search element in Tree!'); + continue; + } + if(val == null){ + print('Failed to search element in Tree!'); + continue; + } + searchTree(root, val); + break; + + case 3: + print('Binary Search Tree Program Complete'); + break; + + default: + continue; + } + } +} + +/* +Sample Input/Output: +Binary Search Tree Program +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in Tree:- +1 +1 +Successfully inserted 1 in Tree! +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in Tree:- +2 +Successfully inserted 2 in Tree! +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in Tree:- +3 +Successfully inserted 3 in Tree! +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +0 +Traversal Order:- +1 - Preorder +2 - Inorder +3 - Postorder +1 +PreOrder Traversal +1 +2 +3 +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +0 +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +0 +Traversal Order:- +1 - Preorder +2 - Inorder +3 - Postorder +2 +InOrder Traversal +1 +2 +3 +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +0 +Traversal Order:- +1 - Preorder +2 - Inorder +3 - Postorder +3 +PostOrder Traversal +3 +2 +1 +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +2 +Enter value that needs to be searched in Tree:- +2 +Found 2 in Tree! +0 - Display Tree +1 - Insert element in Tree +2 - Search element in Tree +3 - Quit +Select task:- +3 +Binary Search Tree Program Complete +*/ From 3e91af41e049387130bd8c0209b2097a4f8f20a9 Mon Sep 17 00:00:00 2001 From: "Kesha K. Kaneria" <46588494+keshakaneria@users.noreply.github.com> Date: Sun, 3 May 2020 13:32:33 +0530 Subject: [PATCH 123/265] Linear Search in dart language (#2410) linear search algorithm in dart Binary search in dart language Binary search algorithm in dart language deleting file to create same in new branch deleting binary search from master branch Linear search algo updated Dynamic values taken from user with conditions to delete, insert and search input given by user as correction suggested in PR #2410 sample input and output added user input along with output added indentation changed changed the indentation from 2 tabs to 4 tabs Delete functionality removed Removed additional functionality which is not required --- Linear_Search/Linear_Search.dart | 129 +++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 Linear_Search/Linear_Search.dart diff --git a/Linear_Search/Linear_Search.dart b/Linear_Search/Linear_Search.dart new file mode 100644 index 000000000..1afcfd8ff --- /dev/null +++ b/Linear_Search/Linear_Search.dart @@ -0,0 +1,129 @@ +//Linear search or sequential search is a method for finding an element within a list. +//It sequentially checks each element of the list until a match is found or the whole list has been searched. +import 'dart:io'; + +void linearSearch(List list, int x) { + int pass = 0; + list.forEach((val) { + if (val == x) { + print('Found $x in the List!'); + pass = 1; + } + }); + if (pass == 0) print('Did not find $x in the List!'); +} + +main() { + List list = new List(); + int task = 0; + print('Linear Search Program'); + while (task != 4) { + print( + '0 - Display List\n1 - Insert element in List \n2 - Search element in List\n3 - Quit\nSelect task:-'); + try { + task = int.parse(stdin.readLineSync()); + } on Exception { + print('Please enter valid Integer value!'); + continue; + } + switch (task) { + case 0: + if (list.length == 0) { + print('Empty List!'); + } else { + print('List:-'); + list.forEach((val) { + print(val); + }); + } + break; + case 1: + int val = null; + print('Enter value that needs to be inserted in List:- '); + try { + val = int.parse(stdin.readLineSync()); + } on Exception { + print('Please enter valid Integer value!'); + continue; + } + if (val == null) { + print('Failed to insert element in List!'); + continue; + } + list.add(val); + print('Successfully inserted $val in List!'); + break; + + case 2: + int val = null; + print('Enter value that needs to be searched in List:- '); + try { + val = int.parse(stdin.readLineSync()); + } on Exception { + print('Please enter valid Integer value!'); + continue; + } + if (val == null) { + print('Failed to search element in List!'); + continue; + } + linearSearch(list, val); + break; + + case 3: + print('Linear Search Program Complete'); + break; + + default: + continue; + } + } +} + +/* +Sample Input/Output: +Linear Search Program +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //to insert element in list +1 +Enter value that needs to be inserted in List:- +1 +Successfully inserted 1 in List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in List:- +2 +Successfully inserted 2 in List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in List:- +3 +Successfully inserted 3 in List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //to search the given element +2 +Enter value that needs to be searched in List:- +2 +Found 2 in the List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //to end the linear program algorithm +3 +Linear Search Program Complete +*/ From 2c2d0bb75ea6fbbb1b22261cf3e5d13ac4732112 Mon Sep 17 00:00:00 2001 From: monikajha <53649201+m-code12@users.noreply.github.com> Date: Sun, 3 May 2020 13:37:49 +0530 Subject: [PATCH 124/265] Depth First Search in Go (#2818) --- Depth_First_Search/Depth_First_Search.go | 114 +++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 Depth_First_Search/Depth_First_Search.go diff --git a/Depth_First_Search/Depth_First_Search.go b/Depth_First_Search/Depth_First_Search.go new file mode 100644 index 000000000..9b3f9e47b --- /dev/null +++ b/Depth_First_Search/Depth_First_Search.go @@ -0,0 +1,114 @@ +package main +import "fmt" +type set map[int]bool + +// Define Graph structure +type Graph struct { + adjList map[int]set +} + +// Create a graph and initialize its adjacency list, and return a pointer to it. +func createGraph() *Graph { + var g = Graph{} + g.adjList = make(map[int]set) + return &g +} + +// Add an edge between the two given nodes.If a node does not exist in the graph yet, add it. +func (g *Graph) addEdge(node1 int, node2 int) { + // Check if node1 is already in the graph + if g.adjList[node1] == nil { + g.adjList[node1] = make(set) + } + + g.adjList[node1][node2] = true + // Check if node2 is already in the graph + if g.adjList[node2] == nil { + g.adjList[node2] = make(set) + } + + g.adjList[node2][node1] = true +} + +// Perform a depth first search from the given node and apply the given function to each node. +func dfs(g *Graph, current int, visited set, visitFunction func(int)) { + if _, seen := visited[current]; seen { + return + } + + visited[current] = true + visitFunction(current) + for neighbour := range g.adjList[current] { + dfs(g, neighbour, visited, visitFunction) + } +} + +func main() { + graph := createGraph() + var n int + fmt.Println("Enter the number of vertices : ") + fmt.Scan(&n) + for i := 0; i < n; i++ { + var a int + var b int + fmt.Println("Enter the source vertex : ") + fmt.Scan(&a) + fmt.Println("Enter the destination vertex : ") + fmt.Scan(&b) + graph.addEdge(a, b) + } + fmt.Println("\nThe DFS Traversal of the graph is : ") + visited := make(set) + dfs(graph, 1, visited, func(node int) { + fmt.Print(node, " ") + }) +} + + +/* + + The sample input is given in the form of the following graph : + 1 + / \ + / \ + 2 5 + / \ / \ + 3 - 4 6 7 + + Sample Input : + Enter the number of vertices : + 7 + Enter the source vertex : + 1 + Enter the destination vertex : + 2 + Enter the source vertex : + 2 + Enter the destination vertex : + 3 + Enter the source vertex : + 2 + Enter the destination vertex : + 4 + Enter the source vertex : + 3 + Enter the destination vertex : + 4 + Enter the source vertex : + 1 + Enter the destination vertex : + 5 + Enter the source vertex : + 5 + Enter the destination vertex : + 6 + Enter the source vertex : + 5 + Enter the destination vertex : + 7 + + The DFS Traversal of the graph is : + 1 2 3 4 5 6 7 + +*/ + From 7f0ec41d8b5cef2d6179ca940e49791715460ea9 Mon Sep 17 00:00:00 2001 From: shivank singh <97shivank@gmail.com> Date: Sun, 3 May 2020 13:41:53 +0530 Subject: [PATCH 125/265] Qsort in kotlin (#2831) --- Quick_Sort/Quick_Sort.kt | 63 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Quick_Sort/Quick_Sort.kt diff --git a/Quick_Sort/Quick_Sort.kt b/Quick_Sort/Quick_Sort.kt new file mode 100644 index 000000000..509722dd1 --- /dev/null +++ b/Quick_Sort/Quick_Sort.kt @@ -0,0 +1,63 @@ +/* QuickSort is a Divide and Conquer algorithm. It picks an element as pivot and partitions the given array +around the picked pivot.It's Best case complexity is n*log(n) & Worst case complexity is n^2. */ + +//partition array +fun quick_sort(A: Array, p: Int, r: Int) { + if (p < r) { + var q: Int = partition(A, p, r) + quick_sort(A, p, q - 1) + quick_sort(A, q + 1, r) + + } +} + +//assign last value as pivot +fun partition(A: Array, p: Int, r: Int): Int { + var x = A[r] + var i = p - 1 + for (j in p until r) { + if (A[j] <= x) { + i++ + exchange(A, i, j) + } + } + exchange(A, i + 1, r) + return i + 1 +} + +//swap +fun exchange(A: Array, i: Int, j: Int) { + var temp = A[i] + A[i] = A[j] + A[j] = temp +} + +fun main(arg: Array) { + print("Enter no. of elements :") + var n = readLine()!!.toInt() + + println("Enter elements : ") + var A = Array(n, { 0 }) + for (i in 0 until n) + A[i] = readLine()!!.toInt() + + quick_sort(A, 0, A.size - 1) + + println("Sorted array is : ") + for (i in 0 until n) + print("${A[i]} ") +} + +/*-------OUTPUT-------------- +Enter no. of elements :6 +Enter elements : +4 +8 +5 +9 +2 +6 +Sorted array is : +2 4 5 6 8 9 +*/ + From 9dc9e66956fcaa2f0d696e4f1187fa0da620940d Mon Sep 17 00:00:00 2001 From: coderprasukj <60914425+coderprasukj@users.noreply.github.com> Date: Sun, 3 May 2020 20:49:13 +0530 Subject: [PATCH 126/265] Added Postman Sort in JavaScript (#2729) Modified Modified --- Postman_Sort/Postman_Sort.js | 88 ++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 Postman_Sort/Postman_Sort.js diff --git a/Postman_Sort/Postman_Sort.js b/Postman_Sort/Postman_Sort.js new file mode 100644 index 000000000..01c6ecc65 --- /dev/null +++ b/Postman_Sort/Postman_Sort.js @@ -0,0 +1,88 @@ +/* +* JavaScript Implementation for Postman Sort Algorithm +*/ + +let temp, max, count, maxdigits = 0, c = 0; +let t1, t2, k, t, n = 1, p, s; + +/* Function to arrange the of sequence having same base */ +function arrange(p, s) { + for(var i = p; i < s - 1; i++) { + for(var j = i + 1; j < s; j++) { + if(arr1[i] > arr1[j]) { + // swap array1[i] and array1[j] + swap (arr1[i], arr1[j]); + + temp = arr[i] % 10; + arr[i] = arr[j] % 10; + arr[j] = temp; + } + } + } +} + +count = 10; +console.log("The size of the Array : " + count); +let arr = [70, 80, 20, 50, 10, 60, 40, 100, 90, 30]; +console.log("The Unsorted Array is : "); +console.log(arr); + +let arr1 = new Array(); +for(let i = 0; i < count; i++) { + // first element in t + t = arr[i]; + // Calculating the Number of digits using logarithmic + c = Math.trunc(Math.log(arr[i] / Math.log(10))); + // number of digits in a each number + if(maxdigits < c) + maxdigits = c; +} + +while(--maxdigits) + n = n * 10; + +for(var i = 0; i < count; i++) { + // MSB - Dividing by particular base + max = arr[i] / n; + t = i; + for(var j = i + 1; j < count; j++) { + if(max > arr[j] / n) { + max = arr[j] / n; + t = j; + } + } + temp = arr1[t]; + arr1[t] = arr1[i]; + arr1[i] = temp; + temp = arr[t]; + arr[t] = arr[i]; + arr[i] = temp; +} + +function swap(x, y) { + var t = x; + x = y; + y = t; +} + +while (n >= 1) { + for(var i = 0; i < count;) { + t1 = arr[i] / n; + for(j = i + 1; t1 == (arr[j] / n); j++); + arrange(i, j); + i = j; + } + n = n / 10; +} + +console.log("Sorted Array is : "); +console.log(arr); + +/* +INPUT : +The size of the Array : 10 +The Unsorted Array is : [70, 80, 20, 50, 10, 60, 40, 100, 90, 30] + +OUTPUT : +Sorted Array is : [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] +*/ From 553c775ea86abdf12e7fb458e43440fdf90a60b9 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sun, 3 May 2020 20:51:38 +0530 Subject: [PATCH 127/265] Matrix_identical in java (#2750) Changes done --- Matrix_Operations/Java/Matrix_identical.java | 104 +++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 Matrix_Operations/Java/Matrix_identical.java diff --git a/Matrix_Operations/Java/Matrix_identical.java b/Matrix_Operations/Java/Matrix_identical.java new file mode 100644 index 000000000..03028e617 --- /dev/null +++ b/Matrix_Operations/Java/Matrix_identical.java @@ -0,0 +1,104 @@ +// Java Program to check and find if two matrices are identical or not +import java.util.Scanner; + +public class Matrix_identical { + + // This function return true if the matrices are identical otherwise false + public static boolean check_identical(int[][] matrix1, int[][] matrix2){ + int index1, index2 = 0; + for ( index1 = 0; index1 < matrix1.length; index1++ ){ + for ( index2 = 0; index2 < matrix1[0].length; index2++ ){ + if (matrix1[index1][index2] != matrix2[index1][index2]) { + return false; + } + } + } + return true; + } + + public static void main(String args[]){ + Scanner s = new Scanner(System.in); + + System.out.println("Of First Matrix"); + System.out.println(" Enter number of rows "); + int rows_first = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_first = s.nextInt(); + int[][] matrix1 = new int[rows_first][columns_first]; + + System.out.println("Of Second Matrix"); + System.out.println(" Enter number of rows "); + int rows_second = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_second = s.nextInt(); + int[][] matrix2 = new int[rows_second][columns_second]; + + if (columns_first != columns_second || rows_first != rows_second) { + System.out.println(" Matrices's order is not identical "); + } + else { + + System.out.println(" Enter elements of 1st matrix "); + for (int i = 0; i < rows_first; i++) { + for (int j = 0; j < columns_first; j++) { + matrix1[i][j] = s.nextInt(); + } + } + + System.out.println(" Enter elements of 2nd matrix "); + for (int i = 0; i < rows_first; i++) { + for (int j = 0; j < columns_first; j++) { + matrix2[i][j] = s.nextInt(); + } + } + boolean b = check_identical(matrix1, matrix2); + if (b) System.out.println("Matrices are identical"); + else System.out.println(" Matrices are not identical"); + } + } +} +/* +TEST CASES +INPUT +Of First Matrix + Enter number of rows +2 + Enter number of columns +2 +Of Second Matrix + Enter number of rows +2 + Enter number of columns +2 + Enter elements of 1st matrix +1 2 +0 4 + Enter elements of 2nd matrix +1 2 +7 6 +OUTPUT + Matrices are not identical + +INPUT +Of First Matrix + Enter number of rows +2 + Enter number of columns +2 +Of Second Matrix + Enter number of rows +2 + Enter number of columns +2 + Enter elements of 1st matrix +1 2 +0 4 + Enter elements of 2nd matrix +1 2 +0 4 +OUTPUT + Matrices are identical +*/ + From 9819cdb6d1a158b52ea41e6c20a019e64fed66c1 Mon Sep 17 00:00:00 2001 From: "Kesha K. Kaneria" <46588494+keshakaneria@users.noreply.github.com> Date: Sun, 3 May 2020 21:01:58 +0530 Subject: [PATCH 128/265] Binary search in dart language (#2411) Binary search algorithm in dart language deleting file to create same in new branch deleting binary search from master branch Binary Search in Dart language Binary search algorithm in dart Deleting this irrelevant file of linear search Change in deleting file as requested binary search code with dynamic user values dynamic values taken with sample input and output changed the indentation indentation added from 2 tab to 4 tab Delete functionality removed Delete functionality was not required in binary search program so is removed. --- Binary_Search/Binary_Search.dart | 149 +++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 Binary_Search/Binary_Search.dart diff --git a/Binary_Search/Binary_Search.dart b/Binary_Search/Binary_Search.dart new file mode 100644 index 000000000..a6b7e1fe8 --- /dev/null +++ b/Binary_Search/Binary_Search.dart @@ -0,0 +1,149 @@ +//Binary Search is an efficient algorithm for finding an item from a sorted list of items. +//This is the implementation of Binary Search in dart language to insert and search the elements. +import 'dart:io'; + +void binarySearch(List list, int x){ + int size = list.length; + int low = 0; + int high = size - 1; + while(low <= high){ + int mid = ((low + high) / 2).floor(); + if(list[mid] == x){ + print('Found $x in the List at Index $mid!'); + return; + } + if(list[mid] > x){ + high = mid - 1; + continue; + } + low = mid + 1; + } + print('Did not $x in the List!'); + return; +} + +main(){ + List list = new List(); + int task = 0; + print('Binary Search Program'); + while(task != 4){ + print('0 - Display List\n1 - Insert element in List \n2 - Search element in List\n3 - Quit\nSelect task:-'); + try{ + task = int.parse(stdin.readLineSync()); + } on Exception{ + print('Please enter valid Integer value!'); + continue; + } + switch(task){ + case 0: + if(list.length == 0){ + print('Empty List!'); + } + else{ + print('List:-'); + list.forEach((val){ + print(val); + }); + } + break; + case 1: + int val = null; + print('Enter value that needs to be inserted in List:- '); + try{ + val = int.parse(stdin.readLineSync()); + } on Exception{ + print('Please enter valid Integer value!'); + continue; + } + if(val == null){ + print('Failed to insert element in List!'); + continue; + } + list.add(val); + list.sort(); + print('Successfully inserted $val in List!'); + break; + + case 2: + int val = null; + print('Enter value that needs to be searched in List:- '); + try{ + val = int.parse(stdin.readLineSync()); + } on Exception{ + print('Please enter valid Integer value!'); + continue; + } + if(val == null){ + print('Failed to search element in List!'); + continue; + } + binarySearch(list, val); + break; + + case 3: + print('Binary Search Program Complete'); + break; + default: + continue; + } + } +} + + +/* +Sample Input/Output: +Binary Search Program +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //to add element +1 +Enter value that needs to be inserted in List:- +1 +Successfully inserted 1 in List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in List:- +2 +Successfully inserted 2 in List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- +1 +Enter value that needs to be inserted in List:- +3 +Successfully inserted 3 in List! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //to display the list +0 +List:- +1 +2 +3 +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //to search the element +2 +Enter value that needs to be searched in List:- +2 +Found 2 in the List at Index 1! +0 - Display List +1 - Insert element in List +2 - Search element in List +3 - Quit +Select task:- //quiting the program +3 +Binary Search Program Complete +*/ From 80216a45bc39db8d8733e4b5289e4449394727c7 Mon Sep 17 00:00:00 2001 From: Roma Vardiyani <59890472+bohemian98@users.noreply.github.com> Date: Mon, 4 May 2020 15:03:30 +0530 Subject: [PATCH 129/265] KMP Algorithm in JavaScript is added (#2801) KMP in JavaScript Input/Output added suggested changes made in KMP.js file Changes in KMP.js done as suggested KMP Algo in JS was added --- Knuth_Morris_Pratt_Algorithm/KMP.js | 95 +++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/KMP.js diff --git a/Knuth_Morris_Pratt_Algorithm/KMP.js b/Knuth_Morris_Pratt_Algorithm/KMP.js new file mode 100644 index 000000000..884336313 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/KMP.js @@ -0,0 +1,95 @@ +/* Function to create Longest Proper Prefix for given pattern that we want to search in the text*/ +function lpsValues( lps, pattern, len_pattern) +{ + //length of longest prefix that is also suffix, will be zero for 1st charater as no prefix ans no suffix + lps[0] = 0; + //length of previous longest prefix that is also suffix + var len_prev = 0; + //iterator to calculate values lps[1].....lps[len_pattern] + var i = 1; + while (i < len_pattern ) + { + if (pattern.charAt(i) === pattern.charAt( len_prev)) + { + len_prev = len_prev+1;; + lps[i] = len_prev; + i++; + } + else // (pat[i] != pat[len]) + { + + if (len_prev != 0) + { + len_prev = lps[len_prev - 1]; + } + + else // if (len == 0) as no prefix found + { + lps[i] = 0; + i++; + } + } + } +} + + +function KmpPatternSearch(pattern, text) +{ + len_pattern = pattern.length; + len_text = text.length; + + //We find Longest Proper Prefix to decide which chater will be matched next + var lps = new Array(len_pattern); + + lpsValues(lps, pattern, len_pattern); + + //iterator + var i = j = 0; + while (i < len_text) + { + if (pattern.charAt(j) === text.charAt(i)) + { + //Pattern ans text matched + i = i+1; + j = j+1; + } + if (j === len_pattern) + { + return i-j; + j = lps[j-1]; + } + else if (j != len_pattern && pattern.charAt(j) != text.charAt(i)) + { + + if (j != 0) + { + j = lps[j-1]; + } + else + { + i = i+1; + } + } + } +} +//Used synchronous readline package to take console input +var readlineSync = require('readline-sync'); +//User input for text to be searched +var a = readlineSync.question('Enter text to be searched: '); +//User input for pattern to be searched in text +var b = readlineSync.question('Enter the pattern to be searched: '); +var index=KmpPatternSearch(b,a); +if (index == undefined) +{ + console.log("Pattern not found."); +} +else +{ + console.log("Pattern observed at index:", index); +} +//Input 1: text :"abcabaabcabac" pattern:"abaa" +//Output will be 3 +//Input 2: text:"aabbcdefgh" pattern:"fgh" +//Output will be 7 +//Input 3: text:"aaaaaa" pattern:"bb" +//Output: Pattern not found From fbf8ee5229dd7316ff72e9d1780bad3de9f2b17b Mon Sep 17 00:00:00 2001 From: Manas2520 <60315152+Manas2520@users.noreply.github.com> Date: Mon, 4 May 2020 22:34:04 +0530 Subject: [PATCH 130/265] Updated Decimal_to_Binary.cpp (#2862) * Updated Decimal_to_Binary.cpp * Update Decimal_to_Binary.cpp Co-authored-by: Shreya Singh --- Number_Conversion/C++/Decimal_to_Binary.cpp | 41 +++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Number_Conversion/C++/Decimal_to_Binary.cpp diff --git a/Number_Conversion/C++/Decimal_to_Binary.cpp b/Number_Conversion/C++/Decimal_to_Binary.cpp new file mode 100644 index 000000000..219352146 --- /dev/null +++ b/Number_Conversion/C++/Decimal_to_Binary.cpp @@ -0,0 +1,41 @@ + +// C++ program to convert numbers from decimal to binary form + +#include +#include +using namespace std; + +// Function to convert the number from decimal to binary form +void printBinary(int n){ + + // command to find out number of bits in the given number + // which decides the size of the array + int size = log2(n) + 1; + + // Array to store the binary number + int b[size], j = 0; + while(n != 0){ + b[j] = n % 2; + n = n / 2; + j++; + } + + cout << "The binary form is : "; + for(j = size - 1; j >= 0; j--) + cout << b[j]; +} + + +int main() +{ + cout << "Enter the number you wish to convert:" << endl; + int n; + cin >> n; + printBinary(n); // Calling function printBinary to convert the number to binary form + cout << "\n"; + return 0; +} +/* +Input : 25 +Output : 11001 +*/ From 90c61a0ce48634c08800cdc71edab35136c5b406 Mon Sep 17 00:00:00 2001 From: thakran14 <47153756+thakran14@users.noreply.github.com> Date: Mon, 4 May 2020 22:39:56 +0530 Subject: [PATCH 131/265] Update Longest_Common_Subsequence.php (#2815) --- .../Longest_Common_Subsequence.php | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Longest_Common_Subsequence/Longest_Common_Subsequence.php diff --git a/Longest_Common_Subsequence/Longest_Common_Subsequence.php b/Longest_Common_Subsequence/Longest_Common_Subsequence.php new file mode 100644 index 000000000..72a618ec1 --- /dev/null +++ b/Longest_Common_Subsequence/Longest_Common_Subsequence.php @@ -0,0 +1,78 @@ + 0 && $j > 0) + { + // If current character in X[] and Y are same, + // then current character is part of LCS + if ($X[$i - 1] == $Y[$j - 1]) + { + // Put current character in result + $lcs[$index - 1] = $X[$i - 1]; + $i--; + $j--; + $index--; // reduce values of i, j and index + } + + // If not same, then find the larger of two + // and go in the direction of larger value + else if ($L[$i - 1][$j] > $L[$i][$j - 1]) + $i--; + else + $j--; + } + + // Print the lcs + echo "LCS of " . $X . " and " . $Y . " is "; + for($k = 0; $k < $temp; $k++) + echo $lcs[$k]; +} + +// Driver Code +$X = "ABCDE"; +$Y = "BCDEF"; +$m = strlen($X); +$n = strlen($Y); +lcs($X, $Y, $m, $n); + +/* +OUTPUT: +LCS of ABCDE and BCDEF is BCDE +*/ + +?> From ad27788db9d61ff097d944da95c1e68c17f66dea Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Tue, 5 May 2020 17:53:30 +0530 Subject: [PATCH 132/265] Multiplication in java (#2856) --- Matrix_Operations/Java/Matrix_multiply.java | 109 ++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 Matrix_Operations/Java/Matrix_multiply.java diff --git a/Matrix_Operations/Java/Matrix_multiply.java b/Matrix_Operations/Java/Matrix_multiply.java new file mode 100644 index 000000000..94260cbd6 --- /dev/null +++ b/Matrix_Operations/Java/Matrix_multiply.java @@ -0,0 +1,109 @@ +// Java Program to calculation multiplication of 2 matrices (2D Array) +import java.util.*; + +public class Matrix_Multiplication { + // Find multiplication of 2 Matrices and store it in matrix3 + public static void multiply_matrices(int[][] matrix1, int[][] matrix2) { + + int index1, index2, index3; + int[][] matrix3 = new int[matrix1.length][matrix1[0].length]; + + for ( index1 = 0; index1 < matrix1.length; index1++) { + for ( index2 = 0; index2 < matrix2[0].length; index2++) { + matrix3[index1][index2] = 0; + for ( index3 = 0; index3 < matrix1.length; index3++){ + matrix3[index1][index2] += matrix1[index1][index3] * matrix2[index3][index2]; + } + } + } + // Print the calculated matrix + for ( index1 = 0; index1 < matrix3.length; index1++) { + for ( index2 = 0; index2 < matrix3[0].length; index2++) { + System.out.print( matrix3[index1][index2] + " "); + } + System.out.println(); + } + } + + public static void main(String args[]) { + Scanner s = new Scanner(System.in); + + System.out.println("Of First Matrix"); + System.out.println(" Enter number of rows "); + int rows_first = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_first = s.nextInt(); + int[][] matrix1 = new int[rows_first][columns_first]; + + System.out.println("Of Second Matrix"); + System.out.println(" Enter number of rows "); + int rows_second = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_second = s.nextInt(); + int[][] matrix2 = new int[rows_second][columns_second]; + + if (columns_first != rows_second) { + System.out.println(" Multiplication of matrix is not possible "); + } + else { + + System.out.println(" Enter elements of 1st matrix "); + for (int i = 0; i < rows_first; i++) { + for (int j = 0; j < columns_first; j++) { + matrix1[i][j] = s.nextInt(); + } + } + + System.out.println(" Enter elements of 2nd matrix "); + for (int i = 0; i < rows_first; i++) { + for (int j = 0; j < columns_first; j++) { + matrix2[i][j] = s.nextInt(); + } + } + multiply_matrices(matrix1, matrix2); + } + } +} +/* +TEST CASE + +INPUT +Of First Matrix + Enter number of rows +1 + Enter number of columns +2 +Of Second Matrix + Enter number of rows +1 + Enter number of columns +3 + +OUTPUT + Multiplication of matrix is not possible + +INPUT +Of First Matrix + Enter number of rows +2 + Enter number of columns +2 +Of Second Matrix + Enter number of rows +2 + Enter number of columns +2 + Enter elements of 1st matrix +1 2 +3 4 + Enter elements of 2nd matrix +1 1 +1 1 + +OUTPUT +3 3 +7 7 +*/ + From a67cc022135676d479c6fc2430729fe77692e438 Mon Sep 17 00:00:00 2001 From: Ankita Saloni Date: Wed, 6 May 2020 15:31:20 +0530 Subject: [PATCH 133/265] Created Shell_Sort.php (#2772) Created Insertion_Sort.php Delete Insertion_Sort.php Updated Shell_Sort.php --- Shell_Sort/Shell_Sort.php | 41 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Shell_Sort/Shell_Sort.php diff --git a/Shell_Sort/Shell_Sort.php b/Shell_Sort/Shell_Sort.php new file mode 100644 index 000000000..b37063bc7 --- /dev/null +++ b/Shell_Sort/Shell_Sort.php @@ -0,0 +1,41 @@ + 0) + { + for($b = $a; $b < count($new_arr); $b++) //Comparing and Sorting the elements of array + { + $d = $new_arr[$b]; + $c = $b; + while($c >= $a && $new_arr[$c - $a] > $d) + { + $new_arr[$c] = $new_arr[$c - $a]; + $c -= $a; + } + $new_arr[$c] = $d; + } + $a = round($a / 2.2); + } + return $new_arr; //Array is returned after sorting +} + +//Driver Code : +$sample_arr = array(4, 9, 11, -5, 8, 1, 0, 6, -3); +echo "Array before sorting :
"; +echo implode(', ', $sample_arr); +echo "
"; +echo "
Array after sorting :
"; +echo implode(', ', shell_Sort($sample_arr)). PHP_EOL; + +/* +Implementing Shell Sort Algorithm : + +Array before sorting : +4, 9, 11, -5, 8, 1, 0, 6, -3 + +Array after sorting : +-5, -3, 0, 1, 4, 6, 8, 9, 11 +*/ + +?> From 7631ddb95a13021e5dfff13abaaf29c09bfe92c4 Mon Sep 17 00:00:00 2001 From: Sukriti Shah Date: Wed, 6 May 2020 15:39:56 +0530 Subject: [PATCH 134/265] Updated Prim's Algorithm in JS (#2835) Updated Prims_Algorithm.js Adding Prim's algorithm in JS Updated Prims_Algorithm.js Updated Prim's Algorithm in JS --- Prims_Algorithm/Prims_Algorithm.js | 81 ++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Prims_Algorithm/Prims_Algorithm.js diff --git a/Prims_Algorithm/Prims_Algorithm.js b/Prims_Algorithm/Prims_Algorithm.js new file mode 100644 index 000000000..cf2d2d18b --- /dev/null +++ b/Prims_Algorithm/Prims_Algorithm.js @@ -0,0 +1,81 @@ +/* Prim's algorithm is used to find minimum cost spanning tree (MST). It uses the greedy approach. */ + +// Represents a weighted edge from first to second +var Edge = function(first, second, weight) { + this.first = first; + this.second = second; + this.weight = weight; +}; + +// To create graph +var Graph = function() { + this.vertices = []; + this.edges = {}; + + // Add a node to the graph + this.addVertex = function(vertex) { + this.vertices.push(vertex); + this.edges[vertex] = []; + }; + + // Add a weighted edge from first to second + this.addEdge = function(first, second, weight) { + this.edges[first].push(new Edge(first, second, weight)); + this.edges[second].push(new Edge(second, first, weight)); + }; +}; + +// To get nearest vertex to visited vertices +function getMinVertex(g, result, visitedVertices) { + var min = [Infinity , null]; + for(var i = 0; i < result.length; i++) + for(var j = 0; j < g.edges[result[i]].length; j++) + if(g.edges[result[i]][j].weight < min[0] && visitedVertices[g.edges[result[i]][j].second] === undefined) + min = [g.edges[result[i]][j].weight, g.edges[result[i]][j].second]; + return min[1]; +} + +// To perform Prim's algorithm +function Prims(g) { + var result = []; + var visitedVertices = {}; + + // Start from node 0 + var start = g.vertices[0]; + result.push(start); + visitedVertices[start] = true; + + var min = getMinVertex(g, result, visitedVertices); + while(min != null) { + result.push(min); + visitedVertices[min] = true; + min = getMinVertex(g, result, visitedVertices); + } + + return result; +}; + +var g = new Graph(); + +// Vertices for the graph - Sample Input +g.addVertex(0); +g.addVertex(1); +g.addVertex(2); +g.addVertex(3); + +// Weighted edges for the graph - Sample Input +g.addEdge(0, 1, 3); +g.addEdge(1, 3, 1); +g.addEdge(1, 2, 5); +g.addEdge(2, 3, 8); + +var result = Prims(g); +console.log("Order in which vertices are visited during the implementation of Prim's Algorithm: ") +console.log(result); + +/* + Sample Input is as taken in the code. + Sample Output: + Order in which vertices are visited during the implementation of Prim's Algorithm: + 0,1,3,2 +*/ From 41604ec8f7f934248e36ac35e6e65519a68e4353 Mon Sep 17 00:00:00 2001 From: Santushti Sharma <60578091+santushtisharma10@users.noreply.github.com> Date: Fri, 8 May 2020 23:31:51 +0530 Subject: [PATCH 135/265] adding c file of fenwick tree --- Fenwick_Tree/Fenwick_Tree.c | 122 ++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 Fenwick_Tree/Fenwick_Tree.c diff --git a/Fenwick_Tree/Fenwick_Tree.c b/Fenwick_Tree/Fenwick_Tree.c new file mode 100644 index 000000000..3553fb4f4 --- /dev/null +++ b/Fenwick_Tree/Fenwick_Tree.c @@ -0,0 +1,122 @@ +/* + Fenwick Tree[also known as binary indexed tree] is used when there is a problem of range sum query wiht update i.e.RMQ. + Suppose you have an array and you have been asked to find sum in range.It can be done in linear time with static array + method.It will be difficult for on to do it in linear time when you have point updates.In this, update operation + incrementing an index by some value.Brute force approach will take O(n^2) time but Fenwick tree will take O(nlogn) time. +*/ + +#include +#include + +/* n --> No. of elements present in input array. + BITree[0..n] --> Array that represents Fenwick Tree(Binary Indexed Tree). + arr[0..n-1] --> Input array for which prefix sum is evaluated. +*/ +/* + Returns sum of arr[0..index]. This function assumes that the array is preprocessed and partial sums of + array elements are stored in BITree[]. +*/ + +int getSum(int BITree[], int index) +{ + int sum = 0; // Iniialize result + + // index in BITree[] is 1 more than the index in arr[] + index = index + 1; + + // Traverse ancestors of BITree[index] + while (index > 0) + { + // Add current element of BITree to sum + sum += BITree[index]; + + // Move index to parent node in getSum View + index -= index & (-index); + } + return sum; +} + +/* + Updates a node in Fenwick Tree at given index in BITree. The given value 'val' is added to BITree[i] and + all of its ancestors in tree. +*/ + +void updateBIT(int BITree[], int n, int index, int val) +{ + // index in BITree[] is 1 more than the index in arr[] + index = index + 1; + + // Traverse all ancestors and add 'val' + while (index <= n) + { + // Add 'val' to current node of BI Tree + BITree[index] += val; + + // Update index to that of parent in update View + index += index & (-index); + } +} + +/* + Constructs and returns a Fenwick Tree for given array of size n. +*/ + +int *constructBITree(int arr[], int n) +{ + // Create and initialize BITree[] as 0 + int *BITree = (int*) calloc(n+1, sizeof(int)); + + for (int i = 1; i <= n; ++i) + BITree[i] = 0; + + // Store the actual values in BITree[] using update() + for (int i = 0; i < n; ++i) + updateBIT(BITree, n, i, arr[i]); + + return BITree; +} + +int rangeSum(int l, int r, int BITree[]) +{ + return getSum(BITree, r) - getSum(BITree, l); +} + +int main() +{ + int n; + scanf("%d", &n); + + int freq[n]; + for (int i = 0; i < n; ++i) + { + scanf("%d", &freq[i]); + } + int *BITree = constructBITree(freq, n); + // Print sum of freq[0...5] + printf("%d\n", getSum(BITree, 5)); + + //Update operation + freq[4] += 16; + updateBIT(BITree, n, 4, 16); + + //Print sum of freq[2....7] after update + printf("%d\n", rangeSum(2, 7, BITree)); + + return 0; + +} + +/* +INPUT +----- +n=12 +freq :[2,1,1,3,2,3,4,5,6,7,8,9]; +Print sum of freq[0...5] +Update position 4 by adding 16 +Print sum of freq[2....7] after update + +OUTPUT +------ +12 +33 +*/ From ba243da8eb54e15bde67b22042e714d21bf9c675 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sat, 9 May 2020 02:57:16 +0530 Subject: [PATCH 136/265] Subtraction of matrix in java (#2528) changes made Changes done --- .../Java/Matrix_Subtraction.java | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 Matrix_Operations/Java/Matrix_Subtraction.java diff --git a/Matrix_Operations/Java/Matrix_Subtraction.java b/Matrix_Operations/Java/Matrix_Subtraction.java new file mode 100644 index 000000000..ab1419281 --- /dev/null +++ b/Matrix_Operations/Java/Matrix_Subtraction.java @@ -0,0 +1,90 @@ +// Java Program to calculation subtraction of 2 matrices (2D Array) +import java.util.*; + +public class Matrix_Subtraction { + + // Find subtraction of 2 Matrices and store it in matrix3 + public static void subtract_matrices(int[][] matrix1, int[][] matrix2){ + int index1, index2 = 0; + int[][] matrix3 = new int[matrix1.length][matrix1[0].length]; + for ( index1 = 0; index1 < matrix1.length; index1++ ){ + for ( index2 = 0; index2 < matrix1[0].length; index2++ ){ + matrix3[index1][index2] = matrix1[index1][index2] - matrix2[index1][index2]; + } + } + + // Print the calculated matrix + for ( index1 = 0; index1 < matrix3.length; index1++ ){ + for ( index2 = 0; index2 < matrix3[0].length; index2++ ){ + System.out.print( matrix3[index1][index2] + " "); + } + System.out.println(); + } + } + + public static void main(String args[]){ + Scanner s = new Scanner(System.in); + + System.out.println("Of First Matrix"); + System.out.println(" Enter number of rows "); + int rows_first = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_first = s.nextInt(); + int[][] matrix1 = new int[rows_first][columns_first]; + + System.out.println("Of Second Matrix"); + System.out.println(" Enter number of rows "); + int rows_second = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_second = s.nextInt(); + int[][] matrix2 = new int[rows_second][columns_second]; + + if (columns_first != columns_second || rows_first != rows_second) { + System.out.println(" Subtraction of matrix is not possible "); + } + else { + + System.out.println(" Enter elements of 1st matrix "); + for (int i = 0 ; i < rows_first; i++) { + for (int j = 0 ; j < columns_first; j++) { + matrix1[i][j] = s.nextInt(); + } + } + + System.out.println(" Enter elements of 2nd matrix "); + for (int i = 0 ; i < rows_first; i++) { + for (int j = 0 ; j < columns_first; j++) { + matrix2[i][j] = s.nextInt(); + } + } + subtract_matrices(matrix1, matrix2); + } + } +} + +/* +TEST CASES + +INPUT +Of First Matrix + Enter number of rows +1 + Enter number of columns +2 +Of Second Matrix + Enter number of rows +1 + Enter number of columns +2 + Enter elements of 1st matrix +3 +4 + Enter elements of 2nd matrix +1 +3 + +OUTPUT +2 1 +*/ From 2f8a66f28ab6c5e8ceb629d553bc561f71ab89fa Mon Sep 17 00:00:00 2001 From: Disha Sinha <42354197+disha2sinha@users.noreply.github.com> Date: Sat, 9 May 2020 03:04:44 +0530 Subject: [PATCH 137/265] KMP algorithm in dart added (#2852) KMP in Dart KMP in Dart KMP in Dart --- Knuth_Morris_Pratt_Algorithm/KMP.dart | 73 +++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/KMP.dart diff --git a/Knuth_Morris_Pratt_Algorithm/KMP.dart b/Knuth_Morris_Pratt_Algorithm/KMP.dart new file mode 100644 index 000000000..318f7b788 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/KMP.dart @@ -0,0 +1,73 @@ +/*The KMP matching algorithm uses degenerating property (pattern having same sub-patterns appearing more than once in the pattern) +of the pattern and improves the worst case complexity to O(n). The basic idea behind KMP’s algorithm is: whenever we detect a mismatch +(after some matches), we already know some of the characters in the text of the next window. This information is used to avoid +matching the characters that will anyway match.*/ +import 'dart:io'; + +List prefix_function (String pattern) +{ + var m = pattern.length; + var pi = []; + pi.add(-1); + var k = -1; + for (var j = 1; j < m; j++) + { + while (k > -1 && pattern[k + 1] != pattern[j]) + { + k = pi[k]; + } + if (pattern[k + 1] == pattern[j]) + { + k = k + 1; + } + pi.insert(j,k); + } + return pi; +} + +void KMP_matcher (String text, String pattern) +{ + var n = text.length; + var m = pattern.length; + var pi = []; + pi = prefix_function(pattern); + + var j = -1; //number of chars matched + for (var i = 0; i < n; i++) + { + while (j >= 0 && pattern[j+1] != text[i]) + { + j = pi[j]; //next char doesnot match + } + if (pattern[j+1] == text[i]) + { + j = j + 1; + } + if (j == m - 1) + { + var result = i - m + 2; + print ("Pattern found at position: $result"); + j = pi[j]; + } + } +} + +main() +{ + print ("Enter Text:"); + String text = stdin.readLineSync(); + print ("Enter Pattern:"); + String pattern = stdin.readLineSync(); + KMP_matcher (text, pattern); + return 0; +} + +/* +Enter Text: +gfmghdmgmgcc +Enter Pattern: +mg +Pattern found at position: 3 +Pattern found at position: 7 +Pattern found at position: 9 */ + From 03e3e33ffc0b2919d0f9d9e6077d78a2e5246fa9 Mon Sep 17 00:00:00 2001 From: Shweta Bhardwaj <59722795+BhardwajShweta25@users.noreply.github.com> Date: Sat, 9 May 2020 15:09:26 +0530 Subject: [PATCH 138/265] Added Selection_Sort.php (#2272) --- Selection_Sort/Selection_Sort.php | 43 +++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Selection_Sort/Selection_Sort.php diff --git a/Selection_Sort/Selection_Sort.php b/Selection_Sort/Selection_Sort.php new file mode 100644 index 000000000..e4f57201d --- /dev/null +++ b/Selection_Sort/Selection_Sort.php @@ -0,0 +1,43 @@ +/* + * Selection sort is used for sorting arrays. + * It is based on identifying minimum element from the array + * and placing it in beginning. + * This is repeated until we reach the end of array. + */ + +/* + * Sample Output + * 1 3 4 5 10 + */ From 9d417bb3c0cf83ad6a482366f1445e5b20be018d Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sun, 10 May 2020 16:08:32 +0530 Subject: [PATCH 139/265] Matrix_intersection in java (#2877) changes done --- .../Java/Matrix_intersection.java | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 Matrix_Operations/Java/Matrix_intersection.java diff --git a/Matrix_Operations/Java/Matrix_intersection.java b/Matrix_Operations/Java/Matrix_intersection.java new file mode 100644 index 000000000..d4d077c79 --- /dev/null +++ b/Matrix_Operations/Java/Matrix_intersection.java @@ -0,0 +1,90 @@ +// Java Program to check where the elements of matrix are different and replacing them with a character +import java.util.Scanner; + +public class Matrix_intersection { + + //Finding the elements which are different in both the matrices and replacing it with a char + public static void check_intersection(int[][] matrix1, int[][] matrix2, String character){ + int index1, index2 = 0; + for ( index1 = 0; index1 < matrix1.length; index1++) { + for ( index2 = 0; index2 < matrix1[0].length; index2++) { + if (matrix1[index1][index2] != matrix2[index1][index2]) { + System.out.print(character + " "); + } + else{ + System.out.print(matrix1[index1][index2] + " "); + } + } + System.out.println(); + } + } + + public static void main(String args[]){ + Scanner s = new Scanner(System.in); + + System.out.println("Of First Matrix"); + System.out.println(" Enter number of rows "); + int rows_first = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_first = s.nextInt(); + int[][] matrix1 = new int[rows_first][columns_first]; + + System.out.println("Of Second Matrix"); + System.out.println(" Enter number of rows "); + int rows_second = s.nextInt(); + + System.out.println(" Enter number of columns "); + int columns_second = s.nextInt(); + int[][] matrix2 = new int[rows_second][columns_second]; + + if (columns_first != columns_second || rows_first != rows_second) { + System.out.println(" Matrices's order is not same "); + } + else { + + System.out.println(" Enter elements of 1st matrix "); + for (int i = 0; i < rows_first; i++) { + for (int j = 0; j < columns_first; j++) { + matrix1[i][j] = s.nextInt(); + } + } + + System.out.println(" Enter elements of 2nd matrix "); + for (int i = 0; i < rows_first; i++) { + for (int j = 0; j < columns_first; j++) { + matrix2[i][j] = s.nextInt(); + } + } + System.out.println("Enter character to replace"); + String character = s.next(); + check_intersection(matrix1, matrix2, character); + } + } +} +/* +TEST CASES +INPUT +OOf First Matrix + Enter number of rows +2 + Enter number of columns +2 +Of Second Matrix + Enter number of rows +2 + Enter number of columns +2 + Enter elements of 1st matrix +4 0 +1 2 + Enter elements of 2nd matrix +4 9 +3 2 +Enter character to replace +% +OUTPUT +4 % +% 2 +*/ + From da4a40a70fe9313f8b61ab10f7a665ccf1237628 Mon Sep 17 00:00:00 2001 From: Chandrika Deb Date: Sun, 10 May 2020 16:12:20 +0530 Subject: [PATCH 140/265] Create Readme.md (#2843) Updated Chinese Remainder Theorem Readme.md --- Chinese_Remainder_Theorem/Readme.md | 116 ++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 Chinese_Remainder_Theorem/Readme.md diff --git a/Chinese_Remainder_Theorem/Readme.md b/Chinese_Remainder_Theorem/Readme.md new file mode 100644 index 000000000..136c5d072 --- /dev/null +++ b/Chinese_Remainder_Theorem/Readme.md @@ -0,0 +1,116 @@ +# Chinese Remainder Theorem + +If m1, m2, .., mk are pairwise relatively prime positive integers, and if a1, a2, .., ak are any integers, then the simultaneous congruences x ≡ a1 (mod m1), x ≡ a2 (mod m2), ..., x ≡ ak (mod mk) have a solution, and the solution is unique modulo m, where m = m1m2⋅⋅⋅mk . + +**Problem Statement :** + +We are given two arrays num[0..n-1] and rem[0..n-1]. In num[0..n-1], every pair is coprime (gcd for every pair is 1). We need to find minimum positive number x such that: + + x % num[0] = rem[0], + x % num[1] = rem[1], + x % num[2] = rem[2], + ....................... + x % num[n-1] = rem[n-1] + +## Algorithm + +The solution is based on the below given formula : + + x = sum of { (rem[i]* pp[i]* inv[i]) % prod } where 0 <= i <= n-1 + + where, + + rem[i] is given array of remainders + + prod is product of all given numbers + prod = num[0] * num[1] * ... * num[k-1] + + pp[i] is product of all divided by num[i] + pp[i] = prod / num[i] + + inv[i] = Modular Multiplicative Inverse of pp[i] with respect to num[i] + + +## Example + +![Pic01](https://i.pinimg.com/474x/f4/62/23/f46223a470eb8f967b3be60f8a255c6e--chinese-remainder-theorem-the-chinese.jpg) + +Consider the above given example for understanding **Chinese Remainder Theorem**. + + Input : num[] = {3, 5, 7}, rem[] = {1, 2, 3} + output : x = 52 + + Explanation: 52 is the smallest number such that: + (1) When we divide it by 3, we get remainder 1. + (2) When we divide it by 5, we get remainder 2 + (3) When we divide it by 7, we get remainder 3. + + +Let us consider an example for a better understanding of **above given formula**. + + Input: num[] = {3, 5, 7}, rem[] = {1, 2, 3} + Output: x = 52 + + Explanation: num[] = {3, 5, 7}, rem[] = {1, 2, 3} + prod = 3*5*7 = 105 + pp[] = {35, 21, 15} + inv[] = {2, 1, 1} // (35*2)%3 = 1, (21*1)%5 = 1, // (15*1)%7 = 1 + + x = (rem[0]* pp[0]* inv[0] + rem[1]* pp[1]* inv[1] + rem[2]* pp[2]* inv[2]) % prod + = (1*35*2 + 2*21*1 + 3*15*1) % 105 + = (70 + 42 + 45) % 105 + = 52 + +## Pseudo Code + +The code is a simple 4-step process followed to find the solution : + + STEP 1 : Find the Product of all the numbers given in num[]. + STEP 2 : Find the number which is equal to Product divided by num[i] and store it in pp[i]. + STEP 3 : Find the Modular Multiplicative Inverse of pp[i] with respect to num[i] and store it + in inv[i]. + STEP 4 : Multiply rem[i] with the product of pp[i] and inv[i] for all 0 <= i <= n-1 and + add them. This is our required Output. + + +## Complexity + + Time complexity : __O(n*log(max(a,b))__ , where + +* __n__ is the total number of elements in the array. +* __a__ is the maximum value in __num[ ]__ +* __b__ is the minimum value in __rem[ ]__ + + +## Implementation + +- [C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_remainder_theorem.c) + +- [CoffeeScript code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.coffee) + +- [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.cpp) + +- [C# Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.cs) + +- [Dart Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.dart) + +- [Go Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.go) + +- [Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.java) + +- [JavaScript Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.js) + +- [PHP Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.php) + +- [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Chinese_Remainder_Theorem/Chinese_Remainder_Theorem.py) + +### Refer this [link](https://www.youtube.com/watch?v=ru7mWZJlRQg) to know more! + +## References + +Image source: [https://www.storyofmathematics.com/chinese.html](https://www.storyofmathematics.com/chinese.html) + +#### Websites: +1. [http://homepages.math.uic.edu/~leon/mcs425-s08/handouts/chinese_remainder.pdf](http://homepages.math.uic.edu/~leon/mcs425-s08/handouts/chinese_remainder.pdf) +2. [https://www.geeksforgeeks.org/chinese-remainder-theorem-set-2-implementation/](https://www.geeksforgeeks.org/chinese-remainder-theorem-set-2-implementation/) +3. [https://medium.com/free-code-camp/how-to-implement-the-chinese-remainder-theorem-in-java-db88a3f1ffe0](https://medium.com/free-code-camp/how-to-implement-the-chinese-remainder-theorem-in-java-db88a3f1ffe0) From 35097a319f0abff7b8eff3985420ca0ba10c3bfd Mon Sep 17 00:00:00 2001 From: Chandrika Deb Date: Sun, 10 May 2020 16:13:21 +0530 Subject: [PATCH 141/265] Readme for Segment_Tree_RMQ (#2841) Updated Readme.md for Segment Tree RMQ --- Segment_Tree_RMQ/README.md | 134 +++++++++++++++++++++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 Segment_Tree_RMQ/README.md diff --git a/Segment_Tree_RMQ/README.md b/Segment_Tree_RMQ/README.md new file mode 100644 index 000000000..a0bc4dd71 --- /dev/null +++ b/Segment_Tree_RMQ/README.md @@ -0,0 +1,134 @@ +# Segment Tree + +Segment Tree is a basically a binary tree used for storing the intervals or segments. Each node in the Segment Tree represents an interval. + +Segment Tree is used in cases where there are multiple range queries on array and modifications of elements of the same array. For example, finding the sum of all the elements in an array from indices L to R, or finding the minimum (famously known as __Range Minumum Query__ problem) of all the elements in an array from indices L to R. + +## Explanation + +Consider an array __A__ of size __N__ and a corresponding Segment Tree __T__: + +1. The root of __T__ will represent the whole array __A[0 : N-1]__. +2. Each leaf in the Segment Tree __T__ will represent a single element __A[i]__ such that __0 <= i < N__. +3. The internal nodes in the Segment Tree __T__ represents the union of elementary intervals __A[i : j]__ where __0<=i2N__. +* There are __N__ leaves representing the elements of the array. The number of internal nodes is __N - 1__. So, a total number of nodes are __2 * N - 1__. + +The Segment Tree of array __A__ of size __7__ will look like this: + +![Pic01](https://he-s3.s3.amazonaws.com/media/uploads/a0c7f90.jpg) + +![Pic02](https://he-s3.s3.amazonaws.com/media/uploads/aad673e.jpg) + +## Algorithm + +#### Query for minimum value of given range + +Once the tree is constructed, how to do range minimum query using the constructed segment tree. Following is the algorithm to get the minimum. + +``` +// qs --> query start index, qe --> query end index +int RMQ(node, qs, qe) +{ + if range of node is within qs and qe + return value in node + else if range of node is completely outside qs and qe + return ZERO + else + return min( RMQ(node's left child, qs, qe), RMQ(node's right child, qs, qe) ) +} +``` + +## Pseudocode + +After we've built a tree, we want to be able to search the tree for its values. (Which, in this case, is the minimum value between indices L and R.) + +Similar to the technique we used before, we recursively search the tree, starting from the root, and if a node is within the range [L, R], then we check it's value as a valid minimum of the range. + +``` +function RecursivelySearchForMin(L, R, nodeIndex, nodeStartIndex, nodeEndIndex) +{ + /* + If this node's range is anywhere outside of [L, R] + then don't use it's value. Just return some + really big number (which wouldn't be taken as the minimum). + */ + if(nodeEndIndex < L || R < nodeStartIndex) + { + return reallyBigNumber; + } + + /* + If this node is completely within [L, R], + then return it as the min value. + */ + if(L <= nodeStartIndex && nodeEndIndex <= R) + { + return stArray[nodeIndex]; + } + + /* + Otherwise this node is partially within [L, R]. + (Recursively) check this node's children and return the min of those two. + */ + middleIndex = nodeStartIndex + ((nodeEndIndex - nodeStartIndex) / 2); + + leftChildNodeIndex = 2 * nodeIndex; + rightChildNodeIndex = 2 * nodeIndex + 1; + + leftChildMin = RecursivelySearchForMin(L, R, leftChildNodeIndex, nodeStartIndex, middleIndex); + rightChildMin = RecursivelySearchForMin(L, R, rightChildNodeIndex, middleIndex + 1, nodeEndIndex); + + minOfThisNode = min(leftChildMin, rightChildMin); + + return minOfThisNode; +} + +// Find the minimum value between indices L and R. +function FindMin(L, R) +{ + // Recursively search the tree, starting from the root (node 0). + min = RecursivelySearchForMin(L, R, 0, 0, origArrayLength - 1); + return min; +} +``` +## Example + +Given an array A[1 … n] of n objects taken from a well-ordered set(such as numbers), returns the position of the minimal element in the specified sub-array A[l … r], (r<=n). + +When A = [2,4,3,1,6,7,8,9,1,7], then the answer to the range minimum query for the sub-array A[2 … 7] = [3,1,6,7,8,9] is 3, as A[3] = 1. + +![Pic03](https://encrypted-tbn0.gstatic.com/images?q=tbn%3AANd9GcRviJId20R7OU-1qdCFVqWY6jkM9lmqw2LPj_PGRqaDbW8ThaDf&usqp=CAU) + +## Time Complexity + +Time Complexity for tree construction is __O(n)__. There are total __2N - 1__ nodes, and value of every node is calculated only once in tree construction. + +Time complexity to query is __O(Log N)__. To query a range minimum, at worst, we'll have to go down the height of the tree twice, once for the left subtree, and one for the right subtree. We process at most two nodes at every level and number of levels is **O(Log N)**. + +## Implementation + +-[C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Segment_Tree_RMQ/Segement_Tree_RMQ.c) + +-[C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Segment_Tree_RMQ/Segement_Tree_RMQ.cpp) + +-[Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Segment_Tree_RMQ/Segement_Tree_RMQ.py) + +-[Dart Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Segment_Tree_RMQ/Segment_Tree_RMQ.dart) + +-[Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Segment_Tree_RMQ/Segment_Tree_RMQ.java) + +## References + +#### Images source: +1. [https://www.hackerearth.com/practice/notes/segment-tree-and-lazy-propagation/](https://www.hackerearth.com/practice/notes/segment-tree-and-lazy-propagation/) +2. [https://www.topcoder.com/community/competitive-programming/tutorials/range-minimum-query-and-lowest-common-ancestor/](https://www.topcoder.com/community/competitive-programming/tutorials/range-minimum-query-and-lowest-common-ancestor/) + +#### Websites: +1. [https://www.hackerearth.com/practice/data-structures/advanced-data-structures/segment-trees/tutorial/](https://www.hackerearth.com/practice/data-structures/advanced-data-structures/segment-trees/tutorial/) +2. [https://www.geeksforgeeks.org/segment-tree-set-1-range-minimum-query/](https://www.geeksforgeeks.org/segment-tree-set-1-range-minimum-query/) +3. [https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/](https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/) +4. [https://www.srcmake.com/home/segment-tree](https://www.srcmake.com/home/segment-tree) From c49739c043d7a69dee5539fdb702fcd0c12834be Mon Sep 17 00:00:00 2001 From: Mrunal <44579222+mruna7@users.noreply.github.com> Date: Sun, 10 May 2020 16:18:15 +0530 Subject: [PATCH 142/265] squashingthecommits (#2827) Create Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Add files via upload Update Binary_To_Octal.java Update Decimal_to_Binary Update Decimal_to_Binary Update Binary_To_Octal.java Update Binary_To_Octal.java Delete Decimal_to_Binary --- Number_Conversion/Java/Binary_To_Octal.java | 46 +++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Number_Conversion/Java/Binary_To_Octal.java diff --git a/Number_Conversion/Java/Binary_To_Octal.java b/Number_Conversion/Java/Binary_To_Octal.java new file mode 100644 index 000000000..edea549b6 --- /dev/null +++ b/Number_Conversion/Java/Binary_To_Octal.java @@ -0,0 +1,46 @@ +import java.io.*; +import java.util.Scanner; + +public class Binary_To_Octal +{ + public static void binToOctal(long num) + { + int n = 0, decimal = 0; + //converting binary to decimal + while(num > 0) + { + long temp = num % 10; + decimal += temp * Math.pow(2, n); + num = num / 10; + n++; + } + int octal[] = new int[20]; + int i = 0; + while(decimal > 0) + { + int t = decimal % 8; + octal[i++] = t; + decimal = decimal / 8; + } + System.out.print("Octal representation"); + for(int j = i-1 ; j >= 0 ; j--) + System.out.print(octal[j]); + } + public static void main(String[] args) + { + long num; + Scanner sc = new Scanner(System.in); + System.out.println("Enter a Binary number"); + num = sc.nextLong(); + binToOctal(num); + sc.close(); + } +} +/* +Input: +Enter a Binary number +1011001010 +Output: +Octal representation +2625 +*/ From 1c7f472f99700013b6167ee49f2aa3a4c5cfa983 Mon Sep 17 00:00:00 2001 From: Ritish Singh Date: Sun, 10 May 2020 20:04:15 +0530 Subject: [PATCH 143/265] Kosraju Algorithm in C# (#2834) Update Kosaraju_Algorithm.cs --- Kosaraju_Algorithm/Kosaraju_Algorithm.cs | 84 ++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 Kosaraju_Algorithm/Kosaraju_Algorithm.cs diff --git a/Kosaraju_Algorithm/Kosaraju_Algorithm.cs b/Kosaraju_Algorithm/Kosaraju_Algorithm.cs new file mode 100644 index 000000000..1c2046d8f --- /dev/null +++ b/Kosaraju_Algorithm/Kosaraju_Algorithm.cs @@ -0,0 +1,84 @@ +using System; +using System.Collections.Generic; + +namespace Declaring_Method +{ + public static class Kosaraju_Algorithm + { + public static void Main(string[] args) + { + List[] g = new List[3]; + for (int i = 0; i < g.Length; i++) + g[i] = new ArrayList<>(); + + //Initializing the List. + g[2].Add(0); + g[2].Add(1); + g[0].Add(1); + g[1].Add(0); + + List> components = scc(g); + + //Final Output + foreach (int i in components) + { + Console.WriteLine(i); + } + } + + public static List> scc(List[] graph) + { + int n = graph.Length; // Storing length of the graph + bool[] used = new bool[n]; + List order = new ArrayList<>(); + for (int i = 0; i < n; i++) + if (!used[i]) + dfs(graph, used, order, i); + + List[] reverseGraph = new List[n]; + for (int i = 0; i < n; i++) + reverseGraph[i] = new ArrayList<>(); + for (int i = 0; i < n; i++) + foreach (int j in graph[i]) + reverseGraph[j].Add(i); + + List> components = new ArrayList<>(); + fill(used, false); + order.Reverse(); // Reversing the contents + + foreach (int u in order) + if (!used[u]) + { + List component = new ArrayList<>(); + dfs(reverseGraph, used, component, u); + components.Add(component); + } + + return components; + } + + //Depth First Search + static void dfs(List[] graph, bool[] used, List res, int u) + { + used[u] = true; + foreach (int v in graph[u]) + if (!used[v]) + dfs(graph, used, res, v); + res.Add(u); + } + + //To fill the bool array + public static void fill(this T[] originalArray, T with) + { + for (int i = 0; i < originalArray.Length; i++) + { + originalArray[i] = with; + } + } + + } +} +/*OUTPUT: +2 +1 +0*/ From b58f319845cbbc466e8e4227f6f18816b22eac6e Mon Sep 17 00:00:00 2001 From: jedicakelord <46528937+jedicakelord@users.noreply.github.com> Date: Sun, 10 May 2020 23:00:26 +0530 Subject: [PATCH 144/265] Z Algorithm in Rust (#2677) --- Z_Algorithm/Z_Algorithm.rs | 103 +++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 Z_Algorithm/Z_Algorithm.rs diff --git a/Z_Algorithm/Z_Algorithm.rs b/Z_Algorithm/Z_Algorithm.rs new file mode 100644 index 000000000..e20bf9792 --- /dev/null +++ b/Z_Algorithm/Z_Algorithm.rs @@ -0,0 +1,103 @@ +/* Problem Statement : Find all occurrences of + * a pattern in a string in linear time O(m+n) + * where m is the length of the pattern and n + * is the length of the string.*/ + +use std::io::{stdin, stdout, Write}; +use std::convert::TryInto; + +fn z_array(zstring: &Vec) -> Vec { + let z_length = zstring.len(); + let mut z_arr = vec![0u32; z_length]; + z_arr[0] = 1; + let mut index = 1; + let mut var_ind = 0; + let mut left = 0; let mut right = 0; + /* To form the z array, run two loops from the beg of the + * array, match the char at that index for the outer loop + * with the char at index in the inner loop. If they match, + * move both of the indices forward, calculate the max length + * til which they match. */ + while index < z_length { + + if index > right { + left = index; right = index; + + while right < z_length && + zstring[right - left] == zstring[right] { + right += 1; + } + z_arr[index] = (right - left).try_into().unwrap(); + right -= 1; + } + else { + var_ind = index - left; + + if z_arr[var_ind] < ((right - index + 1).try_into().unwrap()) { + z_arr[index] = z_arr[var_ind]; + } + else { + left = index; + while (right < z_length && + zstring[right - left] == zstring[right]) { + right += 1; + } + + z_arr[index] = (right - left).try_into().unwrap(); + right -= 1; + } + } + index += 1; + } + + z_arr +} + +fn search_the_pattern(strng :&str, pattern :&str) { + let strng: Vec = strng.chars().collect(); + let pattern: Vec = pattern.chars().collect(); + let mut z_string = Vec::with_capacity(strng.len() + pattern.len()); + let pattern_length = pattern.len(); + z_string.extend(pattern); + z_string.push('$'); + z_string.extend(strng); + let z_array = z_array(&z_string); + + // Go through the z array, if at any index value is equal to the + // length of the pattern, the pattern appears in the string. + for index in pattern_length + 1.. z_array.len() - 1 { + if z_array[index] as usize == pattern_length { + println!("Pattern found at index : {}", index - pattern_length - 1); + } + } + +} + +fn main() { + println!("Enter the string :"); + let mut strng = String::new(); + //let _ = stdout().flush(); + stdin().read_line(&mut strng).expect("Error in string input."); + let strng: String = strng.trim().parse().unwrap(); + let strng: &str = &*strng; + + let mut pattern = String::new(); // make a mutable string variable + println!("Enter the pattern :"); + stdin().read_line(&mut pattern).expect("Error in pattern input."); + let pattern: String = pattern.trim().parse().unwrap(); + let pattern: &str = &*pattern; + //let tokens:Vec<&str>= strng.split(",").collect(); + + // Call the driver function with the string and the pattern + search_the_pattern(strng, pattern); +} + +/* Example : + * Enter the string : +The thesis was defended there then. +Enter the pattern : +the +Pattern found at index : 4 +Pattern found at index : 24 +Pattern found at index : 30 +*/ From 7f375480773d83849d99cd304591d218daaeee51 Mon Sep 17 00:00:00 2001 From: Simrann Arora Date: Mon, 11 May 2020 22:17:24 +0530 Subject: [PATCH 145/265] Create Readme.md (#2480) (#2888) --- Boyer_Moore_Algorithm/Readme.md | 137 ++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 Boyer_Moore_Algorithm/Readme.md diff --git a/Boyer_Moore_Algorithm/Readme.md b/Boyer_Moore_Algorithm/Readme.md new file mode 100644 index 000000000..f86721f1e --- /dev/null +++ b/Boyer_Moore_Algorithm/Readme.md @@ -0,0 +1,137 @@ +# Boyer Moore Algorithm +The Boyer Moore Algorithm was established by Robert Boyer and J Strother Moore in 1977. The Boyer Moore (B-M) String search algorithm is a particularly efficient algorithm and has served as a standard benchmark for string search algorithm ever since.The algorithm takes a 'backward' approach: the pattern string (P) is aligned with the start of the text string (T), and then compares the characters of a pattern from right to left, beginning with rightmost character.If a character is compared that is not within the pattern, no match can be found by analyzing any further aspects at this position so the pattern can be changed entirely past the mismatching character. +## **Explanation** +The B-M algorithm ,for deciding the possible shifts, uses two preprocessing strategies simultaneously. Whenever a mismatch occurs, the algorithm calculates a variation using both approaches and selects the more significant shift thus, if make use of the most effective strategy for each case. +The two strategies are called heuristics of B - M as they are used to reduce the search. They are: +1) Bad Character Heuristics +2) Good Suffix Heuristics + + ***Bad Character Heuristic*** +The idea of bad character heuristic is simple. The character of the text which doesn’t match with the current character of the pattern is called the Bad Character. Upon mismatch, we shift the pattern until – +1) The mismatch becomes a match +2) Pattern P move past the mismatched character. ++ Case 1 – Mismatch become match +We will lookup the position of last occurrence of mismatching character in pattern and if mismatching character exist in pattern then we’ll shift the pattern such that it get aligned to the mismatching character in text T. +![Pic01](https://media.geeksforgeeks.org/wp-content/uploads/bad_match_heuristic_case_1.jpg) ++ Case 2 – Pattern move past the mismatch character +We’ll lookup the position of last occurrence of mismatching character in pattern and if character does not exist we will shift pattern past the mismatching character. +![Pic02](https://media.geeksforgeeks.org/wp-content/uploads/bad_match_heuristic_case_2.jpg) + + ***Good Suffix Heuristic*** + Let t be substring of text T which is matched with substring of pattern P. Now we shift pattern until : + 1) Another occurrence of t in P matched with t in T. + 2) A prefix of P, which matches with suffix of t + 3) P moves past t ++ Case 1: Another occurrence of t in P matched with t in T +Pattern P might contain few more occurrences of t. In such case, we will try to shift the pattern to align that occurrence with t in text T. For example- +![Pic03](https://media.geeksforgeeks.org/wp-content/uploads/1-36.jpg) ++ Case 2: A prefix of P, which matches with suffix of t in T +It is not always likely that we will find the occurrence of t in P. Sometimes there is no occurrence at all, in such cases sometimes we can search for some suffix of t matching with some prefix of P and try to align them by shifting P. For example – +![Pic04](https://media.geeksforgeeks.org/wp-content/uploads/2-32.jpg) ++ Case 3: P moves past t +If the above two cases are not satisfied, we will shift the pattern past the t. For example – +![Pic05](https://media.geeksforgeeks.org/wp-content/uploads/3-19.jpg) +## Algorithm +``` +fullSuffixMatch(shiftArray, borderArray, pattern) + +Input: Array to store shift locations, the border array and the pattern to search + +Output: Fill the shift array and the border array + +Begin + n := pattern length + j := n + j := n + 1 + borderArray[i] := j + + while i > 0, do + while j <= n AND pattern[i - 1] ≠ pattern[j - 1], do + if shiftArray[j] = 0, then + shiftArray[j] := j - i; + j := borderArray[j]; + done + + decrease i and j by 1 + borderArray[i] := j + done +End + +partialSuffixMatch(shiftArray, borderArray, pattern) + +Input: Array to store shift locations, the border array and the pattern to search + +Output: Fill the shift array and the border array + +Begin + n := pattern length + j := borderArray[0] + + for index of all characters ‘i’ of pattern, do + if shiftArray[i] = 0, then + shiftArray[i] := j + if i = j then + j := borderArray[j] + done +End + +searchPattern(text, pattern) + +Input: The main text and the pattern, that will be searched + +Output: The indexes where the pattern is found + +Begin + patLen := pattern length + strLen := text size + + for all entries of shiftArray, do + set all entries to 0 + done + + call fullSuffixMatch(shiftArray, borderArray, pattern) + call partialSuffixMatch(shiftArray, borderArray, pattern) + shift := 0 + + while shift <= (strLen - patLen), do + j := patLen -1 + while j >= 0 and pattern[j] = text[shift + j], do + decrease j by 1 + done + + if j < 0, then + print the shift as, there is a match + shift := shift + shiftArray[0] + else + shift := shift + shiftArray[j + 1] + done +End +``` +## Examples + Input: txt[] = "THIS IS A TEST TEXT" + pat[] = "TEST" + Output: Pattern found at index 10 + Input: txt[] = "AABAACAADAABAABA" + pat[] = "AABA" + Output: Pattern found at index 0 + Pattern found at index 9 + Pattern found at index 12 + + ![Pic06](https://media.geeksforgeeks.org/wp-content/cdn-uploads/Pattern-Searching-2.png) +## Time Complexity + Preprocessing Time Complexity: O(|∑|) + Matching Time Complexity: (O ((n - m + 1) + |∑|)) +## Implementation +- [C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.c) +- [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.cpp ) +- [C# Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.cs) +- [Go Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.go) +- [Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.java) +- [Kotlin Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.kt) +- [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/da4a40a70f/Boyer_Moore_Algorithm/Boyer_Moore.py) +## References ++ Image source: [https://www.geeksforgeeks.org/boyer-moore-algorithm-for-pattern-searching/](https://www.geeksforgeeks.org/boyer-moore-algorithm-for-pattern-searching/) +#### Websites: +1. [https://www.javatpoint.com/daa-boyer-moore-algorithm](https://www.javatpoint.com/daa-boyer-moore-algorithm) +2. [https://www.cs.auckland.ac.nz/courses/compsci369s1c/lectures/GG-notes/CS369-StringAlgs.pdf](https://www.cs.auckland.ac.nz/courses/compsci369s1c/lectures/GG-notes/CS369-StringAlgs.pdf) +3. [geeksforgeeks.org/boyer-moore-algorithm-good-suffix-heuristic/?ref=rp](geeksforgeeks.org/boyer-moore-algorithm-good-suffix-heuristic/?ref=rp) From 48c56280516608bc4ebf91b082de37135ce97128 Mon Sep 17 00:00:00 2001 From: Shr03mink <44133832+Shr03mink@users.noreply.github.com> Date: Tue, 12 May 2020 13:07:49 +0000 Subject: [PATCH 146/265] Go implementation of Heap Sort (#2884) changes made in heapsort.go reduced blank lines Co-authored-by: unknown --- Heap_Sort/heapsort.go | 99 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 Heap_Sort/heapsort.go diff --git a/Heap_Sort/heapsort.go b/Heap_Sort/heapsort.go new file mode 100644 index 000000000..16b1548d3 --- /dev/null +++ b/Heap_Sort/heapsort.go @@ -0,0 +1,99 @@ +/* Heap Sort is a comparison-based sorting method performed on a Heap data structure. + Here we build a max heap first to later sort the elements in the heap in ascending order. +*/ + +package main +import "fmt" + +func max_heapify(arr []int, n int, i int) { + + largest := i // Initialize largest as root + l := 2 * i + 1 // left child + r := 2 * i + 2 // right child + + // If left child is larger than root + if l < n && arr[l] > arr[largest] { + largest = l + } + + // If right child is larger than largest so far + if r < n && arr[r] > arr[largest] { + largest = r + } + + // If largest is not root + if largest != i { + + //swapping + arr[i], arr[largest] = arr[largest], arr[i] + + // Recursively heapify the affected sub-tree + max_heapify(arr, n, largest) + } +} + +func heapSort(arr []int, n int) { + + // Build heap (rearrange array) + for i := n / 2 - 1; i >= 0; i-- { + max_heapify(arr, n, i) + } + + // One by one extract an element from heap + for i := n - 1; i >= 0; i-- { + + // Move current root to end + arr[0], arr[i] = arr[i], arr[0]; + + // call heapify on the reduced heap + max_heapify(arr, i, 0); + } +} + +func printArray(arr []int, no int) { + + //printing the sorted array + for i := 0; i < no; i++ { + fmt.Print(arr[i], " ") + } + +} + +func main() { + var n int + fmt.Println("Enter the number of elements :") + + //accepting the number of elements from the user + fmt.Scan(&n) + arr := make([]int, n) + for i := 0; i < n; i++ { + + //accepting input elements + fmt.Scan(&arr[i]) + } + fmt.Println(arr) + + fmt.Println("\nSorted array is") + heapSort(arr, n) + printArray(arr, n) +} + +/* OUTPUT: + +Enter the number of elements : 7 +Enter the elements : +0 +12 +11 +13 +5 +6 +7 + +Original Array: [0 12 11 13 5 6 7] + +Sorted array is +0 5 6 7 11 12 13 + +*/ + From 24c52a807ba7be536319417498be1f51c4cc616f Mon Sep 17 00:00:00 2001 From: Arkadip Bhattacharya Date: Tue, 12 May 2020 18:44:31 +0530 Subject: [PATCH 147/265] Added Knuth Morris Pratt Algorithm in Kotlin (#2814) Update KMP.kt feat: added comments Signed-off-by: Arkadip Bhattacharya --- Knuth_Morris_Pratt_Algorithm/KMP.kt | 83 +++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/KMP.kt diff --git a/Knuth_Morris_Pratt_Algorithm/KMP.kt b/Knuth_Morris_Pratt_Algorithm/KMP.kt new file mode 100644 index 000000000..8882c1623 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/KMP.kt @@ -0,0 +1,83 @@ +/* +Knuth Morris Pratt String Searching Algorithm +Given a text txt[0..n-1] and a pattern pat[0..m-1], the algo will find all occurrences of pat[] in txt[] +*/ + +import java.util.* + +internal class KMP { + fun kmpSearch(pat: String, txt: String) { + val m = pat.length + val n = txt.length + // longest_prefix_suffix array + val lps = IntArray(m) + + // index for pat[] + var j = 0 + + //calculate lps[] array + computeLPSArray(pat, m, lps) + + //index for txt[] + var i = 0 + while (i < n) { + if (pat[j] == txt[i]) { + j++ + i++ + } + if (j == m) { + println("Found pattern at index" + (i - j)) + j = lps[j - 1] + } else if (i < n && pat[j] != txt[i]) { + if (j != 0) j = lps[j - 1] else i += 1 + } + } + } + + // length of the previous longest prefix suffix + private fun computeLPSArray(pat: String, M: Int, lps: IntArray) { + var len = 0 + var i = 1 + + //lps[0] is always 0 + lps[0] = 0 + + //calculate lps[i] for i=1 to M-1 + while (i < M) + { + if (pat[i] == pat[len]) { + len++ + lps[i] = len + i++ + } + else { + if (len != 0) len = lps[len - 1] else { + lps[i] = len + i++ + } + } + } + } + + companion object { + //Driver program to test above function + @JvmStatic + fun main(args: Array) { + val sc = Scanner(System.`in`) + val txt = sc.nextLine() + val pat = sc.nextLine() + KMP().kmpSearch(pat, txt) + } + } +} + +/* +Sample Input +namanchamanbomanamansanam +aman + +Sample Output: +Patterns occur at shift = 1 +Patterns occur at shift = 7 +Patterns occur at shift = 16 + */ From ad5c987d44a99e59499a0ffcffe9f17e422d6247 Mon Sep 17 00:00:00 2001 From: Tahanima Chowdhury Date: Tue, 12 May 2020 19:18:11 +0600 Subject: [PATCH 148/265] Added KMP implementation in Ruby (#2555) (#2848) --- Knuth_Morris_Pratt_Algorithm/KMP.rb | 76 +++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/KMP.rb diff --git a/Knuth_Morris_Pratt_Algorithm/KMP.rb b/Knuth_Morris_Pratt_Algorithm/KMP.rb new file mode 100644 index 000000000..677e37f10 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/KMP.rb @@ -0,0 +1,76 @@ +# Given a text and a pattern, we need to find all occurrences of pattern in text + +def kmp_search(pattern, text) + pattern_size = pattern.length + text_size = text.length + + lps = Array.new(pattern_size) # longest_prefix_suffix array + lps = calculate_lps(pattern, lps) # compute lps[] + i = 0 # index for pattern[] + j = 0 # index for text[] + + while i < text_size + if pattern[j] == text[i] + i += 1 + j += 1 + end + + if j == pattern_size + puts "Pattern found at #{i - j + 1}" + j = lps[j - 1] + elsif i < text_size && pattern[j] != text[i] + if j != 0 + j = lps[j - 1] + else + i += 1 + end + end + end +end + +# function to preprocess lps[] to hold the longest prefix suffix values for pattern +def calculate_lps(pattern, lps) + len = 0 + lps[0] = 0 + + i = 1 + while i < pattern.length + if pattern[i] == pattern[len] + len += 1 + lps[i] = len + i += 1 + else + if len != 0 + len = lps[len - 1] + else + lps[i] = 0 + i += 1 + end + end + end + + return lps +end + +# Driver Code +puts "Enter the text:" +text = gets.chomp + +puts "Enter the pattern:" +pattern = gets.chomp + +kmp_search(pattern, text) + +=begin +Enter the text: +namanchamanbomanamansanam + +Enter the pattern: +aman + +Output + +Pattern found at 2 +Pattern found at 8 +Pattern found at 17 +=end From 6b87d35e1a98c4fb627e2452fb7c91fede4f0df9 Mon Sep 17 00:00:00 2001 From: thakran14 <47153756+thakran14@users.noreply.github.com> Date: Tue, 12 May 2020 18:50:03 +0530 Subject: [PATCH 149/265] Update Depth_First_Search.php (#2876) --- Depth_First_Search/Depth_First_Search.php | 81 +++++++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Depth_First_Search/Depth_First_Search.php diff --git a/Depth_First_Search/Depth_First_Search.php b/Depth_First_Search/Depth_First_Search.php new file mode 100644 index 000000000..85c0197be --- /dev/null +++ b/Depth_First_Search/Depth_First_Search.php @@ -0,0 +1,81 @@ +// Depth First Search implementation in PHP + + name = $name; + } + + public function link_to(Node $node, $also = true) + { + if (!$this -> linked($node)) + $this -> linked[] = $node; + if ($also) + $node -> link_to($this, false); + return $this; + } + + private function linked(Node $node) + { + foreach ($this->linked as $l) + { + if ($l -> name === $node -> name) + return true; + } + return false; + } + + public function not_visited_nodes($visited_names) + { + $ret = array(); + foreach ($this -> linked as $l) + { + if (!in_array($l -> name, $visited_names)) $ret[] = $l; + } + return $ret; + } +} + +/* Building Graph */ +$root = new Node('root'); +foreach (range(1, 6) as $v) +{ + $name = "node{$v}"; + $$name = new Node($name); +} + +$root -> link_to($node1) -> link_to($node2); +$node1 -> link_to($node3) -> link_to($node4); +$node2 -> link_to($node5) -> link_to($node6); +$node4 -> link_to($node5); + + +/* Searching Path */ +function dfs(Node $node, $path = '', $visited = array()) +{ + $visited[] = $node -> name; + $not_visited = $node -> not_visited_nodes($visited); + if (empty($not_visited)) + { + echo 'path : ' . $path . ' -> ' . $node -> name . PHP_EOL; + return; + } + foreach ($not_visited as $n) + dfs($n, $path . ' -> ' . $node -> name, $visited); +} + +dfs($root); + +/* +OUTPUT: +path : -> root -> node1 -> node3 +path : -> root -> node1 -> node4 -> node5 -> node2 -> node6 +path : -> root -> node2 -> node5 -> node4 -> node1 -> node3 +path : -> root -> node2 -> node6 +*/ From da0c596a934e02b68449c9af5e5567b6a5cc8c40 Mon Sep 17 00:00:00 2001 From: Jyoti Jauhari Date: Wed, 13 May 2020 18:52:50 +0530 Subject: [PATCH 150/265] introsort.py added in new folder named Intro_Sort (#2895) Update introsort.py Update introsort.py --- Intro_Sort/introsort.py | 101 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 Intro_Sort/introsort.py diff --git a/Intro_Sort/introsort.py b/Intro_Sort/introsort.py new file mode 100644 index 000000000..b8b1ab814 --- /dev/null +++ b/Intro_Sort/introsort.py @@ -0,0 +1,101 @@ +''' +Introsort sort is a sorting algorithm that initially uses quicksort, +but switches to heap sort if the depth of the recursion is too deep, +and uses insertion sort for small cases. +''' + +#a function that takes a list as argument. +def introsort(nlist): + + #maxdepth is chosen equal to 2 times floor of log base 2 of the length of the list. + maxdepth = (len(nlist).bit_length() - 1 ) * 2 + # Call introsort_helper with start = 0 and end = len(alist). + introsort_helper(nlist, 0, len(nlist), maxdepth) + +#The function sorts the list from indexes start to end. +def introsort_helper(nlist, start, end, maxdepth): + if end - start <= 1: + return + elif maxdepth == 0: + heapsort(alist, start, end) + else: + p = partition(nlist, start, end) + introsort_helper(nlist, start, p + 1, maxdepth - 1) + introsort_helper(nlist, p + 1, end, maxdepth - 1) + +#partition function uses Hoare partition scheme to partition the list. +def partition(nlist, start, end): + pivot = nlist[start] + i = start - 1 + j = end + + while True: + i = i + 1 + while nlist[i] < pivot: + i = i + 1 + j = j - 1 + while nlist[j] > pivot: + j = j - 1 + + if i >= j: + return j + + swap(nlist, i, j) + +#function for swapping +def swap(nlist, i, j): + nlist[i], nlist[j] = nlist[j], nlist[i] + +#heapsort from indexes start to end - 1 +def heapsort(alist, start, end): + build_max_heap(nlist, start, end) + for i in range(end - 1, start, -1): + swap(alist, start, i) + max_heapify(nlist, index = 0, start = start, end = i) + +#rearrange the list into a list representation of a heap. +def build_max_heap(nlist, start, end): + def parent(i): + return (i - 1) // 2 + length = end - start + index = parent(length - 1) + while index >= 0: + max_heapify(nlist, index, start, end) + index = index - 1 + +#modifies the heap structure at and below the node at given index to make it satisfy the heap property. +def max_heapify(nlist, index, start, end): + def left(i): + return 2 * i + 1 + def right(i): + return 2 * i + 2 + + size = end - start + l = left(index) + r = right(index) + if (l < size and nlist[start + l] > nlist[start + index]): + largest = l + else: + largest = index + if (r < size and nlist[start + r] > nlist[start + largest]): + largest = r + if largest != index: + swap(alist, start + largest, start + index) + max_heapify(alist, largest, start, end) + +#taking list as input from user (dynamic input) +nlist = input('Enter the list of numbers: ').split() +nlist = [int(n) for n in nlist] +introsort(nlist) +print('Sorted list: ', end = '') +#printing sorted list +print(nlist) + + +''' +Sample input +Enter the list of numbers: 8 4 3 2 1 + +Sample output +Sorted list: [1, 2, 3, 4, 8] +''' From 9c3e46faf7c5bf7a759aa498a19ccb603314be82 Mon Sep 17 00:00:00 2001 From: j-shreya <53999364+j-shreya@users.noreply.github.com> Date: Wed, 13 May 2020 23:14:05 +0530 Subject: [PATCH 151/265] Generic tree (#2365) * Create GENERIC_TREE_LOTRAVERSAL.java * Update GENERIC_TREE_LOTRAVERSAL.java * Revert "Update GENERIC_TREE_LOTRAVERSAL.java" This reverts commit dfdd3095201cbf35c1ee673a6332a0eaf4960a88. * Revert "Create GENERIC_TREE_LOTRAVERSAL.java" This reverts commit 2c87bbb08c1e7f312d3e9410b7ff5423d25f1458. * Create GenericTree_Levelorder_Traversal.java * Update GenericTree_Levelorder_Traversal.java * Update GenericTree_Levelorder_Traversal.java Corrected the indentation and allignment as requested * Update GenericTree_Levelorder_Traversal.java All extra lines removed. * Update GenericTree_Levelorder_Traversal.java Removed the lines requested --- .../GenericTree_Levelorder_Traversal.java | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 GenericTree_Levelorder_Traversal/GenericTree_Levelorder_Traversal.java diff --git a/GenericTree_Levelorder_Traversal/GenericTree_Levelorder_Traversal.java b/GenericTree_Levelorder_Traversal/GenericTree_Levelorder_Traversal.java new file mode 100644 index 000000000..cb1726cf7 --- /dev/null +++ b/GenericTree_Levelorder_Traversal/GenericTree_Levelorder_Traversal.java @@ -0,0 +1,94 @@ +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.Scanner; + +public class GenericTree_Levelorder_Traversal { + Scanner scn = new Scanner(System.in); + + private class Node { + int data; + ArrayList children = new ArrayList<>(); + } + + private Node root; + + public GenericTree_Levelorder_Traversal() { + root = takeInput(null, -1); + } + + private Node takeInput(Node parent, int ith) { + if (parent == null) { + System.out.println("Enter the data for Root Node ?"); + } else { + System.out.println( + "Enter data for " + ith + " child of " + parent.data); + } + + // take input + int item = scn.nextInt(); + // make a new node + Node nn = new Node(); + nn.data = item; + + System.out.println("No. of children for " + nn.data + " ?"); + int noc = scn.nextInt(); + + for (int i = 0; i < noc; i++) { + + Node child = takeInput(nn, i); + // add children in array list + nn.children.add(child); + } + return nn; + } + + public void display() { + display(root); + } + + // function to display generic tree + private void display(Node node) { + String str = node.data + " -> "; + + for (Node child : node.children) { + str += child.data + ", "; + } + + str += "."; + System.out.println(str); + + for (Node child : node.children) { + display(child); + } + } + + // level order traversal + public void levelorder() { + // create a linked list which will be used as queue + LinkedList queue = new LinkedList(); + // add root node to last of queue + queue.addLast(root); + + while (!queue.isEmpty()) { + + // remove node from front and print + Node rn = queue.removeFirst(); + + System.out.print(rn.data + " "); + + // add children of current node to the end of queue + for (Node child : rn.children) { + queue.addLast(child); + } + } + System.out.println(); + } + + public static void main(String[] args) { + GenericTree_Levelorder_Traversal gt = new GenericTree_Levelorder_Traversal(); + gt.levelorder(); + } +} + +//SAMPLE INPUT: 10 3 20 2 50 0 60 0 30 0 40 0 +//OUTPUT: 10 20 30 40 50 60 From 5021c39810e9aea4fef00abc61c1d1c810744d79 Mon Sep 17 00:00:00 2001 From: Disha Sinha <42354197+disha2sinha@users.noreply.github.com> Date: Thu, 14 May 2020 02:53:21 +0530 Subject: [PATCH 152/265] Rabin Karp in C (#2844) Changes in file made Changes Done in Rabin_Karp --- Rabin_Karp/Rabin_Karp.c | 77 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 Rabin_Karp/Rabin_Karp.c diff --git a/Rabin_Karp/Rabin_Karp.c b/Rabin_Karp/Rabin_Karp.c new file mode 100644 index 000000000..f2df21efd --- /dev/null +++ b/Rabin_Karp/Rabin_Karp.c @@ -0,0 +1,77 @@ +/*Rabin Karp algorithm is a string matching algorithm which matches the hash value of the pattern with the hash +value of current substring of text and if the hash values match then only it starts matching individual characters*/ + +#include +#include + +void Rabin_Karp (char *text, char *pattern) +{ + int text_len = strlen (text); + int pattern_len = strlen (pattern); + int hash = 1; + int asciichars = 256; + int prime = 149; + + for (int i = 0; i < pattern_len - 1; i++) + { + hash = (hash * asciichars) % prime; + // there are 256 total characters in Ascii table & 149 is a prime number chosen randomly + } + int hash_txt = 0, hash_pat = 0; + + for (int i = 0; i < pattern_len; i++) + { + hash_txt = (hash_txt * asciichars + text [i]) % prime; // hash value for text + hash_pat = (hash_pat * asciichars + pattern [i]) % prime; // hash value for pattern + } + + for(int i = 0; i <= text_len - pattern_len; i++) + { + int j; + + if (hash_txt == hash_pat) + { + // checking if all the chars are equal in text portion & pattern + for (j = 0; j < pattern_len; j++) + { + if (text [i+j] != pattern [j]) + break; + } + if (j == pattern_len) + { + printf ("\n\nPattern searched is found at position %d\n\n", i+1); + } + } + // finding the pattern in remaining portion of the text + if (i < text_len-pattern_len) + { + hash_txt = ((hash_txt - text [i] * hash) * asciichars + text [i + pattern_len]) % prime; + if (hash_txt < 0) + { + hash_txt = hash_txt + prime; + } + } + } +} + +int main() +{ + char text [30]; + char pattern [15]; + printf ("Enter Text:\n"); + scanf ("%s", text); + printf ("Enter Pattern to be searched:\n"); + scanf ("%s", pattern); + Rabin_Karp (text, pattern); + return 0; +} + +/* Input/Output Demo: +Enter Text: +bbaavcaavaavifjkdfkfaav +Enter Pattern to be searched: +aav +Pattern searched is found at position 3 +Pattern searched is found at position 7 +Pattern searched is found at position 10 +Pattern searched is found at position 21 */ From 8b7e6fed1a03046727d222d0504ea4b2f6d4ec46 Mon Sep 17 00:00:00 2001 From: shweta gurnani <43384092+shwetagurnani@users.noreply.github.com> Date: Fri, 15 May 2020 19:56:12 +0530 Subject: [PATCH 153/265] Kosaraju readme added (#2920) --- .../Kosaraju_algorithm.cpp | 0 Kosaraju_Algorithm/readme.md | 104 ++++++++++++++++++ 2 files changed, 104 insertions(+) rename kosaraju_algorithm/kosaraju_algorithm.cpp => Kosaraju_Algorithm/Kosaraju_algorithm.cpp (100%) create mode 100644 Kosaraju_Algorithm/readme.md diff --git a/kosaraju_algorithm/kosaraju_algorithm.cpp b/Kosaraju_Algorithm/Kosaraju_algorithm.cpp similarity index 100% rename from kosaraju_algorithm/kosaraju_algorithm.cpp rename to Kosaraju_Algorithm/Kosaraju_algorithm.cpp diff --git a/Kosaraju_Algorithm/readme.md b/Kosaraju_Algorithm/readme.md new file mode 100644 index 000000000..c0068c647 --- /dev/null +++ b/Kosaraju_Algorithm/readme.md @@ -0,0 +1,104 @@ +# Kosaraju Algorithm + +Kosaraju Algorithm is used to find strongly connected components in a directed graph. A directed graph is strongly connected if there is a path between all pairs of vertices. + +## Example + +Let's find strongly connected components in the directed graph given below. + +![Screenshot from 2020-05-13 18-30-06](https://user-images.githubusercontent.com/43384092/81815746-00185500-9548-11ea-961a-0d5a4506dd20.png) +- Create an empty stack 's'. Push the vertex in the stack only after all its neighbours are visited. + +- Create a boolean array 'visited' to keep track of all the vertices which are visited. + +- Let's start the DFS from vertex 0. Mark 0 as visited. Mark the neighbour of vertex 0 i.e. 2 as visited. Now mark the neighbour of 2 i.e. 1 as visited. There is only one neighbour of 1 i.e. 0 which is already visited. So, no neighbours of 1 are left to be traversed therefore push vertex 1 into the stack. Now, backtrack. There is no neighbour of vertex 2 left to be traversed. Push 2 into the stack.
+Stack: 1, 2
+ +- Now mark the another neighbour of 0 i.e. 3 as visited. Mark the neighbour of 3 i.e. 4 as visited. There is no neighbour of 4 left to be visited. Push 4 into the stack. Similarly, push 3 into the stack.
+Stack: 1, 2, 4, 3
+ +- All neighbours of vertex 0 are marked visited. Push 0 into the stack
+Stack: 1, 2, 4, 3, 0
+ +![a1](https://user-images.githubusercontent.com/43384092/81813457-18d33b80-9545-11ea-9324-ef0c72cb65b4.png) + +- Reverse directions of all arcs to obtain the transpose graph. Also, initialise the boolean array 'visited' as false. + +- Pop a vertex from stack 's' i.e. 0. Take vertex 0 as source and do DFS. Now, DFS will print the strongly connected component of vertex 0.
+Print: 0, 1, 2
+Stack: 1, 2, 4, 3
+ +- Pop again from the stack i.e. 3. Take vertex 3 as source and do DFS. Now, DFS will print the strongly connected component of vertex 3.
+Print: 0, 1, 2
+           3
+Stack: 1, 2, 4
+ +- Repeat the above step with vertex 4.
+Print: 0, 1, 2
+           3
+           4
+Stack: 1, 2
+ +- Now pop 2 from the stack. It is already marked as visited so no DFS will be performed. Similar case with vertex 1.
+Print: 0, 1, 2
+           3
+           4
+ +## Algorithm + +1. Create an empty stack ‘S’ and do DFS traversal of a graph. In DFS traversal, after calling recursive DFS for adjacent vertices of a vertex, push the vertex to stack.
+ +2. Reverse directions of all arcs to obtain the transpose graph.
+ +3. One by one pop a vertex from S while S is not empty. Let the popped vertex be ‘v’. Take v as source and do DFS (call DFSUtil(v)). The DFS starting from v prints strongly connected component of v.
+ +## Pseudocode +``` +Declare array of vectors adj and transpose, stack st and a boolean array visited. +Initialise all the elements of array visited with false. +dfs(s) + visited[s] = true + for(i = 0; i < adj[s].size; i++) + if(visited[adj[s][i]] == false) + dfs(adj[s][i]) + st.push(s) + +dfsUtil(s) + visited[s] = true + print(s) + for(i = 0; i < transpose[s].size; i++) + if(visited[transpose[s][i]] == false) + dfsUtil(transpose[s][i]) + +Kosaraju_Algorithm(nodes, edges, adj, src) + dfs(0) + Initialise all the elements of array visited with false. + for(i = 0; i < stack.size; i++) + top = stack.top + stack.pop + if(visited[top] is false): + dfsUtil(top) + print new line +``` + +## Complexity + + Time Complexity = O(V + E) + Space Complexity = O(V) + +where +>V = number of vertices
+>E = number of edges
+ +## Implementation + +* [C# Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Kosaraju_Algorithm/Kosaraju_Algorithm.cs) +* [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Kosaraju_Algorithm/Kosaraju_Algorithm.py) +* [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Kosaraju_Algorithm/Kosaraju_Algorithm.cpp) + +## References + +* [Tutorial - GeeksforGeeks](https://www.geeksforgeeks.org/strongly-connected-components/) +* [Tutorial - OpenGenus](https://iq.opengenus.org/kosarajus-algorithm-for-strongly-connected-components/) +* [Wikipedia](http://en.wikipedia.org/wiki/Kosaraju%27s_algorithm) + From 44121a0cf3bfa2ddb24d96aaa353e87240aa3077 Mon Sep 17 00:00:00 2001 From: Amit sharma <54413110+Amitsharma45@users.noreply.github.com> Date: Fri, 15 May 2020 19:58:23 +0530 Subject: [PATCH 154/265] Create README.md (#2822) --- Sleep_Sort/README.md | 84 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 Sleep_Sort/README.md diff --git a/Sleep_Sort/README.md b/Sleep_Sort/README.md new file mode 100644 index 000000000..6e39d8942 --- /dev/null +++ b/Sleep_Sort/README.md @@ -0,0 +1,84 @@ +# Sleep Sort + + Sleep sort works by starting a separate task for each item to be sorted, where each task sleeps for an interval corresponding to the item's sort key, then emits the item. Items are then collected sequentially in time. +# Example + Let’s assume we have a laptop that’s takes 1 seconds to work through each element. + + **INPUT: 10 8 6** + + - 1s 10 + - 2s: 8 + - 3s: 6 + - 9s: print(6) (6 wake up so print it) + - 10s: print(8) (8 wake up so print it) + - 11s: print(10) (10 wake up so print it) + + **OUTPUT : 6 8 10** + + # Time complexity + + - Creating multiple threads is done internally by the OS using a priority queue (used for scheduling purposes). Hence inserting all the array elements in the priority queue takes O(Nlog N) time. + +- Also the output is obtained only when all the threads are processed, i.e., when all the elements ‘wakes’ up. Since it takes O(arr[i]) time to wake the ith array element’s thread. So it will take a maximum of O(max_element(array)) for the largest element of the array to wake up. + + - Thus overall time complexitu is ,O(NlogN + max(input)) + ("where, N = number of elements in the input array, and input = input array elements") + + # Limitations + - This algorithm won’t work for negative numbers as a thread cannot sleep for a negative amount of time. + + # Sleep Sort Algorithm implementation in Python + import threading + import time + + _lk = threading.Lock() + + class SleepSortThread(threading.Thread): + def __init__(self, val): + self.val = val + threading.Thread.__init__(self) + + def run(self): + global _lk + # Thread is made to sleep in proportion to value + time.sleep(self.val * 0.1) + # Acquire lock + _lk.acquire() + print(self.val, end = " ") + # Release lock + _lk.release() + + def SleepSort(list): + ts = [] + # Intialize a thread corresponding to each element in list + for i in list: + t = SleepSortThread(i) + ts.append(t) + # Start all Threads + for i in ts: + i.start() + # Wait for all threads to terminate + for i in ts: + i.join() + + x = [2, 4, 3, 1, 6, 8, 4] + x = SleepSort(x) + + # Output + # 1 2 3 4 4 6 8 + +# Pseudocode + + procedure print(n) + sleep n second + print(n) + end + for arg in args + run print(arg) in background + end + + wait for all processes o finish + +[Reference: Geeksforgeeks](https://www.geeksforgeeks.org/sleep-sort-king-laziness-sorting-sleeping/) + +[Reference: Wikipedia](https://it.wikipedia.org/wiki/Sleep_sort) From 8a262204b00582096abab091d9bbd1e704d1e366 Mon Sep 17 00:00:00 2001 From: monikajha <53649201+m-code12@users.noreply.github.com> Date: Fri, 15 May 2020 20:01:34 +0530 Subject: [PATCH 155/265] Bucket_Sort in go (#2898) --- Bucket_Sort/Bucket_Sort.go | 104 +++++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 Bucket_Sort/Bucket_Sort.go diff --git a/Bucket_Sort/Bucket_Sort.go b/Bucket_Sort/Bucket_Sort.go new file mode 100644 index 000000000..7a7d11022 --- /dev/null +++ b/Bucket_Sort/Bucket_Sort.go @@ -0,0 +1,104 @@ +/* + Bucket Sort Implementation in GO + --------------------------------------------------- + Bucket Sort + --------------------------------------------------- +Bucket Sort is a sorting technique that sorts the elements by first dividing the elements into several groups called buckets. +The elements inside each bucket are sorted using any of the suitable sorting algorithms or recursively calling the same algorithm. +Several buckets are created. Each bucket is filled with a specific range of elements. +The elements inside the bucket are sorted using any other algorithm. Finally, the elements of the bucket are gathered to get the sorted array. +The process of bucket sort can be understood as a scatter-gather approach. The elements are first scattered into buckets then +the elements of buckets are sorted. + +Bucket sort is used when: +-> input is uniformly distributed over a range. +-> there are floating point values +*/ + + +package main + +import ( + "fmt" + "os" + "strconv" +) + +func insertionSort(array []float64) { + for i := 0; i < len(array); i++ { + temp := array[i] + j := i - 1 + for ; j >= 0 && array[j] > temp; j-- { + array[j + 1] = array[j] + } + array[j + 1] = temp + } +} + +func bucketSort(array []float64, bucketSize int) []float64 { + var max, min float64 + for _, n := range array { + if n < min { + min = n + } + if n > max { + max = n + } + } + + nBuckets := int(max-min) / bucketSize + 1 + buckets := make([][]float64, nBuckets) + for i := 0; i < nBuckets; i++ { + buckets[i] = make([]float64, 0) + } + + for _, n := range array { + idx := int(n-min) / bucketSize + buckets[idx] = append(buckets[idx], n) + } + + sorted := make([]float64, 0) + for _, bucket := range buckets { + if len(bucket) > 0 { + insertionSort(bucket) + sorted = append(sorted, bucket...) + } + } + return sorted +} + +func main() { + var x int + fmt.Printf("Enter the size of the array : ") + fmt.Scan(&x) + fmt.Printf("Enter the elements of the array : ") + a := make([]float64, x) + for i := 0; i < x; i++ { + fmt.Scan(&a[i]) + } + + array := a // A copy of the array 'a' is assigned to 'array' + for _, arg := range os.Args[1:] { + if n, err := strconv.ParseFloat(arg, 64); err == nil { + array = append(array, n) + } + } + + fmt.Printf("The array before sorting is %v\n", array) + array = bucketSort(array, 5) + fmt.Printf("The array after sorting is %v\n", array) +} + + +/* + + Sample Input : + Enter the size of the array : 3 + Enter the elements of the array : 2 8 5 + + Sample Output : + The array before sorting is [2 8 5] + The array after sorting is [2 5 8] + +*/ + From a675575be4711bed74bb85791fb5ada365062cec Mon Sep 17 00:00:00 2001 From: Ritish Singh Date: Fri, 15 May 2020 22:31:41 +0530 Subject: [PATCH 156/265] Red Black Tree implementation in C# (#2924) --- Red_Black_Tree/Red_Black_Tree.cs | 554 +++++++++++++++++++++++++++++++ 1 file changed, 554 insertions(+) create mode 100644 Red_Black_Tree/Red_Black_Tree.cs diff --git a/Red_Black_Tree/Red_Black_Tree.cs b/Red_Black_Tree/Red_Black_Tree.cs new file mode 100644 index 000000000..da8abef36 --- /dev/null +++ b/Red_Black_Tree/Red_Black_Tree.cs @@ -0,0 +1,554 @@ +using System; + +namespace Declaring_Methods +{ + public static class Program + { + public static void Main(String[] args) + { + RedBlackTree bst = new RedBlackTree(); + bst.insert(54); + bst.insert(38); + bst.insert(62); + bst.insert(58); + bst.insert(73); + bst.insert(55); + bst.printTree(); + Console.WriteLine("\nAfter deleting:"); + bst.deleteNode(40); + bst.printTree(); + } + public class Node + { + public int data; + public Node parent; + public Node left; + public Node right; + public int color; + } + + public class RedBlackTree + { + public Node root; + public Node TNULL; + + //PreOder Traversal + public void PreOder(Node node) + { + if (node != TNULL) + { + Console.Write(node.data + " "); + PreOder(node.left); + PreOder(node.right); + } + } + + //InOder Traversal + public void InOrder(Node node) + { + if (node != TNULL) + { + InOrder(node.left); + Console.Write(node.data + " "); + InOrder(node.right); + } + } + + //PostOder Traversal + public void PostOrder(Node node) + { + if (node != TNULL) + { + PostOrder(node.left); + PostOrder(node.right); + Console.Write(node.data + " "); + } + } + + //Searching in the Tree + public Node searchTreeHelper(Node node, int key) + { + if (node == TNULL || key == node.data) + { + return node; + } + + if (key < node.data) + { + return searchTreeHelper(node.left, key); + } + return searchTreeHelper(node.right, key); + } + + // Balance the tree after deletion of a node + public void fixDelete(Node x) + { + Node s; + while (x != root && x.color == 0) + { + if (x == x.parent.left) + { + s = x.parent.right; + if (s.color == 1) + { + s.color = 0; + x.parent.color = 1; + leftRotate(x.parent); + s = x.parent.right; + } + + if (s.left.color == 0 && s.right.color == 0) + { + s.color = 1; + x = x.parent; + } + else + { + if (s.right.color == 0) + { + s.left.color = 0; + s.color = 1; + rightRotate(s); + s = x.parent.right; + } + + s.color = x.parent.color; + x.parent.color = 0; + s.right.color = 0; + leftRotate(x.parent); + x = root; + } + } + else + { + s = x.parent.left; + if (s.color == 1) + { + s.color = 0; + x.parent.color = 1; + rightRotate(x.parent); + s = x.parent.left; + } + + if (s.right.color == 0 && s.right.color == 0) + { + s.color = 1; + x = x.parent; + } + else + { + if (s.left.color == 0) + { + s.right.color = 0; + s.color = 1; + leftRotate(s); + s = x.parent.left; + } + + s.color = x.parent.color; + x.parent.color = 0; + s.left.color = 0; + rightRotate(x.parent); + x = root; + } + } + } + x.color = 0; + } + + public void rbTransplant(Node u, Node v) + { + if (u.parent == null) + { + root = v; + } + else if (u == u.parent.left) + { + u.parent.left = v; + } + else + { + u.parent.right = v; + } + v.parent = u.parent; + } + + //Deleting the Node element + public void deleteNodeHelper(Node node, int key) + { + Node z = TNULL; + Node x, y; + while (node != TNULL) + { + if (node.data == key) + { + z = node; + } + + if (node.data <= key) + { + node = node.right; + } + else + { + node = node.left; + } + } + + if (z == TNULL) + { + Console.WriteLine("Couldn't find key in the tree"); + return; + } + + y = z; + int yOriginalColor = y.color; + if (z.left == TNULL) + { + x = z.right; + rbTransplant(z, z.right); + } + else if (z.right == TNULL) + { + x = z.left; + rbTransplant(z, z.left); + } + else + { + y = minimum(z.right); + yOriginalColor = y.color; + x = y.right; + if (y.parent == z) + { + x.parent = y; + } + else + { + rbTransplant(y, y.right); + y.right = z.right; + y.right.parent = y; + } + + rbTransplant(z, y); + y.left = z.left; + y.left.parent = y; + y.color = z.color; + } + if (yOriginalColor == 0) + { + fixDelete(x); + } + } + + // Balance the node after insertion + public void fixInsert(Node k) + { + Node u; + while (k.parent.color == 1) + { + if (k.parent == k.parent.parent.right) + { + u = k.parent.parent.left; + if (u.color == 1) + { + u.color = 0; + k.parent.color = 0; + k.parent.parent.color = 1; + k = k.parent.parent; + } + else + { + if (k == k.parent.left) + { + k = k.parent; + rightRotate(k); + } + k.parent.color = 0; + k.parent.parent.color = 1; + leftRotate(k.parent.parent); + } + } + else + { + u = k.parent.parent.right; + + if (u.color == 1) + { + u.color = 0; + k.parent.color = 0; + k.parent.parent.color = 1; + k = k.parent.parent; + } + else + { + if (k == k.parent.right) + { + k = k.parent; + leftRotate(k); + } + k.parent.color = 0; + k.parent.parent.color = 1; + rightRotate(k.parent.parent); + } + } + if (k == root) + { + break; + } + } + root.color = 0; + } + + //Printing the Tree + public void printHelper(Node root, String indent, bool last) + { + if (root != TNULL) + { + Console.Write(indent); + if (last) + { + Console.Write("R----"); + indent += " "; + } + else + { + Console.Write("L----"); + indent += "| "; + } + + String sColor = root.color == 1 ? "RED" : "BLACK"; + Console.WriteLine(root.data + "(" + sColor + ")"); + printHelper(root.left, indent, false); + printHelper(root.right, indent, true); + } + } + + public RedBlackTree() + { + TNULL = new Node(); + TNULL.color = 0; + TNULL.left = null; + TNULL.right = null; + root = TNULL; + } + + // PreOder Traversal + public void preorder() + { + PreOder(this.root); + } + + //InOder Traversal + public void inorder() + { + InOrder(this.root); + } + + //Post Oder Traversal + public void postorder() + { + PostOrder(this.root); + } + + //Searching in the tree + public Node searchTree(int k) + { + return searchTreeHelper(this.root, k); + } + + //Finding the minimum Node element + public Node minimum(Node node) + { + while (node.left != TNULL) + { + node = node.left; + } + return node; + } + + //Finding the maximum Node element + public Node maximum(Node node) + { + while (node.right != TNULL) + { + node = node.right; + } + return node; + } + + //Find the Successor of the element + public Node successor(Node x) + { + if (x.right != TNULL) + { + return minimum(x.right); + } + + Node y = x.parent; + while (y != TNULL && x == y.right) + { + x = y; + y = y.parent; + } + return y; + } + + //Finding the Predecessor of the element + public Node predecessor(Node x) + { + if (x.left != TNULL) + { + return maximum(x.left); + } + + Node y = x.parent; + while (y != TNULL && x == y.left) + { + x = y; + y = y.parent; + } + + return y; + } + + //Left Rotation + public void leftRotate(Node x) + { + Node y = x.right; + x.right = y.left; + if (y.left != TNULL) + { + y.left.parent = x; + } + y.parent = x.parent; + if (x.parent == null) + { + this.root = y; + } + else if (x == x.parent.left) + { + x.parent.left = y; + } + else + { + x.parent.right = y; + } + y.left = x; + x.parent = y; + } + + //Right Rotation + public void rightRotate(Node x) + { + Node y = x.left; + x.left = y.right; + if (y.right != TNULL) + { + y.right.parent = x; + } + y.parent = x.parent; + if (x.parent == null) + { + this.root = y; + } + else if (x == x.parent.right) + { + x.parent.right = y; + } + else + { + x.parent.left = y; + } + y.right = x; + x.parent = y; + } + + //Inserting Key to Tree + public void insert(int key) + { + Node node = new Node(); + node.parent = null; + node.data = key; + node.left = TNULL; + node.right = TNULL; + node.color = 1; + + Node y = null; + Node x = this.root; + + while (x != TNULL) + { + y = x; + if (node.data < x.data) + { + x = x.left; + } + else + { + x = x.right; + } + } + + node.parent = y; + if (y == null) + { + root = node; + } + else if (node.data < y.data) + { + y.left = node; + } + else + { + y.right = node; + } + + if (node.parent == null) + { + node.color = 0; + return; + } + + if (node.parent.parent == null) + { + return; + } + + fixInsert(node); + } + + //Getting the Root element of the tree + public Node getRoot() + { + return this.root; + } + + //Delete Node + public void deleteNode(int data) + { + deleteNodeHelper(this.root, data); + } + + //Print the Tree + public void printTree() + { + printHelper(this.root, " ", true); + } + } + } +} +/*R----54(BLACK) + L----38(BLACK) + R----62(RED) + L----58(BLACK) + | L----55(RED) + R----73(BLACK) + +After deleting: +Couldn't find key in the tree + R----54(BLACK) + L----38(BLACK) + R----62(RED) + L----58(BLACK) + | L----55(RED) + R----73(BLACK)*/ From ffb5a2cca7ec4800bbe29fd2e1f0f07e47c9a3a1 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 17 May 2020 13:30:41 +0530 Subject: [PATCH 157/265] AVL Tree implemented in Dart (#2914) --- AVL_Tree/AVL_Tree.dart | 321 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 AVL_Tree/AVL_Tree.dart diff --git a/AVL_Tree/AVL_Tree.dart b/AVL_Tree/AVL_Tree.dart new file mode 100644 index 000000000..a0e496ebd --- /dev/null +++ b/AVL_Tree/AVL_Tree.dart @@ -0,0 +1,321 @@ +/** + * ------------------------------------------------ + * AVL Tree implementation in Dart + * ------------------------------------------------ + * + * AVL Tree is a binary search tree that provides insertion, deletion + * and search in O(logn) time in all cases. It is an improvement over BST as a BST can + * take O(n) time when the tree takes a linear shape whereas AVL tree takes O(logn) time + * in all cases as it balances the tree using various rotations. + * + * AVL tree is preferred when insertions and deletions are less frequent and search is a + * more frequent operation. + * + * References - Geeksforgeeks + * + */ + +// Importing required libraries +import 'dart:io'; +import 'dart:math'; + +// Class definition for a tree node. +class Node{ + int value; + Node left , right; + int height; + + Node(value){ + this.value = value; + this.left = null; + this.right = null; + this.height = 1; + } +} + +// Class defintion for an AVL tree. +class AVL_Tree{ + Node root; + + // Utility function to print the tree in preorder traversal. + void print_AVL(Node root){ + if(root != null){ + print(root.value); + print_AVL(root.left); + print_AVL(root.right); + } + } + + // Utility function to find the height of the tree. + int height(Node node){ + if(node == null){ + return 0; + } + return node.height; + } + + // Utility function ro find the balance of the tree. + int balance(Node node){ + if(node == null){ + return 0; + } + return height(node.left) - height(node.right); + } + + //Utility function for right rotation + Node rightRotate(Node root){ + Node z = root , y = root.left , x = y.left; + Node c2 = root.left.right; + y.right = z; + y.left = x; + z.left = c2; + y.height = 1 + max(height(y.left) , height(y.right)); + x.height = 1 + max(height(x.left) , height(x.right)); + z.height = 1 + max(height(z.left) , height(z.right)); + return y; + } + + // Utility function for left rotation + Node leftRotate(Node root){ + Node z = root , y = root.right , x = y.right; + Node c2 = y.left; + y.left = z; + y.right = x; + z.right = c2; + y.height = 1 + max(height(y.left) , height(y.right)); + x.height = 1 + max(height(x.left) , height(x.right)); + z.height = 1 + max(height(z.left) , height(z.right)); + return y; + } + + // Utility function for leftRight rotation + Node leftRightRotate(Node root){ + Node z = root , y = root.left , x = y.right; + Node c1 = z.right , c2 = y.left , c3 = x.left , c4 = x.right; + x.right = z; + x.left = y; + y.left = c2; + y.right = c3; + z.left = c4; + z.right = c1; + y.height = 1 + max(height(y.left) , height(y.right)); + x.height = 1 + max(height(x.left) , height(x.right)); + z.height = 1 + max(height(z.left) , height(z.right)); + return x; + } + + // Utility function for rightLeft rotation + Node rightLeftRotate(Node root){ + Node z = root , y = z.right , x = y.left; + Node c1 = z.left , c2 = x.left , c3 = x.right , c4 = y.right; + x.left = z; + x.right = y; + z.left = c1; + z.right = c2; + y.left = c3; + y.right = c4; + y.height = 1 + max(height(y.left) , height(y.right)); + x.height = 1 + max(height(x.left) , height(x.right)); + z.height = 1 + max(height(z.left) , height(z.right)); + return x; + } + + // Utility function to find the successor of a node. + Node successor(Node root){ + Node temp = root; + while(temp.left != null){ + temp = temp.left; + } + return temp; + } + + // Function to delete a node in the tree. + Node delete_AVL(Node root , int key){ + if(root == null){ + return root; + } + else if(key > root.value){ + root.right = delete_AVL(root.right , key); + } + else if(key < root.value){ + root.left = delete_AVL(root.left , key); + } + else{ + Node temp; + if(root.left == null || root.right == null){ + if(root.left == null && root.right != null){ + temp = root.right; + } + else if(root.right == null && root.left != null){ + temp = root.left; + } + + if(temp == null){ + temp = root; + root = null; + } + else{ + root = temp; + } + } + else{ + Node temp1 = successor(root.right); + root.value = temp1.value; + root.right = delete_AVL(root.right , temp1.value); + } + } + + if(root == null){ + return root; + } + + root.height = 1 + max(height(root.left) , height(root.right)); + int difference = balance(root); + + if(difference > 1 && balance(root.left)>=0){ + return rightRotate(root); + } + + if(difference > 1 && balance(root.left)<0){ + return leftRightRotate(root); + } + + if(difference < -1 && balance(root.right)<=0){ + return leftRotate(root); + } + + if(difference < -1 && balance(root.left)>0){ + return rightLeftRotate(root); + } + + return root; + } + + // Function to insert a value as a node into a tree. + Node insert_AVL(Node root , int key){ + if(root == null){ + return Node(key); + } + else if(key < root.value){ + root.left = insert_AVL(root.left, key); + } + else{ + root.right = insert_AVL(root.right, key); + } + + root.height = 1 + max(height(root.left), height(root.right)); + int difference = balance(root); + + if(difference > 1 && key < root.left.value){ + return rightRotate(root); + } + + if(difference > 1 && key > root.left.value){ + return leftRightRotate(root); + } + + if(difference < -1 && key > root.right.value){ + return leftRotate(root); + } + + if(difference < -1 && key < root.right.value){ + return rightLeftRotate(root); + } + + return root; + } + +} + +void main(){ + + int continued = 1; + AVL_Tree tree = AVL_Tree(); + + while(continued == 1){ + print("Enter 1 to insert , 2 to delete and 3 to print the AVL tree:"); + var input = stdin.readLineSync(); + int operation = int.parse(input); + + if(operation == 1){ + input = stdin.readLineSync(); + int value = int.parse(input); + tree.root = tree.insert_AVL(tree.root , value); + } + else if(operation == 3){ + tree.print_AVL(tree.root); + } + else{ + input = stdin.readLineSync(); + int value = int.parse(input); + tree.root = tree.delete_AVL(tree.root , value); + } + + print("Enter 1 to continue:"); + input = stdin.readLineSync(); + continued = int.parse(input); + } + +} + +/** + * ------------------------------------------------ + * Sample Input and Output + * ------------------------------------------------ + * + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 1 + * 10 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 1 + * 20 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 1 + * 30 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 1 + * 40 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 1 + * 50 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 1 + * 25 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 3 + * 30 + * 20 + * 10 + * 25 + * 40 + * 50 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 2 + * 50 + * Enter 1 to continue: + * 1 + * Enter 1 to insert , 2 to delete and 3 to print the AVL tree: + * 3 + * 30 + * 20 + * 10 + * 25 + * 40 + * Enter 1 to continue: + * 0 + * + */ From 419e8fd3655d20148234f26951ec594f8e8367cb Mon Sep 17 00:00:00 2001 From: Ritish Singh Date: Mon, 18 May 2020 14:48:44 +0530 Subject: [PATCH 158/265] Jhonson Algorithm in Kotlin (#2925) --- Jhonson_Algoritm/Jhonson_Algorithm.kt | 76 +++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Jhonson_Algoritm/Jhonson_Algorithm.kt diff --git a/Jhonson_Algoritm/Jhonson_Algorithm.kt b/Jhonson_Algoritm/Jhonson_Algorithm.kt new file mode 100644 index 000000000..e3fdc8cb8 --- /dev/null +++ b/Jhonson_Algoritm/Jhonson_Algorithm.kt @@ -0,0 +1,76 @@ +fun main() +{ + var vert = 0 + var edge = 0 + var i = 0 + var j = 0 + var k = 0 + var c = 0 + var inf = 999999; + var cost = Array(10, {IntArray(10)}) + var adj = Array(10, {IntArray(10)}) + + println("Enter no of vertices: ") + vert = readLine() !!.toInt() + println("Enter no of Edges: "); + edge = readLine() !!.toInt() + println("Enter the EDGE cost: "); + + for (k in 1..edge) + { + i = readLine() !!.toInt() + j = readLine() !!.toInt() + c = readLine() !!.toInt() + adj[i][j] = c + cost[i][j] = c + } + + for (i in 1..vert) + for (j in 1..vert) + { + if (adj[i][j] == 0 && i != j) + //If its not a edge put infinity + adj[i][j] = inf + } + + for (k in 1..vert) + for (i in 1..vert) + for (j in 1..vert) + //Finding the minimum + //find minimum path from i to j through k + if ((adj[i][k] + adj[k][j]) > adj[i][j]) + adj[i][j] = adj[i][j] + else + adj[i][j] = (adj[i][k] + adj[k][j]) + + println("The distance matrix of the graph."); + // Output the resultant matrix + for (i in 1..vert) + { + for (j in 1..vert) + { + if (adj[i][j] != inf) + print("${adj[i][j]} "); + } + println(" "); + } +} + +/*Enter no of vertices: +3 +Enter no of Edges: +5 +Enter the EDGE cost: +1 2 8 + +2 1 12 + +1 3 22 + +3 1 6 + +2 3 4 +The distance matrix of the graph. +0 8 12 +10 0 4 +6 14 0*/ From 237ffcebe547f118698f07f8caba77dc7695d2eb Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 18 May 2020 14:59:09 +0530 Subject: [PATCH 159/265] Z Algorithm In C# (#2900) --- Z_Algorithm/Z_Algorithm.cs | 121 +++++++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 Z_Algorithm/Z_Algorithm.cs diff --git a/Z_Algorithm/Z_Algorithm.cs b/Z_Algorithm/Z_Algorithm.cs new file mode 100644 index 000000000..8c04a5f49 --- /dev/null +++ b/Z_Algorithm/Z_Algorithm.cs @@ -0,0 +1,121 @@ +/* + Z Algorithm In C# + + This algorithm finds all occurrences + of a pattern in a text in linear time. +*/ + +using System; + +class PatternSearch +{ + + /* + This function prints all the occurences + of a pattern in a text using Z algorithm + */ + + public static void search(string text, string pattern) + { + // Creation of Concatenated String + string concat = pattern + "$" + text; + int l = concat.Length; + + // Construct a new temporary array + int[] temp = new int[l]; + + getTempArr(concat, temp); + + /* + Iterate through temp array to + find the matching condition + */ + + for (int i = 0; i < l; ++i) + { + /* + If matched region is equal to + pattern lentgh, pattern is found + */ + + if (temp[i] == pattern.Length) + { + Console.WriteLine("Pattern occurs at index: " + + (i - pattern.Length - 1)); + } + } + } + + // Fills temporary array for given string str + private static void getTempArr(string str, int[] temp) + { + int n = str.Length; + int L = 0, R = 0; + + for (int i = 1; i < n; ++i) + { + if (i > R) + { + L = R = i; + + while (R < n && str[R - L] == str[R]) + { + R++; + } + temp[i] = R - L; + R--; + } + + else + { + int k = i - L; + + if (temp[k] < R - i + 1) + { + temp[i] = temp[k]; + } + + else + { + L = i; + + while (R < n && str[R - L] == str[R]) + { + R++; + } + temp[i] = R - L; + R--; + } + } + } + } + + public static void Main(string[] args) + { + Console.WriteLine("Enter the String value: "); + String text = Console.ReadLine(); + + Console.WriteLine("Enter the Pattern to search: "); + String pattern = Console.ReadLine(); + Console.WriteLine(); + + search(text, pattern); + } +} + +/** + +Enter the String value: AABACAADAAABACHGGH +Enter the Pattern to search: AABA + +Pattern occurs at index: 0 +Pattern occurs at index: 9 + +--------------------------------------------------- + +Enter the String value: THIS IS A TEST CASE +Enter the Pattern to search: TEST + +Pattern occurs at index: 10 + +*/ From 4b231dca11ba5a9fb608eefbd112b88c3d5a16a9 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 18 May 2020 15:30:29 +0530 Subject: [PATCH 160/265] Circle Sort In Ruby (#2896) Updated Minor Change --- Circle_Sort/Circle_Sort.rb | 76 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Circle_Sort/Circle_Sort.rb diff --git a/Circle_Sort/Circle_Sort.rb b/Circle_Sort/Circle_Sort.rb new file mode 100644 index 000000000..2a27d7fb3 --- /dev/null +++ b/Circle_Sort/Circle_Sort.rb @@ -0,0 +1,76 @@ +# Circle Sort In Ruby + +class Array + def circle_sort! + while _circle_sort!(0, size - 1) > 0 + end + self + end + + private + def _circle_sort!(lower, higher, swapping = 0) + return swapping if lower == higher + low, high = lower, higher + middle = (lower + higher) / 2 + + while lower < higher + if self[lower] > self[higher] + self[lower], self[higher] = self[higher], self[lower] + swapping += 1 + end + lower += 1 + higher -= 1 + end + + if lower == higher && self[lower] > self[higher+1] + self[lower], self[higher + 1] = self[higher + 1], self[lower] + swapping += 1 + end + + swapping + _circle_sort!(low, middle) + _circle_sort!(middle + 1, high) + end +end + +puts "Enter the size of array: " +size = gets.to_i +puts +input_array = Array.new(size) + +counter = 0 + +while(counter != size) + puts "Enter the value at index #{counter}: " + input_array[counter] = gets.to_i + counter += 1 +end + +puts + +puts "Input Array: #{input_array}" +puts "Circle Sort: #{input_array.circle_sort!}" + += begin + +Enter the size of array: 3 + +Enter the value at index 0: 999 +Enter the value at index 1: 21 +Enter the value at index 2: 58 + +Input Array: [999, 21, 58] +Circle Sort: [21, 58, 999] + +-------------------------------------------------- + +Enter the size of array: 5 + +Enter the value at index 0: 121 +Enter the value at index 1: 71 +Enter the value at index 2: 1 +Enter the value at index 3: 88 +Enter the value at index 4: 9 + +Input Array: [121, 71, 1, 88, 9] +Circle Sort: [1, 9, 71, 88, 121] + += end From 055a103de9e3d8b3c662dd03a6e79b54d1be72c8 Mon Sep 17 00:00:00 2001 From: coderprasukj <60914425+coderprasukj@users.noreply.github.com> Date: Tue, 19 May 2020 03:16:36 +0530 Subject: [PATCH 161/265] Added Postman Sort in JavaScript (#2901) Modified Modified Postman Sort in C++ Modified Delete Postman_Sort.js --- Postman_Sort/Postman_Sort.cpp | 98 +++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 Postman_Sort/Postman_Sort.cpp diff --git a/Postman_Sort/Postman_Sort.cpp b/Postman_Sort/Postman_Sort.cpp new file mode 100644 index 000000000..f25c4b651 --- /dev/null +++ b/Postman_Sort/Postman_Sort.cpp @@ -0,0 +1,98 @@ +/* +* C++ Implementation for Postman Sort Algorithm. +* This is the algorithm used by letter-sorting machines in the post office: +* first states, then post offices, then routes, etc. +* Since keys are not compared against each other, sorting time is O(cn), +* where c depends on the size of the key and number of buckets. +*/ + +#include +using namespace std; + +void arrange(int p, int s); +int temp, maxdigits = 0, c = 0; +int t1, t2, k, t, n = 1, i, j; +int arr[100], arr1[100]; +int main(){ + int count, max; + cout << "The size of the Array : " ; + cin >> count; + int arr[count]; + for(i = 0; i < count; i++) + cin >> arr[i]; + + cout << "\nThe Unsorted Array is : \n" ; + for(i = 0; i < count; i++) + cout << arr[i] << " "; + + for(i = 0; i < count; i++) { + // first element in t + t = arr[i]; + // Calculating the Number of digits using logarithmic + c = log10(arr[i]); + // number of digits in a each number + if(maxdigits < c) + maxdigits = c; + } + + while(--maxdigits) + n = n * 10; + + for(i = 0; i < count; i++) { + // MSB - Dividing by particular base + max = arr[i] / n; + t = i; + for(j = i + 1; j < count; j++) { + if(max > arr[j] / n) { + max = arr[j] / n; + t = j; + } + } + swap(arr1[t], arr1[i]); + swap(arr[t], arr[i]); + } + + while (n >= 1) { + for(i = 0; i < count;) { + t1 = arr[i] / n; + for(j = i + 1; t1 == (arr[j] / n); j++); + arrange(i, j); + i = j; + } + n = n / 10; + } + + cout << "\nThe Sorted Array is : \n"; + for(int i = 0; i < count; i++) + cout << arr[i] << " "; + cout << "\n"; + return 0; +} + +// Function to arrange the of sequence having same base +void arrange(int p, int s) { + for(int i = p; i < s - 1; i++) { + for(int j = i + 1; j < s; j++) { + if(arr1[i] > arr1[j]) { + // swap arr1[i] and arr1[j] + swap(arr1[i], arr1[j]); + + temp = arr[i] % 10; + arr[i] = arr[j] % 10; + arr[j] = temp; + } + } + } +} + +/* +INPUT : +The size of the Array : 10 +70, 80, 20, 50, 10, 60, 40, 100, 90, 30 + +OUTPUT : +The Unsorted Array is : +70 80 20 50 10 60 40 100 90 30 +The Sorted Array is : +10 20 30 40 50 60 70 80 90 100 +*/ From 2c7a046449b74f63af730dd25850bfa4ed80744f Mon Sep 17 00:00:00 2001 From: Kamal Sharma <43444282+KamalDGRT@users.noreply.github.com> Date: Tue, 19 May 2020 22:29:39 +0530 Subject: [PATCH 162/265] Create Pancake_Sort.go (#2928) --- Pancake_Sort/Pancake_Sort.go | 85 ++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 Pancake_Sort/Pancake_Sort.go diff --git a/Pancake_Sort/Pancake_Sort.go b/Pancake_Sort/Pancake_Sort.go new file mode 100644 index 000000000..0feb1e14f --- /dev/null +++ b/Pancake_Sort/Pancake_Sort.go @@ -0,0 +1,85 @@ +// Program in Go language that implements Pancake Sort + +package main + +import "fmt" + +//Reverses array +func flip(array []int, index int) { + var start int + start = 0 + for start < index { + array[start], array[index] = array[index], array[start] + start++ + index-- + } +} + +// Returns index of element with maximum value in the array +func maxIndex(array []int, n int) int { + var index int + index = 0 + for i := 0; i < n; i++ { + if array[i] > array[index] { + index = i + } + } + return index +} + +// Function to sort the array using pancake sort + +func pancakeSort(array []int, n int) { + // Reducing the size of the array one at a time + for size := n; size > 1; size-- { + max := maxIndex(array, size) + // If the max element is not in the end of the array, move it there + if max != size-1 { + // We move the maximum element to the beginning and then flip the array to move the element to the end + flip(array, max) + flip(array, size-1) + } + } +} + +func main() { + + // Declare the array size + var arraySize int + + fmt.Print("Enter number of elements in your array: ") + + fmt.Scan(&arraySize) + + fmt.Print("Enter your array: ") + + // Creating the array + array := make([]int, arraySize) + + for i := 0; i < arraySize; i++ { + fmt.Scan(&array[i]) + } + + fmt.Printf("Unsorted Array: ") + for i := 0; i < arraySize; i++ { + fmt.Printf("%d ", array[i]) + } + + pancakeSort(array, arraySize) + + fmt.Printf("\nSorted Array: ") + for i := 0; i < arraySize; i++ { + fmt.Printf("%d ", array[i]) + } + +} + +/* +Output after Execution: + +Enter number of elements in your array: 6 +Enter your array: 2 1 5 4 9 8 +Unsorted Array: 2 1 5 4 9 8 +Sorted Array: 1 2 4 5 8 9 + +*/ From 57b6134d66751d6730177254fe6e51aaafa84725 Mon Sep 17 00:00:00 2001 From: Monika Jha <53649201+m-code12@users.noreply.github.com> Date: Wed, 20 May 2020 00:17:29 +0530 Subject: [PATCH 163/265] Bubble Sort in Rust (#2899) --- Bubble_Sort/Bubble_Sort.rs | 48 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 Bubble_Sort/Bubble_Sort.rs diff --git a/Bubble_Sort/Bubble_Sort.rs b/Bubble_Sort/Bubble_Sort.rs new file mode 100644 index 000000000..c6ecd9053 --- /dev/null +++ b/Bubble_Sort/Bubble_Sort.rs @@ -0,0 +1,48 @@ +use std::io; +use std::str::FromStr; + +fn main() { + println!("Enter the numbers to be sorted (separated by space) : "); + let i = read_values::().unwrap(); + let a = bubble_sort(i); + println!("Sorted array: {:?}", a) + } + +fn bubble_sort(mut a: Vec) -> Vec { + for _ in 0..a.len() { + let mut flag = false; + for j in 0..a.len() - 1 { + if a[j] > a[j + 1] { + let temp = a[j]; + a[j] = a[j + 1]; + a[j + 1] = temp; + flag = true + } + } + if !flag { + break; + } + } + a +} + +fn read_values() -> Result, T::Err> { + let mut s = String::new(); + io::stdin() + .read_line(&mut s) + .expect("could not read from stdin"); + s.trim() + .split_whitespace() + .map(|word| word.parse()) + .collect() +} + +/* + + Output : + Enter the numbers to be sorted (separated by space) : + 5 2 8 6 89 + Sorted array: [2, 5, 6, 8, 89] + +*/ + From 3101e392361bbfdb0b5cebe43c3ccc97743dcd94 Mon Sep 17 00:00:00 2001 From: Monika Jha <53649201+m-code12@users.noreply.github.com> Date: Wed, 20 May 2020 00:21:10 +0530 Subject: [PATCH 164/265] Merge Sort in Typescript (#2891) --- Merge_Sort/Merge_Sort.ts | 46 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Merge_Sort/Merge_Sort.ts diff --git a/Merge_Sort/Merge_Sort.ts b/Merge_Sort/Merge_Sort.ts new file mode 100644 index 000000000..4ba47def7 --- /dev/null +++ b/Merge_Sort/Merge_Sort.ts @@ -0,0 +1,46 @@ +export function mergeSort(array: number[]): number[] { + if (array.length <= 1) { + return array; + } + const middle = Math.floor(array.length / 2); + const left = array.slice(0, middle); + const right = array.slice(middle); + return merge(mergeSort(left), mergeSort(right)); +} + +function merge(left: number[], right: number[]): number[] { + const array: number[] = []; + let lIndex = 0; + let rIndex = 0; + while (lIndex + rIndex < left.length + right.length) { + const lItem = left[lIndex]; + const rItem = right[rIndex]; + if (lItem == null) { + array.push(rItem); + rIndex++; + } + else if (rItem == null) { + array.push(lItem); + lIndex++; + } + else if (lItem < rItem) { + array.push(lItem); + lIndex++; + } + else { + array.push(rItem); + rIndex++; + } + } + return array; +} +console.log(mergeSort([8, 7, 4, 30, 21, 12])); + + +/* + + Input : [8, 7, 4, 30, 21, 12] + Output : [ 4, 7, 8, 12, 21, 30 ] + +*/ + From c8b8ccb09dd64a92f7caf78c4779c2344c08ad74 Mon Sep 17 00:00:00 2001 From: Simrann Arora Date: Wed, 20 May 2020 00:27:14 +0530 Subject: [PATCH 165/265] Create Euclidean_Algorithm.c (#2944) --- Euclidean_Algorithm/Euclidean_Algorithm.c | 31 +++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Euclidean_Algorithm/Euclidean_Algorithm.c diff --git a/Euclidean_Algorithm/Euclidean_Algorithm.c b/Euclidean_Algorithm/Euclidean_Algorithm.c new file mode 100644 index 000000000..977cf2ad9 --- /dev/null +++ b/Euclidean_Algorithm/Euclidean_Algorithm.c @@ -0,0 +1,31 @@ +// Program to demonstrate Basic Euclidean Algorithm +#include + +// Function to return gcd of x and y +int gcd_algorithm(int x,int y) +{ + // if the remainder is 0, return second number + if(x == 0) + { + return y; + } + return gcd_algorithm((y % x),x); // recursive call to the function +} + +// Driver program +int main() +{ + int num1, num2, gcd; + printf("\nEnter two numbers to find gcd using Euclidean algorithm: "); + scanf("%d %d", &num1, &num2); + gcd = gcd_algorithm(num1, num2); + printf("\nThe GCD of %d and %d is %d\n", num1, num2, gcd); + return 0; +} + +/* +Output- +Enter two numbers to fing gcd using Euclidean algorithm: +12 16 +The GCD of 12 and 16 is 4 +*/ From 10c7d526422e3c66143ea97f6b9289338bf84dda Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Wed, 20 May 2020 00:30:34 +0530 Subject: [PATCH 166/265] Add Counting sort in Kotlin (#2902) --- Counting_Sort/Counting_Sort.kt | 78 ++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Counting_Sort/Counting_Sort.kt diff --git a/Counting_Sort/Counting_Sort.kt b/Counting_Sort/Counting_Sort.kt new file mode 100644 index 000000000..a009de4bc --- /dev/null +++ b/Counting_Sort/Counting_Sort.kt @@ -0,0 +1,78 @@ +// Kotlin Code for Counting Sort + +public class Counting_Sort { + // Function that sort the given input + fun sort(int:input[]):void + { + int n = input.length; + int output[] = new int[n]; + int max = input[0]; + int min = input[0]; + + for(i in 1 until n) + { + if(input[i] > max) + { + max = input[i]; + } + + else if(input[i] < min) + { + min = input[i]; + } + } + + // Size of count array + int k = max - min + 1; + int count_array[] = new int[k]; + + for(i in 0 until n) + { + count_array[input[i] - min]++; + } + + for(i in 1 until k) + { + count_array[i] += count_array[i - 1]; + } + + + for(i in 0 until n) + { + output[count_array[input[i] - min] - 1] = input[i]; + count_array[input[i] - min]--; + } + // Copy the output array to input, so that input now contains sorted values + for(i in 0 until n) + { + input[i] = output[i]; + } + } + + // Main Function + fun main() + { + var read = Scanner(System.`in`) + println("Enter the size of Array:") + val arrSize = read.nextLine().toInt() + var input = IntArray(arrSize) + println("Enter elements") + for(i in 0 until arrSize) + { + input[i] = read.nextLine().toInt() + } + + sort(input); + for(i in 0 until arrSize) + { + println(input[i]); + } + } +} + +/* +Input +2 1 4 1 3 5 7 5 4 +Output +1 1 2 3 4 4 5 5 7 +*/ From f9bbcf17f2dedb5de257ca1942f0985be35e0668 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Wed, 20 May 2020 00:35:35 +0530 Subject: [PATCH 167/265] Selection sort in rust (#2916) Selection sort in rust --- Selection_Sort/Selection_sort.rs | 63 ++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Selection_Sort/Selection_sort.rs diff --git a/Selection_Sort/Selection_sort.rs b/Selection_Sort/Selection_sort.rs new file mode 100644 index 000000000..2653dd244 --- /dev/null +++ b/Selection_Sort/Selection_sort.rs @@ -0,0 +1,63 @@ +// Rust program for Selection Sort +use std::io; + +fn main() { + println!(" Enter number of elements to be entered in the array "); + let mut size = String::new(); + + io::stdin().read_line(&mut size).expect("failed to read input."); + let size: usize = size.trim_end().parse().expect("invalid input"); + + let mut vector: Vec = Vec::with_capacity(size as usize); + + println!("Enter elements of array "); + let mut index = 0; + + // Enter values into vector + while index < size { + index += 1; + // Note: Rust takes spaces as non-intergral value + let mut temp_arr = String::new(); + io::stdin().read_line(&mut temp_arr).expect("failed to read input."); + let temp_arr: usize = temp_arr.trim_end().parse().expect("invalid input"); + vector.push(temp_arr); + } + + for index in 0..size - 1 { + let mut minimum = index; + let mut j = index + 1; + while j < size { + if vector[j] < vector[minimum] { + minimum = j; + j += 1; + } + // Swapping the smallest number in vector with the indexth location number + let temp = vector[minimum]; + vector[minimum] = vector[index]; + vector[index] = temp; + } + } + + println!("Sorted array is "); + for index in 0..size { + println!("{:?}",vector[index]); + } +} +/* +TEST CASE + +INPUT + Enter number of elements to be entered in the array +3 +Enter elements of array +3 +2 +1 + +OUTPUT +Sorted array is +1 +2 +3 +*/ + From 179d58403e0996595ecca4519fdad38823b3548e Mon Sep 17 00:00:00 2001 From: Abhinav Anand Date: Wed, 20 May 2020 00:41:46 +0530 Subject: [PATCH 168/265] Fixed a typo in the code (#2938) --- Bubble_Sort/Bubble_Sort.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Bubble_Sort/Bubble_Sort.cpp b/Bubble_Sort/Bubble_Sort.cpp index 7c0f90d72..2ad496eae 100644 --- a/Bubble_Sort/Bubble_Sort.cpp +++ b/Bubble_Sort/Bubble_Sort.cpp @@ -44,7 +44,7 @@ int main() cout<<"Enter number of elements in your array: "; cin>>num; int array[num]; - cou<<"Enter your array: "; + cout<<"Enter your array: "; for (int i = 0; i < num; i++) { cin>>array[i]; From 07e46122fcf2dbe2391d6269c47fb870fcda2622 Mon Sep 17 00:00:00 2001 From: Akash Kumar <47351616+kmrakash@users.noreply.github.com> Date: Wed, 20 May 2020 08:53:42 +0530 Subject: [PATCH 169/265] Added Readme (#2794) * Added Readme * Updated ReadMe * fixes issue * Updated * Added Readme for Flyod cycle Detection Algorithm --- Floyd_Cycle_Detection_Algorithm/README.md | 36 +++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Floyd_Cycle_Detection_Algorithm/README.md diff --git a/Floyd_Cycle_Detection_Algorithm/README.md b/Floyd_Cycle_Detection_Algorithm/README.md new file mode 100644 index 000000000..cb8606196 --- /dev/null +++ b/Floyd_Cycle_Detection_Algorithm/README.md @@ -0,0 +1,36 @@ +# Flyod's_Cycle_Detection + +Floyd's cycle-finding algorithm is a pointer algorithm that uses only two pointers, which move through the sequence at different speeds. It determines if a singly linked list is circular and if it is, It is going to return the node where the cycle begins +It was invented by **Robert W. Floyd** in late 1960s. +The algorithm is also popularly known as **The Tortoise and the Hare (Floyd’s Algorithm)** + + +## Algorithm + +1. Initialize two pointers (tortoise and hare) that both point to the head of the linked list +2. Loop as long as the hare does not reach null +3. Set tortoise to next node +4. Set hare to next, next node +5. If they are at the same node, reset the tortoise back to the head. +6. Have both tortoise and hare both move one node at a time until they meet again +7. Return the node in which they meet +8. Else, if the hare reaches null, then return null + +## Pseudo code +``` +Node Cycle_detection(Node Hare, Node Tortoise) + while(Tortoise and Hare and Hare->next) + Tortoise = Tortoise->next + Hare = Hare->next->next + if(Hare == Tortoise) + return Hare + return null +``` +## Example + +![Gif-hare-tortoise](https://miro.medium.com/max/780/1*clbAFjEFicLYjsq4pVVP4g.gif) + +## Complexity + +Time Complexity - O(N) , N :- Length of List
+Space Complexity - O(1) \ No newline at end of file From 5da2ea88af74f3c477b2decf70d8d6293fa0fd58 Mon Sep 17 00:00:00 2001 From: Sukriti Shah Date: Wed, 20 May 2020 12:35:57 +0530 Subject: [PATCH 170/265] PHP implementation for Dijkstra's Algorithm (Issue #2204) (#2890) Adding PHP Implementation of Dijkstra's Algo. Updated PHP implementation for Dijkstra's Algorithm (Issue #2204) --- Dijkstra_Algorithm/Dijkstra_Algorithm.php | 82 +++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 Dijkstra_Algorithm/Dijkstra_Algorithm.php diff --git a/Dijkstra_Algorithm/Dijkstra_Algorithm.php b/Dijkstra_Algorithm/Dijkstra_Algorithm.php new file mode 100644 index 000000000..c16e38c63 --- /dev/null +++ b/Dijkstra_Algorithm/Dijkstra_Algorithm.php @@ -0,0 +1,82 @@ + $dist[$i])) ){ + $minVertex = $i; + } + } + return $minVertex; +} + +function dijkstra($graph, $vertices){ + + $visited = array(); + $dist = array(); + + for($i = 0; $i < $vertices; ++$i){ + $visited[$i] = false; + $dist[$i] = PHP_INT_MAX; + } + + // 0 is the source/starting vertex + $dist[0] = 0; + + for($i = 0; $i < $vertices-1; ++$i){ + $minVertex = getMinVertex($dist, $visited, $vertices); + // Mark the minVertex as visited + $visited[$minVertex] = true; + + // Explore all unvisited neighbours of minVertex + // and update the dist array if required + for($j = 0; $j < $vertices; ++$j){ + if($graph[$minVertex][$j] != 0 && !$visited[$j]){ + $currD = $dist[$minVertex] + $graph[$minVertex][$j]; + if($dist[$j] > $currD){ + $dist[$j] = $currD; + } + } + } + } + + // Print the vertices and their corresponding distances from the source vertex + echo "Vertex\tDistance from source\n"; + for($k = 0; $k < $vertices; ++$k){ + echo $k."\t".$dist[$k]."\n"; + } +} + +// Sample Graph (Sample Input) - Adjacency Matrix representation +$graph = array( + array(0, 3, 0, 5), + array(3, 0, 1, 0), + array(0, 1, 0, 8), + array(5, 0, 8, 0) + ); + +// Function for Dijkstra'a algorithm +dijkstra($graph, 4); + +/* +Sample Input: +$graph = array( + array(0, 3, 0, 5), + array(3, 0, 1, 0), + array(0, 1, 0, 8), + array(5, 0, 8, 0) + ); + +Sample Output: +Vertex Distance from source +0 0 +1 3 +2 4 +3 5 +*/ + +?> From a04087e5e82e82ee98a686dc09f360cbb8e051c2 Mon Sep 17 00:00:00 2001 From: shivanidalmia1203 <47073500+shivanidalmia1203@users.noreply.github.com> Date: Wed, 20 May 2020 13:32:04 +0530 Subject: [PATCH 171/265] Add files in TypeScript (#2945) --- .../Tree_Inorder_Traversal.ts | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 Tree_Inorder_Traversal/Tree_Inorder_Traversal.ts diff --git a/Tree_Inorder_Traversal/Tree_Inorder_Traversal.ts b/Tree_Inorder_Traversal/Tree_Inorder_Traversal.ts new file mode 100644 index 000000000..dbb6ab474 --- /dev/null +++ b/Tree_Inorder_Traversal/Tree_Inorder_Traversal.ts @@ -0,0 +1,57 @@ +export {} +// Node +interface node +{ + key: number; + parent?: node; + left?: node; + right?: node; +} + + +// Defining the nodes with their values and left right children +const node9: node = { key: 9, left: undefined, right: undefined }; +const node8: node = { key: 8, left: undefined, right: undefined }; +const node7: node = { key: 7, left: undefined, right: undefined }; +const node6: node = { key: 6, left: undefined, right: undefined }; +const node5: node = { key: 5, left: undefined, right: undefined }; +const node4: node = { key: 4, left: node8, right: node9 }; +const node3: node = { key: 3, left: node6, right: node7 }; +const node2: node = { key: 2, left: node4, right: node5 }; +const root: node = { key: 1, parent: undefined, left: node2, right: node3 }; + +// Construct a tree by assigning parents +function constructTree(): node +{ + root.parent = undefined; + node2.parent = root; + node3.parent = root; + node4.parent = node2; + node5.parent = node2; + node6.parent = node3; + node7.parent = node3; + node8.parent = node4; + node9.parent = node4; + + return root; + } + +function inOrderTraversal(node: node) : null + { + if (!node) + return; + inOrderTraversal(node.left); + console.log(node.key + " -> "); + inOrderTraversal(node.right); + } + + +constructTree(); +console.log("The inorder traversal of the binary tree is :"); +inOrderTraversal(root); + +/* +Output +The inorder traversal of the binary tree is : +8 -> 4 -> 9 -> 2 -> 5 -> 1 -> 6 -> 3 -> 7 +*/ \ No newline at end of file From 48abee1db7b9c5b7428afe7049676dfc618494e5 Mon Sep 17 00:00:00 2001 From: Roma Vardiyani <59890472+bohemian98@users.noreply.github.com> Date: Wed, 20 May 2020 21:12:25 +0530 Subject: [PATCH 172/265] Ford Fulkerson in JS(changes made) (#2865) --- .../Ford_Fulkerson_Method.js | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 Ford_Fulkerson_Method/Ford_Fulkerson_Method.js diff --git a/Ford_Fulkerson_Method/Ford_Fulkerson_Method.js b/Ford_Fulkerson_Method/Ford_Fulkerson_Method.js new file mode 100644 index 000000000..fc177a725 --- /dev/null +++ b/Ford_Fulkerson_Method/Ford_Fulkerson_Method.js @@ -0,0 +1,142 @@ +//+++++++++++++++Utility+++++++++++++++++ +//Queue Data Structure implemented +function Queue() { + this.elements = []; + } + Queue.prototype.enqueue = function (e) { + this.elements.push(e); + }; + // remove an element from the front of the queue +Queue.prototype.dequeue = function () { + return this.elements.shift(); +}; +// check if the queue is empty +Queue.prototype.isEmpty = function () { + return this.elements.length == 0; +}; +// get the element at the front of the queue +Queue.prototype.peek = function () { + return !this.isEmpty() ? this.elements[0] : undefined; +}; +Queue.prototype.length = function() { + return this.elements.length; +} + +//++++++++++++++++++++++++++++++++++++++++++ +//Function to do breadth first search in graph +function bfs(reducedGraph, source, sink, path, V) +{ + //array to store if the node is visited or not + var visited = [V]; + //intially no node is visited + for (var i = 0; i < V; i++) + visited[i] = false; + let q = new Queue(); + //Starting from source + q.enqueue(source); + visited[source] = true; + //parent of starting node will be nothing hence -1 is stored in it + path[source] = -1; + + while (!q.isEmpty()) + { + var u = q.peek(); + q.dequeue(); + for(var v = 0; v < V; v++) + { + if(visited[v] === false && reducedGraph[u][v] > 0) + { + q.enqueue(v); + path[v] = u; + visited[v] = true; + } + } + } + //If there exist path from source to sink then it will return true else false + return (visited[sink] === true); +} + +function fordFulkerson(graph,source,sink,V) +{ + //reducedGraph is used to store the remaining capacity. reducedGraph[i][j] + //indicates remaining capacity of edge from i to jif edge exists. + var reducedGraph = []; + for( var i = 0; i < V; i++) + { + reducedGraph[i] = []; + for(var j = 0; j < V; j++) + { + reducedGraph[i][j] = graph[i][j]; + } + } + //Path is used to store parent + var path = [V]; + //variable to store maximum flow in the path chosen + var max_flow = 0; + while (bfs(reducedGraph, source, sink, path, V)) + { + var path_flow = Number.MAX_VALUE; + //Finding maximum flow in the path selected + for(var v = sink; v != source; v = path[v]) + { + var u = path[v]; + path_flow = Math.min( path_flow, reducedGraph[u][v]); + } + //Updating remaining capacity odf the edges + for( var v = sink ; v != source; v = path[v]) + { + var u = path[v]; + reducedGraph[u][v] -= path_flow; + reducedGraph[v][u] += path_flow; + } + max_flow += path_flow; + } + return max_flow; +} +//Used synchronous readline package to take console input +var readlineSync = require('readline-sync'); +//Input number of nodes in a graph +var V = readlineSync.question('Enter number of nodes in a graph: '); +//Input the weight matrix for the directed graph + +var graph = []; +for(var i = 0; i < V; i++) +{ + graph[i] = []; + for(var j = 0; j < V; j++) + { + console.log(`Enter the weight form ` , i , `to `,j, `: `); + var a = readlineSync.question(); + graph[i][j] = a; + } +} +var source = readlineSync.question("Enter source: "); +var sink = readlineSync.question("Enter Sink: "); +var ans = fordFulkerson(graph,source,sink,V); +console.log('Maximum flow from source to sink is: ', ans); +/*Input1: +V = 6 +graph = [ [0, 16, 13, 0, 0, 0], + [0, 0, 10, 12, 0, 0], + [0, 4, 0, 0, 14, 0], + [0, 0, 9, 0, 0, 20], + [0, 0, 0, 7, 0, 4], + [0, 0, 0, 0, 0, 0] + ]; +source = 0 sink = 5 +Output1: 23 + +Input2: +V = 6 +graph = [ [0, 10, 0, 3, 0, 0], + [0, 0, 8, 2, 0, 0], + [0, 0, 0, 0, , 10], + [0, 0, 6, 0, 7, 0], + [0, 0, 0, 0, 10, 0], + [0, 0, 0, 0, 0, 0] + ]; +source = 0 +sink = 5 +Output2: 10 +*/ + From 1fcf5733d7f09005ff8db011febabc55aa5804e0 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Thu, 21 May 2020 23:20:38 +0530 Subject: [PATCH 173/265] linear search in rust (#2950) linear search in rust Linear search in rust --- Linear_Search/Linear_Search.rs | 68 ++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 Linear_Search/Linear_Search.rs diff --git a/Linear_Search/Linear_Search.rs b/Linear_Search/Linear_Search.rs new file mode 100644 index 000000000..d6c5d2aef --- /dev/null +++ b/Linear_Search/Linear_Search.rs @@ -0,0 +1,68 @@ +// Rust program for Linear Search +use std::io; + +fn main() { + println!(" Enter number of elements to be entered in the array "); + let mut size = String::new(); + + io::stdin().read_line(&mut size).expect("failed to read input."); + let size: usize = size.trim_end().parse().expect("invalid input"); + let mut vector: Vec = Vec::with_capacity(size as usize); + + println!("Enter element to be searched " ); + let mut element = usize::new(); + + println!("Enter elements of array "); + let mut index = 0; + + // Enter values into vector + while index < size { + index += 1; + // Note: Rust takes spaces as non-intergral value + let mut temp_arr = String::new(); + io::stdin().read_line(&mut temp_arr).expect("failed to read input."); + let temp_arr: usize = temp_arr.trim_end().parse().expect("invalid input"); + vector.push(temp_arr); + } + + // Linear Search process + let mut checkpoint = 0; + for index in 0..size - 1 { + if element == vector[index]{ + checkpoint = 1; + println!("Element is found at index "); + println!("{:?}" , index + 1); + } + } + + if checkpoint == 0 { + println!("Element is not found in the array "); + } +} +/* +TEST CASE +INPUT + Enter number of elements to be entered in the array +3 +Enter element to be searched +2 +Enter elements of array +1 +2 +3 +OUTPUT +Element is found at index +2 +INPUT + Enter number of elements to be entered in the array +3 +Enter element to be searched +5 +Enter elements of array +1 +2 +3 +OUTPUT +Element is not found in the array +*/ + From f4b3b3f73fa895376ab362906e382c3e8b09799a Mon Sep 17 00:00:00 2001 From: Abhinav Anand Date: Fri, 22 May 2020 21:45:25 +0530 Subject: [PATCH 174/265] Create Extended_Euclidean_Algorithm.rb (#2949) --- .../Extended_Euclidean_Algorithm.rb | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.rb diff --git a/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.rb b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.rb new file mode 100644 index 000000000..e4076814a --- /dev/null +++ b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.rb @@ -0,0 +1,36 @@ +=begin +Extended Euclidean Algorithm +============================== +GCD of two numbers is the largest number that divides both of them. +A simple way to find GCD is to factorize both numbers and multiply common factors. + +GCD(a,b) = ax + by +If we can find the value of x and y then we can easily find the +value of GCD(a,b) by replacing (x,y) with their respective values. +=end + +def extended_gcd(a, b, x, y) #Function for extended Euclidean Algorithm + + #Base Case + return b if a == 0 + + x1, y1 = 1, 1 #To store results of recursive call + gcd = extended_gcd(b % a, a, x1, y1) + #Update x and y using results of recursive call + x = y1 - (b / a) * x1 + y = x1 + return gcd +end + +x , y = 1, 1 +a = gets.to_i +b = gets.to_i +puts "GCD of numbers #{a} and #{b} is #{extended_gcd(a, b, x, y)}" + +=begin +INPUT: +27 +81 +OUTPUT: +GCD of numbers 27 and 81 is 27 +=end From dc117b69a6f8f461d5f6e131e495a9ee42fb125d Mon Sep 17 00:00:00 2001 From: Lakshyajit Laxmikant <30868587+lakshyajit165@users.noreply.github.com> Date: Fri, 22 May 2020 13:27:44 -0400 Subject: [PATCH 175/265] Modified spacing extended euclidean algorithm in java (#2953) --- .../Extended_Euclidean_Algorithm.java | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.java diff --git a/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.java b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.java new file mode 100644 index 000000000..eaa13be6b --- /dev/null +++ b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.java @@ -0,0 +1,46 @@ +import java.util.*; + +public class Extended_Euclidean_Algorithm +{ + // extended Euclidean Algorithm + public static int getGCD(int a, int b, int x, int y) + { + // Base Case + if (a == 0) + { + x = 0; + y = 1; + return b; + } + + int x1 = 1, y1 = 1; // To store results of recursive call + int gcd = getGCD(b % a, a, x1, y1); + + // Update x and y after recursive call + x = y1 - (b / a) * x1; + y = x1; + + return gcd; + } + +// Main function + public static void main(String[] args) + { + int x = 1, y = 1; + Scanner s = new Scanner(System.in); + int a = s.nextInt(); + int b = s.nextInt(); + int g = getGCD(a, b, x, y); + System.out.print("GCD of " + a + " , " + b + " = " + g); + } +} + + + +/* + INPUT + a = 35, b = 15; + + Output: + GCD of 35 , 15 = 5 +*/ From 4f2b73b0b6f1ceb4b50f551c8ef9754cbaecf7a6 Mon Sep 17 00:00:00 2001 From: thakran14 <47153756+thakran14@users.noreply.github.com> Date: Sat, 23 May 2020 00:06:25 +0530 Subject: [PATCH 176/265] Added Exponential Search in PHP (#2957) Update Exponential_Search.php --- Exponential_Search/Exponential_Search.php | 50 +++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 Exponential_Search/Exponential_Search.php diff --git a/Exponential_Search/Exponential_Search.php b/Exponential_Search/Exponential_Search.php new file mode 100644 index 000000000..11a24146c --- /dev/null +++ b/Exponential_Search/Exponential_Search.php @@ -0,0 +1,50 @@ + $left) + { + $mid = $left + ($right - $left) / 2; + if ($input_arr[$mid] == $x) + return $mid; + if ($x < $input_arr[$mid] ) + return Binary_Search($input_arr, $left, $mid - 1, $x); + + return Binary_Search($input_arr, $mid + 1, $right, $x); + } + return -1; +} + +function Exponential_Search($input_arr,$size,$x) +{ + if ($input_arr[0] == $x) + return 0; + $i = 1; + while ($i < $size and $input_arr[$i] <= $x) + { + $i = $i * 2; + } + + return Binary_Search($input_arr, $i / 2, min($i, $size), $x); + +} + +//Driver Code + +$input_arr = array(1, 2, 3, 4, 5, 6); +$size = count($input_arr); +$x = 4; +$result = exponential_search($input_arr, $size, $x); +if ($result != -1) + echo "The index at which the element " , $x, " is present is " , $result; + +else + echo "The element is not present in array"; + +/* +OUTPUT: +The index at which the element 4 is present is 3 +*/ + +?> From 2e71476b4193ee8831c1a8335d81d334224eb1bd Mon Sep 17 00:00:00 2001 From: shivanidalmia1203 <47073500+shivanidalmia1203@users.noreply.github.com> Date: Sat, 23 May 2020 18:41:14 +0530 Subject: [PATCH 177/265] Add Aho-Corasick in Python (#2962) --- Aho-Corasick/Aho-Corasick.py | 89 ++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 Aho-Corasick/Aho-Corasick.py diff --git a/Aho-Corasick/Aho-Corasick.py b/Aho-Corasick/Aho-Corasick.py new file mode 100644 index 000000000..91f96f169 --- /dev/null +++ b/Aho-Corasick/Aho-Corasick.py @@ -0,0 +1,89 @@ +# AhoNode class +class AhoNode: + def __init__(self): + self.goto = {} + self.out = [] + self.fail = None + + +# creating aho forest +def aho_create_forest(patterns): + root = AhoNode() + + for path in patterns: + node = root + for symbol in path: + node = node.goto.setdefault(symbol, AhoNode()) + node.out.append(path) + return root + + +# Creating aho automata +def aho_create_statemachine(patterns): + root = aho_create_forest(patterns) + queue = [] + for node in root.goto.values(): + queue.append(node) + node.fail = root + + while len(queue) > 0: + rnode = queue.pop(0) + + for key, unode in rnode.goto.items(): + queue.append(unode) + fnode = rnode.fail + while fnode is not None and key not in fnode.goto: + fnode = fnode.fail + unode.fail = fnode.goto[key] if fnode else root + unode.out += unode.fail.out + + return root + + +def aho_find_all(s, root, callback): + node = root + + for i in range(len(s)): + while node is not None and s[i] not in node.goto: + node = node.fail + if node is None: + node = root + continue + node = node.goto[s[i]] + for pattern in node.out: + callback(i - len(pattern) + 1, pattern) + + +# Printing the position of pattern found +def print_pattern(pos, patterns): + print("At pos %s found pattern: %s" % (pos, patterns)) + + +if __name__ == "__main__": + patterns = [] + + # taking inputs + n = int(input("Enter no. of elements :- ")) + for i in range(0, n): + ele = input("Enter element :- ") + patterns.append(ele) + s = input("Enter text :- ") + + root = aho_create_statemachine(patterns) + aho_find_all(s, root, print_pattern) + + +""" +INPUT: +n=6 +patterns = ['a', 'ab', 'abc', 'bc', 'c', 'cba'] +s = "abcba" + +OUTPUT: +At pos 0 found pattern: a +At pos 0 found pattern: ab +At pos 0 found pattern: abc +At pos 1 found pattern: bc +At pos 2 found pattern: c +At pos 2 found pattern: cba +""" \ No newline at end of file From 25e6d6128a8d3c9041aad42a8b797e8dee0bb7f8 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Mon, 25 May 2020 00:43:18 +0530 Subject: [PATCH 178/265] Binary search in rust (#2927) Binary search in rust --- Binary_Search/Binary_Search.rs | 88 ++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 Binary_Search/Binary_Search.rs diff --git a/Binary_Search/Binary_Search.rs b/Binary_Search/Binary_Search.rs new file mode 100644 index 000000000..08d24b231 --- /dev/null +++ b/Binary_Search/Binary_Search.rs @@ -0,0 +1,88 @@ +// Rust program for Binary Search +use std::io; + +fn main() { + println!(" Enter number of elements to be entered in the array "); + let mut size = String::new(); + + io::stdin().read_line(&mut size).expect("failed to read input."); + let size: usize = size.trim_end().parse().expect("invalid input"); + let mut vector: Vec = Vec::with_capacity(size as usize); + + println!("Enter element to be searched " ); + let mut element = usize::new(); + + println!("Enter elements of array in a sorted array "); + let mut index = 0; + + // Enter values into vector + while index < size { + index += 1; + // Note: Rust takes spaces as non-intergral value + let mut temp_arr = String::new(); + io::stdin().read_line(&mut temp_arr).expect("failed to read input."); + let temp_arr: usize = temp_arr.trim_end().parse().expect("invalid input"); + vector.push(temp_arr); + } + + // Binary Search process + let mut leftpart = 0; + let mut rightpart = size - 1; + let mut midindex = 0; + let mut checkpoint = 0; + while leftpart <= rightpart { + midindex = leftpart + (rightpart - leftpart) / 2; + + // Element found + if vector[midindex] == element{ + checkpoint = 1; + println!("Element is found at index "); + println!("{:?}" , midindex + 1); + break; + } + + else if vector[midindex] < element{ + leftpart = midindex + 1; + } + + else { + rightpart = midindex - 1; + } + + } + + if checkpoint == 0 { + println!("Element is not found in the array "); + } +} +/* +TEST CASE + +INPUT + Enter number of elements to be entered in the array +3 +Enter element to be searched +2 +Enter elements of array in a sorted array +1 +2 +3 + +OUTPUT +Element is found at index +2 + +INPUT + Enter number of elements to be entered in the array +3 +Enter element to be searched +5 +Enter elements of array in a sorted array +1 +2 +3 + +OUTPUT +Element is not found in the array +*/ + From d8e3a027e632c1310522218a16bf85a331dd7d51 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 25 May 2020 00:54:13 +0530 Subject: [PATCH 179/265] Shell Sort In Ruby (#2969) Updated Minor Changes --- Shell_Sort/Shell_Sort.rb | 76 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Shell_Sort/Shell_Sort.rb diff --git a/Shell_Sort/Shell_Sort.rb b/Shell_Sort/Shell_Sort.rb new file mode 100644 index 000000000..30b17ada8 --- /dev/null +++ b/Shell_Sort/Shell_Sort.rb @@ -0,0 +1,76 @@ +# Shell Sort In Ruby + +# Function Definition +def shell_sort(values) + inct = values.size / 2 + + while inct > 0 + inct.upto(values.size - 1){ |i| + j = i + temp = values[i] + + while j >= inct and values[j - inct] > temp + values[j] = values[j - inct] + j -= inct + end + + values[j] = temp + } + inct = (inct == 2 ? 1 : inct * 10 / 22) + end + values +end + +# Taking User Input +puts "Enter the size of array: " +size = gets.to_i +puts +input_array = Array.new(size) + +counter = 0 + +# Input Array Values Using While Loop +while(counter != size) + puts "Enter the value at index #{counter}: " + input_array[counter] = gets.to_i + counter += 1 +end + +puts + +puts "Input Array: #{input_array}" +puts "Shell Sort: " + +# Function Call +shell_sort(input_array) +puts "#{input_array}" + += begin + +Enter the size of array: 5 + +Enter the value at index 0: 121 +Enter the value at index 1: 71 +Enter the value at index 2: 1 +Enter the value at index 3: 88 +Enter the value at index 4: 9 + +Input Array: [121, 71, 1, 88, 9] +Shell Sort: [1, 9, 71, 88, 121] + +----------------------------------------------- + +Enter the size of array: 7 + +Enter the value at index 0: 68 +Enter the value at index 1: 1 +Enter the value at index 2: 11 +Enter the value at index 3: -8 +Enter the value at index 4: 0 +Enter the value at index 5: 3 +Enter the value at index 6: 35 + +Input Array: [68, 1, 11, -8, 0, 3, 35] +Shell Sort: [-8, 0, 1, 3, 11, 35, 68] + += end From 27e85302f140dc4169b5335bc791a5b37d96abe8 Mon Sep 17 00:00:00 2001 From: Vyom Chandra Gallani <36289357+vyom153069@users.noreply.github.com> Date: Mon, 25 May 2020 14:22:15 +0530 Subject: [PATCH 180/265] Tower_Of_Honoi.ts (#2964) --- Tower_Of_Hanoi/Tower_Of_Hanoi.ts | 118 +++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 Tower_Of_Hanoi/Tower_Of_Hanoi.ts diff --git a/Tower_Of_Hanoi/Tower_Of_Hanoi.ts b/Tower_Of_Hanoi/Tower_Of_Hanoi.ts new file mode 100644 index 000000000..8aabec37d --- /dev/null +++ b/Tower_Of_Hanoi/Tower_Of_Hanoi.ts @@ -0,0 +1,118 @@ +function solveHanoi( + count: number, + from: string, + to: string, + other: string, + move: (from: string, to: string) => void +) +{ + if (count > 0) { + //shift plat "from" to "to" using "other" plate + solveHanoi(count - 1, from, other, to, move) + move(from, to) + //shift plat "other" to "from" using "to" plate + solveHanoi(count - 1, other, to, from, move) + } +} +/**/ +// Example: six discs +var moveCount = 0 +solveHanoi(6, "Left", "Right", "Middle", (from , to) => { + ++moveCount + console.log(moveCount + ": Move Disk from " + from + " to " + to + ".") +}) + +//output for 3 +/* +1: Move Disk from Left to Right. +2: Move Disk from Left to Middle. +3: Move Disk from Right to Middle. +4: Move Disk from Left to Right. +5: Move Disk from Middle to Left. +6: Move Disk from Middle to Right. +7: Move Disk from Left to Right. +*/ + +//output for 4 +/* +1: Move Disk from Left to Middle. +2: Move Disk from Left to Right. +3: Move Disk from Middle to Right. +4: Move Disk from Left to Middle. +5: Move Disk from Right to Left. +6: Move Disk from Right to Middle. +7: Move Disk from Left to Middle. +8: Move Disk from Left to Right. +9: Move Disk from Middle to Right. +10: Move Disk from Middle to Left. +11: Move Disk from Right to Left. +12: Move Disk from Middle to Right. +13: Move Disk from Left to Middle. +14: Move Disk from Left to Right. +15: Move Disk from Middle to Right. +*/ + +//output for 6 +/* +1: Move Disk from Left to Middle. +2: Move Disk from Left to Right. +3: Move Disk from Middle to Right. +4: Move Disk from Left to Middle. +5: Move Disk from Right to Left. +6: Move Disk from Right to Middle. +7: Move Disk from Left to Middle. +8: Move Disk from Left to Right. +9: Move Disk from Middle to Right. +10: Move Disk from Middle to Left. +11: Move Disk from Right to Left. +12: Move Disk from Middle to Right. +13: Move Disk from Left to Middle. +14: Move Disk from Left to Right. +15: Move Disk from Middle to Right. +16: Move Disk from Left to Middle. +17: Move Disk from Right to Left. +18: Move Disk from Right to Middle. +19: Move Disk from Left to Middle. +20: Move Disk from Right to Left. +21: Move Disk from Middle to Right. +22: Move Disk from Middle to Left. +23: Move Disk from Right to Left. +24: Move Disk from Right to Middle. +25: Move Disk from Left to Middle. +26: Move Disk from Left to Right. +27: Move Disk from Middle to Right. +28: Move Disk from Left to Middle. +29: Move Disk from Right to Left. +30: Move Disk from Right to Middle. +31: Move Disk from Left to Middle. +32: Move Disk from Left to Right. +33: Move Disk from Middle to Right. +34: Move Disk from Middle to Left. +35: Move Disk from Right to Left. +36: Move Disk from Middle to Right. +37: Move Disk from Left to Middle. +38: Move Disk from Left to Right. +39: Move Disk from Middle to Right. +40: Move Disk from Middle to Left. +41: Move Disk from Right to Left. +42: Move Disk from Right to Middle. +43: Move Disk from Left to Middle. +44: Move Disk from Right to Left. +45: Move Disk from Middle to Right. +46: Move Disk from Middle to Left. +47: Move Disk from Right to Left. +48: Move Disk from Middle to Right. +49: Move Disk from Left to Middle. +50: Move Disk from Left to Right. +51: Move Disk from Middle to Right. +52: Move Disk from Left to Middle. +53: Move Disk from Right to Left. +54: Move Disk from Right to Middle. +55: Move Disk from Left to Middle. +56: Move Disk from Left to Right. +57: Move Disk from Middle to Right. +58: Move Disk from Middle to Left. +59: Move Disk from Right to Left. +60: Move Disk from Middle to Right. +61: Move Disk from Left to Middle. +62: Move Disk from Left to Right.*/ From 7356f1a3e4ed0a0203dc068faca928274729f505 Mon Sep 17 00:00:00 2001 From: Satyam Chaudhary Date: Mon, 25 May 2020 16:43:54 +0530 Subject: [PATCH 181/265] code added (#2967) --- .../Extended_Euclidean_Algorithm.js | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.js diff --git a/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.js b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.js new file mode 100644 index 000000000..cf5d61394 --- /dev/null +++ b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.js @@ -0,0 +1,39 @@ +// Extended Euclidean Algorithm to find GCD of two numbers + +// Function to return gcd of a and b +function gcdExtended(a, b, x, y) +{ + // Base Case + if (a == 0) + { + x = 0; + y = 1; + return b; + } + + var x1, y1; // To store results of recursive call + var gcd = gcdExtended(b % a, a, x1, y1); + + // Update x and y using results of + // recursive call + x = y1 - (b / a) * x1; + y = x1; + + return gcd; +} + +// Used synchronous readline package to take console input +var readlineSync = require('readline-sync'); + +var a = readlineSync.question('Enter first Number'); +a = parseInt(a); +var b = readlineSync.question('Enter second number'); +b = parseInt(b); + +var result = gcdExtended(a, b); +console.log("The GCD is" + " " + result) + +/* + Sample Input : 9 6 + Sample Output : The GCD is 3 +*/ From 2e415ba77bc1df2ab33293de6d65707dad0a8101 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Mon, 25 May 2020 16:51:58 +0530 Subject: [PATCH 182/265] Cycle Sort In Ruby (#2970) Updated Changes --- Cycle_Sort/Cycle_Sort.rb | 93 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 Cycle_Sort/Cycle_Sort.rb diff --git a/Cycle_Sort/Cycle_Sort.rb b/Cycle_Sort/Cycle_Sort.rb new file mode 100644 index 000000000..0203c852d --- /dev/null +++ b/Cycle_Sort/Cycle_Sort.rb @@ -0,0 +1,93 @@ +# Cycle Sort In Ruby + +# Function definition +def cycleSort!(input) + change = 0 + + # Looping through the input to find cycles to rotate + for cycleStart in 0 .. input.size - 2 + item = input[cycleStart] + + # Finding where to put the item + position = cycleStart + for i in cycleStart + 1 ... input.size + position += 1 if input[i] < item + end + + # If the item is already present, there is no cycle + next if position == cycleStart + + # Otherwise, put the item there or right after any duplicates + position += 1 while item == input[position] + input[position], item = item, input[position] + change += 1 + + # Rotate the rest of the cycle + while position != cycleStart + + # Finding where to put the item + position = cycleStart + for i in cycleStart + 1 ... input.size + position += 1 if input[i] < item + end + + # Putting the item there or right after any duplicates + position += 1 while item == input[position] + input[position], item = item, input[position] + change += 1 + end + end + change +end + +# Taking User Input +puts "Enter the size of array: " +size = gets.to_i +puts +input_array = Array.new(size) + +counter = 0 + +# Input array values using while loop +while(counter != size) + puts "Enter the value at index #{counter}: " + input_array[counter] = gets.to_i + counter += 1 +end + +puts + +puts "Input Array: #{input_array}" +puts "Cycle Sort: " + +cycleSort!(input_array) +puts "#{input_array}" + +=begin + +Sample Input + +Enter the size of array: 15 + +Enter the value at index 0: 0 +Enter the value at index 1: 1 +Enter the value at index 2: 2 +Enter the value at index 3: 2 +Enter the value at index 4: 2 +Enter the value at index 5: 2 +Enter the value at index 6: 1 +Enter the value at index 7: 9 +Enter the value at index 8: 3.5 +Enter the value at index 9: 5 +Enter the value at index 10: 8 +Enter the value at index 11: 4 +Enter the value at index 12: 7 +Enter the value at index 13: 0 +Enter the value at index 14: 6 + +Sample Output + +Input Array: [0, 1, 2, 2, 2, 2, 1, 9, 3, 5, 8, 4, 7, 0, 6] +Cycle Sort: [0, 0, 1, 1, 2, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9] + +=end From 0290290a610e5436e13af7e3fc256ca29a70b97d Mon Sep 17 00:00:00 2001 From: shivanidalmia1203 <47073500+shivanidalmia1203@users.noreply.github.com> Date: Mon, 25 May 2020 23:53:41 +0530 Subject: [PATCH 183/265] Updated file (#2989) --- .../Extended_Euclidean_Algorithm.ts | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.ts diff --git a/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.ts b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.ts new file mode 100644 index 000000000..5b82e9342 --- /dev/null +++ b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.ts @@ -0,0 +1,35 @@ +export {} + +/* +Extended Euclidean Algorithm :- Find greatest common divisor of the two numbers + a*x + b*y = gcd(a,b) + and solves the above linear equation +*/ + +// find greatest common divisor +function gcdExtended(a:number , b:number) : number[] +{ + //base case + if (a==0) + { + return [b,0,1]; + } + //recursive call + let ans: number[] = gcdExtended(b%a , a); + return [ans[0], (ans[2] - (Math.floor(b/a) * ans[1])) , ans[1]]; +} + +let a : number = 12; +let b : number = 16; + +let ans : number[] = gcdExtended(a,b); +console.log(ans[0] , ans[1] , ans[2]); + +/* +INPUT +a = 12 +b = 16 + +OUTPUT +4 -1 1 +*/ From a6923fb562faa90ca54d6e7ae7689b502aefc6f1 Mon Sep 17 00:00:00 2001 From: Satyam Chaudhary Date: Tue, 26 May 2020 00:01:41 +0530 Subject: [PATCH 184/265] Euclidean Algo added (#2966) --- Euclidean_Algorithm/Euclidean_Algorithm.js | 28 ++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Euclidean_Algorithm/Euclidean_Algorithm.js diff --git a/Euclidean_Algorithm/Euclidean_Algorithm.js b/Euclidean_Algorithm/Euclidean_Algorithm.js new file mode 100644 index 000000000..d27b6661d --- /dev/null +++ b/Euclidean_Algorithm/Euclidean_Algorithm.js @@ -0,0 +1,28 @@ +// Euclidean Algorithm to find GCD of two numbers + +// Function to return gcd of a and b +function gcd(a, b) +{ + // base case + if(b == 0) + { + return a; + } + return gcd(b, a % b); +} + +// Used synchronous readline package to take console input +var readlineSync = require('readline-sync'); + +var a = readlineSync.question('Enter first Number'); +a = parseInt(a); +var b = readlineSync.question('Enter second number'); +b = parseInt(b); + +var result = gcd(a, b); +console.log("The GCD is" + " " + result) + +/* + Sample Input : 9 6 + Sample Output : The GCD is 3 +*/ From 7344243a4db8abb89007ca237347c0f0579f57d0 Mon Sep 17 00:00:00 2001 From: Shriya Bhat <44133832+Shr03mink@users.noreply.github.com> Date: Tue, 26 May 2020 00:05:15 +0530 Subject: [PATCH 185/265] Binary Search in TypeScript (#2941) Correct Indentation fixed indentation --- Binary_Search/Binary search.ts | 59 ++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 Binary_Search/Binary search.ts diff --git a/Binary_Search/Binary search.ts b/Binary_Search/Binary search.ts new file mode 100644 index 000000000..7ff9a3d90 --- /dev/null +++ b/Binary_Search/Binary search.ts @@ -0,0 +1,59 @@ +/* Implenetation of Binary Search algorithm to find value 6 in a given array of numbers */ + +function BinarySearch( arr:number[] , n:number , val:number ) :number +{ + var start = 0 //starting index of the array + var end = n-1 //ending index + var mid = 0 + var ind = -1 + + while (start <= end) + { + mid = Math.floor((start + end) / 2) + + //checking if value to be found is at the middle + if ( val == arr[mid] ) + { + ind = mid + break + } + + /* if value to be found is greater than the middle then the algorithm + searches to the right of the middle element in the array */ + else if ( val > arr[mid] ) + { + start = mid + 1 + } + /* if value to be found is less than the middle then the algorithm + searches to the left of the middle element in the array */ + else + { + end = mid - 1 + } + } + return ind //returning the index of the value if found, else returns -1 +} +var result = 0 +var n = 0 +var val = 6 //input value +console.log(" value to be found: ", val); +var n: number = 6 //no. of elements in the array +var arr = [1, 2, 3, 4, 5, 6]; //input array +console.log(" Array of numbers is: ", arr); +result = BinarySearch(arr, n, val) +if (result != -1) { + console.log(" value ", val," found at index no. ", result," in the array "); +} +else { + console.log(" value ", val," not found "); +} + + +/* OUTPUT: + + value to be found: 6 + Array of numbers is: [ 1, 2, 3, 4, 5, 6 ] + value 6 found at index no. 5 in the array +*/ + + From 7b31916d83d579bbe73c24d3e5ca40f910dbada6 Mon Sep 17 00:00:00 2001 From: Harshita Date: Tue, 26 May 2020 12:52:31 +0530 Subject: [PATCH 186/265] circle_sort.php added (#2919) --- Circle_Sort/Circle_Sort.php | 85 +++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 Circle_Sort/Circle_Sort.php diff --git a/Circle_Sort/Circle_Sort.php b/Circle_Sort/Circle_Sort.php new file mode 100644 index 000000000..8545d9470 --- /dev/null +++ b/Circle_Sort/Circle_Sort.php @@ -0,0 +1,85 @@ + $a[$hi]) + { + $temp = $a[$lo]; + $a[$lo] = $a[$hi]; + $a[$hi] = $temp; + $swapped = true; + } + $lo++; + $hi--; + } + + if($lo == $hi) + if($a[$lo] > $a[$hi + 1]) + { + $t = $a[$low]; + $a[$low] = $a[$hi + 1]; + $a[$hi + 1] = $t; + $swapped = true; + } + + $mid = ($high - $low) / 2; + $firstHalf = circleSortRec($a , $low , $low + $mid); + $secondHalf = circleSortRec($a , $low + $mid + 1 , $high); + return $swapped || $firstHalf || $secondHalf; +} + +function circleSort($a , $n) +{ + + while(circleSortRec($a,0,$n - 1)) + { + ; + } +} + +$a = explode(' ',readline()); +$n = sizeof($a) / sizeof($a[0]); + +echo "Unsorted: "; + +for($i = 0; $i < $n; $i++) +{ + echo "$a[$i] "; +} + +circleSort($a , $n); + +echo "\n Sorted: "; + +for($i = 0; $i < $n; $i++) +{ + echo "$a[$i] "; +} + +return 0; + +/* +Input: +7 5 3 1 2 4 6 8 + +Output: +Unsorted: [6, 5, 3, 1, 8, 7, 2, 4] +Sorted: [1, 2, 3, 4, 5, 6, 7, 8] +*/ + +?> From 14da38db41e4166158a6ea011be4771e3e2131c4 Mon Sep 17 00:00:00 2001 From: Sukriti Shah Date: Wed, 27 May 2020 01:24:33 +0530 Subject: [PATCH 187/265] Adding PHP Implementation for Boyer Moore Algo. (#2968) --- Boyer_Moore_Algorithm/Boyer_Moore.php | 81 +++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Boyer_Moore_Algorithm/Boyer_Moore.php diff --git a/Boyer_Moore_Algorithm/Boyer_Moore.php b/Boyer_Moore_Algorithm/Boyer_Moore.php new file mode 100644 index 000000000..83aba52ab --- /dev/null +++ b/Boyer_Moore_Algorithm/Boyer_Moore.php @@ -0,0 +1,81 @@ += 0 && $pattern[$j] == $text[$s + $j]) + $j--; + + // If the pattern is present at current shift, then index j will become -1, so + // Shift the pattern so that the next character in text aligns + // with the last occurrence of it in pattern. + // Else, Shift the pattern so that the bad character in text aligns with + // the last occurrence of it in pattern. + if ($j < 0){ + $arr[$i++] = $s; + $s += ($s + $patternLength < $textLength) ? + $patternLength - $badChar[ord($text[$s + $patternLength])] : 1; + } + else + $s += max(1, $j - $badChar[ord($text[$s + $j])]); + } + + for ($j = 0; $j < $i; $j++) + $result[$j] = $arr[$j]; + return $result; +} + +// Sample Input +$text = "I scream, you scream, we all scream for ice cream"; +$pattern = "scream"; + +$occ = search($text, $pattern); +echo "Occurrences of pattern in text are as follows:\n"; +foreach ($occ as $res){ + echo "$res \n"; +} + +/* +Sample Input as mentioned in the code- +$text = "I scream, you scream, we all scream for ice cream" +$pattern = "scream" + +Sample Output- +Occurrences of pattern in text are as follows: +2 +14 +29 +8 +*/ +?> + + From 1bda3342aeeec923c1972a845232ac8e07c71a58 Mon Sep 17 00:00:00 2001 From: Mrunal <44579222+mruna7@users.noreply.github.com> Date: Wed, 27 May 2020 18:56:59 +0530 Subject: [PATCH 188/265] Sieve_Of_Eratosthenes (#2904) Sieve_of_eratosthenes.php Delete Binary_To_Octal.java Update Sieve_Of_Eratosthenes.php squashingthecommits Create Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Update Decimal_to_Binary Add files via upload Update Binary_To_Octal.java Update Decimal_to_Binary Update Decimal_to_Binary Update Binary_To_Octal.java Update Binary_To_Octal.java Delete Decimal_to_Binary Delete Binary_To_Octal.java --- .../Sieve_Of_Eratosthenes.php | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.php diff --git a/Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.php b/Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.php new file mode 100644 index 000000000..342c1f089 --- /dev/null +++ b/Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.php @@ -0,0 +1,29 @@ + + +/*Input: +Enter an integer + 10 +Output + 2 3 5 7 +*/ From b7a3d92aa9a6530302b7004afb3ca9508f5e567a Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Wed, 27 May 2020 19:08:31 +0530 Subject: [PATCH 189/265] Depth First Search in Kotlin (#2980) --- Depth_First_Search/Depth_First_Search.kt | 77 ++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 Depth_First_Search/Depth_First_Search.kt diff --git a/Depth_First_Search/Depth_First_Search.kt b/Depth_First_Search/Depth_First_Search.kt new file mode 100644 index 000000000..4e4817db3 --- /dev/null +++ b/Depth_First_Search/Depth_First_Search.kt @@ -0,0 +1,77 @@ +import java.util.LinkedList + +class Dfs(private val vertices: Int) { + private val adj: List> = (0 until vertices).map { LinkedList() } + fun addEdge(vertex: Int, weight: Int) { + adj[vertex].add(weight) // Add weight to vertex's list. + } + + private fun dfsUtil(vertex: Int, visited: BooleanArray) { + visited[vertex] = true // Mark the current node as visited and print it + print("$vertex ") + adj[vertex].filter { !visited[it] }.forEach { dfsUtil(it, visited) } + } + + fun traverse(startVertex: Int) { + dfsUtil(startVertex, BooleanArray(vertices)) // Call the recursive helper function to print DFS traversal + } +} + +fun main(args: Array) { + var read = Scanner(System.`in`) + println("Enter the number of vertices :") + val arrSize = read.nextLine().toInt() + val graph = Dfs(arrSize) + for(i in 0 until arrSize) + { + println("Enter the source vertex :") + val a = read.nextLine().toInt() + println("Enter the destination vertex :") + val b = read.nextLine().toInt() + graph.addEdge(a,b) + } + println("\nFollowing is Depth First Traversal :") + graph.traverse(0) + println() +} + + +/* + + Sample Input : + Enter the number of vertices : + 7 + Enter the source vertex : + 1 + Enter the destination vertex : + 2 + Enter the source vertex : + 2 + Enter the destination vertex : + 3 + Enter the source vertex : + 2 + Enter the destination vertex : + 4 + Enter the source vertex : + 3 + Enter the destination vertex : + 4 + Enter the source vertex : + 1 + Enter the destination vertex : + 5 + Enter the source vertex : + 5 + Enter the destination vertex : + 6 + Enter the source vertex : + 5 + Enter the destination vertex : + 7 + + Following is Depth First Traversal : + 1 2 3 4 5 6 7 + +*/ + From 53673273fb9e13880e00cc873a38d811acad194f Mon Sep 17 00:00:00 2001 From: Ritish Singh Date: Thu, 28 May 2020 22:47:50 +0530 Subject: [PATCH 190/265] Kosaraju Algorithm Implemenation in Kotlin (#2994) --- Kosaraju_Algorithm/Kosaraju_Algorithm.kt | 70 ++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Kosaraju_Algorithm/Kosaraju_Algorithm.kt diff --git a/Kosaraju_Algorithm/Kosaraju_Algorithm.kt b/Kosaraju_Algorithm/Kosaraju_Algorithm.kt new file mode 100644 index 000000000..0cbe967b0 --- /dev/null +++ b/Kosaraju_Algorithm/Kosaraju_Algorithm.kt @@ -0,0 +1,70 @@ +import java.util.* + +object SCCKosaraju +{ + fun scc(graph: Array>): List> + { + // Storing length of the graph + val n: Int = graph.size + //Boolean Array Initialisation + val used = BooleanArray(n) + val order: MutableList = ArrayList() + for (i in 0 until n) + if (!used[i]) + dfs(graph, used, order, i) + + val reverseGraph: Array> = arrayOf>(n) + for (i in 0 until n) + reverseGraph[i] = ArrayList() + for (i in 0 until n) + for (j in graph[i]) + reverseGraph[j].add(i) + + val components: MutableList> = ArrayList() + Arrays.fill(used, false) + Collections.reverse(order) // Reversing the contents + + for (u in order) if (!used[u]) + { + val component: MutableList = ArrayList() + dfs(reverseGraph, used, component, u) + components.add(component) + } + return components + } + + //Depth First Search + fun dfs(graph: Array>, used: BooleanArray, res: MutableList, u: Int) + { + used[u] = true + for (v in graph[u]) + if (!used[v]) + dfs(graph, used, res, v) + res.add(u) + } + + // Usage example + @JvmStatic + fun main(args: Array) + { + val g: Array> = arrayOf>(3) + for (i in g.indices) + g[i] = ArrayList() + + //Initializing the List. + g[2].add(0) + g[2].add(1) + g[0].add(1) + g[1].add(0) + val components = scc(g) + println(components) + } +} +/*Input:- +0 +1 +1 +0 +Output:- +[[2],[1, 0]]*/ + From ec6a8b5a370bbdfad3a3b5454ab435e42a7d68e7 Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Thu, 28 May 2020 22:50:59 +0530 Subject: [PATCH 191/265] Comb Sort in Kotlin (#2886) --- Comb_Sort/Comb_Sort.kt | 67 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 Comb_Sort/Comb_Sort.kt diff --git a/Comb_Sort/Comb_Sort.kt b/Comb_Sort/Comb_Sort.kt new file mode 100644 index 000000000..517e9b77a --- /dev/null +++ b/Comb_Sort/Comb_Sort.kt @@ -0,0 +1,67 @@ +// Kotlin Code for Comb Sort + +import java.lang.Math; +class CombSort +{ + // Function to swap elements at index a and b + fun swap(int:arr[], int:a, int:b):void + { + int temp = arr[a]; + arr[a] = arr[b]; + arr[b] = temp; + } + + // Function to sort arr[] using Comb Sort + fun combSort(int:arr[], int:n):void + { + // initialize gap value to array length + int gap = n; + int flag = 1; + while (gap > 1 || flag == 1 ) + { + // Update gap value by using shrink factor 1.3 + gap = (gap * 10) / 13; + gap = Math.max(1, gap); + flag = 0; + // Compare all elements with the obtained gap value + for (i in 0 until (n-gap)) + { + if (arr[i] > arr[i+gap]) + { + swap(arr, i, i + gap); + flag = 1; + } + } + } + } + + // Main function + fun main() + { + CombSort obj = new CombSort(); + var read = Scanner(System.`in`) + println("Enter the size of Array:") + val arrSize = read.nextLine().toInt() + var arr = IntArray(arrSize) + println("Enter elements") + for(i in 0 until arrSize) + { + arr[i] = read.nextLine().toInt() + } + int n = arrSize; + obj.combSort(arr, n); + + println("Array after sorting:"); + for (i in 0 until arrSize) + { + println(arr[i] + " "); + } + } +} + +/* +Input +-10, 50, 20, 0, 15, -25, 30 +Output +-25 -10 0 15 20 30 50 +*/ From a28af4215ab0d767772bf8a72cc5f8d07f137ac6 Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Thu, 28 May 2020 22:52:55 +0530 Subject: [PATCH 192/265] Cycle Sort in Go (#2995) --- Cycle_Sort/Cycle_Sort.go | 67 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 Cycle_Sort/Cycle_Sort.go diff --git a/Cycle_Sort/Cycle_Sort.go b/Cycle_Sort/Cycle_Sort.go new file mode 100644 index 000000000..b4087920d --- /dev/null +++ b/Cycle_Sort/Cycle_Sort.go @@ -0,0 +1,67 @@ +package main +import ( + "fmt" +) + +func main() { + var x int + fmt.Printf("Enter the size of the array : ") + fmt.Scan(&x) + fmt.Printf("Enter the elements of the array : ") + a := make([]int, x) + for i := 0; i < x; i++ { + fmt.Scan(&a[i]) + } + arr := a // A copy of the array 'a' is assigned to 'randomSlice' + CycleSort(&arr) + fmt.Printf("After sort: %v\n", arr) +} + +func CycleSort(arr *[]int) int { + writes := 0 + for cycleStart, item := range *arr { // Loop through the array to find cycles to rotate. + pos := cycleStart // Find where to put the item. + for i := cycleStart + 1; i < len(*arr); i++ { + if (*arr)[i] < item { + pos++ + } + } + + if pos != cycleStart { // If the item is already there, this is not a cycle. + for item == (*arr)[pos] { // Put the item there or right after any duplicates. + pos++ + } + + (*arr)[pos], item = item, (*arr)[pos] + writes++ + for pos != cycleStart { // Rotate the rest of the cycle + pos = cycleStart // Find where to put the item + for i := cycleStart + 1; i < len(*arr); i++ { + if (*arr)[i] < item { + pos++ + } + } + + for item == (*arr)[pos] { // Put the item there or right after any duplicates. + pos++ + } + (*arr)[pos], item = item, (*arr)[pos] + writes++ + } + } + } + return writes +} + + +/* + +Sample Input : + Enter the size of the array : 4 + Enter the elements of the array : 23 78 56 9 + +Sample Output : + After sort: [9 23 56 78] + +*/ + From c188bf4a59523486a7734f4dbca39c85f13bb50a Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Thu, 28 May 2020 22:55:59 +0530 Subject: [PATCH 193/265] Pigeonhole Sort in Go (#2984) --- Pigeonhole_Sort/Pigeonhole_Sort.go | 65 ++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Pigeonhole_Sort/Pigeonhole_Sort.go diff --git a/Pigeonhole_Sort/Pigeonhole_Sort.go b/Pigeonhole_Sort/Pigeonhole_Sort.go new file mode 100644 index 000000000..ee636d4b0 --- /dev/null +++ b/Pigeonhole_Sort/Pigeonhole_Sort.go @@ -0,0 +1,65 @@ +package main +import ( + "fmt" +) + +func PigeonholeSort(a []int) { + arrayLength := len(a) + if arrayLength == 0 { // this is used to handle for the edge case when there is nothing to sort + return + } + min := a[0] + max := a[0] + for _, value := range a { // get the min and max values of the array + if value < min { + min = value + } + if value > max { + max = value + } + } + size := max - min + 1 + holes := make(map[int][]int, size) // create the pigeon holes with the initial values + for i := 0; i < size; i++ { + holes[i] = []int{} + } + for _, value := range a { // for every value in the array, put it in the corresponding pigeonhole + holes[value - min] = append(holes[value-min], value) + } + + // finally, replace the values in the array with the values from each pigeonhole in order + j := 0 + for i := 0; i < size; i++ { + for _, value := range holes[i] { + a[j] = value + j++ + } + } +} + +func main() { + var x int + fmt.Printf("Enter the size of the array : ") + fmt.Scan(&x) + fmt.Printf("Enter the elements of the array : ") + a := make([]int, x) + for i := 0; i < x; i++ { + fmt.Scan(&a[i]) + } + randomSlice := a // A copy of the array 'a' is assigned to 'randomSlice' + PigeonholeSort(randomSlice) + fmt.Println("Sorted Slice: ", randomSlice) +} + + +/* + +Sample Input : + Enter the size of the array : 5 + Enter the elements of the array : 67 23 90 12 7 + +Sample Output : + The sorted array is : [7 12 23 67 90] + +*/ + From 52d9c24957f39f1b7e68029149a4680e7767bf56 Mon Sep 17 00:00:00 2001 From: shweta gurnani <43384092+shwetagurnani@users.noreply.github.com> Date: Fri, 29 May 2020 10:28:36 +0530 Subject: [PATCH 194/265] dijkstra algo readme added (#2997) --- Dijkstra_Algorithm/readme.md | 85 ++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 Dijkstra_Algorithm/readme.md diff --git a/Dijkstra_Algorithm/readme.md b/Dijkstra_Algorithm/readme.md new file mode 100644 index 000000000..4ca1f206f --- /dev/null +++ b/Dijkstra_Algorithm/readme.md @@ -0,0 +1,85 @@ +# Dijkstra Algorithm + +Dijkstra's algorithm is used to find the shortest paths from the source vertex to all other vertices in the graph. + +## Example + +Let's find shortest distance of all the vertices from the vertex 0 in the graph given below. + +![Screenshot from 2020-05-27 01-01-28](https://user-images.githubusercontent.com/43384092/82946882-c0785100-9fbc-11ea-8726-688335180c17.png) + +- The set sptSet is initially empty and distances assigned to vertices are {0, INF, INF, INF} where INF indicates infinite. Now pick the vertex with minimum distance value. The vertex 0 is picked, include it in sptSet. So sptSet becomes {0}. After including 0 to sptSet, update distance values of its adjacent vertices. Adjacent vertices of 0 are 1 and 3. The distance values of 1 and 3 are updated as 1 and 2. + +- Pick the vertex with minimum distance value and not already included in sptSet. The vertex 1 is picked and added to sptSet. So sptSet now becomes {0, 1}. Update the distance values of adjacent vertices of 1. The distance value of vertex 2 becomes 4. + +- Pick the vertex with minimum distance value and not already included in sptSet. Vertex 3 is picked. So sptSet now becomes {0, 1, 3}. Update the distance values of adjacent vertices of 3. The adjacent vertices of 3 are 0 and 2 which already have a minimum value so they will not be updated. + +- Pick the vertex with minimum distance value and not already included in sptSet. Vertex 2 is picked. So sptSet now becomes {0, 1, 3, 2}. The adjacent vertices of 2 are 1 and 3 which already have a minimum value so they will not be updated. + +- Now we stop the process as sptSet does include all vertices of given graph. Finally, we get the shortest distances of all the vertices from the vertex 0. + +## Algorithm + +1) Create an array dist. The size of the array is equal to the number of vertices V in the graph. Initialise all the elements of the array with INFINITE. + +2) Create an empty set s of type pair(weight, vertex). + +3) Insert source vertex into the set and its distance as 0. + Update dist[src] = 0. + +4) Repeat the below steps while set is not empty
+ a) Extract the minimum distance vertex from the set s i.e. the top element from the set as the set is sorted in ascending order on the basis of distance from the source. Let it be u.
+ b) Loop through all the adjacent vertices of u. Let the adjacent vertex be labelled as v. For every v,
+           if dist[v] > dist[u] + weight(u, v)
+                      (i) dist[v] = dist[u] + weight(u, v)
+                      (ii) If v is in set, remove it.
+                      (iii) Insert v in the set with updated distance.
+ +5) Print distance array dist[ ] along with the vertex number. + +## Pseudocode +``` +minDistance(dist[], sptSet[]) + min = INT_MAX + for(v = 0; v < V; v++) + if (sptSet[v] == false and dist[v] <= min) + min = dist[v], min_index = v + return min_index + +dijkstra(int graph[V][V], int src) + for(i = 0; i < V; i++) + dist[i] = INT_MAX + sptSet[i] = false + dist[src] = 0 + for(count = 0; count < V - 1; count++) + u = minDistance(dist, sptSet) + sptSet[u] = true + for(v = 0; v < V; v++) + if(not(sptSet[v]) && graph[u][v] && dist[u] not equal to INT_MAX && dist[u] + graph[u][v] < dist[v]) + dist[v] = dist[u] + graph[u][v] + for(i = 0; i < V; i++) + display i, dist[i] +``` +## Complexity + + Time Complexity: O(V * V) + Space Complexity: O(V) + +where +>V = number of vertices
+ +## Implementation + * [C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm.c) + * [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm.cpp) + * [Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm.java) + * [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm.py) + * [JS Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm.js) + * [Ruby Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm.rb) + * [C++ STL Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Algorithm_STL.cpp) + * [C++ Efficient Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Dijkstra_Algorithm/Dijkstra_Efficient.cpp) + +## References + +* [Tutorial - GeeksforGeeks](https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/) +* [Wikipedia](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) + From a87620bf33aa80c95a5257e8c04eff3cf508c15e Mon Sep 17 00:00:00 2001 From: utkarshanehe <55992544+utkarshanehe@users.noreply.github.com> Date: Fri, 29 May 2020 10:35:09 +0530 Subject: [PATCH 195/265] Extended Euclidean Algorithm in PHP (#2988) * Extended Euclidean Algorithm in PHP * Update Extended_Euclidean_Algorithm.php * Update Extended_Euclidean_Algorithm.php --- .../Extended_Euclidean_Algorithm.php | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.php diff --git a/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.php b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.php new file mode 100644 index 000000000..20efb80f8 --- /dev/null +++ b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.php @@ -0,0 +1,45 @@ + From 0d5be801c83e7fe002a8b70c7a131cedb7c79a99 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Fri, 29 May 2020 10:38:07 +0530 Subject: [PATCH 196/265] Postman sort implemented in Dart (#3001) --- Postman_Sort/Postman_Sort.dart | 99 ++++++++++++++++++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 Postman_Sort/Postman_Sort.dart diff --git a/Postman_Sort/Postman_Sort.dart b/Postman_Sort/Postman_Sort.dart new file mode 100644 index 000000000..999841484 --- /dev/null +++ b/Postman_Sort/Postman_Sort.dart @@ -0,0 +1,99 @@ +// Importing required libraries +import 'dart:io'; +import 'dart:math'; + +// Declaring required variables +int temp, max, count, maxdigits = 0, c = 0; +int t1, t, i, j; +List array, array1; +int n = 1; + +// Method to arrange numbers that have same base +void arrange(int k, int n){ + for(int i = k; i < n - 1; i ++){ + for(int j = i + 1; j < n; j ++){ + if(array1[i] > array1[j]){ + temp = array1[i]; + array1[i] = array1[j]; + array1[j] = temp; + temp = array[i]%10; + array[i] = array[j]%10; + array[j] = temp; + } + } + } +} + + +void main(){ + + // Input of the size of the array + print("Enter the number of elements in the array:"); + var input = stdin.readLineSync(); + count = int.parse(input); + + // Input of array elements + print("Enter the array elements:"); + input = stdin.readLineSync(); + var lis = input.split(' '); + array = lis.map(int.parse).toList(); + array1 = lis.map(int.parse).toList(); + + // Finding the maximum possible length of the numbers in the array + for(i = 0; i < count; i ++){ + t = array[i]; + c = (log(array[i])/log(10)).floor(); + if(c > maxdigits){ + maxdigits = c; + } + } + + for(i = 0; i < maxdigits - 1; i ++){ + n = n * 10; + } + + for(i = 0; i < count; i ++){ + max = (array[i]/n).floor(); + t = i; + for(j = i + 1; j < count; j ++){ + if(max > (array[j]/n).floor()){ + max = (array[j]/n).floor(); + t = j; + } + } + + // Swapping + temp = array1[t]; + array1[t] = array1[i]; + array1[i] = temp; + temp = array[t]; + array[t] = array[i]; + array[i] = temp; + } + + while(n >= 1){ + for(i = 0; i < count;){ + t1 = (array[i]/n).floor(); + for(j = i + 1; j < count && t1 == (array[j]/n).floor(); j ++){ + arrange(i, j); + } + i = j; + } + n = (n / 10).floor(); + } + + print("The sorted array is:"); + print(array.join(" ")); +} + +/** + * Sample Input and Output + * ---------------------------- + * Enter the number of elements in the array: + * 10 + * Enter the array elements: + * 10 9 8 7 6 5 4 3 2 1 + * The sorted array is: + * 1 2 3 4 5 6 7 8 9 10 + * + */ From 27d1f4239ba195dba4ab26f09f796cef85f8c32d Mon Sep 17 00:00:00 2001 From: Tahanima Chowdhury Date: Sat, 30 May 2020 10:21:35 +0600 Subject: [PATCH 197/265] Added Rabin-Karp implementation in Ruby (#2161) (#2926) --- Rabin_Karp/Rabin_Karp.rb | 71 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 Rabin_Karp/Rabin_Karp.rb diff --git a/Rabin_Karp/Rabin_Karp.rb b/Rabin_Karp/Rabin_Karp.rb new file mode 100644 index 000000000..ae392a526 --- /dev/null +++ b/Rabin_Karp/Rabin_Karp.rb @@ -0,0 +1,71 @@ +=begin +Rabin–Karp algorithm is a string-searching algorithm that uses +hashing to find any one of a set of pattern strings in a text. +=end + +PN = 101 # prime number +AN = 256 # no. of characters in alphabet + +def search(pattern, text) + patlen = pattern.length # pattern length + txtlen = text.length # text length + val = 1 + hpat = 0 # pattern hash value + htxt = 0 # text hash value + + for i in 0..(patlen - 2) + val = (val * AN) % PN # PN is a prime number + end + + for i in 0..(patlen - 1) + hpat = (AN * hpat + pattern[i].ord) % PN + htxt = (AN * htxt + text[i].ord) % PN + end + + for i in 0..(txtlen - patlen) + if (hpat == htxt) + # check for patterns + for j in 0..(patlen - 1) + if (text[i + j] != pattern[j]) + break + end + + j += 1 + + if (j == patlen) + puts "Found at index starting from #{i}" + end + end + end + + # Calculate the new pattern including i+m + if (i < txtlen - patlen) + htxt = (AN * (htxt - text[i].ord * val) + text[i + patlen].ord) % PN + + if (htxt < 0) + htxt = htxt + PN + end + end + end +end + +# Driver program +puts "Enter the text:" +text = gets.chomp + +puts "Enter the pattern:" +pattern = gets.chomp + +search(pattern, text) + +=begin +Enter the text: +XWINGO XOR WINGO + +Enter the pattern: +WINGO + +Output +Found at index starting from 1 +Found at index starting from 11 +=end From 66a414692673c239f071760cced44834926ccf71 Mon Sep 17 00:00:00 2001 From: Tahanima Chowdhury Date: Sat, 30 May 2020 10:30:30 +0600 Subject: [PATCH 198/265] Added Euclidean Algorithm implementation in Ruby (#2905) (#2934) --- Euclidean_Algorithm/Euclidean_Algorithm.rb | 30 ++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Euclidean_Algorithm/Euclidean_Algorithm.rb diff --git a/Euclidean_Algorithm/Euclidean_Algorithm.rb b/Euclidean_Algorithm/Euclidean_Algorithm.rb new file mode 100644 index 000000000..f8a7d9e30 --- /dev/null +++ b/Euclidean_Algorithm/Euclidean_Algorithm.rb @@ -0,0 +1,30 @@ +# Given two numbers, we need to find the greatest common divisor of those two numbers + +def gcd(x, y) + # every number divides 0 + if (x == 0) + return y + else + return gcd(y % x, x) + end +end + +# Driver Code +puts "Enter first number:" +x = gets.to_i + +puts "Enter second number:" +y = gets.to_i + +puts "GCD of numbers #{x} and #{y} is #{gcd(x, y)}" + +=begin +Enter first number: +462 + +Enter second number: +780 + +Output: +GCD of numbers 462 and 780 is 6 +=end From 95e6ac90aa9c6f59fe30876a4316a87997b1576d Mon Sep 17 00:00:00 2001 From: Anushka118 <39857792+Anushka118@users.noreply.github.com> Date: Sat, 30 May 2020 10:13:25 +0530 Subject: [PATCH 199/265] Pigeonhole Sort algorithm using Kotlin (#2960) --- Pigeonhole_Sort/Pigeonhole_Sort.kt | 57 ++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 Pigeonhole_Sort/Pigeonhole_Sort.kt diff --git a/Pigeonhole_Sort/Pigeonhole_Sort.kt b/Pigeonhole_Sort/Pigeonhole_Sort.kt new file mode 100644 index 000000000..7462ac862 --- /dev/null +++ b/Pigeonhole_Sort/Pigeonhole_Sort.kt @@ -0,0 +1,57 @@ +import java.util.* + +fun main(args: Array) { + + var n: Int = Integer.valueOf(readLine()) + var arr = arrayOfNulls(n) + var read = Scanner(System.`in`) + for(i in 0..(n-1)){ + arr[i] = read.nextInt() + } + var min = arr[0] + var max = arr[0] + //finding the minimum and maximum elements in the array + for(i in 0..(n-1)){ + if(arr[i]!! < min!!) + min = arr[i] + if(arr[i]!! > max!!) + max = arr[i] + } + + var noOfPigeonHoles = max!! - min!! + 1 //size of the pigeonhole array + var pigeonHoles = IntArray(noOfPigeonHoles) //pigeonhole array + Arrays.fill(pigeonHoles,0) //initializing all the elements to 0 + + //pigeonhole sort algorithm + for(i in 0..(n-1)){ + var x = arr[i]!! - min + pigeonHoles[x]++ + } + var index = 0 + + for(i in 0..(noOfPigeonHoles-1)){ + while(pigeonHoles[i] > 0){ + arr[index++] = i + min + pigeonHoles[i]-- + } + } + + //printing the array + println("Sorted Array") + for(i in 0..(n-1)){ + println(arr[i]) + } +} + +/* +Sample Input +5 +1 5 4 2 0 +Sample Output +Sorted Array +0 +1 +2 +4 +5 +*/ From 10d01e211f8bada16b792e6106368cc82ca873ea Mon Sep 17 00:00:00 2001 From: Jasbir Date: Sat, 30 May 2020 10:20:34 +0530 Subject: [PATCH 200/265] Added Fenwick_Tree in Kotlin (#2963) --- Fenwick_Tree/Fenwick_Tree.kt | 127 +++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 Fenwick_Tree/Fenwick_Tree.kt diff --git a/Fenwick_Tree/Fenwick_Tree.kt b/Fenwick_Tree/Fenwick_Tree.kt new file mode 100644 index 000000000..8cf232208 --- /dev/null +++ b/Fenwick_Tree/Fenwick_Tree.kt @@ -0,0 +1,127 @@ +/*Fenwick Tree is used when there is a problem of range sum query with update +i.e. RMQ. Suppose you have an array and you have been asked to find sum in +range. It can be done in linear time with static array method. If will be +difficult for one to do it in linear time when you have point updates. In this +update operation is incrementing an index by some value. Brute force approach +will take O(n^2) time but Fenwick Tree will take O(nlogn) time +*/ + +//Sum function +fun sum(ft:Array, _index:Int):Int{ + /* + Argument + ft : Fenwick Tree + index : Index upto which you want to find prefix sum + Initialize the result "s" then increment the value of + index "index". + + Returns : sum of given arr[0..index]. This function assumes + that the array is preprocessed and partial sums of + array elements are stored in ft[]. + */ + + // Initialize sum variable to 0 + var s:Int = 0 + // Increment index + var index = _index + 1 + + while (index > 0){ + + // Adding tree node to sum + s += ft[index] + // Update tree node + index -= index and (-index) + } + // Return total sum + return s +} + + +// Update function +fun update(ft:Array,size:Int,_index:Int,value:Int){ + /* + Arguments + ft : Fenwick Tree + index : Index of ft to be updated + size : Length of the original array + val : Add val to the index "index" + Traverse all ancestors and add 'val'. + Add 'val' to current node of Fenwick Tree. + Update index to that of parent in update. + */ + + var index = _index + 1 + while (index <= size) { + + // Update tree node value + ft[index] += value + // Update node index + index += index and (-index) + } + +} + +// Construct function +fun construct(array:Array, size:Int):Array{ + /* + Argument + arr : The original array + size : The length of the given array + This function will construct the Fenwick Tree + from the given array of length "size" + + Return : Fenwick Tree array ft[] + */ + + // Init ft array of length size+1 with zero value initially + var ft = Array(size+1,{0}) + + // Constructing Fenwick Tree by Update operation + for (i in 0 until size){ + // Update operation + update(ft,size,i,array[i]) + } + // Return Fenwick Tree array + return ft +} + +fun main(){ + /* + INPUT + ------- + arr : [2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9] + Print sum of freq[0...5] + Update position 4 by adding 16 + Print sum of freq[2....7] after update + Update position 5 by adding 10 + Print sum of freq[2....7] after update + + OUTPUT + ------ + 12 + 33 + 43 + */ + + // Given array + var list = arrayOf(2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9) + + // Build Fenwick Tree + var ft = construct(list,list.size) + + // Print Sum of array from index = 0 to index = 5 + println(sum(ft,5)) + + // Increment list[4] by 16 + update(ft,list.size,4,16) + + // Print sum from index = 2 to index = 7 + println(sum(ft,7) - sum(ft,2)) + + // Increment list[5] by 10 + update(ft,list.size,5,10) + + // Print sum from index = 2 to index = 7 + println(sum(ft,7) - sum(ft,2)) +} + From bacdd614fc9c991a75e8e8ce8f803d52cb1e8c78 Mon Sep 17 00:00:00 2001 From: Jitmanew Tyagi <54436520+Jitmanew-Tyagi@users.noreply.github.com> Date: Sat, 30 May 2020 10:43:55 +0530 Subject: [PATCH 201/265] Squashed commits (#2977) Extended eucledian algorithm in Dart Extended eucledian algorithm in Dart Extended euclidean algorithm in dart Update extended_euc_algo.dart Added sample input and output --- .../Extended_Euclidean_Algorithm.dart | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.dart diff --git a/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.dart b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.dart new file mode 100644 index 000000000..ee2d2779b --- /dev/null +++ b/Extended_Euclidean_Algorithm/Extended_Euclidean_Algorithm.dart @@ -0,0 +1,42 @@ +/* Extended Euclidean Algorithm + ============================== + GCD of two numbers is the largest number that divides both of them. + A simple way to find GCD is to factorize both numbers and multiply + common factors. + + GCD(a,b) = ax + by + If we can find the value of x and y then we can easily find the + value of GCD(a,b) by replacing (x,y) with their respective values. +*/ + +import 'dart:io'; + +void main() { + int x = 0, y = 0; + var a = int.parse(stdin.readLineSync()); + var b = int.parse(stdin.readLineSync()); + // function called for 98 and 21 + print(gcdFunction(a, b, x, y)); +} + +int gcdFunction(a, b, x, y) { + if (a == 0) { + x = 0; + y = 0; + return b; + } + + int x1 = 0, y1 = 0; + int gcd = gcdFunction(b % a, a, x1, y1); + + x = y1 - (b / a).round() * x1; + y = x1; + + return gcd; +} + +// Sample input : +// 98 +// 21 +// Sample output : +// 7 From 777eaa0ba14d2a9ced4c64e87c7ca5a92f8a58fb Mon Sep 17 00:00:00 2001 From: Abhishek Jain Date: Sat, 30 May 2020 10:52:15 +0530 Subject: [PATCH 202/265] Adding Floyd Warshall Algorithm in Kotlin (#2986) * Floyd Warshall Algorithm in Kotlin * Floyd Warshall Algorithm in Kotlin * Floyd Warshall Algorithm in Kotlin * Floyd Warshall Algorithm in Kotlin --- .../Floyd_Warshall_Algorithm.kt | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.kt diff --git a/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.kt b/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.kt new file mode 100644 index 000000000..d2464f44e --- /dev/null +++ b/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.kt @@ -0,0 +1,78 @@ +// version 1.1 + +object FloydWarshall { + fun doCalcs(weights: Array, nVertices: Int) { + val dist = Array(nVertices) { DoubleArray(nVertices) { Double.POSITIVE_INFINITY } } + for (w in weights) dist[w[0] - 1][w[1] - 1] = w[2].toDouble() + val next = Array(nVertices) { IntArray(nVertices) } + for (i in 0 until next.size) { + for (j in 0 until next.size) { + if (i != j) next[i][j] = j + 1 + } + } + for (k in 0 until nVertices) { + for (i in 0 until nVertices) { + for (j in 0 until nVertices) { + if (dist[i][k] + dist[k][j] < dist[i][j]) { + dist[i][j] = dist[i][k] + dist[k][j] + next[i][j] = next[i][k] + } + } + } + } + printResult(dist, next) + } + + private fun printResult(dist: Array, next: Array) { + var u: Int + var v: Int + var path: String + println("pair dist path") + for (i in 0 until next.size) { + for (j in 0 until next.size) { + if (i != j) { + u = i + 1 + v = j + 1 + path = ("%d -> %d %2d %s").format(u, v, dist[i][j].toInt(), u) + do { + u = next[u - 1][v - 1] + path += " -> " + u + } while (u != v) + println(path) + } + } + } + } +} + +fun main(args: Array) { + val weights = arrayOf( + intArrayOf(1, 3, -2), + intArrayOf(2, 1, 4), + intArrayOf(2, 3, 3), + intArrayOf(3, 4, 2), + intArrayOf(4, 2, -1) + ) + val nVertices = 4 + FloydWarshall.doCalcs(weights, nVertices) +} + +/* +* Output: +* +* pair dist path +* 1 -> 2 -1 1 -> 3 -> 4 -> 2 +* 1 -> 3 -2 1 -> 3 +* 1 -> 4 0 1 -> 3 -> 4 +* 2 -> 1 4 2 -> 1 +* 2 -> 3 2 2 -> 1 -> 3 +* 2 -> 4 4 2 -> 1 -> 3 -> 4 +* 3 -> 1 5 3 -> 4 -> 2 -> 1 +* 3 -> 2 1 3 -> 4 -> 2 +* 3 -> 4 2 3 -> 4 +* 4 -> 1 3 4 -> 2 -> 1 +* 4 -> 2 -1 4 -> 2 +* 4 -> 3 1 4 -> 2 -> 1 -> 3 +* +*/ + From 4084abe48e905293e33b0294dd28aeda10445ab9 Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Sat, 30 May 2020 10:54:37 +0530 Subject: [PATCH 203/265] Radix Sort in Rust (#2987) --- Radix_Sort/Radix_Sort.rs | 68 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 Radix_Sort/Radix_Sort.rs diff --git a/Radix_Sort/Radix_Sort.rs b/Radix_Sort/Radix_Sort.rs new file mode 100644 index 000000000..506c2ef3c --- /dev/null +++ b/Radix_Sort/Radix_Sort.rs @@ -0,0 +1,68 @@ +use std::io; +use std::str::FromStr; + +fn main() { + println!("Enter the numbers to be sorted (separated by space) : "); + let mut arr: Vec = read_values::().unwrap(); + radix_sort(&mut arr); + println!("The sorted array is : {:?}", arr); +} + +fn radix_sort(input: &mut [u32]) { + if input.len() == 0 { + return; + } + + let mut buckets: Vec> = Vec::with_capacity(10); // initialize buckets + for _ in 0..10 { + buckets.push(Vec::new()); + } + + let count: usize = input.iter() // count how many digits the longest number has + .max() + .unwrap() + .to_string() + .len(); + let mut divisor: u32 = 1; + + for _ in 0..count { + for num in input.iter() { + let temp = (num / divisor) as usize; + buckets[temp % 10].push(*num); + } + + let mut j: usize = 0; + for k in 0..10 { + for x in buckets[k].iter() { + input[j] = *x; + j += 1; + } + buckets[k].clear(); + } + divisor *= 10; + } +} + +fn read_values() -> Result, T::Err> { + let mut s = String::new(); + io::stdin() + .read_line(&mut s) + .expect("could not read from stdin"); + s.trim() + .split_whitespace() + .map(|word| word.parse()) + .collect() +} + + +/* + +Sample Input : + Enter the numbers to be sorted (separated by space) : + 45 23 15 80 5 + +Sample Output : + The sorted array is : [5, 15, 23, 45, 80] + +*/ + From f11da2be0def3099065eae911edd26e7494c738b Mon Sep 17 00:00:00 2001 From: Ritish Singh Date: Sat, 30 May 2020 10:58:28 +0530 Subject: [PATCH 204/265] Fenwick Tree implementation in C# (#2993) --- Fenwick_Tree/Fenwick_Tree.cs | 78 ++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Fenwick_Tree/Fenwick_Tree.cs diff --git a/Fenwick_Tree/Fenwick_Tree.cs b/Fenwick_Tree/Fenwick_Tree.cs new file mode 100644 index 000000000..2ebb3d992 --- /dev/null +++ b/Fenwick_Tree/Fenwick_Tree.cs @@ -0,0 +1,78 @@ +using System; + +internal class BinaryIndexedTree +{ + // Max tree size + internal + const int MAX = 1000; + internal static int[] BITree = new int[MAX]; + + internal virtual int getSum(int index) + { + // Iniialize result + int sum = 0; + + // index in BITree[] is 1 more than + // the index in arr[] + index = index + 1; + + // Traverse ancestors of BITree[index] + while (index > 0) { + sum += BITree[index]; + index -= index & (-index); + } + return sum; + } + + // Updates a node in Binary Index Tree (BITree) at given index in BITree. + public static void updateBIT(int n, int index, int val) + { + // index in BITree[] is 1 more than + // the index in arr[] + index = index + 1; + + // Traverse all ancestors and add 'val' + while (index <= n) + { + BITree[index] += val; + index += index & (-index); + } + } + + /* Function to construct fenwick tree + from given array.*/ + internal virtual void constructBITree(int[] arr, int n) + { + // Initialize BITree[] as 0 + for (int i = 1; i <= n; i++) + { + BITree[i] = 0; + } + + // Store the actual values in BITree[] + // using update() + for (int i = 0; i < n; i++) + { + updateBIT(n, i, arr[i]); + } + } + + // Main function + public static void Main(string[] args) + { + int[] freq = new int[] {2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9}; + int n = freq.Length; + BinaryIndexedTree tree = new BinaryIndexedTree(); + // Build fenwick tree from given array + tree.constructBITree(freq, n); + Console.WriteLine("Sum of elements in arr[0..5]" + " is = " + tree.getSum(5)); + freq[3] += 6; + updateBIT(n, 3, 6); + // Find sum after the value is updated + Console.WriteLine("Sum of elements in arr[0..5]" + " after update is = " + tree.getSum(5)); + } +} + +/*Output:- +Sum of elements in arr[0..5] is = 12 +Sum of elements in arr[0..5] after update is = 18*/ From 6640118503bca49dc3982b5791aed80aa7fb38d0 Mon Sep 17 00:00:00 2001 From: SHIVAM GUPTA <31137037+shivamgupta57121@users.noreply.github.com> Date: Sat, 30 May 2020 11:04:03 +0530 Subject: [PATCH 205/265] Add Euclidean Algorithm in TypeScript (#3000) --- Euclidean_Algorithm/Euclidean_Algorithm.ts | 23 ++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Euclidean_Algorithm/Euclidean_Algorithm.ts diff --git a/Euclidean_Algorithm/Euclidean_Algorithm.ts b/Euclidean_Algorithm/Euclidean_Algorithm.ts new file mode 100644 index 000000000..5d220d693 --- /dev/null +++ b/Euclidean_Algorithm/Euclidean_Algorithm.ts @@ -0,0 +1,23 @@ +// Euclidean Algorithm to find GCD of two numbers + +export {} + +// Recursive Function to return gcd of a and b +function gcd(a:number , b:number) : number +{ + return (b === 0) ? a : gcd(b, a % b); +} + +let x : number = 24; +let y : number = 60; +let ans : number = gcd(x,y); +console.log("The GCD of " + x + " and " + y + " is " + ans); + +/* +INPUT +x = 24 +y = 60 + +OUTPUT +The GCD of 24 and 60 is 12 +*/ \ No newline at end of file From 4d34cfdea5993a16d7bbd10506a29f9b95d23275 Mon Sep 17 00:00:00 2001 From: vedangi163 <59529326+vedangi163@users.noreply.github.com> Date: Sat, 30 May 2020 11:09:07 +0530 Subject: [PATCH 206/265] Radix Sort in PHP (#3006) * Committed changes * Change suggested by you is done. Hello @asha15 @singh-shreya6 @somya-kapoor @jainaman224, change suggested by you is done. Please review my PR. * Update RadixSort.php * Update RadixSort.php * Update RadixSort.php * Update RadixSort.php --- Radix_Sort/RadixSort.php | 73 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Radix_Sort/RadixSort.php diff --git a/Radix_Sort/RadixSort.php b/Radix_Sort/RadixSort.php new file mode 100644 index 000000000..3efd23f4c --- /dev/null +++ b/Radix_Sort/RadixSort.php @@ -0,0 +1,73 @@ += 0; $i--) + { + $output[$count[ ($arr[$i] / $exp) % 10 ] - 1] = $arr[$i]; + $count[ ($arr[$i] / $exp) % 10 ]--; + } + + // Copy the output array to arr[] + for ($i = 0; $i < $n; $i++) + $arr[$i] = $output[$i]; +} + +// The main function that sorts arr[] +function radixsort(&$arr, $n) +{ + // Find the maximum number to know number of digits + $m = max($arr); + + // Do counting sort for every digit + for ($exp = 1; $m / $exp > 0; $exp *= 10) + countSort($arr, $n, $exp); +} + +// A utility function to print an array +function PrintArray(&$arr,$n) +{ + echo "sorted Array : "; + for ($i = 0; $i < $n; $i++) + echo $arr[$i] . " "; +} + +// Driver Code +$n = readline ("Enter size of an array : "); +readline ("Enter the elements : "); +for ($i = 0; $i < $n; $i++) +{ + $arr[$i] = readline(); +} + +radixsort($arr, $n); +PrintArray($arr, $n); + +/* +OUTPUT: +Enter size of an array : 7 +Enter the elements : +12 +45 +9 +85 +700 +2 +4 +Sorted Array : 2 4 9 12 45 85 700 +*/ + +?> From 8614656ea0c1d9714fccc6fe609d738e4a642867 Mon Sep 17 00:00:00 2001 From: Ashish Nagpal <36301481+ashishnagpal2498@users.noreply.github.com> Date: Sat, 30 May 2020 12:17:26 +0530 Subject: [PATCH 207/265] :star: kosaraju algorithm in JS (#2887) --- Kosaraju_Algorithm/kosaraju_algorithm.js | 147 +++++++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 Kosaraju_Algorithm/kosaraju_algorithm.js diff --git a/Kosaraju_Algorithm/kosaraju_algorithm.js b/Kosaraju_Algorithm/kosaraju_algorithm.js new file mode 100644 index 000000000..c54e8630e --- /dev/null +++ b/Kosaraju_Algorithm/kosaraju_algorithm.js @@ -0,0 +1,147 @@ +// Program to implement Kosaraju Algorithm for Strongly Connected Components +class Graph { + constructor(nodes) { + //2 class variables + this.nodes = nodes; // no of vertices + this.adj = new Array(nodes); // adjacency list + for (let i = 0; i < nodes; i++) { + this.adj[i] = new Array(); + } + } + //A function to print graph in readable format + showGraph() { + const { + nodes, + adj + } = this; // destructuring for clarity + + for (let i = 0; i < nodes; i++) { + console.log(`Vertex ${i} is connected to verices `, adj[i]); + } + }; + //Create Graph by adding edge between the nodes + addEdge(x, y) { + const { + nodes, + adj + } = this; + // x is connected to y + // Directed Graph + adj[x].push(y); + }; + // Recursive function to visit neighbouring nodes + dfsHelper(arr, start, visited) { + const { + nodes, + adj + } = this; + + visited[start] = true; + arr.push(start); + for (let x of adj[start]) { + if (!visited[x]) { + this.dfsHelper(arr, x, visited); + } + } + }; + //A function which will return transpose of a graph + transposeGraph() { + const gr = new Graph(this.nodes); + for (let v = 0; v < this.nodes; v++) { + // Reverse the edges of each node + let neighNodes = this.adj[v]; + for (let i of neighNodes) { + gr.adj[i].push(v); + } + } + return gr; + }; + // A Function to create stack in order to process nodes in DFS + // Stack will be created according to the finish time of node + // The node with maximum finish time will be at the top of stack + createStackOrder(v, visited, Stack) { + // Current node marked as visited + visited[v] = true; + + let neighNodes = this.adj[v]; + for (let i of neighNodes) { + if (!visited[i]) + this.createStackOrder(i, visited, Stack); + } + // All the nodes reachable by v has been traversed, pushing vertix 'v' + Stack.push(v); + }; + // A Function to print strongly connected components in a graph + stronglyConnectedComponents() { + const { + nodes, + } = this; + let Stack = []; + // All the values by default are undefined in JavaScript + // Therefore creating a visited array and marking all the nodes as not visited. + let visited = new Array(nodes); + for (let i = 0; i < nodes; i++) + visited[i] = false; + + // Creating order of stack in which the nodes will be processed + for (let i = 0; i < nodes; i++) + if (visited[i] === false) + this.createStackOrder(i, visited, Stack); + + // Create a reverse graph + let gr = this.transposeGraph(); + + // Now to perform DFS on transpose graph unmark all the visited nodes + for (let i = 0; i < nodes; i++) + visited[i] = false; + + // Performing DFS by poping each node from stack as start node, if it is not visited. + while (Stack.length) { + // Pop a vertex from stack + let n = Stack[Stack.length - 1]; + Stack.pop(); + // Array used for displaying strongly connected component in each line separately + let arr = []; + // Strongly connected component of node n + if (visited[n] == false) { + gr.dfsHelper(arr, n, visited); + console.log(arr); + } + } + } +}; + +// Implementation +let n = 7; // 7 vertices +let graph = new Graph(n); // initialise the graph + +// add edges +graph.addEdge(1, 0); +graph.addEdge(0, 2); +graph.addEdge(2, 1); +graph.addEdge(0, 3); +graph.addEdge(3, 4); +graph.addEdge(4, 5); +graph.addEdge(5, 3); +graph.addEdge(5, 6); + +console.log("The Graph is:"); +graph.showGraph(); +console.log("The Strongly Connected Components by Kosaraju Algorithm are: "); +graph.stronglyConnectedComponents(); + +// Output: +/* +The Graph is: +Vertex 0 is connected to verices [ 2, 3 ] +Vertex 1 is connected to verices [ 0 ] +Vertex 2 is connected to verices [ 1 ] +Vertex 3 is connected to verices [ 4 ] +Vertex 4 is connected to verices [ 5 ] +Vertex 5 is connected to verices [ 3, 6 ] +Vertex 6 is connected to verices [] +The Strongly Connected Components by Kosaraju Algorithm are: +[ 0, 1, 2 ] +[ 3, 5, 4 ] +[ 6 ] +*/ From 6ce77daec312957d63b8066a99a0917ab8a1cfb5 Mon Sep 17 00:00:00 2001 From: Arkadip Bhattacharya Date: Sat, 30 May 2020 12:30:13 +0530 Subject: [PATCH 208/265] Create Prims_Algorithm.kt (#2713) fix: Changes done --- Prims_Algorithm/Prims_Algorithm.kt | 127 +++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 Prims_Algorithm/Prims_Algorithm.kt diff --git a/Prims_Algorithm/Prims_Algorithm.kt b/Prims_Algorithm/Prims_Algorithm.kt new file mode 100644 index 000000000..cda2a7905 --- /dev/null +++ b/Prims_Algorithm/Prims_Algorithm.kt @@ -0,0 +1,127 @@ +import java.util.* +internal class Edge(var from: Int, var to: Int, var weight: Int) + +internal object Prims { + /** + * Function to compute MST + * + * @param graph + * @return mst + */ + private fun prims(graph: ArrayList>): ArrayList { // ArrayList to store obtained MST + val mst = ArrayList() + // Priority Queue which gives minimum weight edge + val pq = PriorityQueue(Comparator { edge1: Edge?, edge2: Edge? -> + if (edge1!!.weight < edge2!!.weight) + return@Comparator -1 + else if (edge1.weight > edge2.weight) + return@Comparator 1 + else return@Comparator 0 }) + + // add the source vertex in Priority queue + pq.addAll(graph[0]) + var cost = 0.0 + val size = graph.size + val visited = BooleanArray(size) + // mark source vertex as visited + visited[0] = true + + // Keep extracting edges till priority is not empty + while (!pq.isEmpty()) { // extract edge with minimum weight from priority queue + val edge = pq.peek() + // pop the edge from priority queue + pq.poll() + if (visited[edge!!.to] && visited[edge.from]) continue + // mark the from vertex as visited + visited[edge.from] = true + // if the adjacent vertex to source is unvisited, add the edge to the priority queue + for (edge1 in graph[edge.to]) { + if (!visited[edge1!!.to]) pq.add(edge1) + } + // mark the adjacent vertex as visited + visited[edge.to] = true + // add the edge in minimum spanning tree + cost += edge.weight + mst.add(edge) + } + println("Total cost of MST: $cost") + return mst + } + + /** + * Function to create adjacency list representation of graph + * @param edges + * @param nodes + * @return graph + */ + private fun createGraph(edges: Array, nodes: Int): ArrayList> { // initialise graph as Adjacency List + val graph = ArrayList>() + // for adding Arraylist to Arraylist + for (i in 0 until nodes) graph.add(ArrayList()) + // Create adjacency list from the edge connectivity information + for (source in edges) { + val destination = Edge(source!!.from, source.to, source.weight) + graph[source.from].add(source) + graph[source.to].add(destination) + } + // Return constructed graph + return graph + } + + /** + * Main Function + * @param args + */ + @JvmStatic + fun main(args: Array) { // initialise number of nodes and edges + val nodes = 7 + val countEdges = 10 + /* Input Graph is: + 0 + / \ + / \ + 1 ------ 2 + / \ / \ + 3 -- 4 -- 5 -- 6 + */ + val edges = arrayOfNulls(countEdges) + // initialising edges with from, to and weight value + edges[0] = Edge(0, 1, 10) + edges[1] = Edge(0, 2, 15) + edges[2] = Edge(1, 2, 7) + edges[3] = Edge(2, 5, 6) + edges[4] = Edge(1, 3, 12) + edges[5] = Edge(1, 4, 9) + edges[6] = Edge(4, 5, 14) + edges[7] = Edge(3, 4, 13) + edges[8] = Edge(5, 6, 8) + edges[9] = Edge(2, 6, 12) + // Adjacency List representation of graph + val graph = createGraph(edges, nodes) + // ArrayList to store final MST obtained + val mst = prims(graph) + println("Minimum Spanning Tree:") + for (edge in mst) println(edge!!.from.toString() + " - " + edge.to + " : " + edge.weight) + } +} + +/** + * Input Graph is: + * 0 + * / \ + * / \ + * 1-----2 + * / \ / \ + * 3---4-5---6 + * + * Output: + * Total cost: 52.0 + * Minimum Spanning Tree: + * 0 - 1 : 10.0 + * 1 - 2 : 7.0 + * 2 - 5 : 6.0 + * 5 - 6 : 8.0 + * 1 - 4 : 9.0 + * 1 - 3 : 12.0 + * + */ From 3751213ac2807988a550c16d354b5a9dab35145f Mon Sep 17 00:00:00 2001 From: Sri Manikanta Palakollu Date: Sat, 30 May 2020 12:32:29 +0530 Subject: [PATCH 209/265] Implemented the Knuth Morris Pattern Matching Algorithm. (#2702) --- Knuth_Morris_Pratt_Algorithm/KMP.php | 86 ++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/KMP.php diff --git a/Knuth_Morris_Pratt_Algorithm/KMP.php b/Knuth_Morris_Pratt_Algorithm/KMP.php new file mode 100644 index 000000000..568383d77 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/KMP.php @@ -0,0 +1,86 @@ + \ No newline at end of file From d7366554093db231b34acd437899933bcd6cd940 Mon Sep 17 00:00:00 2001 From: Subhradeep Saha Date: Sat, 30 May 2020 12:43:42 +0530 Subject: [PATCH 210/265] Huffman Encoding using C++ STL (#1964) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Huffman Encoding using C++ STL added simpsons rule in c++ and java (#1828) Added Cyclesort in C# (#1679) Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Revert "Added Cyclesort in C# (#1679)" (#2002) This reverts commit 03676b2a8191bd35cb428fd8fa7a1a8bc15cbb3c. Updated Array_Rotation (#1915) Added code for right rotation in Array_Rotation File Added Merge Sort in C# (#1734) * Added Merge Sort * Updated Requested Changes * Update Merge_sort.cs * Update Merge_Sort.java * Updated * Update Merge_sort.cs Added Implementation of CRT in JavaScript (#1909) Fixes #1571 [Added README File] (#1731) * Added README File * Updated README File Updated README File Added Cyclesort in C# (#2031) Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs Update Cycle_Sort.cs add Armstrong Number code in Golang (#1844) Update issue templates Update issue templates Delete custom.md Rename ArmstrongNumber.go to Armstrong_Number.go Added Egg_Drop problem implementation in C# (#1585) added boyer moore algo in java (#1753) Added boyer moore algo in java * Added jump search. in Cpp (#1646) Implementation of palindrome in C & C++ GSSoC'20 (#1825) Added code for implementation of palindrome in C/C++ Added Sum_Of_Digits.js (#1724) Fibonacci_Number.php added (#1727) * Create Fibonacci_Number.php * Update Fibonacci_Number.php * Update Fibonacci_Number.php * Update Fibonacci_Number.php Create Quick_Sort.cs (#2137) BFS for Disconnected Graph in Java (#1937) * added BFS for Disconnected Graph in Java Start of loop in a linked list (#1743) * Create StartOfLoop.java * Update StartOfLoop.java * Update StartOfLoop.java * Update StartOfLoop.java * Update StartOfLoop.java * Update StartOfLoop.java * Update StartOfLoop.java Create Stooge_Sort.cpp (#2119) Update Stooge_Sort.cpp Coin Change Problem solution in JS (#2132) ADDED Readme for Activity Selection (#2169) Fixes #2117 - [ ] 4 space indentation. - [ ] Coding conventions are followed. - [ ] Input is taken dynamically. - [ ] Sample Input / Output is added at the end of file. - [ ] Logic Documentation (Comments). - [ ] File names are correct. Make sure these boxes are checked before your pull request (PR) is ready to be reviewed and merged. Thanks! - Added Readme.md file - Readme.md > We're happy to help you get this ready -- don't be afraid to ask for help. Thanks! Added JS Implementation (#2180) Implementation of Dijkstra Algorithm in JS (#1944) Linear regression using straight line@abhishekgupta368 (#1834) * reverse_linked_list.cpp * Linear_Regression_Using_Straight_Line@abhishekgupta368 * linear_regression * linear_regression2 * delete reverse.cpp * add_space_and_improve_comment * added_space_in_comp Created Cycle_Sort.js (#1847) Doubly Linked List in Java (#1833) * Doubly Linked List in Java Bucket Sort in Kotlin (#2220) Created Depth_First_Search.js (#1832) Created Fibonacci_Number.js (#1721) Added Tree_Postorder_Traversal implementation in JavaScript. (#1978) * Added Tree_Postorder_Traversal in JavaScript. issue 2024 Fermat_Little_Theorem java (#2264) updated Array_Rotation.cpp (#2277) Create AKS.cs (#2140) * Create AKS.cs * Pancake Sort Algorithm in Python SYNCING WITH MASTER (#2294) Rat In Maze (#2183) Implementation of Binary Insertion Sort in Python (#1980) * Create Binary_Insertion_Sort.py Added README File for Linear Regression * Added README File Eveodd.java #1467 (#1963) A star search - Python Revert " Eveodd.java #1467 (#1963)" (#2385) This reverts commit 75ac3c4ee46e5aa3192e94dbded93b70222be5cf. Bitwise addition in C and C++ added matrix chain multiplication for python (#2306) Create Pigeonhole_Sort.cs (#2307) Added ReadMe for AKS Primality Test (#2134) Code to check whether a LinkedList contains Palindromic data or not (#2197) Lcs in c (#1715) * Added lcs in C language * Dynamic input added * added requested changes for more readability * removed a.out file Matrix chain multiplication in C language. (#1823) * Matrix chain multiplication in C language. * updated problem description and improved readability. * edits for more readability * gave meaningful names to variables Sort Array of 0's 1's 2's in C++ (#1999) Added Digit_Count.rb (#2038) Implemented Armstrong Number in PHP. (#2295) QuickSort Implementaion updated to ES6+ syntax in JS (#1719) Added Hamiltonian_Cycle.cpp (#2314) Subsequence of string using bitmasking (#2017) Finding last digit of nth fibonacci number (#2293) Added C++ implementation of Regula Falsi method (#2379) * Update Karatsuba_multiplication_algo as per #1684 (#1989) Quicksortreadme (#2069) * added karatsuba multiplication in python along with readme * updated readme for quick sort to include the example of last element as pivot * modified readme * modified readme for indentation * modified readme for quicksort * deleting files Anagram Program modified . (#2335) Revert "Revert " Eveodd.java #1467 (#1963)" (#2385)" (#2418) This reverts commit 48895477b85c117fdc633a12c28bae9b3e1a2868. Implementation Optimal strategy for a game (set-1) by dynamic program…(#1622) (#1985) * Implementation Optimal strategy for a game (set-1) by dynamic programming * Changes request #1985 * changes request-2 #1985 * changes the request #1985 Completion of LCS implementation in JS issue#2252 (#2313) added 1-D array in Ruby (#2347) Added Arithmetic Progression in C Sharp (#2351) squashed-with-requested-changes (#1811) Spiral Array C++ (#2234) Large_Number_Factorial added (#2279) Quick_Hull implementation in cpp and python (#1714) Issue#1867 leap year (#2254) Added sum of two matrices in C. (#2368) Closes issue #1599 (#1742) * Parial fulfillment of issue #1599 * Update PowerOfAnyGivenNo.java * Enchacements Made Added additional base cases. Applied 4 space Indentation * Added CPP file * Added C implementation * Update PowerOfAnyGivenNo.java * Update PowerOfAnyGivenNo.cpp * Update PowerOfAnyGivenNo.cpp * Update PowerOfAnyGivenNo.c * Delete PowerOfAnyGivenNo.c * Delete PowerOfAnyGivenNo.cpp * Update PowerOfAnyGivenNo.java Create Binary_Insertion_Sort.cs (#2139) * Create Binary_Insertion_Sort.cs * File changed as requested * Updated * For Loop Updated Factorial (#1854) * Factorial in C,C++,JAVA * Update Factorial.c * C++ * C++ * JAVA * C * Factorial * Update Factorial.c * Update Factorial.cpp * Update Factorial.java * Update Factorial.c * Update Factorial.cpp * Update Factorial.java * Update Factorial.cpp * Update Factorial.c * Update Factorial.cpp * Update Factorial.c * Update Factorial.cpp * Update Factorial.java Minimum inversion cpp code added and changes done (#1902) Changes Done Changes Done Changes Done Added Kmeans algorithm using C (#2417) Fixed indetation for do-while loop Created Radix Sort in C# (#2311) * Create Pancake_Sort.cs * Update Pancake_Sort.cs * Create Radix_Sort.cs * Delete Pancake_Sort.cs * Update Radix_Sort.cs EvenOdd Python (#2303) * EvenOdd Python * EvenODD python * pallindrome of string in python * Update EvenOdd.py plz merge the latest commit. Thanks and sorry for inconvenience. * Delete pallindrome_string.py * Update EvenOdd.py * Update EvenOdd.py Co-authored-by: samjain2001 Karatsuba algorithm (#2490) * added karatsuba multiplication in python along with readme * modifications for karatsuba algorithm Menu Driven Circular Doubly Linked List in c++ (#2423) * Menu Driven Program * Updated and Renamed File * Delete Circular-Doubly-Linked-List.cpp * Menu Driven Program Updated and Renamed File * Update Circular_Doubly_Linked_List.cpp * Delete Circular_Doubly_Linked_List.cpp * Delete Circular-Doubly-Linked-List.cpp * all done * Commited Latest Changes * Commited Latest Changes * Commited Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * Committed Latest Changes * # This is a combination of 6 commits. Menu Driven Program Updated and Renamed File Menu Driven Program Updated and Renamed File Delete Circular-Doubly-Linked-List.cpp Update Circular_Doubly_Linked_List.cpp all done * parent 575de38ca91337ed5420385cf26f76d03460068d author Hardev_Khandhar 1583005888 +0530 committer Hardev_Khandhar 1583948499 +0530 Menu Driven Program Updated and Renamed File Menu Driven Program Updated and Renamed File Delete Circular-Doubly-Linked-List.cpp Update Circular_Doubly_Linked_List.cpp all done Commited Latest Changes Commited Latest Changes Commited Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes Committed Latest Changes * Updated Changes Adding ASCII_Subsequence in C, Python and JavaScript (Closes issue #1703) (#2290) * Add files via upload * Improved Indentation Improved Indentation * Update ASCII_Subsequences.c * Update ASCII_Subsequences.c * Update ASCII_Subsequences.js * Update ASCII_Subsequences.py * Update ASCII_Subsequences.js * Update ASCII_Subsequences.py check whether a string is palindrome (#2402) * pallindrome string python * Update and rename pallindrome_string.py to palindrome_string.py Fixed Typo in file name * Update palindrome_string.py added Power_Of_Two in JS (#2362) * added Power_Of_Twoin JS * Added space around minus in line 11 Implementation of Pascal Triangle in Java and Python Added Adding Python Implementation for Kosaraju Algorithm (Issue #2246) (#2488) * Adding Python implementation for issue #2246 * Update Kosaraju_Algorithm.py Added code for Round Robin Scheduling (#1928) * Add files via upload * Update Readers_Writers_Problem.cpp * Update Readers_Writers_Problem.cpp * Add files via upload * Update Round_Robin_Scheduling.cpp * Delete Round_Robin_Scheduling.cpp * Add files via upload * Delete Readers_Writers_Problem.cpp * Indentation and space around operators fix * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp * Update Round_Robin_Scheduling.cpp Closes Issue #1601 (#1744) Added Count Frequency Of Elements In Java For issue #1601 Pancake Sorting in Java (#2022) * Pancake Sorting implemented in Java language For issue #1988 Implementation of Bucket Sort in JS (#2431) Create Readme.md (#2383) * Create Readme.md * Update Readme.md Added KNN algorithm using C (#2074) Fixed indentation Fixed indentation Fixed indentation again Fixed indentation Added more comments in the code Fixed Identaion and few coding conventions Fixed Identaion Fixed Identaion and few coding conventions Added Bisection_Method.cpp (#2458) Circular Queue in JAVA (#2471) * Added Circular_Queue.java * Added Circular_Queue.java Co-authored-by: pratilipi Fibonacci_Number using DP approach added (#2060) * Fibonacci_Number using DP approach added indentation corrected * Indentation Corrected * Fibonacci number using DP Approach added Length of Linked List in C, Java Added Implemented the Gnome Sort Completely. (#2275) * Implemented the Gnome Sort Completely. * Implemented the requested Changes. * Made the requested changes. * Changes Done. Merge_Sort.php added (#1820) * Create Fibonacci_Number.php * Delete Fibonacci_Number.php * Create Merge_Sort.php * Update Merge_Sort.php * Updated * Updated Implementation of Karatsuba Algorithm in JS (#2420) Create Shell_Sort.cs (#2457) Update Shell_Sort.cs Update Shell_Sort.cs Update Shell_Sort.cs Finding last digit of nth term in squares of fibonacci number (#2285) * Add files via upload * Delete fib.cpp * Create a.txt * Delete a.txt * Issue Resolved and file is added * Issues Resolved please review * Issue of comment resolved * commited changes in issues Added minesweeper implementation in C++ (#2541) LCM of N elements of an array Added Longest Increasing Subsequence code in Go (#2493) * Longest Increasing Subsequence code in Go * Longest Increasing Subsequence code in Go * Updated problem description * No more than 80 chars per line added ruby implementation of Armstrong number (#2501) * this is a ruby implementation of the armstrong number. On branch master Changes to be committed: new file: Armstrong_Number/Armstrong_Number.rb * Update Armstrong_Number.rb ruby implementation of armstrong number. * On branch master Your branch is up to date with 'origin/master'. Changes to be committed: modified: Armstrong_Number.rb checked with 153,370 * Changes to be committed: modified: Armstrong_Number.rb * Added 4 space indent Done with indentation across the file. * Taking input dynamically * Changes to be committed: new file: Bead_Sort.rb * Changes to be committed: new file: Bead_Sort.rb * Revert " Changes to be committed:" * Delete Bead_Sort.rb * Delete Armstrong_Number.rb * Create Armstrong_Number.rb * added Armstrong_Number.rb * Changes to be committed: modified: Armstrong_Number/Armstrong_Number.rb * modified: Armstrong_Number/Armstrong_Number.rb Postfix Evaluation in C Max_circular_sum_added (#2354) Ternary Search in C# (#2176) (#2494) Create arrayList.java (#2230) Update arrayList.java Modifications after Review Update arrayList.java Made changes as suggested palindromic_string_added 2, indentation fixed C/C++ (#2356) check palindrome in a number in Java (#2492) updated with changes updated updated changes check palindrome in a string in Java (#2491) updated Added code for Tower Of Hanoi in Go language (#2562) Added code for Tower Of Hanoi in Go language Merge-sort-3-way-with-reuested-changes (#2505) Created Count_Rotations.java (#1804) Added method to find how many times a sorted array is rotated using Binary Search Integer to Roman Program (#2216) Depth First Search in Dart (#2561) Breadth first search using dart (#2560) Postman Sort in C# (#2511) CircleSort Algo in Kotlin (#2460) * CircleSort in Kotlin * Arranged Code * Update Circle_Sort.kts added armstrong in c# added armstrong in c# Implemented KNN algorithm using C++ (Closes issue #1789) (#2546) * Added the KNN Algorithm implemented using C++ * Added Tree_Inorder_Traversal.js * Delete Tree_Inorder_Traversal.js Binary Tree Bottom View, Top View and Right View in C #1577 (#2396) * Binary Tree Bottom View in C * Update BinaryTree_Bottom_View.c * Update BinaryTree_Bottom_View.c * Create Binary_Tree_Right_View.c * Create Binary_Tree_Top_View.c * Rename BinaryTree_Bottom_View.c to Binary_Tree_Bottom_View.c * Update Binary_Tree_Bottom_View.c * Update Binary_Tree_Right_View.c * Update Binary_Tree_Top_View.c Tower of Hanoi in Kotlin (#2531) * Add files via upload * Update Tower_Of_Hanoi.kt * Update Tower_Of_Hanoi.kt * Update Tower_Of_Hanoi.kt * Update Tower_Of_Hanoi.kt Added Tower Of Hanoi in PHP (#2577) * Added Tower Of Hanoi in PHP * Update Tower_Of_Hanoi.php Tower of Hanoi in Dart (#2513) * Tower of Hanoi in Dart * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart * Add files via upload * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart * Update Tower_of_Hanoi.dart added kadane algo in dart (#2517) * added kadane algo in dart * Dynamic Inputs, Comments position changed 1. Code changed to take dynamic inputs 2. Added comments before the code * Added sample input/output at the end of the file * Indented return statements properly * Added Karatsuba Algo in Dart * Added spaces between operators and Sample I/O * Deleting mistakenly added file Karatsuba_Algorithm.dart was accidentally pushed to the my branch that sent for PR. I have removed it now. Find whether a number is Palindrome or not (#2327) * EvenOdd Python * EvenODD python * pallindrome of string in python * pallindrome number in python * Update and rename pallindrome_no.py to palindrome_no.py Fixed the all the typos * Delete EvenOdd.py * Delete pallindrome_string.py * Update palindrome_no.py * Update palindrome_no.py * Update palindrome_no.py Co-authored-by: samjain2001 Jhonson Algorithm in C# (#2626) * Jhonson Algorithm in C# * Update Jhonson.cs Added Topological_Sort.js (Fixes #2159) (#2369) * Added Topological_Sort.js * Added Topological_Sort.js Addition of matrix in java (#2527) updated Priority_Queue.py Priority_Queue Added implementation of Z-Algorithm in JS (#2607) Created Pancake Sort in C# (#2309) * Create Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs * Update Pancake_Sort.cs Create Tree_Preorder_Traversal.kt (#2585) * Create Tree_Preorder_Traversal.kt * Update Tree_Preorder_Traversal.kt Taking dynamic input add kosaraju algorithm in cpp (#2672) * add kosaraju algorithm in cpp * Update kosaraju_algorithm.cpp Aggressive cows (#2543) * Create GENERIC_TREE_LOTRAVERSAL.java * Update GENERIC_TREE_LOTRAVERSAL.java * Revert "Update GENERIC_TREE_LOTRAVERSAL.java" This reverts commit dfdd3095201cbf35c1ee673a6332a0eaf4960a88. * Revert "Create GENERIC_TREE_LOTRAVERSAL.java" This reverts commit 2c87bbb08c1e7f312d3e9410b7ff5423d25f1458. * Create Aggressive_Cows.java * Update Aggressive_Cows.java 1. Multi comments made 2. Extra spaces and lines removed 3. Indentation corrected Logistic Regression in Python (#2636) Johnson Algorithm Implementation in Dart (#2567) Boyer Moore Algorithm in C# (#2604) * Boyer Moore Algorithm in C# * Updated Changes Adding PHP Implementation for Chinese Rem. Th. (#2685) Added Minimum Absolute Difference in Array Problem[C and C++] (#1845) Count_Inversion.cpp (#2625) Added Tree Inorder Traversal in JS (#2586) * Create Tree_Inorder_Traversal.js * Update Tree_Inorder_Traversal.js Floyd warshal js (#2468) * floyd Warshall in javascript * floyd warshall in java script * floyd warshall in java script * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js * Update Floyd_Warshall.js Added a Number conversion(Decimal to Binary) code in java (#2524) Number conversion (decimal to binary) Linked list merge sort in C, C++, Java, Python #1578 (#2395) * Create Linked_List_Merge_Sort.c * Add files via upload * Update Linked_List_Merge_Sort.c * Update Linked_List_Merge_Sort.c * Update Linked_List_MergeSort.cpp * Update Linked_List_MergeSort.java * Update Linked_List_MergeSort.java * Update Linked_List_MergeSort.py * Update Linked_List_MergeSort.cpp * Update Linked_List_MergeSort.java * Update Linked_List_Merge_Sort.c * Rename Linked_List_MergeSort.cpp to Linked_List_Merge_Sort.cpp * Rename Linked_List_MergeSort.py to Linked_List_Merge_Sort.py * Rename Linked_List_MergeSort.java to Linked_List_Merge_Sort.java Chinese Remainder Theorem in Go (#2675) * Chinese Remainder Theorem in Go * Added comments 1st commit (#2605) Dijkstra Algorithm implementation in dart (#2617) Update Dijkstra_Algorithm.dart added selection sort logic in typescript (#2693) Tower Of Hanoi In Ruby (#2701) * Update Huffman_Encoding_STL.cpp --- Huffman_Encoding/Huffman_Encoding_STL.cpp | 100 ++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 Huffman_Encoding/Huffman_Encoding_STL.cpp diff --git a/Huffman_Encoding/Huffman_Encoding_STL.cpp b/Huffman_Encoding/Huffman_Encoding_STL.cpp new file mode 100644 index 000000000..771039956 --- /dev/null +++ b/Huffman_Encoding/Huffman_Encoding_STL.cpp @@ -0,0 +1,100 @@ +#include +using namespace std; + +// A Huffman tree node +struct MinHeap_Node{ + // Count of the character + int count; + + // One of the input characters + char data; + + // Left and right child + MinHeap_Node *left, *right; + MinHeap_Node(int count, char data){ + left = right = NULL; + this -> count = count; + this -> data = data; + } +}; + +// For comparison of two heap nodes(needed in min heap) +struct compare{ + bool operator()(MinHeap_Node *l, MinHeap_Node *r){ + return l -> count > r -> count; + } +}; + +// Prints huffman codes from the root of Huffman Tree +void print_node(MinHeap_Node *node, string s){ + if(!node) + return; + if(node -> data != '#') + cout << node -> data << " " << s << endl; + print_node(node -> left, s + "0"); + print_node(node -> right, s + "1"); +} + +// The main function that builds a Huffman Tree +// and print codes by traversing the built Huffman Tree +void Huffman(int count[], char data[], int n){ + // Min heap & inserting all characters of data[] + priority_queue, compare> heap; + + for(int i = 0; i < n; i++) + heap.push(new MinHeap_Node(count[i], data[i])); + + while(heap.size() != 1){ + // Extract the two minimum freq items from min heap + MinHeap_Node *left = heap.top(); + heap.pop(); + MinHeap_Node *right = heap.top (); + heap.pop(); + + /* Create a new internal node with count equal to the sum of + the two nodes counts.Make the two extracted node as left and + right children of this new node.Add this node to the min heap + '#' is a special value for internal nodes, not used */ + + MinHeap_Node *top = new MinHeap_Node(left -> count + right -> count, '#'); + top -> left = left; + top -> right = right; + heap.push(top); + } + + // Print Huffman codes using the Huffman tree + print_node(heap.top(), ""); +} + +int main (){ + cout << "Enter the number of input characters: "; + int n; + cin >> n; + + cout << "\nEnter the characters and corresponding count: "; + char data[n]; + int count[n]; + for(int i = 0; i < n; i++) + cin >> data[i] >> count[i]; + + cout << "Following is the Huffman Encoding:\n"; + Huffman(count, data, n); +} + +/* Sample Input-Output +Enter the number of input characters: 6 + +Enter the characters and corresponding count: a 5 +b 9 +c 12 +d 13 +e 16 +f 45 +Following is the Huffman Encoding: +f 0 +c 100 +d 101 +a 1100 +b 1101 +e 111 +*/ From ff15d7a4ba693d1e29a42fa298abd61e06682f10 Mon Sep 17 00:00:00 2001 From: shreya kapoor <31164665+shreyakapoor08@users.noreply.github.com> Date: Sat, 30 May 2020 14:34:27 +0530 Subject: [PATCH 211/265] KMP in C (#2828) KMP in C --- Knuth_Morris_Pratt_Algorithm/KMP.c | 70 ++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/KMP.c diff --git a/Knuth_Morris_Pratt_Algorithm/KMP.c b/Knuth_Morris_Pratt_Algorithm/KMP.c new file mode 100644 index 000000000..b3e804867 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/KMP.c @@ -0,0 +1,70 @@ +// Program to implement KnuthMorrisPratt Algorithm in C + +#include +#include +#include + +void KnuthMorrisPratt(const char* X, const char* Y, int m, int n) +{ + if (*X == '\0' || m < n) + printf("Pattern is not found"); + + if (*X == '\0' || m < n) + printf("Pattern is not found"); + + if (*Y == '\0' || n == 0) + printf("Pattern with shift 0"); + + int alternate[n + 1]; + + for (int i = 0; i < n + 1; i++) + alternate[i] = 0; + + for (int i = 1; i < n; i++) + { + int j = alternate[i + 1]; + while (j > 0 && Y[j] != Y[i]) + j = alternate[j]; + + if (j > 0 || Y[j] == Y[i]) + alternate[i + 1] = j + 1; + } + + for (int i = 0, j = 0; i < m; i++) + { + if (*(X + i) == *(Y + j)) + { + if (++j == n) + printf("Pattern occurs with shift %d\n", i - j + 1); + } + else if (j > 0) { + j = alternate[j]; + i--; + } + } +} + +// Program to implement KnuthMorrisPratt Algorithm in C +int main(void) +{ + char word[20]; + gets(word); + + char pattern[20]; + gets(pattern); + + int n = strlen(word); + int m = strlen(pattern); + + KnuthMorrisPratt(word, pattern, n, m); + + return 0; +} + +///Sample IP: +// BACPARKWRPARM +// PAR + +///Sample OP: +// Pattern occurs with shift 3 +// Pattern occurs with shift 9 From b9a6fc237bf0a3d134cee4dd4bcb4d3c619e96d4 Mon Sep 17 00:00:00 2001 From: sejal-Srivastava <62070965+sejalshri@users.noreply.github.com> Date: Sat, 30 May 2020 14:36:35 +0530 Subject: [PATCH 212/265] Create pancakesort.js (#2893) * Create pancakesort.js --- Pancake_sort/pancakesort.js | 46 +++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Pancake_sort/pancakesort.js diff --git a/Pancake_sort/pancakesort.js b/Pancake_sort/pancakesort.js new file mode 100644 index 000000000..3caa25c4f --- /dev/null +++ b/Pancake_sort/pancakesort.js @@ -0,0 +1,46 @@ +//implementation of pancake sorting in JS +var n = prompt("enter the size of an array required"); +var arr = new Array(); +//taking input for array +for (let i = 0; i < n; i++) { + arr[i] = prompt("element" + (i + 1) + ":"); + arr[i] = parseInt(arr[i]); +} +var count = 0; +for (let i = 0; i < n - 1; i++) { + let max = arr[0]; + let m = 0, + t = m; + //finding maximum element from unsorted array + for (let j = 1; j < n - count; j++) { + if (arr[j] > max) { + max = arr[j]; + t = j; + } + } + if (t != m) { + let newarr; + //reversing the array until the maximum element position + newarr = arr.slice(0, t + 1).reverse(); + for (let i = 0; i < t + 1; i++) { + arr[i] = newarr[i]; + } + } + let neww; + //reversing the whole unsorted array + neww = arr.slice(0, n - count).reverse(); + for (let i = 0; i < n - count; i++) { + arr[i] = neww[i]; + } + count++; +} +console.log("the sorted array is " + arr); + +/* sample input-output +enter the size of an array required: 5 +element 1:56 +element 2:23 +element 3:78 +element 4:18 +element 5:9 +the sorted array is 9,18,23,56,78 */ From e7d5458a3ee0f5263cf1db13e3990e6c9fae576c Mon Sep 17 00:00:00 2001 From: Jasbir Date: Sat, 30 May 2020 14:38:48 +0530 Subject: [PATCH 213/265] Added Karatsuba_Algorithm.php (#2910) * Added Karatsuba_Algorithm.php --- Karatsuba_Algorithm/Karatsuba_Algorithm.php | 50 +++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 Karatsuba_Algorithm/Karatsuba_Algorithm.php diff --git a/Karatsuba_Algorithm/Karatsuba_Algorithm.php b/Karatsuba_Algorithm/Karatsuba_Algorithm.php new file mode 100644 index 000000000..2a7c98f54 --- /dev/null +++ b/Karatsuba_Algorithm/Karatsuba_Algorithm.php @@ -0,0 +1,50 @@ + From b8a12f6cf8b5529642b19e145437b73fec5e9c63 Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Sat, 30 May 2020 17:16:23 +0530 Subject: [PATCH 214/265] Insertion Sort in Rust (#2983) --- Insertion_Sort/Insertion_Sort.rs | 42 ++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 Insertion_Sort/Insertion_Sort.rs diff --git a/Insertion_Sort/Insertion_Sort.rs b/Insertion_Sort/Insertion_Sort.rs new file mode 100644 index 000000000..dcd8f880e --- /dev/null +++ b/Insertion_Sort/Insertion_Sort.rs @@ -0,0 +1,42 @@ +use std::io; +use std::str::FromStr; + +fn main() { + println!("Enter the numbers to be sorted (separated by space) : "); + let mut i = read_values :: ().unwrap(); + insertion_sort(&mut i); + println!("Sorted array: {:?}", i) +} + +fn insertion_sort(arr: &mut Vec) { + for i in 1..arr.len() { + let mut j = i; + while j > 0 && arr[j] < arr[j - 1] { + arr.swap(j, j - 1); + j = j - 1; + } + } +} + +fn read_values() -> Result, T::Err> { + let mut s = String::new(); + io::stdin() + .read_line(&mut s) + .expect("could not read from stdin"); + s.trim() + .split_whitespace() + .map(|word| word.parse()) + .collect() +} + +/* + +Sample Input : + Enter the numbers to be sorted (separated by space) : + 45 34 112 50 91 + +Sample Output : + Sorted array: [34, 45, 50, 91, 112] + +*/ + From daa21c0765452c4b5f6baa4363b8909ac2fb1afa Mon Sep 17 00:00:00 2001 From: shreya kapoor <31164665+shreyakapoor08@users.noreply.github.com> Date: Sat, 30 May 2020 18:37:49 +0530 Subject: [PATCH 215/265] squash (#2483) Issue#2200: Implementation of Kruskal Algorithm in JavaScript minor changes 4 space indentation and unwanted spaces removed --- Kruskal_Algorithm/Kruskal_Algorithm.js | 138 +++++++++++++++++++++++++ 1 file changed, 138 insertions(+) create mode 100644 Kruskal_Algorithm/Kruskal_Algorithm.js diff --git a/Kruskal_Algorithm/Kruskal_Algorithm.js b/Kruskal_Algorithm/Kruskal_Algorithm.js new file mode 100644 index 000000000..176c56ea5 --- /dev/null +++ b/Kruskal_Algorithm/Kruskal_Algorithm.js @@ -0,0 +1,138 @@ +// Javascript Implementation of Kruskals Algorithm + +class UnionFind { + constructor(elements) { + this.count = elements.length; + this.parent = {}; + elements.forEach(e => (this.parent[e] = e)); + } + + union(a, b) { + let rootA = this.find(a); + let rootB = this.find(b); + if (rootA === rootB) return; + if (rootA < rootB) { + if (this.parent[b] != b) this.union(this.parent[b], a); + this.parent[b] = this.parent[a]; + } else { + if (this.parent[a] != a) this.union(this.parent[a], b); + this.parent[a] = this.parent[b]; + } + } + + find(a) { + while (this.parent[a] !== a) { + a = this.parent[a]; + } + return a; + } + + connected(a, b) { + return this.find(a) === this.find(b); + } +} + +class PriorityQueue { + constructor(maxSize) { + if (isNaN(maxSize)) { + maxSize = 10; + } + this.maxSize = maxSize; + this.container = []; + } + + isEmpty() { + return this.container.length === 0; + } + + isFull() { + return this.container.length >= this.maxSize; + } +} + +PriorityQueue.prototype.Element = class { + constructor (data, priority) { + this.data = data; this.priority = priority; + } +} + +function kruskalsMST() { + const MST = new Graph(); + this.nodes.forEach(node => MST.addNode(node)); + if (this.nodes.length === 0) { + return MST; + } + + edgeQueue = new PriorityQueue(this.nodes.length * this.nodes.length); + + + for (let node in this.edges) { + this.edges[node].forEach(edge => { + edgeQueue.enqueue([node, edge.node], edge.weight); + }); + } + + let uf = new UnionFind(this.nodes); + + + while (!edgeQueue.isEmpty()) { + let nextEdge = edgeQueue.dequeue(); + let nodes = nextEdge.data; + let weight = nextEdge.priority; + + if (!uf.connected(nodes[0], nodes[1])) { + MST.addEdge(nodes[0], nodes[1], weight); + uf.union(nodes[0], nodes[1]); + } + } + return MST; +} + +let g = new Graph(); + +g.addNode("A"); +g.addNode("B"); +g.addNode("C"); +g.addNode("D"); +g.addNode("E"); +g.addNode("F"); +g.addNode("G"); + +g.addEdge("A", "C", 100); +g.addEdge("A", "B", 3); +g.addEdge("A", "D", 4); +g.addEdge("C", "D", 3); +g.addEdge("D", "E", 8); +g.addEdge("E", "F", 10); +g.addEdge("B", "G", 9); +g.addEdge("E", "G", 50); + +g.kruskalsMST().display(); + +///Sample Input +// let g = new Graph(); +// g.addNode("A"); +// g.addNode("B"); +// g.addNode("C"); +// g.addNode("D"); +// g.addNode("E"); +// g.addNode("F"); +// g.addNode("G"); + +// g.addEdge("A", "C", 100); +// g.addEdge("A", "B", 3); +// g.addEdge("A", "D", 4); +// g.addEdge("C", "D", 3); +// g.addEdge("D", "E", 8); +// g.addEdge("E", "F", 10); +// g.addEdge("B", "G", 9); +// g.addEdge("E", "G", 50); + +/// Sample Output +// A->B, D +// B->A, G +// C->D +// D->C, A, E +// E->D, F +// F->E +// G->B From 9172c61b11d0075ac5ee16e1678d4b57de45f901 Mon Sep 17 00:00:00 2001 From: SWARNIMA SHUKLA Date: Sat, 30 May 2020 19:09:55 +0530 Subject: [PATCH 216/265] Prims Algorithm implementation in Dart (#2785) --- Prims_Algorithm/Prims_Algorithm.dart | 166 +++++++++++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 Prims_Algorithm/Prims_Algorithm.dart diff --git a/Prims_Algorithm/Prims_Algorithm.dart b/Prims_Algorithm/Prims_Algorithm.dart new file mode 100644 index 000000000..695b5929b --- /dev/null +++ b/Prims_Algorithm/Prims_Algorithm.dart @@ -0,0 +1,166 @@ +/* +Prim's algorithm is to find minimum cost spanning tree (as Kruskal's algorithm) +uses the greedy approach. Prim's algorithm shares a similarity with the +shortest path first algorithms. + +Prim's algorithm, in contrast with Kruskal's algorithm, treats the nodes as a +single tree and keeps on adding new nodes to the spanning tree from the +given graph. + */ + +import 'dart:io'; +import 'dart:svg'; + +var INT_MAX = 9223372036854775807; + +int minnode(dist, fingraph, V) +{ + var min = INT_MAX; + var min_index = 0; + + for (var v = 0; v < V; v++) { + if (fingraph[v] == false && dist[v] < min) { + min = dist[v]; + min_index = v; + } + } + + return min_index; +} + +void printMST(parent, graph, V) +{ + print("Edge \tWeight\n"); + for (var i = 1; i < V; i++) { + print('${parent[i]} - ${i} \t ${graph[i][parent[i]]} \n'); + } +} + +void prim_mst(graph, V) +{ + var parent = new List(V); + var dist = new List(V); + var fingraph = new List(V); + + for (var i = 0; i < V; i++) + { + dist[i] = INT_MAX; + fingraph[i] = false; + } + + dist[0] = 0; + parent[0] = -1; + + for (var count = 0; count < V - 1; count++) + { + var u = minnode(dist, fingraph, V); + fingraph[u] = true; + + for (var v = 0; v < V; v++) + { + if (graph[u][v] > 0 && fingraph[v] == false && graph[u][v] < dist[v]) + { + parent[v] = u; + dist[v] = graph[u][v]; + } + } + } + + printMST(parent, graph, V); +} + +int main() +{ + print('Enter number of nodes 0 to ?'); + + var n = int.parse(stdin.readLineSync()); + var max_edges = (n + 1) * (n); + var adjmat = new List.generate(n + 1, (_) => new List(n + 1)); + + for(var i = 0; i <= n; i++) + { + for(var j = 0; j <= n; j++) + { + adjmat[i][j] = 0; + } + } + + print('Enter in the following format\nsrc\ndest\nweight\n'); + for(var i = 0; i < max_edges; i++) + { + var src = int.parse(stdin.readLineSync()); + var dest = int.parse(stdin.readLineSync()); + var weight = int.parse(stdin.readLineSync()); + + print('*' * 20); + + if((src == -1) && (dest == -1)) + { + break; + } + + if(src > n || dest > n || src < 0 || dest < 0) + { + print('Invalid edge!\n'); + i--; + } + + else + { + adjmat[src][dest] = weight; + } + } + + prim_mst(adjmat, n + 1); + return 0; +} + +/* +Input: +Enter number of nodes 0 to ? +4 +Enter in the following format +Source +Destination +Weight + +Let us create the following graph + + (1)____1___(2) + / \ / \ + 3 4 4 6 + / \ / \ + / \ / \ +(0)___5___(5)____5___(3) + \ | / + \ | / + \ | / + \ 2 / + 6 | 8 + \ | / + \ | / + \ | / + \ | / + (4) + + adjmat = [ + [ 0, 3, 0, 0, 6, 5 ], + [ 3, 0, 1, 0, 0, 4 ], + [ 0, 1, 0, 6, 0, 4 ], + [ 0, 0, 6, 0, 8, 5 ], + [ 6, 0, 0, 8, 0, 2 ], + [ 5, 4, 4, 5, 2, 0 ] + ]; + +Output: + +Edge Weight + +0 - 1 3 +1 - 2 1 +1 - 5 4 +5 - 4 2 +5 - 3 5 +Minimum Weight is 15 + */ + From 3aa5ad88a8e768854a181371ba383b17a9d8ebff Mon Sep 17 00:00:00 2001 From: SWARNIMA SHUKLA Date: Sat, 30 May 2020 19:17:02 +0530 Subject: [PATCH 217/265] Kruskal Algorithm implementation in Dart (#2786) --- Kruskal_Algorithm/Kruskal_Algorithm.dart | 159 +++++++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 Kruskal_Algorithm/Kruskal_Algorithm.dart diff --git a/Kruskal_Algorithm/Kruskal_Algorithm.dart b/Kruskal_Algorithm/Kruskal_Algorithm.dart new file mode 100644 index 000000000..e9fc32906 --- /dev/null +++ b/Kruskal_Algorithm/Kruskal_Algorithm.dart @@ -0,0 +1,159 @@ +/* +Kruskal's algorithm is a minimum spanning tree algorithm that takes a graph a +s input and finds the subset of the edges of that graph which + +(1) form a tree that includes every vertex +(2) has the minimum sum of weights among all the trees that can be + formed from the graph + */ + +import 'dart:io'; + +var INT_MAX = 9223372036854775807; + +int find(i, parent) +{ + while (parent[i] != i) { + i = parent[i]; + } + return i; +} + +void union1(i, j, parent) +{ + var a = find(i, parent); + var b = find(j, parent); + + parent[a] = b; +} + +void kruskal_mst(adjmat, V) +{ + var mincost = 0; + + var parent = new List(V); + + for (var i = 0; i < V; i++) + { + parent[i] = i; + } + + var edge_count = 0; + while (edge_count < V - 1) + { + var min = INT_MAX, a = -1, b = -1; + + for (var i = 0; i < V; i++) + { + for (var j = 0; j < V; j++) + { + if (find(i, parent) != find(j, parent) && adjmat[i][j] < min) + { + min = adjmat[i][j]; + a = i; + b = j; + } + } + } + + union1(a, b, parent); + print('Edge ${edge_count++}:(${a}, ${b}) cost:${min} \n'); + + mincost += min; + } + + print('\n Minimum cost= ${mincost} \n'); +} + +int main() +{ + print('Enter number of nodes 0 to ?'); + + var n = int.parse(stdin.readLineSync()); + var max_edges = (n + 1) * (n); + var adjmat = new List.generate(n+1, (_) => new List(n + 1)); + + for(var i = 0; i <= n; i++) + { + for(var j = 0; j <= n; j++) + { + adjmat[i][j] = INT_MAX; + } + } + + print('Enter in the following format\nsrc\ndest\nweight\n'); + for(var i = 0; i < max_edges; i++) + { + var src = int.parse(stdin.readLineSync()); + var dest = int.parse(stdin.readLineSync()); + var weight = int.parse(stdin.readLineSync()); + + print('*' * 20); + + if((src == -1) && (dest == -1)) + { + break; + } + + if(src > n || dest > n || src < 0 || dest < 0) + { + print('Invalid edge!\n'); + i--; + } + + else + { + adjmat[src][dest] = weight; + } + } + + kruskal_mst(adjmat , n + 1); + return 0; +} + +/* +Input: +Enter number of nodes 0 to ? +4 +Enter in the following format +Source +Destination +Weight + + Let the given graph is : + + (1)____1___(2) + / \ / \ + 3 4 4 6 + / \ / \ + / \ / \ +(0)___5___(5)____5___(3) + \ | / + \ | / + \ | / + \ 2 / + 6 | 8 + \ | / + \ | / + \ | / + \ | / + (4) + + adjmat = [ + [ 0, 3, 0, 0, 6, 5 ], + [ 3, 0, 1, 0, 0, 4 ], + [ 0, 1, 0, 6, 0, 4 ], + [ 0, 0, 6, 0, 8, 5 ], + [ 6, 0, 0, 8, 0, 2 ], + [ 5, 4, 4, 5, 2, 0 ] + ]; +Output: + + Edge: 0-1 cost: 3 + Edge: 1-2 cost: 1 + Edge: 1-5 cost: 4 + Edge: 5-4 cost: 2 + Edge: 5-3 cost: 5 + Minimum Weight is 15 + */ + From 07aa1a2e8eca6d035cda0dd0da0ed2e0b2582280 Mon Sep 17 00:00:00 2001 From: vishakha2108 <50831546+vishakha2108@users.noreply.github.com> Date: Sat, 30 May 2020 19:19:44 +0530 Subject: [PATCH 218/265] Srtf Scheduling (#2482) * Add files via upload * rtf * Create SRTF.java * delete * delete * srtf cpu scheduler in java * srtf java * file name changed and indentation improved * indentation improved * Update SRTF_Scheduling.java * Update SRTF_Scheduling.java Co-authored-by: Shyam Narang --- SRTF_Scheduling/SRTF_Scheduling.java | 162 +++++++++++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 SRTF_Scheduling/SRTF_Scheduling.java diff --git a/SRTF_Scheduling/SRTF_Scheduling.java b/SRTF_Scheduling/SRTF_Scheduling.java new file mode 100644 index 000000000..673238164 --- /dev/null +++ b/SRTF_Scheduling/SRTF_Scheduling.java @@ -0,0 +1,162 @@ +package github; + +import java.util.Scanner; +class Process +{ + static Scanner in = new Scanner(System.in);//for input + float At = 0;//parameters of process + float Bt = 0; + float Ct = 0; + float Tt = 0; + float Wt = 0; + float Timeleft ;//only used for srtf + + Process(float a, float b)// constructor + { + At = a; + Bt = b; + } + + public static float calTt(Process p[], int n)//tt = ct-at and avg tt + { + float avg = 0;//avg + for(int i = 0; i < n; i++) + { + p[i].Tt = p[i].Ct - p[i].At; + avg = avg + p[i].Tt; + } + avg = avg / n; + return avg; + } + + public static float calWt(Process p[], int n)//wt = tt-bt and avg wt + { + float avg = 0;//avg + for(int i = 0; i < n; i++) + { + p[i].Wt = p[i].Tt - p[i].Bt; + avg = avg + p[i].Wt; + } + avg = avg / n;//avg wt + return avg; + } +} + +class SRTF +{ + float Awt; + float Att; + float sumBT; + static Scanner in = new Scanner(System.in); + public SRTF() + { + sumBT = 0; + } + + public void Accept(Process p[], int n)//accept func + { + for(int i = 0; i < n; i++) + { + System.out.println("Enter arrival time for process P" + i);//at + float a = in.nextFloat(); + System.out.println("Enter burst time for process P" + i);//bt + float b = in.nextFloat(); + p[i] = new Process(a, b); + p[i].Timeleft = p[i].Bt;//used to find shortest process remaining + sumBT = sumBT + p[i].Bt;//used for cal ct in calcct function + } + } + + public void CalcCT(Process p[], int n) + { + System.out.println(); + System.out.println(); + int min = 0; + for(int i = 0; i < sumBT; i++) + { + for(int j = 0; j < n; j++) + { + if(p[j].At <= i && p[min].Timeleft > p[j].Timeleft && p[j].Timeleft != 0)//finding process with least bt + { + min = j;// process index with min bt + } + } + p[min].Timeleft--; + if(p[min].Timeleft == 0)//setting ct when execution is done + { + p[min].Ct = i + 1;// +1 because it will complete in next cycle + p[min].Timeleft = 32767; + } + System.out.print("P" + min + "| ");//gantt chart + } + Att = Process.calTt(p, n);//att + Awt = Process.calWt(p, n);//awt + } + + public void Display(Process p[], int n) + { + System.out.println(); + System.out.println("process Arrival Time Burst Time Completion Time Turnover Time Waiting Time");//table + for(int i = 0; i < n; i++) + { + System.out.println("P" + i + "\t " + p[i].At + "\t\t" + p[i].Bt + "\t\t" + p[i].Ct + "\t\t" + p[i].Tt + "\t\t" + p[i].Wt); + } + System.out.println(); + System.out.println("Average waiting time is " + Awt);//other data to be displayed + System.out.println("Average turnover time is " + Att); + System.out.println(); + } +} + + +public class MAIN { + public static void main(String[] args) + { + Scanner in = new Scanner(System.in); + System.out.println("SRTF algorithm"); + int n;//no of processes + System.out.println("Enter no of process");//ip of process + n = in.nextInt(); + Process P[] = new Process[n]; + SRTF S = new SRTF();//object of srtf + S.Accept(P, n); + S.CalcCT(P, n);//all calculations and gantt chart + System.out.println(); + S.Display(P, n);//table display + } +} + +/*sample output + * SRTF algorithm +Enter no of process +4 +Enter arrival time for process P0 +0 +Enter burst time for process P0 +7 +Enter arrival time for process P1 +2 +Enter burst time for process P1 +4 +Enter arrival time for process P2 +4 +Enter burst time for process P2 +2 +Enter arrival time for process P3 +7 +Enter burst time for process P3 +1 + + +P0| P0| P1| P1| P1| P1| P2| P2| P3| P0| P0| P0| P0| P0| + +process Arrival Time Burst Time Completion Time Turnover Time Waiting Time +P0 0.0 7.0 14.0 14.0 7.0 +P1 2.0 4.0 6.0 4.0 0.0 +P2 4.0 2.0 8.0 4.0 2.0 +P3 7.0 1.0 9.0 2.0 1.0 + +Average waiting time is 2.5 +Average turnover time is 6.0 + +*/ From cd4520d2593f207942c37c31a4bd3d3a3ff338bc Mon Sep 17 00:00:00 2001 From: Debdut Goswami Date: Sat, 30 May 2020 19:31:20 +0530 Subject: [PATCH 219/265] README for Longest Increasing Subsequence (#2897) * Insertion Sort #2148 * Readme LIS * LIS Pseudo code --- Longest_Increasing_Subsequence/README.md | 73 ++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Longest_Increasing_Subsequence/README.md diff --git a/Longest_Increasing_Subsequence/README.md b/Longest_Increasing_Subsequence/README.md new file mode 100644 index 000000000..3d1c08af7 --- /dev/null +++ b/Longest_Increasing_Subsequence/README.md @@ -0,0 +1,73 @@ +# Longest Increasing Subsequence + +The Longest Increasing Subsequence (LIS) problem is to find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order. For example, the length of LIS for `{10, 22, 9, 33, 21, 50, 41, 60, 80}` is `6` and LIS is `{10, 22, 33, 50, 60, 80}`. + +![longest-increasing-subsequence](https://media.geeksforgeeks.org/wp-content/cdn-uploads/Longest-Increasing-Subsequence.png) + +## Examples + +``` +Input : arr[] = {3, 10, 2, 1, 20} +Output : Length of LIS = 3 +The longest increasing subsequence is 3, 10, 20 + +Input : arr[] = {3, 2} +Output : Length of LIS = 1 +The longest increasing subsequences are {3} and {2} + +Input : arr[] = {50, 3, 10, 7, 40, 80} +Output : Length of LIS = 4 +The longest increasing subsequence is {3, 7, 40, 80} +``` + +## Recursive Approach + +``` +Let arr[0..n-1] be the input array and L(i) be the length of the LIS ending at index i such that arr[i] is the last element of the LIS. + +Then, L(i) can be recursively written as: + +L(i) = 1 + max( L(j) ) where 0 < j < i and arr[j] < arr[i]; or +L(i) = 1, if no such j exists. + +To find the LIS for a given array, we need to return max(L(i)) where 0 < i < n. + +Thus, we see the LIS problem satisfies the optimal substructure property as the main problem can be solved using solutions to subproblems. +``` + +## Pseudo Code + +``` +LIS(A[1..n]): + Array L[1..n] + (* L[i] = value of LIS ending(A[1..i]) *) + for i = 1 to n do + L[i] = 1 + for j = 1 to i − 1 do + if (A[j] < A[i]) do + L[i] = max(L[i], 1 + L[j]) + return L + +MAIN(A[1..n]): + L = LIS(A[1..n]) + return the maximum value in L +``` + +## Overlapping Subproblems: + +Considering the above implementation, following is recursion tree for an array of size 4. lis(n) gives us the length of LIS for arr[]. + +``` + lis(4) + / | \ + lis(3) lis(2) lis(1) + / \ | + lis(2) lis(1) lis(1) + / +lis(1) +``` + + +# Time Complexity + +O ( n 2 ) \ No newline at end of file From e9587d7181432d9f2e17e3104d2587c025f9a38b Mon Sep 17 00:00:00 2001 From: Shweta Bhardwaj <59722795+BhardwajShweta25@users.noreply.github.com> Date: Sat, 30 May 2020 22:34:29 +0530 Subject: [PATCH 220/265] Added Ternary_Search.php (#3025) --- Ternary_Search/Ternary_Search.php | 63 +++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Ternary_Search/Ternary_Search.php diff --git a/Ternary_Search/Ternary_Search.php b/Ternary_Search/Ternary_Search.php new file mode 100644 index 000000000..1f8e53a4e --- /dev/null +++ b/Ternary_Search/Ternary_Search.php @@ -0,0 +1,63 @@ += l means there is some space to search x in ar + if( $r >= $l ) + { + /* Dividing the array into three parts + * namely ar[0]..ar[mid1], ar[mid1]...ar[mid2], ar[mid2]...ar[length - 1] + */ + $mid1 = (int)($l + ($r - $l) / 3); + $mid2 = (int)($mid1 + ($r - $l) / 3); + + // if x is present at mid1 + if($ar[$mid1] == $x) + return $mid1; + + // if x is present at mid2 + if($ar[$mid2] == $x) + return $mid2; + + // if x is present in left one-third part + if($ar[$mid1] > $x) + return ternary_search($ar, $l, $mid - 1, $x); + + // if x is present in right one third part + if($ar[$mid2] < $x) + return ternary_search($ar, $mid2 + 1, $r, $x); + + // if x is present in middle one third part + return ternary_search($ar, $mid1 + 1, $mid2 - 1, $x); + } + else + return -1; + // if x is not present in ar + } + + // Sample Input (make sure to use sorted array) + $ar = array(1, 2, 3, 4, 5, 6, 7, 8); + + // x will contain the value which is to be searched in given array + $x = 4; + + /* to search x in ar, we firstly pass whole of array to the ternary_search() function + * i.e., (l == 0, r == count(ar) - 1), where count(ar) returns the number of elements in ar + */ + + $index_x = ternary_search($ar, 0, count($ar) - 1, $x); + // index_x holds the "index" where x is found in ar or -1 if not found + + echo "$index_x"; + + /* Sample Output + * 3 + * Note that the 3 is the index of "4" in ar (ar[3] = 4) + */ +?> From 400b9ba612315be07b8799feba6e62b84e819c1b Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 00:15:04 +0530 Subject: [PATCH 221/265] 3 way quick sort implemented in Dart (#3026) --- Quicksort_3_way/Quicksort_3_way.dart | 97 ++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 Quicksort_3_way/Quicksort_3_way.dart diff --git a/Quicksort_3_way/Quicksort_3_way.dart b/Quicksort_3_way/Quicksort_3_way.dart new file mode 100644 index 000000000..285bcdd7d --- /dev/null +++ b/Quicksort_3_way/Quicksort_3_way.dart @@ -0,0 +1,97 @@ +/** + * 3 way Quick sort + * --------------------------------- + * In three way quick sort, we partition the list into three divisions where + * division1 is less than pivot, division2 is equal to pivot and division3 is greater than + * pivot. The sorting is implemented using Dutch National Flag algorithm. + */ + +// Importing required libraries +import 'dart:io'; + +// Method to swap two integers in a list +void swap(List array, int i, int j){ + int temp = array[i]; + array[i] = array[j]; + array[j] = temp; +} + +// Method to partition the array based on 3 way partition +List partition(List array, int low, int high){ + int i, j; + if(high - low <= 1){ + if(array[high] < array[low]){ + swap(array, high, low); + } + i = low; + j = high; + // Returning the partitioning indices as list. + return [i, j]; + } + + int mid = low; + int pivot = array[high]; + while(mid <= high){ + if(array[mid] < pivot){ + swap(array, low++, mid++); + } + else if(array[mid] == pivot){ + mid++; + } + else if(array[mid] > pivot){ + swap(array, mid, high--); + } + } + i = low - 1; + j = mid; + + // Returning the partitioning indices as list + return [i, j]; +} + +// Method to sort a list using 3 way partition quick sort. +void quicksort_3_way(List array, int low, int high){ + + // Base case + if(low >= high){ + return; + } + + // Partitioning indices + List indices = partition(array, low, high); + + // Recursion + quicksort_3_way(array, low, indices[0]); + quicksort_3_way(array, indices[1], high); + +} + +// Driver method of the program +void main(){ + + // Input of number of elements of the array + print("Enter number of elements of the array:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + + // Input of array elements + print("Enter array elements:"); + input = stdin.readLineSync(); + var lis = input.split(" "); + List array = lis.map(int.parse).toList(); + + // Finding the sorted array using quick sort 3 way partition + quicksort_3_way(array, 0, n - 1); + + // Printing the output to stdout. + print(array.join(" ")); +} +/** + * Sample Input and Output + * ------------------------------- + * Enter number of elements of the array: + * 13 + * Enter array elements: + * 4 9 4 4 1 9 4 4 9 4 4 1 4 + * 1 1 4 4 4 4 4 4 4 4 9 9 9 + */ From 9cd94a26c34ee4cac8dc457e487a90c0ea080149 Mon Sep 17 00:00:00 2001 From: Mrunal <44579222+mruna7@users.noreply.github.com> Date: Sun, 31 May 2020 00:25:43 +0530 Subject: [PATCH 222/265] Linear_Search(Typescript) (#3004) Linear_Search.ts Update Linear_Search.ts Update Linear_Search.ts Update Linear_Search.ts Update Linear_Search.ts --- Linear_Search/Linear_Search.ts | 36 ++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Linear_Search/Linear_Search.ts diff --git a/Linear_Search/Linear_Search.ts b/Linear_Search/Linear_Search.ts new file mode 100644 index 000000000..8f137d01a --- /dev/null +++ b/Linear_Search/Linear_Search.ts @@ -0,0 +1,36 @@ +/* Implementation of LinearSearch algorithm to find value 5 in a given array of numbers */ + +function LinearSearch(arr:number[], n:number, val:number) :number +{ + for (let i = 0; i < n; i++) + { + if (val == arr[i]) + return i; + } + return -1; +} + + +var result = 0 +var n = 0 +var val = 5 //input value +console.log(" value to be found: ", val); +var n: number = 10 //no. of elements in the array +var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; //input array +console.log(" Array of numbers is: ", arr); +result = LinearSearch(arr, n, val) +if (result != -1) +{ + console.log(" value ", val," found at index no. ", result," in the array "); +} +else +{ + console.log(" value ", val," not found "); +} + + +/* OUTPUT: + value to be found: 5 + Array of numbers is: [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] + value 5 found at index no. 4 in the array +*/ From eb675af8b32f9ac7a511b3955c09bffbc391cc79 Mon Sep 17 00:00:00 2001 From: sejal-Srivastava <62070965+sejalshri@users.noreply.github.com> Date: Sun, 31 May 2020 00:33:02 +0530 Subject: [PATCH 223/265] Create cyclesort.c #2146 (#2807) * Create cyclesort.c #2146 implementation of cycle sort in C * Delete cyclesort.c * updatedcyclesort.c * Rename cyclesort.c to Cycle_Sort/cyclesort.c * update cyclesort.c * Update cyclesort.c * Update cyclesort.c * Update cyclesort.c * Update cyclesort.c --- Cycle_Sort/cyclesort.c | 97 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 Cycle_Sort/cyclesort.c diff --git a/Cycle_Sort/cyclesort.c b/Cycle_Sort/cyclesort.c new file mode 100644 index 000000000..5103c68c4 --- /dev/null +++ b/Cycle_Sort/cyclesort.c @@ -0,0 +1,97 @@ +#include + +void main() +{ + int arr[100], i, j, k, p, n, value, index, l, temp; + //input for array size + printf("enter the number of elements required \n"); + scanf("%d", &n); + printf("enter the elements of the array"); + + for (i = 0; i < n; i++) + { + scanf("%d", &arr[i]); + } + + //this sorting follows comparing process,with it's right elements hence loop goes to n-2 to avoid garbage values in the output + for (k = 0; k < n - 2; k++) + { + value = arr[k]; + index = k; + + //loop to find number of elements less than the element in consideration + for (j = k + 1; j < n; j++) + { + if (arr[j] < value) + { + index++; + } + } + + //if the element is at right position + if (index == k) + { + continue; + } + + //skipping duplicate elements + while (arr[index] == value) + { + index++; + } + + //providing the correct position to the element + if (index != k) + { + temp = value; + value = arr[index]; + arr[index] = temp; + } + + //rotate rest of the cycle + while (index != k) + { + index = k; + + for (p = k + 1; p < n; p++) + { + if (arr[p] < value) + { + index++; + } + } + + while (arr[index] == value) + { + index++; + } + + if (index != k) + { + temp = value; + value = arr[index]; + arr[index] = temp; + } + } + arr[k] = value; + } + printf("the sorted array is"); + + for (l = 0; l < n; l++) + { + printf("%d\t", arr[l]); + } + +} + +//sample input-output +/*enter the number of elements required +6 +enter the elements of the array +4 +9 +3 +2 +4 +6 +the sorted array is 2 3 4 4 6 9*/ From abddc127d060fbc4450daff791b1da7f365d042e Mon Sep 17 00:00:00 2001 From: shweta0699 <60976710+shweta0699@users.noreply.github.com> Date: Sun, 31 May 2020 00:44:43 +0530 Subject: [PATCH 224/265] Implementation of 0/1 knapsack problem in c++ (updated) (#2433) Update-1 01_knapsack.cpp Update-2 01_knapsack.cpp Update-3 01_knapsack.cpp --- Knapsack/01_knapsack.cpp | 56 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 Knapsack/01_knapsack.cpp diff --git a/Knapsack/01_knapsack.cpp b/Knapsack/01_knapsack.cpp new file mode 100644 index 000000000..7ef322ca4 --- /dev/null +++ b/Knapsack/01_knapsack.cpp @@ -0,0 +1,56 @@ +#include +#include +using namespace std; + +// Function to return maximum profit +int knapsack(vector profit, vector weight, int capacity, int n) { + + if(capacity == 0 || n == 0 ) { + return 0; + } + if(weight[n - 1] > capacity) { + return knapsack(profit, weight, capacity, n - 1); + } + else { + return max(profit[n - 1] + knapsack(profit, weight, capacity - weight[n - 1], n - 1), knapsack(profit, weight, capacity, n - 1)); + } +} + +int max(int a, int b) { + if(a > b) { + return a; + } + else { + return b; + } +} + +int main() { + int capacity, n; + cout << "Enter the number of elements to be stored: "; + cin >> n; + vector profit(n), weight(n); + cout << "Enter the profit values of all elements: "; + for(int i = 0; i < n; i++) { + cin >> profit[i]; + } + cout << "Enter the weights of all elements: "; + for(int i = 0; i < n; i++) { + cin >> weight[i]; + } + cout << "Enter the capacity: "; + cin >> capacity; + cout << "The maximum profit will be: " << knapsack(profit, weight, capacity, n); + return 0; +} + +/* +SAMPLE INPUT: +Enter the number of elements to be stored: 6 +Enter the profit values of all elements: 10 20 30 44 56 72 +Enter the weights of all elements: 5 10 15 25 20 15 +Enter the capacity: 70 + +SAMPLE OUTPUT: +The maximum profit will be: 192 +*/ From 65529ae3ba7b095c8cd5a8e191776788ba45abab Mon Sep 17 00:00:00 2001 From: PrachieNaik <42534757+PrachieNaik@users.noreply.github.com> Date: Sun, 31 May 2020 00:56:58 +0530 Subject: [PATCH 225/265] Create Tree_Postorder_Traversal.kt (#2699) * Create Tree_Postorder_Traversal.kt * Resolving comments * Update Tree_Postorder_Traversal.kt * Correcting identatation * correcting identation * Update Tree_Postorder_Traversal.kt * Update Tree_Postorder_Traversal.kt * Update Tree_Postorder_Traversal.kt --- .../Tree_Postorder_Traversal.kt | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 Tree_Postorder_Traversal/Tree_Postorder_Traversal.kt diff --git a/Tree_Postorder_Traversal/Tree_Postorder_Traversal.kt b/Tree_Postorder_Traversal/Tree_Postorder_Traversal.kt new file mode 100644 index 000000000..ad866b553 --- /dev/null +++ b/Tree_Postorder_Traversal/Tree_Postorder_Traversal.kt @@ -0,0 +1,59 @@ +import java.util.* + +class Node( + var key:Int, + var left:Node? = null, + var right:Node? = null +) +{ + fun postorderTraversal() + { + left?.postorderTraversal() + right?.postorderTraversal() + print("$key ") + } +} + +fun main() { + var read = Scanner(System.`in`) + println("Enter the size of Array:") + val arrSize = read.nextLine().toInt() + var arr = IntArray(arrSize) + val nodes = mutableListOf>() + println("Enter the array respresentaion of binary tree") + + for(i in 0 until arrSize) + { + arr[i] = read.nextLine().toInt() + nodes.add(Node(arr[i])) + } + + for(i in 0..arrSize - 2) + { + if ((i * 2) + 1 < arrSize && arr[(i * 2) + 1] != -1) + { + nodes[i].left = nodes[(i * 2) + 1] + } + + if ((i * 2) + 2 < arrSize && arr[(i * 2) + 2] != -1) + { + nodes[i].right = nodes[(i * 2) + 2] + } + } + print("Post Order traversal of tree is ") + nodes[0].postorderTraversal() +} + +/* +*Enter the size of Array: +*7 +*Enter the array respresentaion of binary tree +*1 +*2 +*3 +*4 +*5 +*6 +*-1 +*Post Order traversal of tree is 4 5 2 6 3 1 +*/ From 87889957e653dc748b28b18ccd20d6a2cc4d14b9 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 01:09:58 +0530 Subject: [PATCH 226/265] Fenwick tree implemented in Dart (#3007) --- Fenwick_Tree/Fenwick_Tree.dart | 159 +++++++++++++++++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 Fenwick_Tree/Fenwick_Tree.dart diff --git a/Fenwick_Tree/Fenwick_Tree.dart b/Fenwick_Tree/Fenwick_Tree.dart new file mode 100644 index 000000000..ee51585b1 --- /dev/null +++ b/Fenwick_Tree/Fenwick_Tree.dart @@ -0,0 +1,159 @@ +/** + * Fenwick Tree + * ------------------------- + * Binary Indexed tree or Fenwick tree is used to solve + * range queries optimally. It has O(n) space complexity, + * O(logn) time complexity to update, O(nlog(n)) time complexity to build + * and O(logn) time complexity to find sum in a given range. + * + */ +// Importing required libraries +import 'dart:io'; + +// Updating the tree with respect to any updates or construction +void updateBITTree(List tree, int n, int index, int val){ + index = index + 1; + + while(index <= n){ + tree[index] += val; + index += index & ( - index); + } + +} + +// Method to find the sum till a given index +int getSum(List tree, int index){ + + int total = 0; + index = index + 1; + + while(index > 0){ + total += tree[index]; + index -= index & ( - index ); + } + + return total; +} + +// Method to find sum between a range using the above method. +int findSum(List tree, int left, int right){ + if(left > right){ + return -1; + } + else if(left == right){ + return getSum(tree, left) - getSum(tree, left - 1); + } + else{ + if(left > 0){ + return getSum(tree,right) - getSum(tree,left) + (getSum(tree, left) - getSum(tree, left - 1)); + } + else if(left == 0){ + return getSum(tree,right); + } + else{ + return -1; + } + } +} + +// Driver method of the program +void main(){ + + // Input of number of array elements + print("Enter number of elements in the array:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + + // Input of array elements + print("Enter array elements:"); + input = stdin.readLineSync(); + var lis = input.split(" "); + List array = lis.map(int.parse).toList(); + + // Fenwick tree initialization + List tree_BIT = List(n + 1); + for(int i = 0; i < n + 1; i ++){ + tree_BIT[i] = 0; + } + + // Tree construction + for(int i = 0; i < n; i ++){ + updateBITTree(tree_BIT, n, i, array[i]); + } + + // Input of number of queries + print("Enter number of queries:"); + input = stdin.readLineSync(); + int q = int.parse(input); + + // Input of queries + print("Enter queries:"); + for(int i = 0 ; i < q ; i ++){ + + print("Enter 1 to update, 2 to find sum:"); + input = stdin.readLineSync(); + int choice = int.parse(input); + switch(choice){ + + case 1: + // Input for updates + print("Enter index and value to update"); + input = stdin.readLineSync(); + lis = input.split(" "); + List choices = lis.map(int.parse).toList(); + array[choices[0]] += choices[1]; + // Updating value + updateBITTree(tree_BIT, n, choices[0], choices[1]); + break; + case 2: + // Input for sum queries + print("Enter range to find the sum"); + input = stdin.readLineSync(); + lis = input.split(" "); + List choices = lis.map(int.parse).toList(); + // Finding sum + int result = findSum(tree_BIT,choices[0],choices[1]); + print(result); + break; + } + } +} + +/** + * + * Sample Input + * ------------------------------------ + * Enter number of elements in the array: + * 12 + * Enter array elements: + * 2 1 1 3 2 3 4 5 6 7 8 9 + * Enter number of queries: + * 5 + * Enter 1 to update, 2 to find sum: + * 2 + * Enter range to find the sum + * 0 5 + * Enter 1 to update, 2 to find sum: + * 1 + * Enter index and value to update + * 3 9 + * Enter 1 to update, 2 to find sum: + * 2 + * Enter range to find the sum + * 0 5 + * Enter 1 to update, 2 to find sum: + * 2 + * Enter range to find the sum + * 5 9 + * Enter 1 to update, 2 to find sum: + * 2 + * Enter range to find the sum + * 8 8 + * + * Sample Output + * ---------------------------------------- + * 12 + * 21 + * 25 + * 6 + */ From b460d6f3e54aea239e64456f13439b6d60ea2af5 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 01:44:34 +0530 Subject: [PATCH 227/265] Red black tree implemented in Dart (#3009) --- Red_Black_Tree/Red_Black_Tree.dart | 346 +++++++++++++++++++++++++++++ 1 file changed, 346 insertions(+) create mode 100644 Red_Black_Tree/Red_Black_Tree.dart diff --git a/Red_Black_Tree/Red_Black_Tree.dart b/Red_Black_Tree/Red_Black_Tree.dart new file mode 100644 index 000000000..295fe18ab --- /dev/null +++ b/Red_Black_Tree/Red_Black_Tree.dart @@ -0,0 +1,346 @@ +/** + * Red Black Tree + * ------------------------------- + * RB Tree is a self balancing tree which is of O(logn) time complexity + * for various operations. It has 4 balancing rules as follows: + * + * 1. Nodes are of either red or black color. + * 2. Root is always black. + * 3. Red node should not have red children + * 4. Every path from a node (including root) to any of its descendant + * NULL node has the same number of black nodes. + * + */ + +// Importing required libraries +import 'dart:io'; + +// Defining colors as constants to increase readability and decrease confusion +const bool BLACK = false; +const bool RED = true; + +// Class definition of a node +class Node{ + int value; + bool color; + Node parent, left, right; + + Node(int value){ + this.value = value; + this.color = RED; + } +} + +// Class definition of a RB Tree +class RBTree{ + + // Tree's root + Node root; + + // Utility function to print a RB Tree + void printRBTree(Node root){ + if(root != null){ + print(root.value); + printRBTree(root.left); + printRBTree(root.right); + } + } + + // Utility method to search in the tree + Node searchRBTree(Node root, int target){ + if(root == null){ + return null; + } + if(root.value == target){ + return root; + } + else if(root.value < target){ + return searchRBTree(root.right, target); + } + else{ + return searchRBTree(root.left, target); + } + } + + // Utility method to perform BST insertion + Node insertBST(Node root, Node node){ + if(root == null){ + root = node; + } + else{ + if(root.value < node.value){ + root.right = insertBST(root.right, node); + root.right.parent = root; + } + else if(root.value > node.value){ + root.left = insertBST(root.left, node); + root.left.parent = root; + } + } + return root; + } + + // Utility method for left rotation + Node rotateLeft(Node root, Node node){ + + Node node_right = node.right; + node.right = node_right.left; + if(node.right != null){ + node.right.parent = node; + } + node_right.parent = node.parent; + if(node.parent == null){ + root = node_right; + } + else if(node == node.parent.left){ + node.parent.left = node_right; + } + else{ + node.parent.right = node_right; + } + node_right.left = node; + node.parent = node_right; + return root; + + } + + // Utility method for right rotation + Node rotateRight(Node root,Node node){ + + Node node_left = node.left; + node.left = node_left.right; + + if(node.left != null){ + node.left.parent = node; + } + + node_left.parent = node.parent; + + if(node.parent == null){ + root = node_left; + } + else if(node == node.parent.left){ + node.parent.left = node_left; + } + else{ + node.parent.right = node_left; + } + + node_left.right = node; + node.parent = node_left; + return root; + } + + // Utility method to swap colors of two nodes + void swapColor(Node node1, Node node2){ + if(node1 == null || node2 == null){ + return; + } + bool temp; + temp = node1.color; + node1.color = node2.color; + node2.color = temp; + } + + // Utility method to fix violation of rules of RB Tree + Node fixViolation(Node root, Node node){ + Node parentnode = null; + Node grandparent = null; + while((node != root) && (node.color != BLACK) && (node.parent.color == RED)){ + parentnode = node.parent; + grandparent = node.parent.parent; + if(parentnode == grandparent.left){ + Node uncle = grandparent.right; + if(uncle != null && uncle.color == RED){ + grandparent.color = RED; + parentnode.color = BLACK; + uncle.color = BLACK; + node = grandparent; + } + else{ + if(node == parentnode.right){ + root = rotateLeft(root,parentnode); + node = parentnode; + parentnode = node.parent; + grandparent = parentnode.parent; + } + root = rotateRight(root, grandparent); + swapColor(parentnode,grandparent); + node = parentnode; + } + } + else{ + Node uncle = grandparent.left; + + if((uncle != null) && (uncle.color == RED)){ + grandparent.color = RED; + parentnode.color = BLACK; + uncle.color = BLACK; + node = grandparent; + } + else{ + if(node == parentnode.left){ + root = rotateRight(root,parentnode); + node = parentnode; + parentnode = node.parent; + grandparent = parentnode.parent; + } + root = rotateLeft(root,grandparent); + swapColor(parentnode,grandparent); + node = parentnode; + } + } + + } + root.color = BLACK; + return root; + } + + // Method to insert into RB Tree + Node insertRBT(Node root, int value){ + Node node = Node(value); + root = insertBST(root, node); + root = fixViolation(root, node); + return root; + } + +} + +// Driver method of the program +void main(){ + + // Initialization of the tree + RBTree tree = RBTree(); + int continued = 1; + + while(continued == 1){ + print("Enter 1 to insert, 2 to search and 3 to print the tree:"); + var input = stdin.readLineSync(); + int option = int.parse(input); + switch(option){ + case 1: + input = stdin.readLineSync(); + int value = int.parse(input); + tree.root = tree.insertRBT(tree.root, value); + break; + case 2: + input = stdin.readLineSync(); + int value = int.parse(input); + Node node1 = tree.searchRBTree(tree.root, value); + if(node1 == null){ + print("Value not found"); + } + else{ + print("Value found!"); + } + break; + case 3: + tree.printRBTree(tree.root); + break; + default: + break; + } + print("Enter 1 to continue:"); + input = stdin.readLineSync(); + continued = int.parse(input); + } +} + +/** + * Sample Input and Output + * ----------------------------------- + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 7 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 3 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 18 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 10 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 22 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 8 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 11 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 26 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 3 + * 7 + * 3 + * 18 + * 10 + * 8 + * 11 + * 22 + * 26 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 2 + * 18 + * Value found!! + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 2 + * 112 + * Value not found!! + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 2 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 6 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 1 + * 13 + * Enter 1 to continue: + * 1 + * Enter 1 to insert, 2 to search and 3 to print the tree: + * 3 + * 10 + * 7 + * 3 + * 2 + * 6 + * 8 + * 18 + * 11 + * 13 + * 22 + * 26 + * Enter 1 to continue: + * 2 + */ From 7a2c24bcb0043010b9ba4e6ab445e363bd5033ae Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Sun, 31 May 2020 13:18:19 +0530 Subject: [PATCH 228/265] Karatsuba Algorithm In Ruby (#3039) --- Karatsuba_Algorithm/Karatsuba_Algorithm.rb | 68 ++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 Karatsuba_Algorithm/Karatsuba_Algorithm.rb diff --git a/Karatsuba_Algorithm/Karatsuba_Algorithm.rb b/Karatsuba_Algorithm/Karatsuba_Algorithm.rb new file mode 100644 index 000000000..691ec4808 --- /dev/null +++ b/Karatsuba_Algorithm/Karatsuba_Algorithm.rb @@ -0,0 +1,68 @@ +# Karatsuba Algorithm In Ruby + += begin + + The Karatsuba Algorithm is a fast multiplication algorithm. + It was discovered by Anatoly Karatsuba in 1960. It reduces + the multiplication of two n-digit numbers to at most single + digit multiplications in general. It is therefore faster + than classical multiplication operation. + += end + +def karatsuba(num1, num2) + + num1, num2 = num1.to_s, num2.to_s + num1_mid_point = (num1.length / 2) + num2_mid_point = (num2.length / 2) + + a = num1[0...num1_mid_point].to_i + b = num1[num1_mid_point..-1].to_i + c = num2[0...num2_mid_point].to_i + d = num2[num2_mid_point..-1].to_i + + # Step 1: Computing the products of a * c + a_c = a * c + + # Step 2: Computing the products of a * c + b_d = b * d + + # Step 3: Computing the products of (a+b) and (c+d) + sum_product = ((a + b) * (c + d)) + + # Step 4: Subtracting first two products from Step 3 + sub_products = sum_product - (a_c + b_d) + + # Step 5: Padding summation + result = (a_c * (10 ** num1.length)) + b_d + (sub_products * (10 ** num1_mid_point)) + +end + +puts "Enter The First Number: " +x = gets.to_i + +puts "Enter The Second Number: " +y = gets.to_i +puts + +answer = karatsuba(x, y) +puts "Result: ", answer +puts + +# Sample Input and Output + += begin + +Enter The First Number: 121547 +Enter The Second Number: 1855324 + +Result: 23133311228 + +-------------------------------------------------- + +Enter The First Number: -8859460 +Enter The Second Number: 1154486 + +Result: -10206279662440 + += end From 8751028d532ddb6eaa0557a607617e08dab6f8bf Mon Sep 17 00:00:00 2001 From: coderprasukj <60914425+coderprasukj@users.noreply.github.com> Date: Sun, 31 May 2020 13:21:43 +0530 Subject: [PATCH 229/265] Rabin Karp in PHP (#3005) Rabin Karp in PHP --- Rabin_Karp/Rabin_Karp.php | 63 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Rabin_Karp/Rabin_Karp.php diff --git a/Rabin_Karp/Rabin_Karp.php b/Rabin_Karp/Rabin_Karp.php new file mode 100644 index 000000000..9969fcc6b --- /dev/null +++ b/Rabin_Karp/Rabin_Karp.php @@ -0,0 +1,63 @@ +// Rabin Karp Algorithm +/* +AN : range or No of alphabets +val : AN ^ patlen-1 +patlen : pattern length +PN: any prime no given input from main +*/ + +/* Time-Complexity:- +The average case running time of the Rabin-Karp algorithm = O(n+m). +The best case running time of the Rabin-Karp algorithm = O(n+m). +The worst-case running time of the Rabin-Karp algorithm = O(nm). +*/ + + + +/* +INPUT : XWINGO XOR WINGO + WINGO + 101 +OUTPUT: Found at index starting from 1 + Found at index starting from 11 +*/ From 7932f22b75dd69f454fcb11b619edd73b13b5314 Mon Sep 17 00:00:00 2001 From: SHIVAM GUPTA <31137037+shivamgupta57121@users.noreply.github.com> Date: Sun, 31 May 2020 13:52:40 +0530 Subject: [PATCH 230/265] Add Tree Postorder Traversal in TypeScript (#3008) --- .../Tree_Postorder_Traversal.ts | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Tree_Postorder_Traversal/Tree_Postorder_Traversal.ts diff --git a/Tree_Postorder_Traversal/Tree_Postorder_Traversal.ts b/Tree_Postorder_Traversal/Tree_Postorder_Traversal.ts new file mode 100644 index 000000000..024a2a638 --- /dev/null +++ b/Tree_Postorder_Traversal/Tree_Postorder_Traversal.ts @@ -0,0 +1,73 @@ +//Tree Postorder Traversal in TypeScript + +export {} + +// Tree Nodes +interface treeNodes +{ + val: number; + parent?: treeNodes; + left?: treeNodes; + right?: treeNodes; +} + +// Defining the nodes with their values and left right children. If a value is not given it is undefined. +const node11: treeNodes = { val: 11 }; +const node10: treeNodes = { val: 10 }; +const node9: treeNodes = { val: 9 }; +const node8: treeNodes = { val: 8 }; +const node7: treeNodes = { val: 7 }; +const node6: treeNodes = { val: 6, left: node10, right: node11}; +const node5: treeNodes = { val: 5 }; +const node4: treeNodes = { val: 4, left: node8, right: node9 }; +const node3: treeNodes = { val: 3, left: node6, right: node7 }; +const node2: treeNodes = { val: 2, left: node4, right: node5 }; +const root: treeNodes = { val: 1, left: node2, right: node3 }; + +// Construct a tree by assigning parent +function constructBinaryTree(): treeNodes +{ + root.parent = undefined; + node2.parent = root; + node3.parent = root; + node4.parent = node2; + node5.parent = node2; + node6.parent = node3; + node7.parent = node3; + node8.parent = node4; + node9.parent = node4; + node10.parent = node6; + node11.parent = node6; + + return root; +} + +// Recursive Function to call itself on left child, then on right child and then print value of current node +function postOrderTraversal(currentNode: treeNodes) +{ + if (!currentNode) + return; + postOrderTraversal(currentNode.left); + postOrderTraversal(currentNode.right); + console.log(currentNode.val + " -> "); +} + +constructBinaryTree(); +console.log("The postorder traversal of the binary tree is :"); +postOrderTraversal(root); + +/* +Output: +The postorder traversal of the binary tree is : +8 -> +9 -> +4 -> +5 -> +2 -> +10 -> +11 -> +6 -> +7 -> +3 -> +1 -> +*/ From f5ee66d3d42397b0aae4fe689015eba8b9232680 Mon Sep 17 00:00:00 2001 From: Sabuj Jana Date: Sun, 31 May 2020 15:25:56 +0530 Subject: [PATCH 231/265] Create Rabin_karp.js (#3038) --- Rabin_Karp/Rabin_karp.js | 43 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Rabin_Karp/Rabin_karp.js diff --git a/Rabin_Karp/Rabin_karp.js b/Rabin_Karp/Rabin_karp.js new file mode 100644 index 000000000..68baac2f9 --- /dev/null +++ b/Rabin_Karp/Rabin_karp.js @@ -0,0 +1,43 @@ +const rabinKarp = (pat, str) => { + let p = 31 + let m = 1000000007 + let S = pat.length + let T = str.length + + let p_pow = [] // precomputing powers of p mod m + p_pow.push(1) // p^0 = 1 + for (let i = 1; i < Math.max(S, T); i++) { + p_pow.push((p_pow[i - 1] * p) % m); + } + + let h = [] // length-wise hash i.e h[i] = hash of the prefix with i characters + h.push(0); // h[0] = 0 + for (let i = 0; i < T; i++) { + h.push((h[i] + (str[i].charCodeAt(0) - 97 + 1) * p_pow[i]) % m); + } + + let h_s = 0; // hash value of the pattern + for (let i = 0; i < S; i++) + h_s = (h_s + (pat[i].charCodeAt(0) - 97 + 1) * p_pow[i]) % m; + + let occurs = []; // desired array storing the indices of given string where pattern occurs + for (let i = 0; i + S - 1 < T; i++) { + // slide a window of length S of the pattern + let cur_h = (h[i + S] - h[i] + m) % m; + // if current_hash matches with the hash of out pattern, then a match is found at this index + if (cur_h == h_s * p_pow[i] % m) + occurs.push(i); + } + + return occurs; +} + +// Calling the function +let str = "girlscriptsummerofcodewithgirlsandboys" +let pat = "girl" + +let ids = rabinKarp(pat, str) // desired array storing the indices of given string where pattern occurs +console.log("Pattern found at indexes: ", ids) + +// Output +// Pattern found at indexes: [ 0, 26 ] From c98def031f4d149092dd598107378cd5cfb24edd Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 15:28:30 +0530 Subject: [PATCH 232/265] Rabin Karp implemented in Dart (#3040) --- Rabin_Karp/Rabin_Karp.dart | 74 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 Rabin_Karp/Rabin_Karp.dart diff --git a/Rabin_Karp/Rabin_Karp.dart b/Rabin_Karp/Rabin_Karp.dart new file mode 100644 index 000000000..00a32483d --- /dev/null +++ b/Rabin_Karp/Rabin_Karp.dart @@ -0,0 +1,74 @@ +/** + * Rabin Karp algorithm + * --------------------------------- + * This is a pattern matching algorithm. It has O(n + m) in best + * and average case and O(n * m) in worst case. + * + */ + +// Importing required libraries +import 'dart:io'; + +// Function to search for the pattern in the text +void search(String pattern, String text, int prime){ + // Initializations + const int d = 256; + int m = pattern.length; + int n = text.length; + int p = 0, t = 0, h = 1; + // Hash value calculation for pattern + for(int i = 0; i < m - 1; i ++){ + h = (h * d) % prime; + } + // Hash value calculation for first substring in the text + for(int i = 0; i < m; i ++){ + p = (d * p + pattern.codeUnitAt(i)) % prime; + t = (d * t + text.codeUnitAt(i)) % prime; + } + + int j; + // Checking for matches in the text + for(int i = 0; i <= n - m; i ++){ + if(p == t){ + for(j = 0; j < m; j ++){ + if(text.codeUnitAt(i + j) != pattern.codeUnitAt(j)){ + break; + } + } + // Match found + if(j == m){ + print("The pattern iS found at index ${i}"); + } + } + if(i < n - m){ + t = (d * (t - text.codeUnitAt(i) * h) + text.codeUnitAt(i + m)) % prime; + if(t < 0){ + t = (t + prime); + } + } + } +} +// Driver method of the program +void main(){ + // Input of the pattern + print("Enter pattern:"); + var input = stdin.readLineSync(); + String pattern = input; + // Input of the text + print("Enter text:"); + input = stdin.readLineSync(); + String text = input; + // Chosen prime number + int q = 101; + // Calling search on pattern and text + search(pattern,text,q); +} +/** + * Sample Input and Output + * --------------------------------- + * Enter pattern: + * GIRL + * Enter text: + * GIRLSCRIPT + * The pattern is found at index 0 + */ From 6bb77d869aa133875d00b997b34cb7805121416a Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 15:35:13 +0530 Subject: [PATCH 233/265] Cycle sort implemented in Dart (#3041) --- Cycle_Sort/Cycle_Sort.dart | 72 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 Cycle_Sort/Cycle_Sort.dart diff --git a/Cycle_Sort/Cycle_Sort.dart b/Cycle_Sort/Cycle_Sort.dart new file mode 100644 index 000000000..526ff3d3d --- /dev/null +++ b/Cycle_Sort/Cycle_Sort.dart @@ -0,0 +1,72 @@ +// Importing required libraries +import 'dart:io'; + +// Function to sort the list using cycle sort +void cycle_sort(List array, int n){ + for(int cycle_start = 0; cycle_start <= n - 2; cycle_start ++){ + // Selecting an element + int value = array[cycle_start]; + int position = cycle_start; + // Finding its position where it should be when the list is sorted + for(int i = cycle_start; i < n; i ++){ + if(array[i] < value){ + position ++; + } + } + // If its in the right position already, ignore + if(position == cycle_start){ + continue; + } + // If not, and there are repititive values, insert after them + while(value == array[position]){ + position += 1; + } + if(position != cycle_start){ + int temp = value; + value = array[position]; + array[position] = temp; + } + // Continue the same process till the cycle ends. + while(position != cycle_start){ + position = cycle_start; + for(int i = cycle_start; i < n; i ++){ + if(array[i] < value){ + position += 1; + } + } + while(value == array[position]){ + position += 1; + } + if(value != array[position]){ + int temp = value; + value = array[position]; + array[position] = temp; + } + } + } +} +// Driver method of the program +void main(){ + // Input of size of the array + print("Enter number of elements in the array:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + // Input of the array elements + print("Enter array elements:"); + input = stdin.readLineSync(); + var lis = input.split(" "); + List array = lis.map(int.parse).toList(); + // Cycle sorting + cycle_sort(array, n); + // Printing the output to stdout + print(array.join(" ")); +} +/** + * Sample Input and Output + * ------------------------------- + * Enter number of elements in the array: + * 7 + * Enter array elements: + * 78 7 8 89 8 8 8 + * 7 8 8 8 8 78 89 + */ From 06ebcbe8488e3fa3a1746efd0e0ed1c68286fec2 Mon Sep 17 00:00:00 2001 From: Hardev Khandhar <54733460+HardevKhandhar@users.noreply.github.com> Date: Sun, 31 May 2020 15:37:27 +0530 Subject: [PATCH 234/265] Cocktail Sort In Ruby (#3044) --- Cocktail_Sort/Cocktail_Sort.rb | 70 ++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Cocktail_Sort/Cocktail_Sort.rb diff --git a/Cocktail_Sort/Cocktail_Sort.rb b/Cocktail_Sort/Cocktail_Sort.rb new file mode 100644 index 000000000..8434b6aa3 --- /dev/null +++ b/Cocktail_Sort/Cocktail_Sort.rb @@ -0,0 +1,70 @@ +# Cocktail Sort In Ruby + +class Array + def cocktailSort! + begin + swap = false + 0.upto(length - 2) do |i| + if self[i] > self[i + 1] + self[i], self[i + 1] = self[i + 1], self[i] + swap = true + end + end + break unless swap + + swap = false + (length - 2).downto(0) do |i| + if self[i] > self[i + 1] + self[i], self[i + 1] = self[i + 1], self[i] + swap = true + end + end + end while swap + self + end +end + +# Taking User Input + +puts "Enter the size of array: " +size = gets.to_i +puts +input_array = Array.new(size) + +counter = 0 + +# Input array values using while loop + +while(counter != size) + puts "Enter the value at index #{counter}: " + input_array[counter] = gets.to_i + counter += 1 +end + +puts + +puts "Input Array: #{input_array}" +print "Cocktail Sort: ", input_array.cocktailSort! + +# Sample Input and Output + += begin + +Enter the size of array: 11 + +Enter the value at index 0: 10 +Enter the value at index 1: 8 +Enter the value at index 2: 4 +Enter the value at index 3: 3 +Enter the value at index 4: 1 +Enter the value at index 5: 9 +Enter the value at index 6: 0 +Enter the value at index 7: 2 +Enter the value at index 8: 7 +Enter the value at index 9: 5 +Enter the value at index 10: 6 + +Input Array: [10, 8, 4, 3, 1, 9, 0, 2, 7, 5, 6] +Cocktail Sort: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + += end From 880e8d65175e0c7e37fa3704e902a5a3577c7cf0 Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Sun, 31 May 2020 15:40:05 +0530 Subject: [PATCH 235/265] Sleep Sort in Go (#3045) --- Sleep_Sort/Sleep_Sort.go | 47 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Sleep_Sort/Sleep_Sort.go diff --git a/Sleep_Sort/Sleep_Sort.go b/Sleep_Sort/Sleep_Sort.go new file mode 100644 index 000000000..7d448061e --- /dev/null +++ b/Sleep_Sort/Sleep_Sort.go @@ -0,0 +1,47 @@ +package main + +import "fmt" +import "time" + +func sleepNumber(number int, results chan<- int) { + time.Sleep(time.Duration(number) * time.Second) + results <- number +} + +func sleepSort(data []int) { + results := make(chan int, len(data)) + for _, v := range data { + go sleepNumber(v, results) + } + + for i, _ := range data { + data[i] = <-results + } + close(results) +} + +func main() { + var x int + fmt.Printf("Enter the size of the array : ") + fmt.Scan(&x) + fmt.Printf("Enter the elements of the array : ") + a := make([]int, x) + for i := 0; i < x; i++ { + fmt.Scan(&a[i]) + } + data := a // A copy of the array 'a' is assigned to 'data' + sleepSort(data) + fmt.Println("After sorting", data) +} + +/* + +Sample Input : + Enter the size of the array : 5 + Enter the elements of the array : 34 23 1 78 6 + +Sample Output : + After sorting [1 6 23 34 78] + +*/ + From 07e48a68aceb4b1a2220030fe92e4bc775760248 Mon Sep 17 00:00:00 2001 From: Shriya Bhat <44133832+Shr03mink@users.noreply.github.com> Date: Sun, 31 May 2020 16:00:55 +0530 Subject: [PATCH 236/265] Implementation of preorder traversal in typescript (#3034) Typo fixed --- .../Tree_Preorder_Traversal.ts | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 Tree_Preorder_Traversal/Tree_Preorder_Traversal.ts diff --git a/Tree_Preorder_Traversal/Tree_Preorder_Traversal.ts b/Tree_Preorder_Traversal/Tree_Preorder_Traversal.ts new file mode 100644 index 000000000..809fdf433 --- /dev/null +++ b/Tree_Preorder_Traversal/Tree_Preorder_Traversal.ts @@ -0,0 +1,53 @@ +/* Implementation of the preorder traversal of a binary tree in TypeScript language */ + +// Declaring the node class +class node { + right: any; + value: any; + left: any; + constructor(value) { + this.value = value; + this.left = null; + this.right = null; + } +} + +// Recursive Function for Preorder Tree Transversal. +function PreOrder(root) +{ + if (root) { + console.log(root.value); + PreOrder(root.left); + PreOrder(root.right); + } +} + +// Sample Input +var root = new node(1); +root.left = new node(2); +root.right = new node(3); +root.left.right = new node(4); +root.right.left = new node(8); +root.right.right = new node(7); +root.left.right.left = new node(5); +root.left.right.left.right = new node(6); + +// Sample Output +console.log("Preorder traversal of tree formed is:-"); +PreOrder(root); + + +/* OUTPUT: + +Preorder traversal of tree formed is:- +1 +2 +4 +5 +6 +3 +8 +7 + +*/ + From 5a4992202f0a616f0e88cac4654a14fac5b723d2 Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Sun, 31 May 2020 16:03:43 +0530 Subject: [PATCH 237/265] Counting Sort in Go (#3046) --- Counting_Sort/Counting_Sort.go | 65 ++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Counting_Sort/Counting_Sort.go diff --git a/Counting_Sort/Counting_Sort.go b/Counting_Sort/Counting_Sort.go new file mode 100644 index 000000000..4db7949a4 --- /dev/null +++ b/Counting_Sort/Counting_Sort.go @@ -0,0 +1,65 @@ +/* + Counting Sort + ------------------------------------ + Counting sort is a sorting technique based on keys between a specific range. + It works by counting the number of objects having distinct key values (kind of hashing). + Then doing some arithmetic to calculate the position of each object in the output sequence. +*/ + +package main +import "fmt" + +const MaxUint = ^uint(0) +const MaxInt = int(MaxUint >> 1) +const MinInt = - MaxInt - 1 + +func countingSort(list []int) { + maxNumber := MinInt + minNumber := MaxInt + for _, v := range list { + if v > maxNumber { + maxNumber = v + } + if v < minNumber { + minNumber = v + } + } + + count := make([]int, maxNumber - minNumber + 1) + + for _, x := range list { + count[x - minNumber]++ + } + index := 0 + for i, c := range count { + for ; c > 0; c-- { + list[index] = i + minNumber + index++ + } + } +} + +func main() { + var x int + fmt.Printf("Enter the size of the array : ") + fmt.Scan(&x) + fmt.Printf("Enter the elements of the array : ") + a := make([]int, x) + for i := 0; i < x; i++ { + fmt.Scan(&a[i]) + } + list := a // A copy of the array 'a' is assigned to 'list' + fmt.Println("before sorting", list) + countingSort(list) + fmt.Println("after sorting", list) +} + +/* +Sample Input : + Enter the size of the array : 4 + Enter the elements of the array : 12 29 10 78 + +Sample Output : + After sorting [10 12 29 78] +*/ + From 622a2d60c779c37c14ff76421aa759e5715f7bbe Mon Sep 17 00:00:00 2001 From: Pooja Date: Sun, 31 May 2020 16:28:12 +0530 Subject: [PATCH 238/265] selection sort (#3048) --- Selection_Sort/Selection_Sort.dart | 63 ++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Selection_Sort/Selection_Sort.dart diff --git a/Selection_Sort/Selection_Sort.dart b/Selection_Sort/Selection_Sort.dart new file mode 100644 index 000000000..6dfa8e256 --- /dev/null +++ b/Selection_Sort/Selection_Sort.dart @@ -0,0 +1,63 @@ +//selection sort + +import 'dart:io'; + +void selection_sort (List arr, int n) +{ + int temp, min_index; + + for (int i = 0; i < n - 1; i++) + { + min_index = i; + + for (int j = i + 1; j < n; j++) + if ( arr[j] < arr[min_index] ) + min_index = j; + + if (i != min_index) + { + temp = arr[i]; + arr[i] = arr[min_index]; + arr[min_index] = temp; + } + } +} + +main() +{ + print ("Enter the size of array "); + int size = int.parse (stdin.readLineSync()); + + List array = List(); + + for (int i = 0; i < size; i++) + { + print ("Enter $i element "); + var ele = int.parse (stdin.readLineSync()); + array.add (ele); + } + + selection_sort (array, size); + + print (array); + +} + +/* +Enter the size of array +5 +Enter 0 element +50 +Enter 1 element +40 +Enter 2 element +30 +Enter 3 element +20 +Enter 4 element +10 +Sorted array is +[10, 20, 30, 40, 50] +*/ + + From 9f500f99d1043e159f085162d5574b69b007e25b Mon Sep 17 00:00:00 2001 From: SHIVAM GUPTA <31137037+shivamgupta57121@users.noreply.github.com> Date: Sun, 31 May 2020 17:17:16 +0530 Subject: [PATCH 239/265] Add Sieve Of Eratosthenes in TypeScript (#3010) --- .../Sieve_Of_Eratosthenes.ts | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.ts diff --git a/Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.ts b/Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.ts new file mode 100644 index 000000000..49fe44805 --- /dev/null +++ b/Sieve_Of_Eratosthenes/Sieve_Of_Eratosthenes.ts @@ -0,0 +1,51 @@ +export {} + +function SieveOfEratosthenes (n : number){ + + // Create a boolean array "prime[0..n]" and initialize + // all entries of it as true. A value in prime[i] will + // finally be false if i is Not a prime, else true. + + let prime : boolean[] = [true]; + let p : number; + let i : number; + + for(p = 0; p <= n; p++) + prime.push(true); + + for(p = 2; p * p <= n; p++){ + // If prime[p] is true, then it is a prime + if(prime[p]){ + // Update all multiples of p + for(i = p * p; i <= n; i += p) + prime[i] = false; + } + } + + // Print all prime numbers + for(p = 2; p <= n; p++) + if(prime[p]) + console.log(p); +} + +let n : number = 30; +console.log("The prime numbers upto " + n); +SieveOfEratosthenes(n); + +/* +INPUT +n = 30 + +OUTPUT +The prime numbers upto 30 +2 +3 +5 +7 +11 +13 +17 +19 +23 +29 +*/ From 5de74e2f4aa5c5ea6b3157fc75cdaa81face7e31 Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Sun, 31 May 2020 18:35:58 +0530 Subject: [PATCH 240/265] Add Longest_Increasing_Subsequence in Kotlin (#2935) Updated LIS --- .../Longest_Increasing_Subsequence.kt | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 Longest_Increasing_Subsequence/Longest_Increasing_Subsequence.kt diff --git a/Longest_Increasing_Subsequence/Longest_Increasing_Subsequence.kt b/Longest_Increasing_Subsequence/Longest_Increasing_Subsequence.kt new file mode 100644 index 000000000..c10c8c24f --- /dev/null +++ b/Longest_Increasing_Subsequence/Longest_Increasing_Subsequence.kt @@ -0,0 +1,52 @@ +//Kotlin code for Longest increasing subsequence + +class LIS +{ + fun lis(int:arr[], int:n):int + { + int lis[] = new int[n]; + int result = Integer.MIN_VALUE; + + for (i in 0 until n) + { + lis[i] = 1; + } + + for (i in 1 until n) + { + for (j in 0 until i) + { + if (arr[i] > arr[j] && lis[i] < lis[j] + 1) + { + lis[i] = lis[j] + 1; + } + } + result = Math.max(result, lis[i]); + } + return result; + } + + fun main() + { + var read = Scanner(System.`in`) + println("Enter the size of the Array:") + val arrSize = read.nextLine().toInt() + var arr = IntArray(arrSize) + println("Enter elements") + + for(i in 0 until arrSize) + { + arr[i] = read.nextLine().toInt() + } + + int n = arrSize; + println("\nLength of the Longest Increasing Subsequence:" + lis(arr, n)) + } +} + +/* +Enter the size of the array : 8 +Enter elements : 15 26 13 38 26 52 43 62 +Length of the Longest Increasing Subsequence : 5 +*/ + From b2a5aa44b0b5a3149eb77398b2e7dd3fd5d25488 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 18:37:49 +0530 Subject: [PATCH 241/265] Radix sort implemented in Dart (#3050) --- Radix_Sort/Radix_Sort.dart | 65 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Radix_Sort/Radix_Sort.dart diff --git a/Radix_Sort/Radix_Sort.dart b/Radix_Sort/Radix_Sort.dart new file mode 100644 index 000000000..48b798f55 --- /dev/null +++ b/Radix_Sort/Radix_Sort.dart @@ -0,0 +1,65 @@ +// Importing required libraries +import 'dart:io'; + +// Function to sort based on bits of integers using count sort +void countSort(List array, int n, int exp){ + List output = List(n); + List count = List(10); + for(int i = 0; i < 10; i ++){ + count[i] = 0; + } + for(int i = 0; i < n; i ++){ + count[((array[i] / exp).floor()) % 10] ++; + } + for(int i = 1; i < 10; i ++){ + count[i] += count[i - 1]; + } + for(int i = n - 1; i >= 0; i --){ + output[count[((array[i] / exp).floor()) % 10] - 1] = array[i]; + count[((array[i] / exp).floor()) % 10] --; + } + for(int i = 0; i < n; i ++){ + array[i] = output[i]; + } +} +// Function to find max of the array +int getMax(List array, int n){ + int max_value = array[0]; + for(int i = 0; i < n; i ++){ + if(max_value < array[i]){ + max_value = array[i]; + } + } + return max_value; +} +// Function to sort an array using radix sort +void radix_sort(List array, int n){ + int max_value = getMax(array, n); + for(int exp = 1; max_value / exp > 0; exp *= 10){ + countSort(array, n, exp); + } +} +// Driver method of the program. +void main(){ + print("Enter number of elements in the array:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + + print("Enter array elements:"); + input = stdin.readLineSync(); + var lis = input.split(" "); + List array = lis.map(int.parse).toList(); + + radix_sort(array, n); + + print(array.join(" ")); +} +/** + * Sample Input and Output + * --------------------------------- + * Enter number of elements in the array: + * 10 + * Enter array elements: + * 10 9 8 7 6 5 4 3 2 1 + * 1 2 3 4 5 6 7 8 9 10 + */ From 6d986d5f6dabc1316dd0ec55a08085e3c2f71bae Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 21:17:09 +0530 Subject: [PATCH 242/265] Bellman Ford algorithm implemented in Dart (#2999) --- Bellmanford_Algorithm/Bellmanford.dart | 248 +++++++++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 Bellmanford_Algorithm/Bellmanford.dart diff --git a/Bellmanford_Algorithm/Bellmanford.dart b/Bellmanford_Algorithm/Bellmanford.dart new file mode 100644 index 000000000..1c44295ee --- /dev/null +++ b/Bellmanford_Algorithm/Bellmanford.dart @@ -0,0 +1,248 @@ +/** + * Bellman Ford Algorithm + * ---------------------------------------------- + * This algorithm is used to find shortest distances of all vertices from + * a source vertex in a graph. It is a DP algorithm unlike Dijkstra which is a greedy one. + * This algorithm has O(m*n) time complexity where Dijkstra has O(n*log(n)). + * Bellman ford is suitable for distributed systems and works well on negative edges unline + * Dijkstra. + * + */ + +// Importing required libraries +import 'dart:io'; + +// Class to define an edge +class Edge{ + int source; + int destination; + int weight; + // Constructor + Edge(int source, int destination, int weight){ + this.source = source; + this.destination = destination; + this.weight = weight; + } +} + +// Class to define a graph +class Graph{ + int numVertices; + int numEdges; + var edges; + + // Constructor + Graph(int n, int m){ + this.numVertices = n; + this.numEdges = m; + edges = List(); + } + + // Method to add an edge to the graph + void add_edge(int src, int dest, int wt){ + Edge edge = Edge(src, dest, wt); + this.edges.add(edge); + } + + /* Method to find shortest distances of all vertices from a source vertex + using Bellman Ford algorithm */ + void bellmanFordShortestDistances(int src){ + // Using maximum int value as infinity + const int int64MaxValue = 9223372036854775807; + var distances = List(this.numVertices); + + // Initializing the distances array + for(int i = 0; i < this.numVertices; i ++){ + distances[i] = int64MaxValue; + } + distances[src] = 0; + + // Finding shortest distances + for(int i = 0; i < this.numVertices - 1; i ++){ + for(int j = 0; j < this.numEdges; j ++){ + int srce = this.edges[j].source; + int desti = this.edges[j].destination; + int wt = this.edges[j].weight; + if(distances[srce] != int64MaxValue && distances[desti] > distances[srce] + wt){ + distances[desti] = distances[srce] + wt; + } + } + } + + // Checking for a negative cycle. + int flag = 0; + for(int j = 0; j < this.numEdges; j ++){ + int srce = this.edges[j].source; + int desti = this.edges[j].destination; + int wt = this.edges[j].weight; + if(distances[srce] != int64MaxValue && distances[desti] > distances[srce] + wt){ + print("Negative cycle found!!"); + flag = 1; + break; + } + } + + // Printing shortest distances if negative cycle is not found + if(flag == 0){ + print("The shortest distances of all vertices from src vertex are in the following order:"); + print(distances.join(" ")); + } + } +} + +// Driver method of the program +void main(){ + + // Input of number of vertices + print("Enter number of vertices:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + + // Input of number of edges + print("Enter number of edges:"); + input = stdin.readLineSync(); + int m = int.parse(input); + + // Creating the graph + Graph g = Graph(n, m); + + // Input of edges + print("Enter edges:"); + for(int i = 0; i < m; i ++){ + print("Enter edge ${i + 1}"); + print("Enter source vertex:"); + int src = int.parse(stdin.readLineSync()); + print("Enter destination vertex:"); + int dest = int.parse(stdin.readLineSync()); + print("Enter weight of the edge:"); + int wt = int.parse(stdin.readLineSync()); + g.add_edge(src, dest, wt); + } + + // Input of source vertex for Bellman Ford + print("Enter the source vertex to find shortest distances:"); + int src = int.parse(stdin.readLineSync()); + + // Printing output of Bellman Ford + g.bellmanFordShortestDistances(src); + +} + +/** + * Sample Input and Output + * ----------------------------- + * Sample 1 + * ----------------------------- + * Enter number of vertices: + * 5 + * Enter number of edges: + * 8 + * Enter edges: + * Enter edge 1 + * Enter source vertex: + * 0 + * Enter destination vertex: + * 1 + * Enter weight of the edge: + * -1 + * Enter edge 2 + * Enter source vertex: + * 0 + * Enter destination vertex: + * 2 + * Enter weight of the edge: + * 4 + * Enter edge 3 + * Enter source vertex: + * 1 + * Enter destination vertex: + * 2 + * Enter weight of the edge: + * 3 + * Enter edge 4 + * Enter source vertex: + * 3 + * Enter destination vertex: + * 1 + * Enter weight of the edge: + * 1 + * Enter edge 5 + * Enter source vertex: + * 1 + * Enter destination vertex: + * 3 + * Enter weight of the edge: + * 2 + * Enter edge 6 + * Enter source vertex: + * 3 + * Enter destination vertex: + * 2 + * Enter weight of the edge: + * 5 + * Enter edge 7 + * Enter source vertex: + * 1 + * Enter destination vertex: + * 4 + * Enter weight of the edge: + * 2 + * Enter edge 8 + * Enter source vertex: + * 4 + * Enter destination vertex: + * 3 + * Enter weight of the edge: + * -3 + * Enter the source vertex to find shortest distances: + * 0 + * The shortest distances of all vertices from src vertex are in the following order: + * 0 -1 2 -2 1 + * ------------------------ + * Sample 2 + * ------------------------ + * Enter number of vertices: + * 4 + * Enter number of edges: + * 5 + * Enter edges: + * Enter edge 1 + * Enter source vertex: + * 0 + * Enter destination vertex: + * 1 + * Enter weight of the edge: + * 5 + * Enter edge 2 + * Enter source vertex: + * 0 + * Enter destination vertex: + * 2 + * Enter weight of the edge: + * 4 + * Enter edge 3 + * Enter source vertex: + * 2 + * Enter destination vertex: + * 1 + * Enter weight of the edge: + * -6 + * Enter edge 4 + * Enter source vertex: + * 1 + * Enter destination vertex: + * 3 + * Enter weight of the edge: + * 3 + * Enter edge 5 + * Enter source vertex: + * 3 + * Enter destination vertex: + * 2 + * Enter weight of the edge: + * 2 + * Enter the source vertex to find shortest distances: + * 0 + * Negative cycle found!! + * + */ From 36eba55b7e0b9c13fe8d9175f087a36dd91e1775 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 21:35:40 +0530 Subject: [PATCH 243/265] Kosaraju Algorithm implemented in Dart (#2991) --- Kosaraju_Algorithm/Kosaraju_algorithm.dart | 211 +++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 Kosaraju_Algorithm/Kosaraju_algorithm.dart diff --git a/Kosaraju_Algorithm/Kosaraju_algorithm.dart b/Kosaraju_Algorithm/Kosaraju_algorithm.dart new file mode 100644 index 000000000..f1c4d73d2 --- /dev/null +++ b/Kosaraju_Algorithm/Kosaraju_algorithm.dart @@ -0,0 +1,211 @@ +/** + * Kosaraju's Algorithm + * ---------------------------------------- + * + * This algorithm is used to find the number of strongly connected components + * in a directed graph. It uses DFS. It performs DFS twice to achieve the goal based on the fact that + * finishing time of starting vertex will be greater than the finishing times of vertices in other SCCs. + * + */ +// Importing required libraries +import 'dart:io'; +import 'dart:collection'; + +// Class definition for a graph +class Graph{ + + // Total number of vertices in a graph + int numVertices; + // Adjacency list of the graph + var adj; + + // Constructor + Graph(int v){ + this.numVertices = v; + this.adj = List(this.numVertices); + for(int i = 0; i < this.numVertices; i ++){ + adj[i] = List(); + } + } + + // Method to add an edge to a graph + void add_edge(int source, int destination){ + adj[source].add(destination); + } + + // Utility method to fill the stack through DFS. + void fillOrder(int v, List visited, Queue stack){ + visited[v] = true; + var temp = this.adj[v]; + int m = temp.length; + int i = 0; + while(i < m){ + if(!visited[this.adj[v][i]]){ + fillOrder(this.adj[v][i], visited, stack); + } + i ++; + } + stack.add(v); + } + + // Utility method to find the transpose of the graph + Graph getTranspose(){ + + Graph transpose = Graph(this.numVertices); + + for(int i = 0; i < transpose.numVertices; i ++){ + int destination = i; + for(int j = 0; j < this.adj[i].length; j ++){ + transpose.adj[this.adj[i][j]].add(destination); + } + } + + return transpose; + } + + // Utility method that performs DFS. + void DFSUtil(int v, List visited, List result){ + visited[v] = true; + result.add(v); + int m = this.adj[v].length; + + for(int i = 0; i < m; i ++){ + if(!visited[this.adj[v][i]]){ + DFSUtil(this.adj[v][i], visited, result); + } + } + } + + // Utility method to print strongly connected components. + void printStronglyConnectedComponents(){ + // Using a LIFO queue as stack + Queue stack = Queue(); + var visited = List(this.numVertices); + + // Initializing the visited list. + for(int i = 0; i < this.numVertices; i ++){ + visited[i] = false; + } + + // Filling the stack through DFS + for(int i = 0; i < this.numVertices; i ++){ + if(visited[i] == false){ + fillOrder(i, visited, stack); + } + } + + // Finding transpose of the graph + Graph g = getTranspose(); + for(int i = 0; i < this.numVertices; i ++){ + visited[i] = false; + } + + + int count = 0; + + // Finding strongly connected components using DFS on all vertices in stack. + while(!stack.isEmpty){ + int v = stack.removeLast(); + + if(visited[v] == false){ + var result = List(); + g.DFSUtil(v, visited, result); + print("Strongly Connected Component ${count+1}:"); + print(result.join(" ")); + count += 1; + } + } + } +} + +// Driver method of the program +void main(){ + + // Input of number of vertices + print("Enter number of vertices in the graph:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + Graph g = Graph(n); + + // Input of number of edges + print("Enter number of edges:"); + input = stdin.readLineSync(); + int m = int.parse(input); + + // Input of edges + for(int i = 0; i < m; i ++){ + print("Edge ${i+1}:"); + print("Enter source vertex:"); + input = stdin.readLineSync(); + int source = int.parse(input); + print("Enter destination vertex:"); + input = stdin.readLineSync(); + int destination = int.parse(input); + g.add_edge(source, destination); + } + + // Output of Strongly Connected Components. + g.printStronglyConnectedComponents(); + +} + +/* + * Sample Input and Output + * ----------------------------- + * Enter number of vertices in the graph: + * 8 + * Enter number of edges: + * 9 + * Edge 1: + * Enter source vertex: + * 0 + * Enter destination vertex: + * 1 + * Edge 2: + * Enter source vertex: + * 3 + * Enter destination vertex: + * 0 + * Edge 3: + * Enter source vertex: + * 1 + * Enter destination vertex: + * 2 + * Edge 4: + * Enter source vertex: + * 2 + * Enter destination vertex: + * 3 + * Edge 5: + * Enter source vertex: + * 2 + * Enter destination vertex: + * 4 + * Edge 6: + * Enter source vertex: + * 4 + * Enter destination vertex: + * 5 + * Edge 7: + * Enter source vertex: + * 5 + * Enter destination vertex: + * 6 + * Edge 8: + * Enter source vertex: + * 6 + * Enter destination vertex: + * 7 + * Edge 9: + * Enter source vertex: + * 6 + * Enter destination vertex: + * 4 + * Strongly Connected Component 1: + * 0 3 2 1 + * Strongly Connected Component 1: + * 4 6 5 + * Strongly Connected Component 1: + * 7 + * + */ From b0db7224e392d540c64ac664d7697401c2ff72a2 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sun, 31 May 2020 22:06:59 +0530 Subject: [PATCH 244/265] Knuth-Morris algo readme (#2948) changes done changes changes --- .../Knuth-Morris_Pratt_Algorithm_README.md | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 Knuth_Morris_Pratt_Algorithm/Knuth-Morris_Pratt_Algorithm_README.md diff --git a/Knuth_Morris_Pratt_Algorithm/Knuth-Morris_Pratt_Algorithm_README.md b/Knuth_Morris_Pratt_Algorithm/Knuth-Morris_Pratt_Algorithm_README.md new file mode 100644 index 000000000..985a7fe74 --- /dev/null +++ b/Knuth_Morris_Pratt_Algorithm/Knuth-Morris_Pratt_Algorithm_README.md @@ -0,0 +1,134 @@ +# Knuth-Morris Pratt Algorithm + +1. It was invented by Donald Knuth and Vaughan Pratt. +2. It was the first linear time complexity algorithm for string matching which is used to find a pattern in a text. +3. This algorithm compares character by character from left to right. + +## Components of Knuth-Morris Pratt algorithm + +Prefix Table : In this algorithm whenever a mismatch occurs,it uses a preprocessed table known as Prefix Table to skip characters comparison while matching. + +LPS Table : It stands for Longest proper Prefix which is also suffix. Sometimes prefix table is also known as LPS Table. + +## Steps for Creating LPS Table + +1. Define a one dimensional array with the size equal to the length of the Pattern. (LPS[size]) +2. Define variables i & j. Set i = 0, j = 1 and LPS[0] = 0. +3. Compare the characters at Pattern[i] and Pattern[j]. +4. If both are matched then set LPS[j] = i + 1 and increment both i & j values by one. Go to Step 3. +5. If both are not matched then check the value of variable 'i'. If it is '0' then set LPS[j] = 0 and increment 'j' value by one, if it is not '0' then set i = LPS[i - 1]. Step 3. +6. Repeat above steps until all the values of LPS[] are filled. + +## ALGORITHM + +**Input** the main text, and the pattern, which will be searched. + +``` +Begin + n := size of text + m := size of pattern + + call findPrefix(pattern, m, prefArray) + while i < n, do + if text[i] = pattern[j], then + increase i and j by 1 + + if j = m, then + print the location (i-j) as there is the pattern + j := prefArray[j-1] + else if i < n AND pattern[j] ≠ text[i] then + if j ≠ 0 then + j := prefArray[j - 1] + else + increase i by 1 + done + End +``` + +**Output**: The location where patterns are found. + +## How The Knuth-Morris Pratt Algorithm Work? + +Let us see an example + +Consider the following Text and Pattern + +Text : ABC ABCDAB ABCDABCDABDE + +Pattern : ABCDABD + +LPS[] table for the above pattern is as follows + +LPS[] is {0,1,2,3,4,5,6} + +**Step 1:** Start comparing first character of pattern with first character of Text from left to right + +Text: ABC ABCDAB ABCDABCDABDE + +Pattern: ABCDABD + +0123456 + +Here mismatch occurred at Pattern[3],so we need to consider LPS[2] value. Since LPS[2] value is '0' we must compare first character in pattern with next character in Text. + +**Step 2:** Start comparing first character of pattern with next character of Text. + +Text : ABC ABCDAB ABCDABCDABDE + +Pattern : ABCDABD + +0123456 + +Here mismatch occurred at Pattern[6], so we need to consider LPS[5] value. Since LPS[5] value is '2' we compare Pattern[2] character with mismatched character in Text. + +**Step 3:** Since LPS value is '2' no need to compare the Pattern[0] and Pattern[1] values + +Text : ABC ABCDAB ABCDABCDABDE + +Pattern : ABCDABD + +0123456 + +Here mismatch occurred at pattern[2],so we need to consider LPS[1] value. Since LPS[1] value is '0' we must compare first character in Pattern with next character in Text. + +**Step 4** Compare Pattern[0] with next character in Text + +Text : ABC ABCDAB ABCDABCDABDE + +Pattern : ABCDABD + +0123456 + +Here mismatch occurred at Pattern[6], so we need to consider LPS[5] value. Since LPS[5] value is '2' we compare Pattern[2] character with mismatched character in Text. + +**Step 5:** Compare Pattern[2] with mismatched character in Text. + +Text : ABC ABCDAB ABCDABCDABDE + +Pattern : ABCDABD + +0123456 + +Here all the characters of Patterns matched with a substring in Text which is starting from index value 15. + +So, we conclude that given Pattern found at index 15 in Text. + +**TIME COMPLEXITY** + +The time complexity of Knuth-Morris Pratt Algorithm is O(n). + +**SPACE COMPLEXITY** + +It also has a space complexity of O (m) because there’s some pre-processing involved. + +**SEE ALSO** + +1. https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Knuth_Morris_Pratt_Algorithm/KMP.cpp +2. https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Knuth_Morris_Pratt_Algorithm/KMP.java +3. https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Knuth_Morris_Pratt_Algorithm/KMP.py +4. https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Knuth_Morris_Pratt_Algorithm/KMP.cs + +**REFERENCES** + +1. https://www.geeksforgeeks.org/kmp-algorithm-for-pattern-searching/ +2. [https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm](https://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm) \ No newline at end of file From 9e6cbdc7929754dc293b88dd7f40383f49908a55 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sun, 31 May 2020 22:12:38 +0530 Subject: [PATCH 245/265] Readme for introsort (#3012) * Readme for introsort changes changes * Update README.md --- Intro_Sort/README.md | 111 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 Intro_Sort/README.md diff --git a/Intro_Sort/README.md b/Intro_Sort/README.md new file mode 100644 index 000000000..b01e32410 --- /dev/null +++ b/Intro_Sort/README.md @@ -0,0 +1,111 @@ +# Introsort + +1. It was invented by David Musser in 1997. +2. It is also known as introspective sort. +3. It is a hybrid sorting algorithm(combines two or more other algorithms that solve the same problem,either choosing one depending upon the data or switching between them over the course of algorithm). +4. It provides both fast average performance and optimal worst performance,thus allowing the performance requirement to become more strict and effective. +5. It combines the good part of three algorithm i.e quick sort, heap sort,insertion sort. + +## ALGORITHM + +``` +procedure sort(A : array): + let maxdepth = ⌊log(length(A))⌋ × 2 + introsort(A, maxdepth) + +procedure introsort(A, maxdepth): + n ← length(A) + // base case + if n ≤ 1: + return + else if maxdepth = 0: + heapsort(A) + // assume this function does pivot selection, p is the final position of the pivot + else: + p ← partition(A) + introsort(A[0:p-1], maxdepth- 1) + introsort(A[p+1:n], maxdepth - 1) + +The factor 2 in the maximum depth is arbitrary; it can be tuned for practical performance. A[i:j] denotes the array slice of items i to j. +``` + +## Example + +![Introsort](https://media.geeksforgeeks.org/wp-content/uploads/20190322164239/page-11.png) + +**Input:** 2, 10, 24, 2, 10, 11, 27, 4, 2, 4, 28, 16, 9, 8, 28, 10, 13, 24, 22, 28, 0, 13, 27, 13, 3, 23, 18, 22, 8, 8 + +**Step 1:** + +begin = 0, end = 29 depthLimit = 8, a[pivot] = 8. + +As the number of elements > 16,the pivot element is calculated based on the quicksort algorithm. Using the median-of-3 concept,the pivot element is calculated and the a[pivot]=8. The method partition() finds the correct position of the a[pivot] and helps in array split-up for further recursion. Here,the element 8 (in comment) lies in the correct position and in the further steps recursion will be carried over for the sub array before and after + + 8. 2, 2, 4, 2, 4, 8, 0, 3, 8, /8/, 28, 16, 9, 11, 28, 10, 13, 24, 22, 28, 27, 13, 27, 13, 24, 23, 18, 22, 10, 10 + + +**Step 2:** From the previous step, + +begin = 0, end = 29, a[pivot] = 8 + +The recursion starts for the sub-array a[begin, pivot - 1] and a[pivot + 1, end] + +2, 2, 4, 2, 4, 8, 0, 3, 8, 8, 28, 16, 9, 11, 28, 10, 13, 24, 22, 28, 27, 13, 27, 13, 27, 13, 24, 23, 18, 22, 10, 10 + +depthLimit = 7, depthLimit = 7, begin = 0, end = 8 begin = 10, end = 29 + +Number of element <= 16 Number of element > 16, + +Hence sortDataUtil(10,29) that calculates the pivot and a[partition] = 27. + +Hence insertionSort (0,8) + +0, 2, 2, 2, 3, 4, 4, 8, 8, 8, 16, 9, 11, 10, 13, 24, 22, 10, 13, 27, 13, 24, 23, 18, 22, 10, 27, 28, 28, 28 + + +**Step 3:** From the previous step, + +depthLimit = 6, begin = 10, end = 29 + +The recursion starts for the sub-array a[begin, partition - 1] and a[partition + 1, end] + +` 0, 2, 2, 2, 3, 4, 4, 8, 8, 8, 16, 9, 11, 10, 13, 24, 22, 10, 13, 27, 13, 24, 23, 18, 22, 10, 27, 28, 28, 28 ` + + `sorted! depthLimit=6 depthLimit=6 ` + +Hence,no further recursion. + + begin = 10, end = 25 begin = 10, end = 25 + +As the number of elements < 16, insertionSort (10,25) + +As the number of element < 16, insertionSort(27,29) + +` 0, 2, 2, 2, 3, 4, 4, 8, 8, 8, 9, 10, 10, 10, 11, 13, 13, 13, 16, 18, 22, 22, 23, 24, 27, 27, 28, 28, 28 ` + +​ `Sorted! Sorted! Sorted! ` + +Hence, no further recursion hence no further recursion hence no further recursion. + + +**Step 4:** + +Output: 0, 2, 2, 2, 3, 4, 4, 8, 8, 8, 9, 10, 10, 11, 13, 13, 13, 16, 18, 22, 22, 23, 24, 24, 27, 27, 28, 28, 28 + +In the above example, the depthLimit came until 6, and for bigger datasets the depthLimit might reach 0 for certain sub-array. The heapSort is carried out only for those sub-array for sorting them. + +Output: 0, 2, 2, 2, 3, 4, 4, 8, 8, 8, 9, 10, 10, 10, 11, 13, 13, 13, 16, 18, 22, 22, 23, 24, 24, 27, 27, 28, 28, 28 + + +## Time Complexity + +Average performance O(n log n) Optimal worst performance O(n log n) where, n = number of elements to be sorted. + +## SEE ALSO : + +https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Intro_Sort/introsort.py + +## REFERENCES : + +1. https://en.wikipedia.org/wiki/Introsort +2. https://www.geeksforgeeks.org/introsort-or-introspective-sort/ From 67ca1a1beb9121c90106fedea7a31cfd09e60b86 Mon Sep 17 00:00:00 2001 From: Raksha <57195964+raksha009@users.noreply.github.com> Date: Sun, 31 May 2020 22:19:48 +0530 Subject: [PATCH 246/265] Binary Insertion sort in dart (#3013) changes --- .../Binary_Insertion_Sort.dart.txt | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 Binary_Insertion_Sort/Binary_Insertion_Sort.dart.txt diff --git a/Binary_Insertion_Sort/Binary_Insertion_Sort.dart.txt b/Binary_Insertion_Sort/Binary_Insertion_Sort.dart.txt new file mode 100644 index 000000000..221d06d98 --- /dev/null +++ b/Binary_Insertion_Sort/Binary_Insertion_Sort.dart.txt @@ -0,0 +1,58 @@ +/* Binary Insertion sort is a special type up of Insertion sort which uses binary search algorithm to find out the correct position of the inserted element in the array. */ + + +void insertionSort(List ar){ + if (ar == null || ar.length == 0){ + return; + } + int n = ar.length; + int temp, i, j; + for (i = 1; i < n; i++){ + temp = ar[i]; + j = i - 1; + while (j >= 0 && temp < ar[j]){ + ar[j+1] = ar[j]; + --j; + } + ar[j+1] = temp; + } +} + +// Binary Search Performed +int binarySearch(List ar, int key, int start, int end){ + if (end-start <= 1){ + if (key < ar[start]){ + return start - 1; + } + else{ + return start; + } + } + int mid = (start + end) ~/ 2; + if (ar[mid] < key){ + return binarySearch(ar, key, mid, end); + } + else if (ar[mid] > key){ + return binarySearch(ar, key, start, mid); + } + else{ + return mid; + } +} + +main(){ + List ar = [1, 5, 3, 4, 8, 6]; + int n = ar.length; + insertionSort(ar); + print("Sorted Array: "); + for (int i = 0;i < n; i++){ + print(ar[i]); + } +} + +/* +OUTPUT: +Sorted Array is: [1, 3, 4, 5, 6, 8] +*/ + + From 44f5e38c4e4a7d52d28434689c58e71b2bbad193 Mon Sep 17 00:00:00 2001 From: sandhyabhan <52604131+sandhyabhan@users.noreply.github.com> Date: Sun, 31 May 2020 22:31:27 +0530 Subject: [PATCH 247/265] Add Pancake Sort in Kotlin (#2889) * Add Pancake Sort in Kotlin * Updated Pancake Sort * Updated Pancake sort * Updated Pancake_Sort.kt * Updated Pancake_Sort.kt * Updated Pancake_Sort.kt * Updated Pancake_Sort.kt * Updated Pancake_Sort.kt --- Pancake_Sort/Pancake_Sort.kt | 71 ++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 Pancake_Sort/Pancake_Sort.kt diff --git a/Pancake_Sort/Pancake_Sort.kt b/Pancake_Sort/Pancake_Sort.kt new file mode 100644 index 000000000..d24e22b8a --- /dev/null +++ b/Pancake_Sort/Pancake_Sort.kt @@ -0,0 +1,71 @@ +// Kotlin Code for Pancake Sort + +class PancakeSorting +{ + // This functions reverses the array upto index n + fun reverseArray (int:a[], int:n):void + { + int temp[] = new int [n+1]; + for (i in 0 until n) + { + temp[i] = a[n-i]; + } + for (i in 0 until n) + { + a[i] = temp[i]; + } + } + + // Function to find index of max element upto index n + fun findMax (int:a[], int:n ):int + { + int max = a[0]; int j = 0; + for (i in 1 until n) + { + if (a[i] > max) + { + max = a[i]; + j = i; + } + } + return j; + } + + fun pancakeSort (int:a [], int:n):void + { + int currentLength; + for (currentLength in n until 0) + { + int j = findmax (a,currentLength-1); + if (j != currentLength) + { + reverseArray (a,j); + reverseArray (a,currentLength-1); + } + } + } + + fun main () + { + var read = Scanner(System.`in`) + int i , j , k , l , m , n; + val n = read.nextLine().toInt() + int array [] = new int [n]; + for(i in 0 until n) + { + array[i] = read.nextLine().toInt() + } + pancakesort (array, n); + for (i in 0 until n) + { + println(array[i] + " "); + } + } +} + +/* +Input +5 4 3 2 1 +Output +1 2 3 4 5 +*/ From 225cf5453b3b5d0ab2e45fd34bcba2602b01412d Mon Sep 17 00:00:00 2001 From: Pratiksha Aggarwal <43148806+pratu098@users.noreply.github.com> Date: Sun, 31 May 2020 22:36:28 +0530 Subject: [PATCH 248/265] Preemptive priority in C++ (#3043) * Create Preemptive.cpp * Update Preemptive.cpp * Update Preemptive.cpp --- Preemptive.cpp | 231 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 Preemptive.cpp diff --git a/Preemptive.cpp b/Preemptive.cpp new file mode 100644 index 000000000..4f02f38ed --- /dev/null +++ b/Preemptive.cpp @@ -0,0 +1,231 @@ +About:In priority scheduling, a number is assigned to each process that indicates its priority level. +Lower the number, higher is the priority. In this type of scheduling algorithm, if a newer process arrives, that is having a higher +priority than the currently running process, then the currently running process is preempted. + +Program for preemptive priority +#include +using namespace std; + +struct Process { + int processID; + int burstTime; + int tempburstTime; + int responsetime; + int arrivalTime; + int priority; + int outtime; + int intime; +}; + +// It is used to include all the valid and eligible +// processes in the heap for execution. heapsize defines +// the number of processes in execution depending on +// the current time currentTime keeps a record of +// the current CPU time. +void insert(Process Heap[], Process value, int* heapsize,int* currentTime) +{ + int start = *heapsize, i; + Heap[*heapsize] = value; + if (Heap[*heapsize].intime == -1) + Heap[*heapsize].intime = *currentTime; + ++(*heapsize); + + // Ordering the Heap + while (start != 0 && Heap[(start - 1) / 2].priority > Heap[start].priority) { + Process temp = Heap[(start - 1) / 2]; + Heap[(start - 1) / 2] = Heap[start]; + Heap[start] = temp; + start = (start - 1) / 2; + } +} + +// It is used to reorder the heap according to +// priority if the processes after insertion +// of new process. +void order(Process Heap[], int* heapsize, int start) +{ + int smallest = start; + int left = 2 * start + 1; + int right = 2 * start + 2; + if (left < *heapsize && Heap[left].priority = 1) { + Heap[0] = Heap[*heapsize]; + order(Heap, heapsize, 0); + } + return min; +} + +// Compares two intervals according to staring times. +int compare(Process p1, Process p2) +{ + if (p1.arrivalTime < p2.arrivalTime) + return 1; + else + return 0; +} + +// This function is responsible for executing +// the highest priority extracted from Heap[]. +void scheduling(Process Heap[], Process array[], int n,int* heapsize, int* currentTime) +{ + if (heapsize == 0) + return; + + Process min = extractminimum(Heap, heapsize, currentTime); + min.outtime = *currentTime + 1; + --min.burstTime; + printf("process id = %d\tcurrent_time = %d\n",min.processID, *currentTime); + + // If the process is not yet finished + // insert it back into the Heap*/ + if (min.burstTime > 0) { + insert(Heap, min, heapsize, currentTime); + return; + } + + for (int i = 0; i < n; i++) + if (array[i].processID == min.processID) { + array[i] = min; + break; + } +} + +// This function is responsible for +// managing the entire execution of the +// processes as they arrive in the CPU +// according to their arrival time. +void priority(Process array[], int n) +{ + sort(array, array + n, compare); + + int totalwaitingtime = 0, totalbursttime = 0, + totalturnaroundtime = 0, i, insertedprocess = 0, + heapsize = 0, currentTime = array[0].arrivalTime, + totalresponsetime = 0; + + Process Heap[4 * n]; + + // Calculating the total burst time + // of the processes + for (int i = 0; i < n; i++) { + totalbursttime += array[i].burstTime; + array[i].tempburstTime = array[i].burstTime; + } + + // Inserting the processes in Heap + // according to arrival time + do { + if (insertedprocess != n) { + for (i = 0; i < n; i++) { + if (array[i].arrivalTime == currentTime) { + ++insertedprocess; + array[i].intime = -1; + array[i].responsetime = -1; + insert(Heap, array[i], &heapsize, ¤tTime); + } + } + } + scheduling(Heap, array, n, &heapsize, ¤tTime); + ++currentTime; + if (heapsize == 0 && insertedprocess == n) + break; + } while (1); + + for (int i = 0; i < n; i++) { + totalresponsetime += array[i].responsetime; + totalwaitingtime += (array[i].outtime - array[i].intime - + array[i].tempburstTime); + totalbursttime += array[i].burstTime; + } + printf("\n\nAverage waiting time = %f\n",((float)totalwaitingtime / (float)n)); + printf("\nAverage response time =%f\n",((float)totalresponsetime / (float)n)); + printf("\nAverage turn around time = %f\n",((float)(totalwaitingtime + totalbursttime) / (float)n)); +} + +// Driver code +int main() +{ + int n, i; + Process a[5]; + printf("Enter the no.of Process:-"); + cin>>n; + printf("Arival_Time Burst_Time Priority\n"); + for(int i=0;i>a[i].arrivalTime; + cin>>a[i].burstTime; + cin>>a[i].priority; + } + priority(a, n); + return 0; +} + + + +Output:- +Enter the no.of Process:-5 +Arival_Time Burst_Time Priority + 1 4 3 + 3 7 2 + 0 9 5 + 4 3 4 + 2 5 1 +process id = 3 current_time = 0 +process id = 1 current_time = 1 +process id = 5 current_time = 2 +process id = 5 current_time = 3 +process id = 5 current_time = 4 +process id = 5 current_time = 5 +process id = 5 current_time = 6 +process id = 2 current_time = 7 +process id = 2 current_time = 8 +process id = 2 current_time = 9 +process id = 2 current_time = 10 +process id = 2 current_time = 11 +process id = 2 current_time = 12 +process id = 2 current_time = 13 +process id = 1 current_time = 14 +process id = 1 current_time = 15 +process id = 1 current_time = 16 +process id = 4 current_time = 17 +process id = 4 current_time = 18 +process id = 4 current_time = 19 +process id = 3 current_time = 20 +process id = 3 current_time = 21 +process id = 3 current_time = 22 +process id = 3 current_time = 23 +process id = 3 current_time = 24 +process id = 3 current_time = 25 +process id = 3 current_time = 26 +process id = 3 current_time = 27 + + +Average waiting time = 9.600000 + +Average response time =3.400000 + +Average turn around time = 15.200000 + From dda8e0e225082ef6ec16a9abc99a1b3f97b31ffe Mon Sep 17 00:00:00 2001 From: Harshita Date: Sun, 31 May 2020 22:43:24 +0530 Subject: [PATCH 249/265] added README for RSA Algorithm issue #2162 (#2918) --- RSA_Algorithm/README.md | 85 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 RSA_Algorithm/README.md diff --git a/RSA_Algorithm/README.md b/RSA_Algorithm/README.md new file mode 100644 index 000000000..0d60440d1 --- /dev/null +++ b/RSA_Algorithm/README.md @@ -0,0 +1,85 @@ +# RSA Algorithm +--- +RSA (Rivest-Shamir-Adleman) is an algorithm used by modern computers to encrypt and decrypt messages. It is an asymmetric cryptographic algorithm. Asymmetric means that there are two different keys. This is also called public key cryptoraphy, because one of the keys can be given to anyone. The other key must be kept private. The algorithm is based on the fact that finding the factors of large composite number is difficult: when the factors are prime numbers, the problem is called prime factorization. It is also a key pair (public and private key) generator. +![rsa algorithm](https://www.educative.io/api/edpresso/shot/5284561120395264/image/5318859621924864) + +## Algorithm +--- +- Generating the keys + 1. Generate two large random primes, p and q, of approximately equal size such that their product n=pq is of the required bit length. + 2. Compute n=pq and ϕ=(p−1)(q−1). + 3. Choose an integer e, 1 1 and is a co-prime of phi. + +// e = 17 satisfies the current values. + +// Using the extended euclidean algorithm, find 'd' which satisfies + +// this equation: + +d = (1 mod (phi))/e; + +// d = 2753 for the example values. + +public_key = (e=17, n=3233); + +private_key = (d=2753, n=3233); + +// Given the plaintext P=123, the ciphertext C is : + +C = (123^17) % 3233 = 855; + +// To decrypt the cypher text C: + +P = (855^2753) % 3233 = 123; +``` +## Complexity +--- + Three major components of the RSA algorithm are exponentiation, inversion and modular operation. Time complexity of the algorithm heavily depends on the complexity of the sub modules used. We can take the liberty to perform modular addition in cryptography in O(logn) where n is the number of digits in any number in Z. + + Now modular multiplication using squaring and multiply technique to get memodNcan be shown as multiplying the digits of m log e times. Considering the complexity of multiplication O({logn}2) i.e. repeated addition of two number of logn bits each, the complexity of the modular exponentiation is about O({logn}3) + + Using Euclidean extended GCD, inverse of a number can be calculated in O({logn}2) + + Thus overall time complexity of the key generation algorithm will be O(N2) encryption and decryption algorithm using squaring and multiply technique will be O(N3):For N digit number space. + +## Implementation +--- +- [C Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/RSA_Algorithm/RSA_Algorithm.c) + +- [C++ Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/RSA_Algorithm/RSA_Algorithm.cpp) + +- [JAVA Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/RSA_Algorithm/RSA_Algorithm.java) + +- [PYTHON Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/RSA_Algorithm/RSA_Algorithm.py) From d5f9a31d69a766fb325b762df83d9face0256975 Mon Sep 17 00:00:00 2001 From: Amit sharma <54413110+Amitsharma45@users.noreply.github.com> Date: Sun, 31 May 2020 22:45:16 +0530 Subject: [PATCH 250/265] Extended Algorithm README.md (#2990) * Create README.md * update readme.md --- ...mplementation for the Rabin Karp algorithm | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Python implementation for the Rabin Karp algorithm diff --git a/Python implementation for the Rabin Karp algorithm b/Python implementation for the Rabin Karp algorithm new file mode 100644 index 000000000..270594dca --- /dev/null +++ b/Python implementation for the Rabin Karp algorithm @@ -0,0 +1,40 @@ + +# Extended Euclidean Algorithm +The Euclidean algorithm is based on the principle that the greatest common divisor of two numbers does not change if the larger number is replaced by its difference with the smaller number. + + +For example, 21 is the GCD of 252 and 105 (as 252 = 21 × 12 and 105 = 21 × 5), and the same number 21 is also the GCD of 105 and 252 − 105 = 147. Since this replacement reduces the larger of the two numbers, repeating this process gives successively smaller pairs of numbers until the two numbers become equal. When that occurs, they are the GCD of the original two numbers. + +By reversing the steps, the GCD can be expressed as a sum of the two original numbers each multiplied by a positive or negative integer, e.g., 21 = 5 × 105 + (−2) × 252. The fact that the GCD can always be expressed in this way is known as Bézout's identity. +# Example: + **Input:** a = 30, b = 20 + + **Output:** gcd = 10 + + x = 1, y = -1 (Note that 30*(1) + 20*(-1) = 10) + + +# Extended Euclidean Algorithm implementation in Python + + def gcdFunction(a, b, x, y): + if a == 0: + x = 0 + y = 1 + return b + x1 = 0; y1 = 0 + gcd = gcdFunction(b % a, a, x1, y1) + x = y1 - int(b / a) * x1 + y = x1 + return gcd + + a = 98; b = 21 + x = 0; y = 0 + print("GCD of numbers " + str(a) + " and " + str(b) + " is " + str(gcdFunction(a, b, x, y))) + + ''' Output + GCD of numbers 98 and 21 is 7 + ''' + +[Reference: Wikipedia](https://en.wikipedia.org/wiki/Euclidean_algorithm) + +[Reference: Geeksforgeeks](https://www.geeksforgeeks.org/euclidean-algorithms-basic-and-extended/) From 432c23b888bdfc3be58ad5a99138da83a382c33f Mon Sep 17 00:00:00 2001 From: Sakshi Khachane <53635792+sakshikhachane@users.noreply.github.com> Date: Sun, 31 May 2020 22:49:22 +0530 Subject: [PATCH 251/265] Created Pancake Sort in php (#2976) * Created using Colaboratory * Deleted accidentally added file * Adding Pancake_Sort.php file * Updated Pancake_Sort.php file * Updated Pancake_Sort.php and made the changes --- Pancake_Sort/Pancake_Sort.php | 75 +++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 Pancake_Sort/Pancake_Sort.php diff --git a/Pancake_Sort/Pancake_Sort.php b/Pancake_Sort/Pancake_Sort.php new file mode 100644 index 000000000..798cb6877 --- /dev/null +++ b/Pancake_Sort/Pancake_Sort.php @@ -0,0 +1,75 @@ + 1; $currentSize--) + { + //finds the index of the maximum element in the array + $maxIndex = findMaxIndex($arr, $currentSize); + //if the maximum index is not at the end of the current array then move the element to the end + if ($maxIndex != $currentSize-1) + { + //moves maximum number to the beginning + reverseArray($arr, $maxIndex); + //moves maximum number to the end by reversing the array + reverseArray($arr, $currentSize-1); + } + } +} + +//reverses the array from index 0 to index +function reverseArray(&$arr, $index) +{ + $startIndex = 0; + //reverses till the startindex is not greater than index provided + while ($startIndex < $index) + { + //swapping of elements + $temp = $arr[$startIndex]; + $arr[$startIndex] = $arr[$index]; + $arr[$index] = $temp; + //increasing starting Index of an array + $startIndex++; + //decreasing ending index of an array + $index--; + } +} + +//Find the index of the maximum element in an array +function findMaxIndex($arr, $num) +{ + $maxIndex = 0; + for ($i = 0; $i < $num; $i++) + { + if ($arr[$i] > $arr[$maxIndex]) + { + $maxIndex = $i; + } + } + return $maxIndex; +} + +$arr = array(112,65,12,56,100,93,20); +//Counts the number of elements in the array +$num = count($arr); + +pancakeSort($arr, $num); + +echo("Sorted Array is:\n"); +//Prints the sorted array +for($i = 0;$i < $num; $i++) +{ + print($arr[$i]." "); +} + +return 0; + +/* +Input: + 112,65,12,56,100,93,20 + +Output: + 12,20,56,65,93,100,112 +*/ +?> From b378ed9b0460a1912c425bbec47feffc66ef4fff Mon Sep 17 00:00:00 2001 From: Monika Jha Date: Sun, 31 May 2020 23:15:41 +0530 Subject: [PATCH 252/265] Quick_Sort in Go (#3055) --- Quick_Sort/Quick_Sort.rs | 66 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 Quick_Sort/Quick_Sort.rs diff --git a/Quick_Sort/Quick_Sort.rs b/Quick_Sort/Quick_Sort.rs new file mode 100644 index 000000000..abfed919c --- /dev/null +++ b/Quick_Sort/Quick_Sort.rs @@ -0,0 +1,66 @@ +use std::io; +use std::str::FromStr; + +fn main() { + println!("Enter the numbers to be sorted (separated by space) : "); + let mut array: Vec = read_values :: ().unwrap(); + quicksort(&mut array, 0, array.len() - 1); + println!("The sorted array is : {:?}", array); +} + +fn quicksort(array: &mut[isize], first: usize, last: usize) { + if first < last { + let midpoint = partition(array, first, last); + quicksort(array, first, midpoint - 1); + quicksort(array, midpoint + 1, last); + } +} + +fn partition(array: &mut[isize], first: usize, last: usize) -> usize { + let pivot = array[last]; + let i: isize = first as isize; + let mut i: isize = i - 1; + let mut j = first; + while j < last - 1 { + if array[j] < pivot { + i = i + 1; + let k: usize = i as usize; + swap(array, k, j); + } + j = j + 1; + } + let k: isize = i + 1; + let k: usize = k as usize; + if array[last] < array[k] { + swap(array, k, last); + } + return k; +} + +fn swap(array: &mut[isize], a: usize, b: usize) { + let temp = array[a]; + array[a] = array[b]; + array[b] = temp; +} + +fn read_values() -> Result, T::Err> { + let mut s = String::new(); + io::stdin() + .read_line(&mut s) + .expect("could not read from stdin"); + s.trim() + .split_whitespace() + .map(|word| word.parse()) + .collect() +} + +/* +Sample Input : + Sample Input : + Enter the numbers to be sorted (separated by space) : + 45 23 15 80 5 + +Sample Output : + The sorted array is : [5, 15, 23, 45, 80] +*/ + From 340eff89eb4014f847300304649b17bced37a494 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 23:23:24 +0530 Subject: [PATCH 253/265] Pancake sort implemented in Dart (#3049) --- Pancake_Sort/Pancake_Sort.dart | 70 ++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Pancake_Sort/Pancake_Sort.dart diff --git a/Pancake_Sort/Pancake_Sort.dart b/Pancake_Sort/Pancake_Sort.dart new file mode 100644 index 000000000..b9b5147a6 --- /dev/null +++ b/Pancake_Sort/Pancake_Sort.dart @@ -0,0 +1,70 @@ +/** + * Pancake Sort + * -------------------------- + * It is a sorting algorithm of O(n^2) algorithm which sorts like selection sort + * by moving the minimum to the front by reversing the array till its index. + */ + +// Importing required libraries +import 'dart:io'; + +// Utility function to find maximum of the array +int findMax(List array, int n){ + int max_value = array[0]; + int max_index = 0; + for (int i = 0; i < n; i ++){ + if (max_value < array[i]){ + max_value = array[i]; + max_index = i; + } + } + return max_index; +} + +// Utility function to flip an array from an index +void flip(List array, int i){ + int start = 0, temp; + while (start < i){ + temp = array[start]; + array[start] = array[i]; + array[i] = temp; + start ++; + i --; + } +} + +// Function to sort a list using pancake sort +void pancakeSort(List array, int n){ + for (int i = n; i > 1; i --){ + int max_index = findMax(array, i); + if (max_index != i - 1){ + flip(array, max_index); + flip(array, i - 1); + } + } +} +// Driver method of the program +void main(){ + print("Enter number of elements of the array:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + + print("Enter array elements:"); + input = stdin.readLineSync(); + var lis = input.split(" "); + List array = lis.map(int.parse).toList(); + + pancakeSort(array, n); + + print(array.join(" ")); +} + +/** + * Sample Input and Output + * ------------------------------------ + * Enter number of elements of the array: + * 10 + * Enter array elements: + * 10 9 8 7 6 5 4 3 2 1 + * 1 2 3 4 5 6 7 8 9 10 + */ From 8433ec3df3d005d3523ef341632b4d318deaffc2 Mon Sep 17 00:00:00 2001 From: Abhinav Anand Date: Sun, 31 May 2020 23:25:00 +0530 Subject: [PATCH 254/265] Added Ternary_Search.rb (#2921) * Create Ternary_Search.rb * Added comments --- Ternary_Search/Ternary_Search.rb | 55 ++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 Ternary_Search/Ternary_Search.rb diff --git a/Ternary_Search/Ternary_Search.rb b/Ternary_Search/Ternary_Search.rb new file mode 100644 index 000000000..07bae69d4 --- /dev/null +++ b/Ternary_Search/Ternary_Search.rb @@ -0,0 +1,55 @@ +=begin + Ternary Search +------------------------------- +Ternary search is a searching technique that is used to search the position of a specific value in an array. +Ternary search is a divide-and-conquer algorithm. +It is mandatory for the array to be sorted (in which you will search for an element). +The array is divided into three parts and then we determine in which part the element exists. +In this search, after each iteration it neglects ⅓ part of the array and repeats the same operations on the remaining ⅔. +Time Complexity: O(log3 n) +Space Complexity: O(1) +=end + +def ternarySearch(l, r, key, ar) #function to perform ternary search + + if (r >= l) + #find mid1 and mid2 + mid1 = l + (r - l) / 3 + mid2 = r - (r - l) / 3 + if ar[mid1] == key #check if key is equal to mid1 + mid1 + elsif ar[mid2] == key #check if key is equal to mid2 + mid2 + #Since key is not present at mid, check in which region it is present + #then repeat the Search operation in that region + elsif key < ar[mid1] + ternarySearch(l, mid1 - 1, key, ar) + elsif (key > ar[mid2]) + ternarySearch(mid2 + 1, r, key, ar) + else + ternarySearch(mid1 + 1, mid2 - 1, key, ar) + end + end +end +n= gets.to_i #length of array +arr = [] +while n>0 + num = gets.chomp.to_i + arr.push(num) + n = n-1 +end +number = gets.to_i #number whose index is to be searched +puts "Index of #{number} is #{ternarySearch(0, arr.length - 1, number, arr)}" + +=begin +input-> +5 +21 +34 +54 +67 +78 +67 +output-> +Index of 67 is 3 +=end From 512143def532853b16f945e2b8e0b47b7c4f01c4 Mon Sep 17 00:00:00 2001 From: Sangeeta Jha <43818333+nehasangeetajha@users.noreply.github.com> Date: Sun, 31 May 2020 23:30:54 +0530 Subject: [PATCH 255/265] Create README.md (#2344) * Create README.md * Update README.md --- Floyd_Warshall_Algorithm/README.md | 111 +++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 Floyd_Warshall_Algorithm/README.md diff --git a/Floyd_Warshall_Algorithm/README.md b/Floyd_Warshall_Algorithm/README.md new file mode 100644 index 000000000..8ddcf4081 --- /dev/null +++ b/Floyd_Warshall_Algorithm/README.md @@ -0,0 +1,111 @@ +# Floyd Warshall Algorithm + +In computer science, the **Floyd–Warshall algorithm** is an algorithm for finding +shortest paths in a weighted graph with positive or negative edge weights (but +with no negative cycles). A single execution of the algorithm will find the +lengths (summed weights) of shortest paths between all pairs of vertices. + +## Algorithm + +The Floyd–Warshall algorithm compares all possible paths through the graph between +each pair of vertices. It is able to do this with `O(|V|^3)` comparisons in a graph. +This is remarkable considering that there may be up to `|V|^2` edges in the graph, +and every combination of edges is tested. It does so by incrementally improving an +estimate on the shortest path between two vertices, until the estimate is optimal. + +Consider a graph `G` with vertices `V` numbered `1` through `N`. Further consider +a function `shortestPath(i, j, k)` that returns the shortest possible path +from `i` to `j` using vertices only from the set `{1, 2, ..., k}` as +intermediate points along the way. Now, given this function, our goal is to +find the shortest path from each `i` to each `j` using only vertices +in `{1, 2, ..., N}`. + +![Recursive Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/f9b75e25063384ccca499c56f9a279abf661ad3b) + +![Recursive Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/34ac7c89bbb18df3fd660225fd38997079e5e513) +![Recursive Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/0326d6c14def89269c029da59eba012d0f2edc9d) + +This formula is the heart of the Floyd–Warshall algorithm. + +### Pseudo Code: + +``` +FLOYD - WARSHALL (W) + 1. n ← rows [W]. + 2. D0 ← W + 3. for k ← 1 to n + 4. do for i ← 1 to n + 5. do for j ← 1 to n + 6. do d(i, j, k) ← min ( d(i, j, k-1),d(i, k, k-1) + d(k, j, k-1) ) + 7. return D(n) +``` + +## Time complexity +The strategy adopted by the Floyd-Warshall algorithm is Dynamic Programming. +The running time of the Floyd-Warshall algorithm is determined by the triply nested for loops of lines 3-6. +Each execution of line 6 takes O (1) time. The algorithm thus runs in time θ(n3 ). + +## Example + +The algorithm above is executed on the graph on the left below: + +![Example](https://upload.wikimedia.org/wikipedia/commons/2/2e/Floyd-Warshall_example.svg) + +In the tables below `i` is row numbers and `j` is column numbers. + + +**k = 0** + +| | 1 | 2 | 3 | 4 | +|:-----:|:---:|:---:|:---:|:---:| +| **1** | 0 | ∞ | −2 | ∞ | +| **2** | 4 | 0 | 3 | ∞ | +| **3** | ∞ | ∞ | 0 | 2 | +| **4** | ∞ | −1 | ∞ | 0 | + + +**k = 1** + +| | 1 | 2 | 3 | 4 | +|:-----:|:---:|:---:|:---:|:---:| +| **1** | 0 | ∞ | −2 | ∞ | +| **2** | 4 | 0 | 2 | ∞ | +| **3** | ∞ | ∞ | 0 | 2 | +| **4** | ∞ | − | ∞ | 0 | + + +**k = 2** + +| | 1 | 2 | 3 | 4 | +|:-----:|:---:|:---:|:---:|:---:| +| **1** | 0 | ∞ | −2 | ∞ | +| **2** | 4 | 0 | 2 | ∞ | +| **3** | ∞ | ∞ | 0 | 2 | +| **4** | 3 | −1 | 1 | 0 | + + +**k = 3** + +| | 1 | 2 | 3 | 4 | +|:-----:|:---:|:---:|:---:|:---:| +| **1** | 0 | ∞ | −2 | 0 | +| **2** | 4 | 0 | 2 | 4 | +| **3** | ∞ | ∞ | 0 | 2 | +| **4** | 3 | −1 | 1 | 0 | + + +**k = 4** + +| | 1 | 2 | 3 | 4 | +|:-----:|:---:|:---:|:---:|:---:| +| **1** | 0 | −1 | −2 | 0 | +| **2** | 4 | 0 | 2 | 4 | +| **3** | 5 | 1 | 0 | 2 | +| **4** | 3 | −1 | 1 | 0 | + + +## Implementation +* [CPP Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.cpp) +* [Go Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.go) +* [Java Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.java) +* [Python Code](https://github.com/jainaman224/Algo_Ds_Notes/blob/master/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.py) From d62a3a12119ed260e9e4833ab03ab284d035acd4 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 23:32:44 +0530 Subject: [PATCH 256/265] Cocktail sort implemented in Dart (#3056) --- Cocktail_Sort/Cocktail_Sort.dart | 64 ++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 Cocktail_Sort/Cocktail_Sort.dart diff --git a/Cocktail_Sort/Cocktail_Sort.dart b/Cocktail_Sort/Cocktail_Sort.dart new file mode 100644 index 000000000..a6693449d --- /dev/null +++ b/Cocktail_Sort/Cocktail_Sort.dart @@ -0,0 +1,64 @@ +// Importing required libraries +import 'dart:io'; + +// Function to sort the input list using cocktail sort +void cocktail_sort(List array, int n){ + bool swapped = true; + int start = 0; + int end = n; + while (swapped == true){ + swapped = false; + // Forward swapping + for (int i = start; i < end - 1; i ++){ + if (array[i] > array[i + 1]){ + int temp = array[i]; + array[i] = array[i + 1]; + array[i + 1] = temp; + swapped = true; + } + } + if (swapped == false){ + break; + } + swapped = false; + end = end - 1; + // Reverse swapping + for (int i = end - 1; i >= start; i --){ + if (array[i] > array[i + 1]){ + int temp = array[i]; + array[i] = array[i + 1]; + array[i + 1] = temp; + swapped = true; + } + } + start = start + 1; + } + +} + +// Driver method of the program +void main(){ + // Input of size of the array + print("Enter number of elements in the array:"); + var input = stdin.readLineSync(); + int n = int.parse(input); + // Input of the array elements + print("Enter array elements:"); + input = stdin.readLineSync(); + var lis = input.split(" "); + List array = lis.map(int.parse).toList(); + // Cocktail sorting + cocktail_sort(array, n); + // Printing the output to stdout + print(array.join(" ")); +} + +/** + * Sample Input and Output + * ------------------------------------ + * Enter number of elements in the array: + * 10 + * Enter array elements: + * 10 9 8 7 6 5 4 3 2 1 + * 1 2 3 4 5 6 7 8 9 10 + */ From 09da3c6459b81cab4ef20b6fc0d4dc9728851a70 Mon Sep 17 00:00:00 2001 From: Ankita Saloni Date: Sun, 31 May 2020 23:36:58 +0530 Subject: [PATCH 257/265] Created Insertion_Sort.php (#2805) * Added Insertion_Sort.php * Update Insertion_Sort.php Co-authored-by: Ankita Saloni <56873389+saloniankita23@users.noreply.github.com> --- Insertion_Sort.php | 64 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 Insertion_Sort.php diff --git a/Insertion_Sort.php b/Insertion_Sort.php new file mode 100644 index 000000000..bcac45d95 --- /dev/null +++ b/Insertion_Sort.php @@ -0,0 +1,64 @@ +arr = $arr; + } + + //Printing the array + public function printArray($array) + { + for($i = 0; $i < count($array); $i++) + { + echo $array[$i]." "; + } + } + + //Sorting the array + public function sort() + { + for($i = 1; $i < count($this->arr); $i++) + { + $temp = $this->arr[$i]; + while($i > 0 && $temp < $this->arr[$i-1]) + { + $this->arr[$i] = $this->arr[$i-1]; + --$i; + } + $this->arr[$i] = $temp; + } + return $this->arr; + } +} + +//Driver Code +echo "

Implementing Insertion Sort Algorithm :

"; +$num = array(); + + for($i = 1; $i <= rand(1, 10); $i++) + { + $num[] = $i; + } + shuffle($num); + + $is = new InsertionSort($num); + +//Printing Unsorted array +echo "
Unsorted Array : "; +$is->printArray($num); + +//Printing Sorted array +echo "
Sorted Array : "; +$is->printArray($is->sort()); + +/* +Implementing Insertion Sort Algorithm : + +Unsorted Array : 5 2 3 4 8 6 1 7 + +Sorted Array : 1 2 3 4 5 6 7 8 +*/ +?> From 3934605691dc19c6d286ed7a5dd779204d9d8b01 Mon Sep 17 00:00:00 2001 From: Ajay Sharma Date: Sun, 31 May 2020 23:37:17 +0530 Subject: [PATCH 258/265] Added the README.md file for Exponential Search (#2448) * ADDED THE README.md FILE FOR FENWICK_TREE * modified * modified * Created README.md file for Exponential Search * modified * Delete README.md * modified Readme.md * Update README.md * Update README.md * Update README.md * Update README.md * Update README.md * Update README.md Co-authored-by: ajay sharma --- Exponential_Search/README.md | 96 ++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 Exponential_Search/README.md diff --git a/Exponential_Search/README.md b/Exponential_Search/README.md new file mode 100644 index 000000000..78e04d6b8 --- /dev/null +++ b/Exponential_Search/README.md @@ -0,0 +1,96 @@ +# Exponential Search + +Exponential search (also called doubling search or galloping search or Struzik search) is a searching technique for sorted, unbounded/infinite lists. +There are multiple ways to perform this method, but the most common and useful one is to find the range in which the element to be searched must be present. This is done by applying a Binary Search between the ranges. + +The name of this searching algorithm may be misleading but it works in O(Log n) time. The name comes from the way it searches an element. + +## Explanation + +Exponential search involves two steps: + +1. Find range where element is present +2. Do Binary Search in above found range. + +The idea is to start with subarray size 1, compare its last element with x, then try size 2, then 4 and so on until last element of a subarray is not greater. +Once we find an index i (after repeated doubling of i), we know that the element must be present between i/2 and i (Why i/2? because we could not find a greater value in previous iteration) + +## Algorithm + +The algorithm consists of two stages. The first stage determines a range in which the search key would reside if it were in the list. In the second stage, a binary search is performed on this range. In the first stage, assuming that the list is sorted in ascending order, the algorithm looks for the first exponent, j, where the value 2j is greater than the search key. This value, 2j becomes the upper bound for the binary search with the previous power of 2, 2j - 1, being the lower bound for the binary search.[3] + +```C++ +// Returns the position of key in the array arr of length size. +template +int exponential_search(T arr[], int size, T key) +{ + if (size == 0) + { + return NOT_FOUND; + } + + int bound = 1; + while (bound < size && arr[bound] < key) + { + bound*= 2; + } + + return binary_search(arr, key, bound/2, min(bound + 1, size)); +} +``` + +In each step, the algorithm compares the search key value with the key value at the current search index. If the element at the current index is smaller than the search key, the algorithm repeats, skipping to the next search index by doubling it, calculating the next power of 2.[3] If the element at the current index is larger than the search key, the algorithm now knows that the search key, if it is contained in the list at all, is located in the interval formed by the previous search index, 2j - 1, and the current search index, 2j. The binary search is then performed with the result of either a failure, if the search key is not in the list, or the position of the search key in the list. + +## Pseudocode + +Input: An sorted array, start and end location, and the search key. + +Output: location of the key (if found), otherwise wrong location. + + Begin + + if (end – start) <= 0 then + + return invalid location + + i := 1 + + while i < (end - start) do + + if array[i] < key then + + i := i * 2 //increase i as power of 2 + + else + + terminate the loop + + done + + call binarySearch(array, i/2, i, key) + + End + + +## Example + +Given a sorted array, and an element x to be searched, find position of x in the array. + +1. Input: arr[] = {10, 20, 40, 45, 55} + x = 45 +Output: Element found at index 3 + +2. Input: arr[] = {10, 15, 25, 45, 55} + x = 15 +Output: Element found at index 1 + +## The complexity of Exponential Search Technique + +1. Time Complexity: O(1) for the best case. O(log2 i) for average or worst case. Where i is the location where search key is present. + +2. Space Complexity: O(1) + +## See also + +* [Wikipedia : Exponential Search](https://en.wikipedia.org/wiki/Exponential_search) +* [geeksforgeeks : Exponential Search](https://www.geeksforgeeks.org/exponential-search/) From 386ebefb2fe6385bf042ef85a5553eec7a47a325 Mon Sep 17 00:00:00 2001 From: Rukmini Meda <44504940+Rukmini-Meda@users.noreply.github.com> Date: Sun, 31 May 2020 23:44:34 +0530 Subject: [PATCH 259/265] Primality test implemented in Dart (#3054) --- AKS_Primarility_Test/AKS.dart | 55 +++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 AKS_Primarility_Test/AKS.dart diff --git a/AKS_Primarility_Test/AKS.dart b/AKS_Primarility_Test/AKS.dart new file mode 100644 index 000000000..aabf1e7c8 --- /dev/null +++ b/AKS_Primarility_Test/AKS.dart @@ -0,0 +1,55 @@ +// Importing required libraries +import 'dart:io'; + +// Function to fill the coefficients array +void coef(int number, List c){ + c[0] = 1; + for (int i = 0; i < number; c[0] = -c[0], i ++){ + c[i + 1] = 1; + for (int j = i; j > 0; j --){ + c[j] = c[j - 1] - c[j]; + } + } +} + +// Function to find the primality of a given number using AKS primality test +bool aks_primality(int number){ + List c = List(100); + coef(number, c); + c[0] ++; + c[number] --; + int i = number; + while ((i --) > 0 && c[i] % number == 0); + return i < 0; +} + +// Driver method of the program +void main(){ + // Input of the number + print("Enter a number for primality test:"); + var input = stdin.readLineSync(); + int number = int.parse(input); + + // Respective output + if (number > 64){ + print("This number is out of scope of this algorithm. This works only till 64"); + return; + } + if (aks_primality(number)){ + print("It is a prime number"); + } + else { + print("It is not a prime number"); + } +} + +/** + * Sample Input and Output + * --------------------------------- + * Enter a number for primality test: + * 37 + * It is a prime number + * Enter a number for primality test: + * 24 + * It is not a prime number + */ From 0357d285d9ce67d99dc05c2e05032fef6227df8e Mon Sep 17 00:00:00 2001 From: Debojyoti Chakraborty <50295688+sparkingdark@users.noreply.github.com> Date: Sun, 31 May 2020 23:53:17 +0530 Subject: [PATCH 260/265] Implementation of Bead sort in ruby (#2441) * this is a ruby implementation of the armstrong number. On branch master Changes to be committed: new file: Armstrong_Number/Armstrong_Number.rb * Update Armstrong_Number.rb ruby implementation of armstrong number. * On branch master Your branch is up to date with 'origin/master'. Changes to be committed: modified: Armstrong_Number.rb checked with 153,370 * Changes to be committed: modified: Armstrong_Number.rb * Added 4 space indent Done with indentation across the file. * Taking input dynamically * Changes to be committed: new file: Bead_Sort.rb * Changes to be committed: new file: Bead_Sort.rb * Revert " Changes to be committed:" * Delete Bead_Sort.rb * Create Bead_Sort.rb * Delete Armstrong_Number.rb * done with documentation. * done with rufo * Done with indentation Changes to be committed: modified: Bead_Sort.rb Co-authored-by: Debojyoti Chakraborty <50295688+darkdebo@users.noreply.github.com> --- Bead_Sort/Bead_Sort.rb | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Bead_Sort/Bead_Sort.rb diff --git a/Bead_Sort/Bead_Sort.rb b/Bead_Sort/Bead_Sort.rb new file mode 100644 index 000000000..1cee3941c --- /dev/null +++ b/Bead_Sort/Bead_Sort.rb @@ -0,0 +1,41 @@ +# Bead Sort is a Natural Sorting Algorithm Also known as Gravity sort, +# this algorithm was inspired from natural phenomenons and was designed keeping in mind objects(or beads) falling under the influence of gravity. +# The Idea: Positive numbers are represented by a set of beads like those on an abacus. +# Implementation of Bead sort in Ruby + +class Array + # BeadSort algorithm function + def beadsort + # this will take the matrix and make transpose of it to sort. + map { |e| [1] * e }.columns.columns.map(&:length) + end + + # Columns for the matrix + def columns + y = length + x = map(&:length).max + Array.new(x) do |row| + Array.new(y) { |column| self[column][row] }.compact # it remove null value + end + end +end + +# function for taking dynamic array input. +def myarray(a, n) + for i in 0..n + a[i] = gets.chomp.to_i + end + return a +end + +# Driver code: +a = Array.new +n = gets.chomp.to_i +new_arr = myarray(a, n) +print(new_arr.beadsort.reverse()) + +# Output +# Before sorting +# 23 2 12 54 90 102 32 +# After sorting +# 2 12 23 32 54 90 102 From 878088281c6b23d61d3eeaaf85f0c5272abd12e4 Mon Sep 17 00:00:00 2001 From: Dhananjay Sachdeva <40068702+dj373@users.noreply.github.com> Date: Thu, 4 Jun 2020 23:05:02 +0530 Subject: [PATCH 261/265] Created Quick_Sort.ts (#3031) * Created Quick_Sort.ts Added quicksort implementation in TypeScript #2131 * Updated Quick_Sort.ts Added 4 space indentation --- Quick_Sort/Quick_Sort.ts | 67 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 Quick_Sort/Quick_Sort.ts diff --git a/Quick_Sort/Quick_Sort.ts b/Quick_Sort/Quick_Sort.ts new file mode 100644 index 000000000..8a5a65165 --- /dev/null +++ b/Quick_Sort/Quick_Sort.ts @@ -0,0 +1,67 @@ +// Description: Function to perform the Quick Sort algorithm on an array of numbers +// Expected Output: returns the sorted array + +// Helper function to get the Pivoting Element Index +function partition(array: number[], left: number = 0, right: number = array.length - 1) +{ + const pivot = array[Math.floor((right + left) / 2)]; + let i = left; + let j = right; + + while (i <= j) + { + while (array[i] < pivot) + { + i++; + } + + while (array[j] > pivot) + { + j--; + } + + // Swap values based on indices + if (i <= j) + { + [array[i], array[j]] = [array[j], array[i]]; + i++; + j--; + } + } + + return i; +} + + +// Function that uses recursive definition for quick sort implementation +function quickSort(array: number[], left: number = 0, right: number = array.length - 1) +{ + let index; + + if (array.length > 1) + { + index = partition(array, left, right); + + if (left < index - 1) + { + quickSort(array, left, index - 1); + } + + if (index < right) + { + quickSort(array, index, right); + } + } + + return array; +} + +// I/P +var arr = [6, 5, 4, 3, 2, 1]; + +console.log("Before sorting ",arr) +var res = quickSort(arr) + +console.log("After sorting ",res) +// O/P +// 1,2,3,4,5,6 From 1700661bb0198efa877dc29391b1d640c58b7f44 Mon Sep 17 00:00:00 2001 From: Chandrika Deb Date: Thu, 4 Jun 2020 23:07:56 +0530 Subject: [PATCH 262/265] Added implementation of AVL tree in PHP (#2939) * Added implementation of AVL tree in PHP * Update avl_tree.php * Update avl_tree.php --- AVL_Tree/avl_tree.php | 192 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 192 insertions(+) create mode 100644 AVL_Tree/avl_tree.php diff --git a/AVL_Tree/avl_tree.php b/AVL_Tree/avl_tree.php new file mode 100644 index 000000000..761a4d828 --- /dev/null +++ b/AVL_Tree/avl_tree.php @@ -0,0 +1,192 @@ +left = NULL; + $this->right = NULL; + $this->depth = 0; + $this->data = NULL; + } + + function balance() + { + $ldepth = $this->left !== NULL + ? $this->left->depth + : 0; + + $rdepth = $this->right !== NULL + ? $this->right->depth + : 0; + + + if( $ldepth > $rdepth + 1 ) + { // LR or LL rotation + $lldepth = $this->left->left !== NULL + ? $this->left->left->depth + : 0; + + $lrdepth = $this->left->right !== NULL + ? $this->left->right->depth + : 0; + + if( $lldepth < $lrdepth ) + { // LR rotation + $this->left->rotateRR(); // consist of a RR rotation of the left child ... + } // ... plus a LL rotation of this node, which happens anyway + + $this->rotateLL(); + } + else if( $ldepth + 1 < $rdepth ) + { // RR or RL rorarion + $rrdepth = $this->right->right !== NULL + ? $this->right->right->depth + : 0; + + $rldepth = $this->right->left !== NULL + ? $this->right->left->depth + : 0; + + if( $rldepth > $rrdepth ) + { // RR rotation + $this->right->rotateLL(); // consist of a LL rotation of the right child ... + } // ... plus a RR rotation of this node, which happens anyway + + $this->rotateRR(); + } + } + + function rotateLL() + { // the left side is too long => rotate from the left (_not_ leftwards) + $data_before =& $this->data; + $right_before =& $this->right; + + $this->data =& $this->left->data; + $this->right =& $this->left; + $this->left =& $this->left->left; + $this->right->left =& $this->right->right; + $this->right->right =& $right_before; + $this->right->data =& $data_before; + $this->right->updateInNewLocation(); + $this->updateInNewLocation(); + } + + function rotateRR() + { // the right side is too long => rotate from the right (_not_ rightwards) + $data_before =& $this->data; + $left_before =& $this->left; + + $this->data =& $this->right->data; + $this->left =& $this->right; + $this->right =& $this->right->right; + $this->left->right =& $this->left->left; + $this->left->left =& $left_before; + $this->left->data =& $data_before; + $this->left->updateInNewLocation(); + $this->updateInNewLocation(); + } + + // -- updateInNewLocation + // may be overloaded by derived class + function updateInNewLocation() + { + $this->getDepthFromChildren(); + } + + + function getDepthFromChildren() + { + $this->depth = $this->data !== NULL ? 1 : 0; + if( $this->left !== NULL ) + $this->depth = $this->left->depth+1; + if( $this->right !== NULL && $this->depth <= $this->right->depth ) + $this->depth = $this->right->depth+1; + } + + // --- debugging functions + + function toString() + { + $s = "\n".$this->toTD(0)."\n"; + $depth = $this->depth - 1; + for( $d = 0; $d < $depth; ++$d ) + { + $s .= ""; + + $s .= $this->left !== NULL + ? $this->left->toTD( $d ) + : ""; + + $s .= $this->right !== NULL + ? $this->right->toTD( $d ) + : ""; + + $s .= "\n"; + } + + $s .= "
\n"; + return $s; + } + + function toTD( $depth ) + { + if( $depth == 0 ) + { + $s = ""; + $s .= $this->data."[".$this->depth."]\n"; + } + else + { + if( $this->left !== NULL ) + { + $s = $this->left->toTD( $depth-1); + } + else + { + $s=""; + } + + if( $this->right !== NULL ) + { + $s .= $this->right->toTD( $depth-1); + } + else + { + if( $this->left !== NULL ) + $s.=""; + } + } + + return $s; + } + + function getNLeafs() + { + if( $this->left !== NULL ) + { + $nleafs = $this->left->getNLeafs(); + + if( $this->right !== NULL ) + $nleafs += $this->right->getNLeafs(); + else + ++$nleafs; // lus one for the right "stump" + } + else + { + if( $this->right !== NULL ) + $nleafs = $this->right->getNLeafs() + 1; // plus one for the left "stump" + else + $nleafs = 1; // this node is a leaf + } + + return $nleafs; + } + +} +?> From 7029a6d1fb00ff028aba7a3f19f7fecfe4928d22 Mon Sep 17 00:00:00 2001 From: Ankita Saloni Date: Thu, 4 Jun 2020 23:10:45 +0530 Subject: [PATCH 263/265] Create Cycle_Sort.c (#3058) --- Cycle_Sort.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Cycle_Sort.c diff --git a/Cycle_Sort.c b/Cycle_Sort.c new file mode 100644 index 000000000..a88653ea1 --- /dev/null +++ b/Cycle_Sort.c @@ -0,0 +1,78 @@ +// Cycle sort is an in-place and unstable sorting algorithm, a comparison sort that is based on the idea that array to be sorted can be divided into cycles. + +# include + +// Cycle Sort begins +void cyclesort(int a[], int n) +{ + int write = 0, start, element, pos, temp, i; + + // Finding the position where we put the element. + for (start = 0 ; start <= n - 2 ; start++) + { + element = a[start]; + pos = start; + + for (i = start + 1 ; i < n ; i++) + if (a[i] < element) + pos++; + + // Checking if element is already in correct position + if (pos == start) + continue; + + while (element == a[pos]) + pos += 1; + + // Putting the element to their right position + if (pos != start) + { + temp = element; + element = a[pos]; + a[pos] = temp; + write++; + } + + // Rotating rest of the cycle + while (pos != start) { + pos = start; + for (i = start + 1 ; i < n ; i++) + if (a[i] < element) + pos += 1; + + while (element == a[pos]) + pos += 1; + + // Putting the element to their right position + if (element != a[pos]) + { + temp = element; + element = a[pos]; + a[pos] = temp; + write++; + } + } + } + } + +int main() +{ int n,i; + int a[20]; + printf("Enter the no. of elements : "); + scanf("%d",&n); + printf("Enter the elements : "); + for(i = 0 ; i < n ; i++) + scanf("%d ",a[i]); + cyclesort(a, n); + printf("After sorting : "); + for (i = 0 ; i < n ; i++) + printf("%d ",a[i]); + return 0; +} + +/* Sample Output: + +Enter the no. of elements : 4 +Enter the elements : 5 8 2 3 +After sorting : 2 3 5 8 +*/ From 60335122d10fd3cf9388427cf5885a522a3f7481 Mon Sep 17 00:00:00 2001 From: Disha Sinha <42354197+disha2sinha@users.noreply.github.com> Date: Thu, 4 Jun 2020 23:14:20 +0530 Subject: [PATCH 264/265] Floyd Warshall Algorithm implemented in Dart (#2883) Changes made Changes made --- .../Floyd_Warshall_Algorithm.dart | 132 ++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.dart diff --git a/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.dart b/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.dart new file mode 100644 index 000000000..01dd2a8c0 --- /dev/null +++ b/Floyd_Warshall_Algorithm/Floyd_Warshall_Algorithm.dart @@ -0,0 +1,132 @@ +import 'dart:io'; + +var pred = []; + +int minimum (var a, var b) +{ + if (a <= b) + { + return a; + } + else + { + return b; + } +} + +void floydwarshall (int n, var weight) +{ + var dist = []; + for(var i = 0; i < n; i++) + { + var distlist = []; + var predlist = []; + for(var j = 0; j < n; j++) + { + distlist.insert(j, weight[i][j]); + predlist.insert(j, -999); + } + dist.insert(i, distlist); + pred.insert(i, predlist); + } + for(int k = 0; k < n; k++) + { + for(int i = 0; i < n; i++) + { + var distlist = []; + var predlist = []; + + for(int j = 0; j < n; j++) + { + distlist.insert(j, minimum(dist[i][j], dist[i][k] + dist[k][j])); + predlist.insert(j, k); + } + + dist.removeAt(i); + dist.insert(i, distlist); + pred.removeAt(i); + pred.insert(i, predlist); + } + } + + print("The matrix shows the shortest distance between each of the vertices:"); + + for (var i = 0; i < n; i++) + print(dist[i]); +} + +main() +{ + print("Enter number of vertices in the graph:"); + var n = int.parse(stdin.readLineSync()); + var weight = []; + print("Enter initial weights of the paths connecting each vertex(Enter 9999 for the pair of vertices with no path):"); + + for(int i = 0; i < n; i++) + { + var weightlist = []; + for(int j = 0; j < n; j++) + { + print("Enter distance between $i to $j: "); + var input = int.parse(stdin.readLineSync()); + weightlist.insert(j, input); + } + weight.insert(i, weightlist); + + } + + print("The initial distances between vertices:"); + + for (var i = 0; i < n; i++) + { + print(weight[i]); + } + floydwarshall(n, weight); +} + +/* +Enter number of vertices in the graph: +4 +Enter initial weights of the paths connecting each vertex(Enter 9999 for the pair of vertices with no path): +Enter distance between 0 to 0: +0 +Enter distance between 0 to 1: +8 +Enter distance between 0 to 2: +9999 +Enter distance between 0 to 3: +1 +Enter distance between 1 to 0: +9999 +Enter distance between 1 to 1: +0 +Enter distance between 1 to 2: +1 +Enter distance between 1 to 3: +9999 +Enter distance between 2 to 0: +4 +Enter distance between 2 to 1: +12 +Enter distance between 2 to 2: +0 +Enter distance between 2 to 3: +5 +Enter distance between 3 to 0: +9999 +Enter distance between 3 to 1: +2 +Enter distance between 3 to 2: +9 +Enter distance between 3 to 3: +0 +The initial distances between vertices: +[0, 8, 9999, 1] +[9999, 0, 1, 9999] +[4, 12, 0, 5] +[9999, 2, 9, 0] +The matrix shows the shortest distance between each of the vertices: +[0, 3, 4, 1] +[5, 0, 1, 6] +[4, 7, 0, 5] +[7, 2, 3, 0]*/ From b0c11a2efe40c827072c63a5c8c4c8994cf4b37b Mon Sep 17 00:00:00 2001 From: Adit Desai <62762086+aditdesai@users.noreply.github.com> Date: Sat, 13 Nov 2021 16:57:58 +0530 Subject: [PATCH 265/265] Corrected technical problem in README.md (#3120) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d669ff797..570c8931a 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ $ git clone https://github.com/Your_Username/Algo_Ds_Notes.git > This makes a local copy of repository in your machine. -Once you have cloned the `Algo_Ds_Notes` repository in Github, move to that folder first using change directory command on linux and Mac. +Once you have cloned the `Algo_Ds_Notes` repository in Github, move to that folder first using change directory command on Linux/Mac/Windows. ```sh # This will change directory to a folder Algo_Ds_Notes