Merge branch 'master' into level-order

Author: mpokryva

Conversions/AnyBaseToAnyBase.java

@@ -0,0 +1,87 @@
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+/**
+ * Class for converting from any base to any other base, though it's unclear how digits greater than
+ * 36 would be represented in bases >36.
+ * 
+ * @author Michael Rolland
+ * @version 2017.09.29
+ *
+ */
+public class AnyBaseToAnyBase {
+	
+	// Driver
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		System.out.print("Enter number: ");
+		String n = in.nextLine();
+		int b1=0,b2=0;
+		while (true) {
+			try {
+				System.out.print("Enter beginning base: ");
+				b1 = in.nextInt();
+				System.out.print("Enter end base: ");
+				b2 = in.nextInt();
+				break;
+			} catch (InputMismatchException e) {
+				System.out.println("Invalid input.");
+				in.next();
+			}
+		}
+		System.out.println(base2base(n, b1, b2));
+	}
+	
+	/**
+	 * Method to convert any integer from base b1 to base b2. Works by converting from b1 to decimal,
+	 * then decimal to b2.
+	 * @param n The integer to be converted.
+	 * @param b1 Beginning base.
+	 * @param b2 End base.
+	 * @return n in base b2.
+	 */
+	public static String base2base(String n, int b1, int b2) {
+		// Declare variables: decimal value of n, 
+		// character of base b1, character of base b2,
+		// and the string that will be returned.
+		int decimalValue = 0, charB2;
+		char charB1;
+		String output="";
+		// Go through every character of n
+		for (int i=0; i<n.length(); i++) {
+			// store the character in charB1
+			charB1 = n.charAt(i);
+			// if it is a non-number, convert it to a decimal value >9 and store it in charB2
+			if (charB1 >= 'A' && charB1 <= 'Z') 
+				charB2 = 10 + (charB1 - 'A');
+			// Else, store the integer value in charB2
+			else 
+				charB2 = charB1 - '0';
+			// Convert the digit to decimal and add it to the
+			// decimalValue of n
+			decimalValue = decimalValue * b1 + charB2;
+		}
+		
+		// Converting the decimal value to base b2:
+		// A number is converted from decimal to another base
+		// by continuously dividing by the base and recording 
+		// the remainder until the quotient is zero. The number in the
+		// new base is the remainders, with the last remainder
+		// being the left-most digit.
+		
+		// While the quotient is NOT zero:
+		while (decimalValue != 0) {
+			// If the remainder is a digit < 10, simply add it to
+			// the left side of the new number.
+			if (decimalValue % b2 < 10) 
+				output = Integer.toString(decimalValue % b2) + output;
+			// If the remainder is >= 10, add a character with the
+			// corresponding value to the new number. (A = 10, B = 11, C = 12, ...)
+			else
+				output = (char)((decimalValue % b2)+55) + output;
+			// Divide by the new base again
+			decimalValue /= b2;
+		}
+		return output;
+	}
+}

Dynamic Programming/Fibonacci.java

@@ -40,7 +40,7 @@ public static int fibMemo(int n) {
             f = 1;
         }
         else {
-            f = fib(n-1) + fib(n-2);
+            f = fibMemo(n-1) + fibMemo(n-2);
             map.put(n,f);
         }
 

Dynamic Programming/Knapsack.java

@@ -0,0 +1,38 @@
+// A Dynamic Programming based solution for 0-1 Knapsack problem
+
+public class Knapsack
+{
+    
+	private static int knapSack(int W, int wt[], int val[], int n)
+	{
+		int i, w;
+	int rv[][] = new int[n+1][W+1];    //rv means return value
+	
+	// Build table rv[][] in bottom up manner
+	for (i = 0; i <= n; i++)
+	{
+		for (w = 0; w <= W; w++)
+		{
+			if (i==0 || w==0)
+				rv[i][w] = 0;
+			else if (wt[i-1] <= w)
+				rv[i][w] = Math.max(val[i-1] + rv[i-1][w-wt[i-1]], rv[i-1][w]);
+			else
+				rv[i][w] = rv[i-1][w];
+		}
+	}
+	
+	return rv[n][W];
+	}
+
+
+	// Driver program to test above function
+	public static void main(String args[])
+	{
+		int val[] = new int[]{50, 100, 130};
+	int wt[] = new int[]{10, 20, 40};
+	int W = 50;
+	int n = val.length;
+	System.out.println(knapSack(W, wt, val, n));
+	}
+}

Dynamic Programming/LongestIncreasingSubsequence.java

@@ -0,0 +1,62 @@
+import java.util.Scanner;
+
+/**
+ *
+ * @author Afrizal Fikri (https://github.com/icalF)
+ *
+ */
+public class LongestIncreasingSubsequence {
+    public static void main(String[] args) throws Exception {
+
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+
+        int ar[] = new int[n];
+        for (int i = 0; i < n; i++) {
+            ar[i] = sc.nextInt();
+        }
+
+        System.out.println(LIS(ar));
+    }
+
+    private static int upperBound(int[] ar, int l, int r, int key) {
+        while (l < r-1) {
+            int m = (l + r) / 2;
+            if (ar[m] >= key)
+                r = m;
+            else
+                l = m;
+        }
+
+        return r;
+    }
+
+    public static int LIS(int[] array) {
+        int N = array.length;
+        if (N == 0)
+            return 0;
+ 
+        int[] tail = new int[N];
+        int length = 1; // always points empty slot in tail
+     
+        tail[0] = array[0];
+        for (int i = 1; i < N; i++) {
+
+            // new smallest value
+            if (array[i] < tail[0])
+                tail[0] = array[i];
+
+            // array[i] extends largest subsequence
+            else if (array[i] > tail[length-1])
+                tail[length++] = array[i];
+
+            // array[i] will become end candidate of an existing subsequence or
+            // Throw away larger elements in all LIS, to make room for upcoming grater elements than array[i]
+            // (and also, array[i] would have already appeared in one of LIS, identify the location and replace it)
+            else
+                tail[upperBound(tail, -1, length-1, array[i])] = array[i];
+        }
+     
+        return length;
+    }
+}

Dynamic Programming/rod_cutting.java

@@ -0,0 +1,33 @@
+/*  A Dynamic Programming solution for Rod cutting problem
+    Returns the best obtainable price for a rod of
+	length n and price[] as prices of different pieces */
+
+public class RodCutting
+{
+	
+	private static int cutRod(int price[],int n)
+	{
+		int val[] = new int[n+1];
+		val[0] = 0;
+
+		for (int i = 1; i<=n; i++)
+		{
+			int max_val = Integer.MIN_VALUE;
+			for (int j = 0; j < i; j++)
+				max_val = Math.max(max_val,price[j] + val[i-j-1]);
+		  
+       val[i] = max_val;
+		}
+
+		return val[n];
+	}
+
+	//main function to test
+	public static void main(String args[])
+	{
+		int arr[] = new int[] {2, 5, 13, 19, 20};
+		int size = arr.length;
+		System.out.println("Maximum Obtainable Value is " +
+							cutRod(arr, size));
+	}
+}

Misc/Abecedarian.java

@@ -0,0 +1,17 @@
+//Oskar Enmalm 29/9/17
+//An Abecadrian is a word where each letter is in alphabetical order
+    
+class Abecedarian{
+
+    public static boolean isAbecedarian(String s){
+        int index = s.length() - 1;
+
+        for(int i =0; i <index; i++){
+
+            if(s.charAt(i)<=s.charAt(i + 1)){} //Need to check if each letter for the whole word is less than the one before it
+
+            else{return false;}
+            }
+        }
+        return true;
+}

Misc/FibToN.java

@@ -0,0 +1,24 @@
+import java.util.Scanner;
+
+public class FibToN {
+
+	public static void main(String[] args) {
+		//take input
+		Scanner scn = new Scanner(System.in);
+		int N = scn.nextInt();
+		// print fibonacci sequence less than N
+		int first = 0, second = 1;
+		//first fibo and second fibonacci are 0 and 1 respectively
+		
+		while(first <= N){
+			//print first fibo 0 then add second fibo into it while updating second as well
+			
+			System.out.println(first);
+			
+			int next = first+ second;
+			first = second;
+			second = next;
+		}
+	}
+
+}

Misc/GCD.java

@@ -0,0 +1,15 @@
+//Oskar Enmalm 3/10/17
+//This is Euclid's algorithm which is used to find the greatest common denominator
+
+public class GCD{
+
+public static int gcd(int a, int b) {
+
+        int r = a % b;
+        while (r != 0) {
+            b = r;
+            r = b % r;
+        }
+        return b;
+    }
+}

Misc/KMP.java

@@ -0,0 +1,55 @@
+
+/*
+Implementation of Knuth–Morris–Pratt algorithm
+Usage: 
+final String T = "AAAAABAAABA";
+final String P = "AAAA";
+KMPmatcher(T, P);
+*/
+public class KMP {
+
+    // find the starting index in string T[] that matches the search word P[]
+    public void KMPmatcher(final String T, final String P) {
+        final int m = T.length();
+        final int n = P.length();
+        final int[] pi = computePrefixFunction(P);
+        int q = 0;
+        for (int i = 0; i < m; i++) {
+            while (q > 0 && T.charAt(i) != P.charAt(q)) {
+                q = pi[q - 1]; 
+            }
+
+            if (T.charAt(i) == P.charAt(q)) {
+                q++;
+            }
+
+            if (q == n) {
+                System.out.println("Pattern starts: " + (i + 1 - n));
+                q = pi[q - 1];  
+            }
+        }
+
+    }
+
+    // return the prefix function 
+    private int[] computePrefixFunction(final String P) {
+        final int n = P.length();
+        final int[] pi = new int[n];
+        pi[0] = 0;
+        int q = 0;
+        for (int i = 1; i < n; i++) {
+            while (q > 0 && P.charAt(q) != P.charAt(i)) {
+                q = pi[q - 1];
+            }
+
+            if (P.charAt(q) == P.charAt(i)) {
+                q++;
+            }
+
+            pi[i] = q;
+
+        }
+
+        return pi;
+    }
+}