Some refactorings

Author: rampatra

src/main/java/com/hackerrank/algorithms/strings/MakingAnagrams.java

@@ -18,7 +18,7 @@ public class MakingAnagrams {
      * @return
      */
     public static int makeAnagrams(String a, String b) {
-        
+
         int i = 0, j = 0, c = 0;
         char[] s1 = a.toCharArray();
         char[] s2 = b.toCharArray();

src/main/java/com/hackerrank/interviewpreparation/arrays/DS2DArrayProblem.java

@@ -16,10 +16,10 @@ public class DS2DArrayProblem {
     private static int hourglassSum(int[][] arr) {
         int maxSum = Integer.MIN_VALUE;
         int hourglassSum;
-        for (int i=0;i<arr.length-2;i++) {
-            for(int j=0;j<arr[0].length-2;j++) {
-                hourglassSum = arr[i][j] + arr[i][j+1] + arr[i][j+2] + arr[i+1][j+1] +
-                        arr[i+2][j] + arr[i+2][j+1] + arr[i+2][j+2];
+        for (int i = 0; i < arr.length - 2; i++) {
+            for (int j = 0; j < arr[0].length - 2; j++) {
+                hourglassSum = arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i + 1][j + 1] +
+                        arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2];
                 if (hourglassSum > maxSum) {
                     maxSum = hourglassSum;
                 }

src/main/java/com/hackerrank/projecteuler/MultiplesOf3and5.java

@@ -13,8 +13,8 @@ public class MultiplesOf3and5 {
 
     public static void main(String a[]) {
         Scanner in = new Scanner(System.in);
-        
+
         int t = Integer.parseInt(in.nextLine());
-        
+
     }
 }

src/main/java/com/rampatra/arrays/CelebrityProblem.java

@@ -13,7 +13,7 @@
  * In a party of N people, only one person is known to everyone. Such a person may be present in the party, if yes,
  * (s)he doesn’t know anyone in the party. We can only ask questions like “does A know B? “. Find the stranger
  * (celebrity) in minimum number of questions.
- * 
+ * <p>
  * TODO: Not tested.
  */
 public class CelebrityProblem {
@@ -44,7 +44,7 @@ public static boolean haveAcquaintance(int[][] peoples, int a, int b) {
      * - Push the remained person onto stack.
      * - Repeat step 2 and 3 until only one person remains in the stack.
      * - Check the remained person in stack does not have acquaintance with anyone else.
-     * 
+     *
      * @param peoples
      * @return
      */

src/main/java/com/rampatra/arrays/EqualProbabilityRandomNoGenerator.java

@@ -6,7 +6,7 @@
 /**
  * Given a random number generator f(n) which generates a random number
  * from {@code 0} (inclusive) to {@code n} (exclusive), design a method
- * which uses f(n) to generate non repeating random numbers from 
+ * which uses f(n) to generate non repeating random numbers from
  * {@code 0} (inclusive) to {@code n} (exclusive)?
  *
  * @author: ramswaroop
@@ -19,9 +19,9 @@ public class EqualProbabilityRandomNoGenerator {
     static int size;
 
     /**
-     * The algorithm is to create a bucket of numbers and then to keep on 
+     * The algorithm is to create a bucket of numbers and then to keep on
      * removing the elements from the bucket which are returned.
-     * 
+     *
      * @return
      */
     public static int getRandom() {
@@ -37,12 +37,12 @@ public static int f(int n) {
 
     public static void main(String a[]) {
         Scanner in = new Scanner(System.in);
-        
+
         System.out.println("How many random numbers you would like to generate?");
         size = in.nextInt();
-        
+
         bucket = new int[size];
-        
+
         for (int i = 0; i < bucket.length; i++) {
             bucket[i] = i;
         }

src/main/java/com/rampatra/arrays/IntersectionAndUnionOf2SortedArrays.java

@@ -12,9 +12,9 @@
 public class IntersectionAndUnionOf2SortedArrays {
 
     /**
-     * Returns a 2-D array consisting of intersection and union of 
+     * Returns a 2-D array consisting of intersection and union of
      * two sorted arrays {@param a} and {@param b} respectively.
-     * 
+     *
      * @param a
      * @param b
      * @return
@@ -24,7 +24,7 @@ public static int[][] getIntersectionAndUnionOf2SortedArrays(int[] a, int[] b) {
         int[] intersection = new int[length], union = new int[length];
 
         for (int i = 0, j = 0; i < a.length || j < b.length; ) {
-            
+
             // if either of the arrays runs out first
             if (i == a.length) {
                 union[y++] = b[j++];

src/main/java/com/rampatra/arrays/InversionsInArray.java

@@ -40,7 +40,7 @@ public static int getInversionCountNaiveApproach(int[] a) {
 
     /**
      * Optimized approach.
-     *
+     * <p>
      * Explanation: In merge() if a[i] > b[j] then all elements in array a starting
      * from i are greater than b[j] which equals to the number of inversions for
      * the two sub-arrays.

src/main/java/com/rampatra/arrays/KLargestElements.java

@@ -15,17 +15,17 @@ public class KLargestElements {
 
     /**
      * Finds {@param k} largest elements in array {@param a}.
-     *
+     * <p>
      * Algorithm:
      * 1) Build a Min Heap MH of the first k elements (arr[0] to arr[k-1]) of the given array. This takes O(k) time.
-     *
+     * <p>
      * 2) For each element, after the kth element (arr[k] to arr[n-1]), compare it with root of MH.
      * ……a) If the element is greater than the root then make it root and call buildHeap for MH
      * ……b) Else ignore it.
      * This step takes (n-k) * O(k) time.
-     *
+     * <p>
      * 3) Finally, MH has k largest elements and root of the MH is the kth largest element.
-     *
+     * <p>
      * Therefore, the total time complexity of the above algorithm is: O(k) + (n-k) * O(k).
      *
      * @param a

src/main/java/com/rampatra/arrays/KthLargestElement.java

@@ -44,7 +44,7 @@ public static int getKthLargestElement(int[] a, int k) {
         maxHeap.buildMaxHeap();
         while (true) {
             if (k == 1) break;
-            
+
             maxHeap.extractMax();
             k--;
         }

src/main/java/com/rampatra/arrays/LargestProductContiguousSubArray.java

@@ -10,7 +10,6 @@
 public class LargestProductContiguousSubArray {
 
     /**
-     *
      * @param a
      * @return
      */

src/main/java/com/rampatra/arrays/MaxInAllSubArrays.java

@@ -46,10 +46,10 @@ public static int[] maxInAllSubArraysOfSizeKNaive(int[] a, int k) {
     /**
      * Finds the maximum element in each and every sub-array
      * in {@param a} of size {@param k}.
-     * 
+     * <p>
      * Time complexity: O(n)
      * Auxiliary Space: O(k)
-     * 
+     *
      * @param a
      * @param k
      * @return

src/main/java/com/rampatra/arrays/MaximumSumNonAdjacentSubSequence.java

@@ -17,7 +17,7 @@ public class MaximumSumNonAdjacentSubSequence {
      * Example:
      * 1) 3 2 7 10 should return 13 (sum of 3 and 10)
      * 2) 3 2 5 10 7 should return 15 (sum of 3, 5 and 7).
-     *
+     * <p>
      * Here we maintain 2 variables incl and excl which is max sum till now (satisfying the constraint)
      * including the current element and excluding the current element respectively.
      *
@@ -26,7 +26,7 @@ public class MaximumSumNonAdjacentSubSequence {
      */
     public static int maximumSumNonAdjacentSubSequence(int[] a) {
         int incl = a[0], excl = 0, prevIncl = incl; // incl is max sum including the current element
-                                                    // and excl is max sum excluding the current element
+        // and excl is max sum excluding the current element
         for (int i = 1; i < a.length; i++) {
             incl = excl + a[i]; // because we have to exclude the previous element if we consider the current element
             excl = Math.max(prevIncl, excl); // we are excluding the current element so we can consider the previous element or dont

src/main/java/com/rampatra/arrays/NextLargerNumber.java

@@ -44,7 +44,7 @@ public static int findNextLargerNumber(Integer n) {
 
         // digits are already in descending order, so return
         if (i <= 0) return -1;
-        
+
         // find index of smallest no. greater than a[i-1] 
         minIndex = i;
         int j = len - 1;

src/main/java/com/rampatra/arrays/NumberOccurringOddTimes.java

@@ -14,7 +14,7 @@
  * Given an array of positive integers. All numbers occur
  * even number of times except one number which occurs odd
  * number of times. Find the number in O(n) time & constant space.
- * 
+ * <p>
  * See {@link TwoNonRepeatingElements} for a more
  * complex problem which is solved in a similar approach.
  */

src/main/java/com/rampatra/arrays/ReservoirSampling.java

@@ -22,10 +22,10 @@ public class ReservoirSampling {
      * a) Generate a random number from 0 to i where i is index of current item in
      * stream[]. Let the generated random number is j.
      * b) If j is in range 0 to k-1, replace reservoir[j] with arr[i].
-     *
+     * <p>
      * In the above procedure, we are computing random number for each of the indexes greater than k
      * thereby giving all items an equal probability.
-     *
+     * <p>
      * NOTE: When {@param k} is small enough we can use a simpler method as follows:
      * Create an array reservoir[] of maximum size k. One by one randomly select an
      * item from stream[0..n-1]. If the selected item is not previously selected, then

src/main/java/com/rampatra/arrays/Segregate0s1sAnd2s.java

@@ -12,15 +12,15 @@
 public class Segregate0s1sAnd2s {
 
     /**
-     * Segregates an array {@param a} consisting of only 0s, 1s and 2s. Based on 
+     * Segregates an array {@param a} consisting of only 0s, 1s and 2s. Based on
      * Dutch National Flag (DNF) problem {@see: http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/}.
-     * 
+     *
      * @param a
      */
     public static void segregate0s1sAnd2s(int[] a) {
         // assume low points to 0 and mid to 1 and high to 2
         int low = 0, mid = 0, high = a.length - 1;
-        
+
         while (mid <= high) {
             switch (a[mid]) {
                 case 0: // mid points to 0 but it should point to 1 so swap it with low

src/main/java/com/rampatra/arrays/SortedSubSequence.java

@@ -13,7 +13,7 @@ public class SortedSubSequence {
      * Finds 3 elements such that a[i] < a[j] < a[k] and i < j < k in O(n) time
      * in an array of n integers. If there are multiple such triplets, then prints any
      * one of them.
-     * 
+     * <p>
      * Algorithm:
      * 1) Create an auxiliary array smaller[0..n-1]. smaller[i] should store the index of a number which is smaller than arr[i] and is on left side of arr[i]. smaller[i] should contain -1 if there is no such element.
      * 2) Create another auxiliary array greater[0..n-1]. greater[i] should store the index of a number which is greater than arr[i] and is on right side of arr[i]. greater[i] should contain -1 if there is no such element.

src/main/java/com/rampatra/arrays/SubsetOfArray.java

@@ -17,7 +17,7 @@ public class SubsetOfArray {
      * Explanation: The below method uses sorting + merge method of merge sort. Time
      * complexity is O(mlogm + nlogn) where m and n are lengths of array a and b resp.
      * You could also have used sorting + binary search but this fails when array
-     * {@param b} has repeating elements for example, a={1,4,2} and b={1,4,4,2}. Time 
+     * {@param b} has repeating elements for example, a={1,4,2} and b={1,4,4,2}. Time
      * complexity would be O(mlogm + nlogm).
      *
      * @param a

src/main/java/com/rampatra/arrays/TwoRepeatingElements.java

@@ -69,9 +69,9 @@ public static int[] getTwoRepeatingElements(int[] a) {
      * Once we encounter a element lets say 2 then we make the element in 2nd index -ve just
      * to mark that we have encountered 2. When we encounter 2 again and see that 2nd index
      * is already -ve we conclude that 2 is repeated.
-     * 
+     * <p>
      * Similar to {@link DuplicatesInArray#findDuplicatesInArray(int[])}.
-     * 
+     *
      * @param a
      * @return
      */

src/main/java/com/rampatra/arrays/TwoStacksInOneArray.java

@@ -4,7 +4,7 @@
 
 /**
  * Created by IntelliJ IDEA.
- * 
+ * <p>
  * Implement two stacks using a single array with efficient use of space.
  * We could do this by dividing the array into two equal halves or storing stack
  * elements alternatively in the array but that wouldn't utilize the space fully.

src/main/java/com/rampatra/arrays/UnsortedSubArray.java

@@ -40,7 +40,7 @@ public static int[] getUnsortedSubArray(int[] a) {
         int[] unsortedArray;
 
         // 1(a)
-        for (int i = 0; i < a.length-1; i++) {
+        for (int i = 0; i < a.length - 1; i++) {
             if (a[i] > a[i + 1]) {
                 start = i;
                 break;

src/main/java/com/rampatra/arrays/sorting/BubbleSort.java

@@ -15,10 +15,10 @@ public class BubbleSort {
      * of the array until it is sorted. In doing so, the smaller items
      * slowly "bubble" up to the beginning of the list and in each inner
      * iteration the largest element is sorted. Ergo, the inner loop runs
-     * until {@code length - i - 1} times. To learn more:
-     * {@see https://youtu.be/6Gv8vg0kcHc}
+     * until {@code length - i - 1} times. Time complexity: O(n^2). Space
+     * complexity: O(1), in place. To learn more: {@see https://youtu.be/6Gv8vg0kcHc}
      *
-     * @param ar
+     * @param ar to be sorted
      */
     private static void bubbleSort(int[] ar) {
         for (int i = 0; i < ar.length - 1; i++) {

src/main/java/com/rampatra/arrays/sorting/SelectionSort.java

@@ -19,7 +19,7 @@ public class SelectionSort {
      * element is chosen and placed at the appropriate position and then again the
      * logic is applied on rest of the elements till the entire array is sorted.
      * <p/>
-     * Time complexity: O(n*n) for all cases.
+     * Time complexity: O(n^2) for all cases. Space complexity: O(1).
      * <p/>
      * NOTE: Advantage of this sort is that it requires minimum number of memory writes
      * like Cycle sort.

src/main/java/com/rampatra/bits/CountSetBits.java

@@ -30,15 +30,14 @@ static int countSetBits(int number) {
 
     /**
      * Optimized version. Works for -ve numbers as well.
-     *
+     * <p>
      * Uses BRIAN KERNIGAN'S bit counting. Acc. to this, the  right most/least significant set bit is unset
      * in each iteration. The time complexity is proportional to the number of bits set.
      *
-     * @link http://stackoverflow.com/questions/12380478/bits-counting-algorithm-brian-kernighan-in-an-integer-time-complexity
-     * @link http://graphics.stanford.edu/~seander/bithacks.html#ParityNaive
-     *
      * @param n
      * @return
+     * @link http://stackoverflow.com/questions/12380478/bits-counting-algorithm-brian-kernighan-in-an-integer-time-complexity
+     * @link http://graphics.stanford.edu/~seander/bithacks.html#ParityNaive
      */
     static int countSetBits(long n) {
         int count = 0;
@@ -62,8 +61,6 @@ public static void main(String[] a) {
 }
 
 /**
- *
  * Learn more:
  * http://javarevisited.blogspot.in/2014/06/how-to-count-number-of-set-bits-or-1s.html
- *
  */

src/main/java/com/rampatra/bits/CountSetBitsFromMinusNtoN.java

@@ -11,15 +11,15 @@ public class CountSetBitsFromMinusNtoN {
 
     /**
      * Explanation:
-     *
+     * <p>
      * -3:  101
      * -2:  110
      * -1:  111
      * 0:   000
      * 1:   001
      * 2:   010
      * 3:   110
-     *
+     * <p>
      * If you fold the above representation between -1 and 0, the total no. of set bits from -3 to 2
      * will be equal to the total no. of bits in nos. from -3 to 2.
      *

src/main/java/com/rampatra/bits/ElementOccurringOnce.java

@@ -48,12 +48,12 @@ public static void main(String a[]) {
  * 6    =   0110
  * -------------
  * res  =   0010
- *
+ * <p>
  * 1st bit of res = (0+0+0+0+0+0+0) % 3 = 0
  * 2nd bit of res = (0+0+1+1+1+0+1) % 3 = 1
  * 3rd bit of res = (1+1+1+1+0+1+1) % 3 = 0
  * 4th bit of res = (1+1+0+0+0+1+0) % 3 = 0
- *
+ * <p>
  * NOTE: Sum of bits at a particular position will not be divisible
  * by 3 if the no. occurring once has a set bit at that position.
  */

src/main/java/com/rampatra/bits/FlippingBits.java

@@ -39,11 +39,11 @@ public static void main(String a[]) {
 
 /**
  * EXPLANATION:
- *
+ * <p>
  * For input: 5
- *
+ * <p>
  * Binary:    000.....101
  * Inverted:  111.....010 (which is the 2's compliment of -6)
- *
+ * <p>
  * Therefore, result is -6.
  */

src/main/java/com/rampatra/bits/Modulo.java

@@ -33,8 +33,8 @@ public static void main(String a[]) {
 
 /**
  * Consider example, for 18 % 8
- *
+ * <p>
  * 18 = 10010
- *  7 = 00111 (8 = 2 ^ 3, therefore mask has to have three 1's)
- *  2 = 00010 (remainder = 18 & (8-1))
+ * 7 = 00111 (8 = 2 ^ 3, therefore mask has to have three 1's)
+ * 2 = 00010 (remainder = 18 & (8-1))
  */