Merge pull request #1 from TheAlgorithms/master

Merge

Author: joaomagfreitas

Conversions/AnyBaseToAnyBase.java

@@ -0,0 +1,130 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+/**
+ * Class for converting from "any" base to "any" other base, when "any" means from 2-36.
+ * Works by going from base 1 to decimal to base 2. Includes auxiliary method for 
+ * determining whether a number is valid for a given base.
+ * 
+ * @author Michael Rolland
+ * @version 2017.10.10
+ *
+ */
+public class AnyBaseToAnyBase {
+	
+	// Smallest and largest base you want to accept as valid input
+	static final int MINIMUM_BASE = 2;
+	static final int MAXIMUM_BASE = 36;
+	
+	// Driver
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		String n;
+		int b1=0,b2=0;
+		while (true) {
+			try {
+				System.out.print("Enter number: ");
+				n = in.next();
+				System.out.print("Enter beginning base (between "+MINIMUM_BASE+" and "+MAXIMUM_BASE+"): ");
+				b1 = in.nextInt();
+				if (b1 > MAXIMUM_BASE || b1 < MINIMUM_BASE) {
+					System.out.println("Invalid base!");
+					continue;
+				}
+				if (!validForBase(n, b1)) {
+					System.out.println("The number is invalid for this base!");
+					continue;
+				}
+				System.out.print("Enter end base (between "+MINIMUM_BASE+" and "+MAXIMUM_BASE+"): ");
+				b2 = in.nextInt();
+				if (b2 > MAXIMUM_BASE || b2 < MINIMUM_BASE) {
+					System.out.println("Invalid base!");
+					continue;
+				}
+				break;
+			} catch (InputMismatchException e) {
+				System.out.println("Invalid input.");
+				in.next();
+			}
+		}
+		System.out.println(base2base(n, b1, b2));
+	}
+	
+	/**
+	 * Checks if a number (as a String) is valid for a given base.
+	 */
+	public static boolean validForBase(String n, int base) {
+		char[] validDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
+				'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+				'W', 'X', 'Y', 'Z'};
+		// digitsForBase contains all the valid digits for the base given
+		char[] digitsForBase = Arrays.copyOfRange(validDigits, 0, base);
+		
+		// Convert character array into set for convenience of contains() method
+		HashSet<Character> digitsList = new HashSet();
+		for (int i=0; i<digitsForBase.length; i++)
+			digitsList.add(digitsForBase[i]);
+		
+		// Check that every digit in n is within the list of valid digits for that base.
+		for (char c : n.toCharArray()) 
+			if (!digitsList.contains(c))
+				return false;
+		
+		return true;
+	}
+	
+	/**
+	 * 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/EggDropping.java

@@ -0,0 +1,53 @@
+//Dynamic Programming solution for the Egg Dropping Puzzle
+public class EggDropping
+{
+	
+	// min trials with n eggs and m floors 
+	
+	private static int minTrials(int n, int m)
+	{
+	    
+		int eggFloor[][] = new int[n+1][m+1];
+		int result, x;
+		
+		for (int i = 1; i <= n; i++)
+		{
+		    eggFloor[i][0] = 0;   // Zero trial for zero floor.
+		    eggFloor[i][1] = 1;   // One trial for one floor 
+		}
+		
+	        // j trials for only 1 egg
+		
+                for (int j = 1; j <= m; j++)
+			 eggFloor[1][j] = j;
+		
+		// Using bottom-up approach in DP
+		
+   		 for (int i = 2; i <= n; i++)
+		  {
+			for (int j = 2; j <= m; j++)
+			{
+				eggFloor[i][j] = Integer.MAX_VALUE;
+				for (x = 1; x <= j; x++)
+				{
+					result = 1 + Math.max(eggFloor[i-1][x-1], eggFloor[i][j-x]);
+          
+					//choose min of all values for particular x
+        				 if (result < eggFloor[i][j])
+					     eggFloor[i][j] = result;
+				}
+			}
+		}
+		  
+		return eggFloor[n][m];
+	}
+		
+	//testing program
+	public static void main(String args[])
+	{
+	      int n = 2, m = 4;
+              //result outputs min no. of trials in worst case for n eggs and m floors
+              int result = minTrials(n, m);
+	      System.out.println(result); 
+	}
+}

Dynamic Programming/Fibonacci.java

@@ -11,7 +11,7 @@
 
 public class Fibonacci {
 
-    public static Map<Integer,Integer> map = new HashMap<Integer,Integer>();
+    private static Map<Integer,Integer> map = new HashMap<Integer,Integer>();
 
     public static void main(String[] args) throws Exception {
 
@@ -29,7 +29,7 @@ public static void main(String[] args) throws Exception {
      * Outputs the nth fibonacci number
      **/
 
-    public static int fibMemo(int n) {
+    private static int fibMemo(int n) {
         if (map.containsKey(n)) {
             return map.get(n);
         }
@@ -54,7 +54,7 @@ public static int fibMemo(int n) {
      * Outputs the nth fibonacci number
      **/
 
-    public static int fibBotUp(int n) {
+    private static int fibBotUp(int n) {
 
         Map<Integer,Integer> fib = new HashMap<Integer,Integer>();
 

Dynamic Programming/Levenshtein_distance.java

@@ -7,7 +7,7 @@
  */
 
 public class Levenshtein_distance{
-	private int minimum(int a, int b, int c){
+	private static int minimum(int a, int b, int c){
 		if(a < b && a < c){
 			return a;
 		}else if(b < a && b < c){
@@ -16,9 +16,9 @@ private int minimum(int a, int b, int c){
 			return c;
 		}
 	}
-	public int calculate_distance(String a, String b){
-		len_a = a.length() + 1;
-		len_b = b.length() + 1;
+	private static int calculate_distance(String a, String b){
+		int len_a = a.length() + 1;
+		int len_b = b.length() + 1;
 		int [][] distance_mat = new int[len_a][len_b];
 		for(int i = 0; i < len_a; i++){
 			distance_mat[i][0] = i;

Dynamic Programming/LongestCommonSubsequence.java

@@ -0,0 +1,66 @@
+class LongestCommonSubsequence {
+
+	public static String getLCS(String str1, String str2) {
+
+		//At least one string is null
+		if(str1 == null || str2 == null)
+			return null;
+
+		//At least one string is empty
+		if(str1.length() == 0 || str2.length() == 0)
+			return "";
+
+		String[] arr1 = str1.split("");
+		String[] arr2 = str2.split("");
+
+		//lcsMatrix[i][j]  = LCS of first i elements of arr1 and first j characters of arr2
+		int[][] lcsMatrix = new int[arr1.length + 1][arr2.length + 1];
+
+		for(int i = 0; i < arr1.length + 1; i++)
+			lcsMatrix[i][0] = 0;
+		for(int j = 1; j < arr2.length + 1; j++)
+			lcsMatrix[0][j] = 0;
+		for(int i = 1; i < arr1.length + 1; i++) {
+			for(int j = 1; j < arr2.length + 1; j++) {
+				if(arr1[i-1].equals(arr2[j-1])) {
+					lcsMatrix[i][j] = lcsMatrix[i-1][j-1] + 1;
+				} else {
+					lcsMatrix[i][j] = lcsMatrix[i-1][j] > lcsMatrix[i][j-1] ? lcsMatrix[i-1][j] : lcsMatrix[i][j-1];
+				}
+			}
+		}
+		return lcsString(str1, str2, lcsMatrix);
+	}
+
+	public static String lcsString (String str1, String str2, int[][] lcsMatrix) {
+		StringBuilder lcs = new StringBuilder();
+		int i = str1.length(),
+			j = str2.length();
+		while(i > 0  && j > 0) {
+			if(str1.charAt(i-1) == str2.charAt(j-1)) {
+				lcs.append(str1.charAt(i-1));
+				i--;
+				j--;
+			} else if(lcsMatrix[i-1][j] > lcsMatrix[i][j-1]) {
+				i--;
+			} else {
+				j--;
+			}
+		}
+		return lcs.reverse().toString();
+	}
+
+	public static void main(String[] args) {
+		String str1 = "DSGSHSRGSRHTRD";
+		String str2 = "DATRGAGTSHS";
+		String lcs = getLCS(str1, str2);
+		
+		//Print LCS
+		if(lcs != null) {
+			System.out.println("String 1: " + str1);
+			System.out.println("String 2: " + str2);
+			System.out.println("LCS: " + lcs);
+			System.out.println("LCS length: " + lcs.length());
+		}
+	}
+}

Dynamic Programming/LongestIncreasingSubsequence.java

@@ -31,7 +31,7 @@ private static int upperBound(int[] ar, int l, int r, int key) {
         return r;
     }
 
-    public static int LIS(int[] array) {
+    private static int LIS(int[] array) {
         int N = array.length;
         if (N == 0)
             return 0;

Dynamic Programming/rod_cutting.java

@@ -2,8 +2,7 @@
     Returns the best obtainable price for a rod of
 	length n and price[] as prices of different pieces */
 
-public class RodCutting
-{
+public class RodCutting {
 
 	private static int cutRod(int price[],int n)
 	{

Misc/Abecedarian.java renamed to Others/Abecedarian.java

@@ -12,6 +12,6 @@ public static boolean isAbecedarian(String s){
 
             else{return false;}
             }
-        }
         return true;
+        }
 }

Others/Armstrong.java

@@ -0,0 +1,47 @@
+import java.util.Scanner;
+
+/**
+ * A utility to check if a given number is armstrong or not. Armstrong number is
+ * a number that is equal to the sum of cubes of its digits for example 0, 1,
+ * 153, 370, 371, 407 etc. For example 153 = 1^3 + 5^3 +3^3
+ * 
+ * @author mani manasa mylavarapu
+ * 
+ */
+public class Armstrong {
+	public static void main(String[] args) {
+		Scanner scan = new Scanner(System.in);
+		System.out.println("please enter the number");
+		int n = scan.nextInt();
+		boolean isArmstrong = checkIfANumberIsAmstrongOrNot(n);
+		if (isArmstrong) {
+			System.out.println("the number is armstrong");
+		} else {
+			System.out.println("the number is not armstrong");
+		}
+	}
+
+	/**
+	 * Checks whether a given number is an armstrong number or not. Armstrong
+	 * number is a number that is equal to the sum of cubes of its digits for
+	 * example 0, 1, 153, 370, 371, 407 etc.
+	 * 
+	 * @param number
+	 * @return boolean
+	 */
+	public static boolean checkIfANumberIsAmstrongOrNot(int number) {
+		int remainder, sum = 0, temp = 0;
+		temp = number;
+		while (number > 0) {
+			remainder = number % 10;
+			sum = sum + (remainder * remainder * remainder);
+			number = number / 10;
+		}
+		if (sum == temp) {
+			return true;
+		} else {
+			return false;
+		}
+
+	}
+}

Misc/CountChar.java renamed to Others/CountChar.java

@@ -4,6 +4,11 @@
 */
 
 
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.Stack;
+
 public class Solution {
 
 public static void main(String[] args) throws IOException {
@@ -30,7 +35,7 @@ public static void main(String[] args) throws IOException {
 
 	//Implementing Dijkshtra's Algorithm 
 
-         Stack <Integer> t=new Stack<Integer>();
+         Stack<Integer> t=new Stack<Integer>();
           int src=in.nextInt();
         for(int i=1;i<=n;i++){
         	if(i!=src){t.push(i);}}