First commit - Added a few algorithms for interview practice

Author: anitaa

src/AlgoTest.java

@@ -0,0 +1,178 @@
+import java.util.*;
+
+public class AlgoTest {
+
+    public static void main(String[] args) {
+//        int[] arr = {-2, -3, -3, -1, -2, -1, -5, -3};
+
+//        //answer should be: 7
+//        System.out.println(findMaxSubArray(arr.length, arr));
+//
+//        System.out.println(isBalanced("{()}[]"));
+
+//        int[] arr2 = {1,2,3,4,5};
+//        findMinMaxSum(arr2);
+
+//        int[] arr3 = {4, 73, 67, 38, 33};
+//        System.out.println(Arrays.toString(gradingStudents(arr3)));
+
+//        System.out.println(calculateLCM(3, 2));
+//        System.out.println(kangaroo(21, 6, 47, 3));
+
+//        String s = "haveaniceday";
+//        double value = Math.sqrt(s.length());
+
+    }
+
+
+
+
+
+
+    /* Kandane's Algorithm */
+    public static int findMaxSubArray(int length, int[] arr) {
+
+        int max_so_far = 0;
+        int max_at_end = 0;
+
+        for(int i=0; i<length; i++) {
+            max_at_end = Math.max(0, max_at_end + arr[i]);
+            max_so_far = Math.max(max_so_far, max_at_end);
+        }
+        return max_so_far;
+    }
+
+
+    /* Check if an expression is balanced */
+    public static boolean isBalanced(String s) {
+        Stack<Character> stack = new Stack();
+
+        for(char c: s.toCharArray()) {
+            if(c == '[' || c =='{' || c == '(') {
+                stack.push(c);
+
+            } else if(c == ']' && (stack.isEmpty() || stack.pop() != '[')) {
+                return false;
+
+            } else if(c == '}' && (stack.isEmpty() || stack.pop() != '{')) {
+                return false;
+
+            } else if(c == ')' && (stack.isEmpty() || stack.pop() != '(')) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    public static void findMinMaxSum(int[] arr) {
+        long sum = 0;
+        long maxSum = 0;
+        long minSum = Long.MAX_VALUE;
+
+        for(int i=0; i<arr.length; i++) {
+            if(arr[i] < minSum) {
+                minSum = arr[i];
+            }
+            if(arr[i] > maxSum) {
+                maxSum = arr[i];
+            }
+            sum+= arr[i];
+        }
+        System.out.print((sum - maxSum) + " " + (sum - minSum));
+    }
+
+
+    //https://www.hackerrank.com/challenges/birthday-cake-candles
+    static int birthdayCakeCandles(int n, int[] arr) {
+        int max = Integer.MIN_VALUE;
+        int count = 0;
+        for(int i=0; i<n; i++) {
+            if(max < arr[i]) {
+                max = arr[i];
+                count = 1;
+            }
+            else if(max == arr[i]) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /* https://www.hackerrank.com/challenges/grading/problem */
+    static int[] gradingStudents(int[] grades) {
+        List<Integer> arr = new ArrayList();
+        for(int grade: grades) {
+            int nextHighestMultiple = (5 *(grade/5))+5;
+            int diff = nextHighestMultiple - grade;
+            int newValue = (diff >= 3) || (grade <  38) ? grade : nextHighestMultiple;
+            arr.add(newValue);
+        }
+        return toIntArray(arr);
+    }
+
+
+
+
+    private static int[] toIntArray(List<Integer> list) {
+        int[] ret = new int[list.size()];
+        int i = 0;
+        for (Integer e : list) {
+            ret[i++] = e.intValue();
+        }
+        return ret;
+    }
+
+
+
+    /* https://www.hackerrank.com/challenges/apple-and-orange/problem */
+    private static void countApplesAndOranges(int s, int t, int a, int b, int[] apples, int[] oranges) {
+        int appleCount=0, orangeCount = 0;
+        for(int apple: apples) {
+            int distance = a + apple;
+            if(distance >= s && distance <= t) {
+                appleCount++;
+            }
+        }
+
+        for(int orange: oranges) {
+            int distance = b + orange;
+            if(distance >= s && distance <= t) {
+                orangeCount++;
+            }
+        }
+        System.out.println(appleCount + "\n" + orangeCount);
+    }
+
+
+    private static int calculateGCM(int a, int b) {
+        int max = Math.max(a,b);
+        int min = Math.min(a,b);
+        while((max-min) != 0) {
+            int diff = max-min;
+            if(diff < min) {
+                min = diff;
+            } else  {
+                max = diff;
+            }
+        }
+        return max;
+    }
+
+    private static int calculateLCM(int a, int b) {
+        //lcm(a, b) = a × b / gcd(a, b).
+        int gcm = calculateGCM(a,b);
+        int lcm = (a*b)/gcm;
+        return lcm;
+    }
+
+    /* https://www.hackerrank.com/challenges/kangaroo/problem */
+    static String kangaroo(int x1, int v1, int x2, int v2) {
+        String result = "YES";
+        double possibleMeetingValue = (double) (x2-x1)/(v1-v2);
+        if( possibleMeetingValue<=0 || (possibleMeetingValue % 1 != 0 ) )
+            result = "NO";
+
+        return result;
+    }
+}

src/arrays/FindMaximumSellProfit.java

@@ -0,0 +1,94 @@
+package arrays;
+
+
+import com.sun.tools.javac.util.Pair;
+
+public class FindMaximumSellProfit {
+
+    /*
+     * Given an array representing prices of the stock on different days,
+     * find the maximum profit that can be earned by performing maximum of one transaction.
+     * A transaction consists of activity of buying and selling the stock on different or same days.
+     *
+     * Eg: 1 - {100, 80, 120, 130, 70, 60, 100, 125}
+     * the price of the stock on day-1 is 100, on day-2 is 80 and so on.
+     * The maximum profit that could be earned in this window is 65 (buy at 60 and sell at 125).
+     *
+     * Eg: 2 - For price array - {100, 80, 70, 65, 60, 55, 50}, maximum profit that could be earned is 0.
+     *
+     * */
+
+
+    public static int findMaximumProfit(int[] stockPrices) {
+        int minimumPrice = Integer.MAX_VALUE;
+        int maxProfit = 0;
+
+        /*
+         * The profit is the maximum value of the maximumProfit so far and
+         * the difference between the current element(selling price) and the minimum buying price - i.e. profit for that buy
+         * Profit = current selling price - the minimum buying price
+         *
+         * Minimum buying price is the minimum value between the current element and the minimum price
+         * */
+        for(int i=0; i<stockPrices.length; i++) {
+            maxProfit = Math.max(maxProfit, stockPrices[i]-minimumPrice);
+            minimumPrice = Math.min(minimumPrice, stockPrices[i]);
+        }
+
+        return maxProfit;
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    public static Pair<Integer, Integer> findMaximumSellProfit(int length, int[] arr) {
+        int currentBuy = arr[0];
+        int globalSell = arr[1];
+        int globalProfit = globalSell - currentBuy;
+
+        int currentProfit;
+
+        for(int i=1; i< length; i++) {
+            int currentSell = arr[i];
+            currentProfit = currentSell - currentBuy;
+
+            if(currentProfit > globalProfit) {
+                globalProfit = currentProfit;
+                globalSell = arr[i];
+            }
+
+            if(currentBuy > arr[i]) {
+                currentBuy = arr[i];
+            }
+        }
+
+        int optimalBuyPrice = globalSell-globalProfit;
+        int optimalSellPrice = globalSell;
+        return Pair.of(optimalBuyPrice, optimalSellPrice) ;
+    }
+
+
+
+
+
+    public static void main(String[] args) {
+        int[] arr = {100, 80, 120, 130, 70, 60, 100, 125};
+        System.out.println(findMaximumSellProfit(arr.length, arr));
+        System.out.println(findMaximumProfit(arr));
+    }
+}

src/arrays/LowHighIndex.java

@@ -0,0 +1,47 @@
+package arrays;
+
+public class LowHighIndex {
+
+
+    /*
+     * Given a sorted array of integers, return the low and high index of the given key.
+     * Return -1 if not found. The array length can be in millions with lots of duplicates.
+     * */
+
+
+    /*
+     * Linear search might be inefficient if the arr length exceeds a millions elements
+     * so we can use a modified version of binary search
+     * */
+
+    /*
+     * Since we are using binary search the runtime complexity is Logarithmic, O(logn).
+     * Memory Complexity = O(1)
+     * */
+    public static void findLowestHighestIndex(int[] arr, int key) {
+        int lowestIndex = arr.length-1;
+        int highestIndex = 0;
+
+        for(int i=0; i<arr.length; i++) {
+            if(arr[i] == key) {
+                if(i < lowestIndex) {
+                    lowestIndex = i;
+
+                }
+                if(i > highestIndex) {
+                    highestIndex = i;
+                }
+            }
+        }
+        System.out.println(lowestIndex + " " + highestIndex);
+    }
+
+    
+
+
+    public static void main(String[] args) {
+        int[] arr = {1, 2, 5, 5, 5, 5, 5, 5, 5, 5, 20};
+        findLowestHighestIndex(arr, 5);
+    }
+
+}