Issue116 complete

Competitive Coding/Graphs/Shortest Path/dijsktra/README.md

@@ -10,9 +10,9 @@ Dijkstra thought about the shortest path problem when working at the Mathematica
  A year later, he came across another problem from hardware engineers working on the institute's next computer: minimize the amount of wire needed to connect the pins on the back panel of the machine. As a solution, he re-discovered the algorithm known as Prim's minimal spanning tree algorithm (known earlier to Jarník, and also rediscovered by Prim).
  Dijkstra published the algorithm in 1959, two years after Prim and 29 years after Jarník.
 
-
  **Algorithm**
 
+>>>>>>> 56b74e922bff38aee9cfff9e7cfde1c6610adc50
  Let the node at which we are starting be called the initial node. Let the distance of node Y be the distance from the initial node to Y. Dijkstra's algorithm will assign some initial distance values and will try to improve them step by step.
 
 Assign to every node a tentative distance value: set it to zero for our initial node and to infinity for all other nodes.
@@ -30,6 +30,7 @@ Otherwise, select the unvisited node that is marked with the smallest tentative
 ---------------------------------------------------
 
 ## Related Problems
+>>>>>>> 56b74e922bff38aee9cfff9e7cfde1c6610adc50
 The functionality of Dijkstra's original algorithm can be extended with a variety of modifications. For example, sometimes it is desirable to present solutions which are less than mathematically optimal. To obtain a ranked list of less-than-optimal solutions, the optimal solution is first calculated. A single edge appearing in the optimal solution is removed from the graph, and the optimum solution to this new graph is calculated. Each edge of the original solution is suppressed in turn and a new shortest-path calculated. The secondary solutions are then ranked and presented after the first optimal solution.
 
 Dijkstra's algorithm is usually the working principle behind link-state routing protocols, OSPF and IS-IS being the most common ones.
@@ -48,15 +49,16 @@ Fast marching method can be viewed as a continuous version of Dijkstra's algorit
 ----------------------------------------------------------
 
 ## Applications
+>>>>>>> 56b74e922bff38aee9cfff9e7cfde1c6610adc50
 
 1. **Flight Agenda** -- A travel agent requests software for making an agenda of flights for clients. The agent has access to a data base with all airports and flights. Besides the flight number, origin airport and destination, the flights have departure and arrival time. Specifically the agent wants to determine the earliest arrival time for the destination given an origin airport and start time
 
 2. **Telephone Network** -- In a telephone network the lines have bandwidth, BW. We want to route the phone call via the highest BW.
 
-
  ----------------------------------------------
  **Source**
 
  [Wikipedia](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
 
+>>>>>>> 56b74e922bff38aee9cfff9e7cfde1c6610adc50
  [Dijkstra](http://www.csl.mtu.edu/cs2321/www/newLectures/30_More_Dijkstra.htm)

Competitive Coding/Math/GCD and LCM/GCDEuclidsAlgorithm.c

@@ -0,0 +1,36 @@
+//Program to calculate the GCD of a number by Euclids algorithm, and then find its LCM
+
+#include<stdio.h>
+
+//Function to calculate the GCD
+//It is assumed that n >= m
+int gcd(int m, int n){
+
+    if(m == 0)
+        return n;
+    else
+        return gcd((n%m) , m);
+}
+
+//Function to calculate LCM
+int lcm(int m, int n, int gcdOfmn){
+
+    int lcm = (m * n) / gcdOfmn;
+    return lcm;
+}
+
+//Driver Function
+int main(){
+
+    int m , n ,Gcd;
+    //Test 1
+    m = 120 , n = 210;
+    Gcd = gcd(m,n);
+    printf("\nThe GCD and LCM of %d and %d are %d and %d.", m , n , Gcd , lcm(m,n,Gcd));
+    //Test 2
+    m = 12 , n = 66;
+    Gcd = gcd(m,n);
+    printf("\n\nThe GCD and LCM of %d and %d are %d and %d.\n\n", m , n , Gcd , lcm(m,n,Gcd));
+    return 0;
+}
+//End driver function

Competitive Coding/Math/GCD and LCM/GCDEuclidsExtendedAlgorithm.c

@@ -0,0 +1,41 @@
+//Program to calculate the GCD of two numbers by Extended Euclid's Algorithm and
+//to find the integers x and y in the equation mx + ny = gcd(m,n)
+//n is assumed to be following the following constariant: n >= m
+
+#include<stdio.h>
+
+//Function to caluclate the GCD of two numbers with euclid's extended Algorithm
+int gcdExtended(int m, int n, int *x, int *y){
+
+    //m and n are the integers
+    //x and y are the integers in the equation mx + ny = gcd(m,n)
+    //x1 and y1 are the intermediate x and y in the recursive calculate
+    int x1 , y1 , gcd;
+    if(m == 0){
+
+        *x = 0;
+        *y = 1;
+        return n;
+    }
+    gcd = gcdExtended(n%m,m,&x1,&y1);
+    *x = y1 - (n/m)*x1;
+    *y = x1;
+    return gcd;
+}
+
+//Driver Function
+int main(){
+
+    int m , n , gcd , x , y;
+    //Test 1
+    m = 74 , n = 120;
+    gcd = gcdExtended(m,n,&x,&y);
+    printf("\n The GCD is %d and x = %d , y = %d.", gcd , x , y);
+    //Test 2
+    m = 12 , n = 22;
+    gcd = gcdExtended(m,n,&x,&y);
+    printf("\n The GCD is %d and x = %d , y = %d.", gcd , x , y);
+
+    return 0;
+}
+//Driver function ends

Competitive Coding/Math/GCD and LCM/GCDSteinsAlgorithm.c

@@ -0,0 +1,63 @@
+//Program to calculate the GCD of two numbers by Stein's Algorithm and
+
+#include<stdio.h>
+#include<math.h>                        //For pow function
+
+
+int gcdSteins(int m ,int n, int *k){
+
+    //m and n are the integers.
+    //k counts the number of common '2' factors
+
+    //Base conditions
+    if(m == n)
+        return m;
+    if(m == 0)
+        return n;
+    if(n == 0)
+        return m;
+    //End of base conditions
+
+    //To check if m is even
+    if(~(m & 1) == 1){
+
+        //if n is even
+        if(~(n & 1) == 1){
+            *k = *k + 1;
+            return gcdSteins((m >> 1) , (n >> 1) , k);                   // m and n are divided by two. k is incremented
+        }
+
+        //if n is odd
+            return gcdSteins((m >> 1) , n , k);                                  // m is divided by 2
+    }
+
+    //m is odd and n is even case
+    if(~(n & 1) == 1)
+        return gcdSteins(m ,(n >> 1) ,k);                                      // n is divided by 2
+
+    //Both are odd case
+    if(m > n)
+        return gcdSteins(((m-n)>>1) , n , k);
+
+    return gcdSteins(((n-m)>>1) , m , k);
+}
+
+//Driver Function
+int main(){
+
+    int m , n ,Gcd , k;
+    //Test 1
+    m = 120 , n = 210 , k = 0;
+    Gcd = gcdSteins(m,n,&k);
+    Gcd *= pow(2,k);
+    printf("\nThe GCD of %d and %d is %d.", m , n , Gcd);
+
+    //Test 2
+    m = 2 , n = 6 , k = 0;
+    Gcd = gcdSteins(m,n,&k);
+    Gcd *= pow(2,k);
+    printf("\nThe GCD of %d and %d is %d.\n\n", m , n , Gcd);
+
+    return 0;
+}
+//End driver function

Competitive Coding/Math/GCD and LCM/README.md

@@ -0,0 +1,28 @@
+#CALCULATING GCD AND LCM USING THREE DIFFERENT APPROACHES
+##Using Euclid's Algorithm
+
+This algorithm works on the famous **Euclid's Algorithm** which states that 'GCD(m,n) = GCD(n%m , m)' and 'GCD(0,m) = m'.  
+It is coded in a recurisve manner.
+
+LCM calculation has one common formula, namely, 'LCM(m,n) = (m*n)/GCD(m,n)'.
+
+##Using Extended Euclid's Algorithm
+
+The Euclid's Extended Algorithm states that there exists two integers x and y such that 'mx + ny = GCD(m,n)'.  
+This algorithm finds the GCD of the integers along with above said integers.
+
+##Using Steins Algorithm
+
+Stein’s algorithm or binary GCD algorithm is an algorithm that computes the greatest common divisor of two non-negative integers. Stein’s algorithm replaces division with arithmetic shifts, comparisons, and subtraction.
+
+The algorithm:
+
+1. If both a and b are 0, gcd is zero gcd(0, 0) = 0.
+2. Gcd(a, 0) = a and gcd(0, b) = b because everything divides 0.
+3. If a and b are both even, gcd(a, b) = 2*gcd(a/2, b/2) because 2 is a common divisor. Multiplication with 2 can be done with bitwise shift operator.
+4. If a is even and b is odd, gcd(a, b) = gcd(a/2, b). Similarly, if a is odd and b is even, then gcd(a, b) = gcd(a, b/2). It is because 2 is not a common divisor.
+5. If both a and b are odd, then gcd(a, b) = gcd(|a-b|/2, b). Note that difference of two odd numbers is even
+6. Repeat steps 3–5 until a = b, or until a = 0. In either case, the GCD is power(2, k) * b, where power(2, k) is 2 raise to the power of k and k is the number of common factors of 2 found in step 2.
+
+
+

Competitive Coding/Math/Prime Factorisation and Divisors/Divisors.c

@@ -0,0 +1,34 @@
+//Program to find the divisors of an integer n in O(root n) time
+
+#include<stdio.h>
+#include<math.h>
+
+// Function to print the divisors of integer n
+void printDivisors(int n){
+
+    printf("\n\nThe divisors of %d are: ", n);
+    //Iterates from i=1 to root n and print divisors as i and n/i at one go
+    for (int i=1; i<=sqrt(n)+1; i++)
+    {
+        if (n%i==0)
+        {
+            // If divisors are equal, print only one
+            if (n/i == i)
+                printf("%d ", i);
+
+            else // Otherwise print both
+                printf("%d %d ", i, n/i);
+        }
+    }
+    printf("\n\n");
+}
+
+//Driver Function
+void main()
+{
+    printf("\n\n\tDIVISOR PROGRAM");
+    int n;
+    printf("\n\nEnter the integer: ");
+    scanf("%d" , &n);
+    printDivisors(n);
+}

Competitive Coding/Math/Prime Factorisation and Divisors/PrimeFactorization.c

@@ -0,0 +1,50 @@
+//Program to find the prime factorization of a number in O(n^1/2) time
+
+#include<stdio.h>
+#include<math.h>
+
+//Function to print prime factors of an integer n
+void primeFactorization(int n){
+
+    printf("\n\nThe prime factors of %d are: ", n);
+
+    //To print factor as 2 until the number is odd
+    while(n % 2 == 0){
+
+        printf("2 ");
+        n = n / 2;                                          //Dividing number by 2
+    }
+
+    //The number would be odd after exiting loop
+    //Factors will be checked from i = 3 to root n, increasing i by 2 every loop, as all even numbers are taken acre of
+    int i = 3 , sqrtN = sqrt(n);
+    while(i<=sqrtN){
+
+        //If i is a prime factor of n
+        while(n%i==0){
+
+            printf("%d ", i);
+            n = n / i;
+        }
+
+        i = i + 2;
+    }
+
+    //If n > 2 after these steps, this tells us that n is aprime numbers
+    if(n > 2){
+
+        printf("%d " , n);
+    }
+    printf("\n\n");
+}
+
+//Driver function
+void main(){
+
+    printf("\n\n\tPRIME FACTORIZATION");
+    printf("\n\nEnter number: ");
+    int n;
+    scanf("%d" , &n);
+    primeFactorization(n);
+}
+//Main ends

Competitive Coding/Math/Prime Factorisation and Divisors/README.md

@@ -0,0 +1,43 @@
+#PRIME FACOTRIZATION AND DIVISOR ALGORITHM
+##PRIME FACTORZATION
+
+Given a number n, write an efficient function to print all prime factors of n. For example, if the input number is 12, then output should be “2 2 3”. And if the input number is 315, then output should be “3 3 5 7”.
+
+###Algorithm
+
+1. While n is divisible by 2, print 2 and divide n by 2.
+2. After step 1, n must be odd. Now start a loop from i = 3 to square root of n. While i divides n, print i and divide n by i, increment i by 2 and continue.
+3. If n is a prime number and is greater than 2, then n will not become 1 by above two steps. So print n if it is greater than 2.
+
+###Working
+
+The steps 1 and 2 take care of composite numbers and step 3 takes care of prime numbers. To prove that the complete algorithm works, we need to prove that steps 1 and 2 actually take care of composite numbers. This is clear that step 1 takes care of even numbers. And after step 1, all remaining prime factor must be odd (difference of two prime factors must be at least 2), this explains why i is incremented by 2.
+Now the main part is, the loop runs till square root of n not till. To prove that this optimization works, let us consider the following property of composite numbers.
+
+Every composite number has at least one prime factor less than or equal to square root of itself.
+
+This property can be proved using counter statement. Let a and b be two factors of n such that a*b = n. If both are greater than √n, then a.b > √n, * √n, which contradicts the expression “a * b = n”.
+
+In step 2 of the above algorithm, we run a loop and do following in loop
+* Find the least prime factor i (must be less than √n,)
+* Remove all occurrences i from n by repeatedly dividing n by i.
+* Repeat steps a and b for divided n and i = i + 2. The steps a and b are repeated till n becomes either 1 or a prime number.
+
+###Time Complexity
+
+O(n^1/2), where n is the integer.
+
+
+##DIVISORS
+
+Given a natural number n, print all distinct divisors of it.
+
+###Algorithm
+
+1. Iterate from i = 1 to i = root(n) + 1.
+2. If i divides n, print i along with (n/i), thus reducing time.
+
+###Time Complexity
+
+O(n^1/2), where n is the integer.
+

Competitive Coding/Sorting/Heap Sort/Readme.md

@@ -1,3 +1,20 @@
+# Heap sort is a comparison based sorting technique based on Binary Heap data structure.
+# Heapsort is an in-place algorithm, but it is not a stable sort.
+# Heap Sort is one of the best sorting methods being in-place and with no quadratic worst-case scenarios.
+# In max-heaps, maximum element will always be at the root. Heap Sort uses this property of heap to sort the array.
+
+Heap sort algorithm is divided into two basic parts :
+(1) Creating a Heap of the unsorted list.
+(2) Then a sorted array is created by repeatedly removing the largest/smallest element from the heap, and inserting it into the array. 
+{3) The heap is reconstructed after each removal.
+
+Time Complexity: Time complexity of heapify is O(logn). 
+Time complexity of BUILD-MAX-HEAP(A) is O(n) 
+and we run max_heapify N−1 times in heap_sort function,
+therefore complexity of heap_sort function in each case (Best, worst and average) is O(nlogn)
+
+Space Complexity: O(1)
+
 ## Documentation for HeapSort
 * Heap sort is a comparison based sorting technique based on Binary Heap data structure.
 * Heapsort is an in-place algorithm, but it is not a stable sort.
@@ -21,3 +38,4 @@ Here, Time complexity of heapify is O(logn) and time complexity of BUILD-MAX-HEA
 * Space Complexity: O(1)
 
 <img align="center" src="https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif">
+