moved initial fork content to backup

Author: abhiabhi

src/main/java/com/backup/ctci/arraysandstrings/CheckPermutation.java

@@ -0,0 +1,67 @@
+package com.backup.ctci.arraysandstrings;
+
+import java.util.Arrays;
+
+/**
+ * @author rampatra
+ * @since 19/11/2018
+ */
+public class CheckPermutation {
+
+    /**
+     * Checks if {@code s1} is a permutation of {@code s2}.
+     *
+     * @param s1
+     * @param s2
+     * @return
+     */
+    private static boolean isOnePermutationOfOther(String s1, String s2) {
+        if (s1.length() != s2.length()) {
+            return false;
+        }
+
+        char[] c1 = s1.toCharArray();
+        char[] c2 = s2.toCharArray();
+        Arrays.sort(c1);
+        Arrays.sort(c2);
+
+        return Arrays.equals(c1, c2);
+    }
+
+    /**
+     * Checks if {@code s1} is a permutation of {@code s2}.
+     *
+     * @param s1
+     * @param s2
+     * @return
+     */
+    private static boolean isOnePermutationOfOtherGivenThatStringsContainOnlyAscii(String s1, String s2) {
+        if (s1.length() != s2.length()) {
+            return false;
+        }
+
+        int[] chars = new int[128]; // assuming strings contain only ASCII characters
+
+        for (int i = 0; i < s1.length(); i++) {
+            chars[s1.charAt(i)]++;
+        }
+
+        for (int i = 0; i < s2.length(); i++) {
+            chars[s2.charAt(i)]--;
+            if (chars[s2.charAt(i)] < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isOnePermutationOfOther("ram", "mar"));
+        System.out.println(isOnePermutationOfOther("rama", "mar"));
+        System.out.println(isOnePermutationOfOther("rama", "marA"));
+        System.out.println("-------");
+        System.out.println(isOnePermutationOfOtherGivenThatStringsContainOnlyAscii("ram", "mar"));
+        System.out.println(isOnePermutationOfOtherGivenThatStringsContainOnlyAscii("rama", "mar"));
+        System.out.println(isOnePermutationOfOtherGivenThatStringsContainOnlyAscii("rama", "marA"));
+    }
+}

src/main/java/com/backup/ctci/arraysandstrings/IsUnique.java

@@ -0,0 +1,51 @@
+package com.backup.ctci.arraysandstrings;
+
+/**
+ * @author rampatra
+ * @since 18/11/2018
+ */
+public class IsUnique {
+
+    private static boolean hasAllUniqueCharacters(String str) {
+        if (str == null || str.length() > 128) return false;
+
+        boolean[] charSet = new boolean[128]; // assuming the string contains only ASCII characters
+        for (int i = 0; i < str.length(); i++) {
+            int charVal = str.charAt(i);
+            if (charSet[charVal]) {
+                return false;
+            }
+            charSet[charVal] = true;
+        }
+        return true;
+    }
+
+    private static boolean hasAllUniqueCharactersWhenStringContainsAllLowercase(String s) {
+        int checker = 0;
+        for (int i = 0; i < s.length(); i++) {
+            int charValue = s.charAt(i) - 'a';
+            if ((checker & (1 << charValue)) > 0) {
+                return false;
+            }
+            checker |= (1 << charValue);
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        String s = "ram";
+        System.out.println(hasAllUniqueCharacters(s));
+        s = "rama";
+        System.out.println(hasAllUniqueCharacters(s));
+        s = "ramA";
+        System.out.println(hasAllUniqueCharacters(s));
+        System.out.println("-------");
+        s = "ram";
+        System.out.println(hasAllUniqueCharactersWhenStringContainsAllLowercase(s));
+        s = "rama";
+        System.out.println(hasAllUniqueCharactersWhenStringContainsAllLowercase(s));
+        // not working as the input contains different cases
+        s = "ramA";
+        System.out.println(hasAllUniqueCharactersWhenStringContainsAllLowercase(s));
+    }
+}

src/main/java/com/backup/ctci/arraysandstrings/OneAway.java

@@ -0,0 +1,70 @@
+package com.backup.ctci.arraysandstrings;
+
+/**
+ * @author rampatra
+ * @since 24/11/2018
+ */
+public class OneAway {
+
+    /**
+     * Checks if two strings are only one edit away, that is, by inserting, deleting, or editing
+     * at max one character in {@code s1} it becomes same as {@code s2}.
+     *
+     * @param s1
+     * @param s2
+     * @return
+     */
+    private static boolean isOneEditAway(String s1, String s2) {
+        if (s1.length() == s2.length()) {
+            return isOneCharacterDiffAtMax(s1, s2);
+        } else if (s1.length() < s2.length()) {
+            return checkForMaxOneInsertOrDeleteInS1(s1, s2);
+        } else {
+            return checkForMaxOneInsertOrDeleteInS1(s1, s2);
+        }
+    }
+
+    private static boolean isOneCharacterDiffAtMax(String s1, String s2) {
+        boolean foundDiff = false;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                if (foundDiff) {
+                    return false; // means we already found a difference earlier
+                }
+                foundDiff = true;
+            }
+        }
+        return true;
+    }
+
+    private static boolean checkForMaxOneInsertOrDeleteInS1(String s1, String s2) {
+        int i = 0;
+        int j = 0;
+        int s1Len = s1.length();
+        int s2Len = s2.length();
+        if (Math.abs(s1Len - s2Len) > 1) return false;
+
+        while (i < s1Len && j < s2Len) {
+            if (s1.charAt(i) != s2.charAt(j)) {
+                if (s1Len > s2Len) {
+                    i++;
+                } else {
+                    j++;
+                }
+                continue;
+            }
+            i++;
+            j++;
+        }
+        return Math.abs(i - j) <= 1; // check whether difference in two strings is not more than 1
+    }
+
+    public static void main(String[] args) {
+        System.out.println("pale,  ple: " + isOneEditAway("pale", "ple"));
+        System.out.println("pales,pale: " + isOneEditAway("pales", "pale"));
+        System.out.println("pale, bale: " + isOneEditAway("pale", "bale"));
+        System.out.println("pale, bake: " + isOneEditAway("pale", "bake"));
+        System.out.println("ram, rama: " + isOneEditAway("ram", "rama"));
+        System.out.println("ram, ramaaaaaaa: " + isOneEditAway("ram", "ramaaaaaaa"));
+    }
+}

src/main/java/com/backup/ctci/arraysandstrings/PalindromePermutation.java

@@ -0,0 +1,103 @@
+package com.backup.ctci.arraysandstrings;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author rampatra
+ * @since 21/11/2018
+ */
+public class PalindromePermutation {
+
+    /**
+     * This method exploits the fact that a palindrome will contain at most
+     * one character with odd counts. All other characters should be of even
+     * counts.
+     *
+     * @param str input string
+     * @return {@code true} if {@code str} is a permutation of a palindrome
+     */
+    private static boolean isPermutationOfPalindrome(String str) {
+        Map<Character, Integer> charCounts = new HashMap<>();
+        Integer freq;
+        int oddCounts = 0; // keep count of odds so that we don't have to loop through the hashmap the second time
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            if (c != 32) {
+                freq = charCounts.get(c) == null ? 0 : charCounts.get(c);
+                if ((freq + 1) % 2 == 1) {
+                    oddCounts++;
+                } else {
+                    oddCounts--;
+                }
+                charCounts.put(c, freq + 1);
+            }
+        }
+        return oddCounts <= 1;
+    }
+
+
+    /**
+     * This approach sets a bit in a number based on the character in the string and
+     * then un-sets the bit if it sees the character again. Finally, checks if the
+     * bitVector has at most one bit set only.
+     *
+     * @param str input string
+     * @return {@code true} if {@code str} is a permutation of a palindrome
+     */
+    private static boolean isPermutationOfPalindromeViaBits(String str) {
+        int bitVector = 0;
+        int index;
+
+        for (int i = 0; i < str.length(); i++) {
+            index = getIndex(str.charAt(i));
+            if (index != -1) {
+                bitVector = toggleBitAt(bitVector, index);
+            }
+        }
+        return (bitVector & (bitVector - 1)) == 0;
+    }
+
+    /**
+     * Calculates the index to set the bit according to the character {@code c}.
+     *
+     * @param c
+     * @return the index to set the bit as per the character {@code c}
+     */
+    private static int getIndex(char c) {
+        char a = 'a';
+        char z = 'z';
+
+        // assuming string contains only lowercase characters
+        if (c < a || c > z) {
+            return -1;
+        }
+
+        return c - a;
+    }
+
+    /**
+     * Toggles the bit at index {@code index} in {@code bitVector}.
+     *
+     * @param bitVector
+     * @param index
+     * @return the resulting {@code bitVector} after toggling the bit
+     */
+    private static int toggleBitAt(int bitVector, int index) {
+        return bitVector ^ (1 << index);
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isPermutationOfPalindrome("tactc oapapa"));
+        System.out.println(isPermutationOfPalindrome("maam"));
+        System.out.println(isPermutationOfPalindrome("maa m"));
+        System.out.println(isPermutationOfPalindrome("rammmar"));
+        System.out.println(isPermutationOfPalindrome("rammmara"));
+        System.out.println("---------");
+        System.out.println(isPermutationOfPalindromeViaBits("tactc oapapa"));
+        System.out.println(isPermutationOfPalindromeViaBits("maam"));
+        System.out.println(isPermutationOfPalindromeViaBits("maa m"));
+        System.out.println(isPermutationOfPalindromeViaBits("rammmar"));
+        System.out.println(isPermutationOfPalindromeViaBits("rammmara"));
+    }
+}

src/main/java/com/backup/ctci/arraysandstrings/RotateMatrix.java

@@ -0,0 +1,16 @@
+package com.backup.ctci.arraysandstrings;
+
+/**
+ * @author rampatra
+ * @since 2019-01-20
+ */
+public class RotateMatrix {
+
+    public static void rotateImage(int[][] pixels) {
+        
+    }
+
+    public static void main(String[] args) {
+        
+    }
+}

src/main/java/com/backup/ctci/arraysandstrings/StringCompression.java

@@ -0,0 +1,39 @@
+package com.backup.ctci.arraysandstrings;
+
+/**
+ * @author rampatra
+ * @since 24/11/2018
+ */
+public class StringCompression {
+
+    /**
+     * Compresses the string {@code s} such that a string {@code aabccccaaa} becomes {@code a2b1c4a3}.
+     * Also, if the compressed string is not shorter than the original, returns the original string.
+     *
+     * @param str input string containing only a-z characters, both cases
+     * @return which ever is the shorter string
+     */
+    private static String compressString(String str) {
+        StringBuilder compressedSb = new StringBuilder();
+        int countConsecutive = 0;
+        for (int i = 0; i < str.length(); i++) {
+            countConsecutive++;
+
+            /* If next character is different than current, append this char to result. */
+            if (i + 1 >= str.length() || str.charAt(i) != str.charAt(i + 1)) {
+                compressedSb.append(str.charAt(i));
+                compressedSb.append(countConsecutive);
+                countConsecutive = 0;
+            }
+        }
+        return compressedSb.length() < str.length() ? compressedSb.toString() : str;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("aabccccaaa: " + compressString("aabccccaaa"));
+        System.out.println("aabccccAAAA: " + compressString("aabccccAAAA"));
+        System.out.println("abcd: " + compressString("abcd"));
+        System.out.println("a: " + compressString("a"));
+        System.out.println("aabcccccccccccccccccccccccccaaa: " + compressString("aabcccccccccccccccccccccccccaaa"));
+    }
+}

src/main/java/com/backup/ctci/arraysandstrings/StringRotation.java

@@ -0,0 +1,39 @@
+package com.backup.ctci.arraysandstrings;
+
+/**
+ * Assume you have a method isSubString which checks if one word is a substring of another. Given two
+ * strings, S1 and S2, write code to check if S2 is a rotation of S1 using only one call to isSubString
+ * (e.g., "waterbottle" is a rotation of" erbottlewat").
+ *
+ * @author rampatra
+ * @since 2019-01-22
+ */
+public class StringRotation {
+
+    private static boolean isStringRotation(String s1, String s2) {
+        if (s1.length() != s2.length()) {
+            return false;
+        }
+        s2 = s2 + s2;
+        return isSubString(s1, s2);
+    }
+
+    /**
+     * Given method in question.
+     *
+     * @param s1 first string
+     * @param s2 second string
+     * @return {@code true} if s1 is a substring of s2 or else {@code false}
+     */
+    private static boolean isSubString(String s1, String s2) {
+        return s2.contains(s1);
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isStringRotation("waterbottle", "erbottlewat")); // true
+        System.out.println(isStringRotation("rampatra", "atraramp")); // true
+        System.out.println(isStringRotation("rampatra", "arampata")); // false
+        System.out.println(isStringRotation("rampatra", "arampat")); // false
+        System.out.println(isStringRotation("", "")); // true
+    }
+}