Merge pull request #17 from alberthu16/day23

Day23: stringRearrangments

Author: Albert Hu

day23/README.md

@@ -0,0 +1,43 @@
+question of the day: https://codefights.com/challenge/RWQS5cCEodqSWx4bR
+
+Given an array of equal-length strings, check if it is possible to
+rearrange the strings in such a way that after the rearrangement the
+strings at consecutive positions would differ by exactly one character.
+
+Example
+
+* For `inputArray = ["aba", "bbb", "bab"]`, the output should be
+`stringsRearrangement(inputArray) = false`.
+
+All rearrangements don't satisfy the description condition.
+
+* For `inputArray = ["ab", "bb", "aa"]`, the output should be
+`stringsRearrangement(inputArray) = true`.
+
+Strings can be rearranged in the following way: `"aa", "ab", "bb"`.
+
+## Ideas
+
+There's a smart way to do this problem and a not-as-smart way. I'm going
+to use my knowledge of how to do permutations from [yesterday](../day22)
+to implement the brute-force check by iterating over all permutations of
+the input list and checking whether the current permutation is a possible
+solution. If it is, break there and return `true`. Otherwise, keep going
+until the last permutation has been checked, and then return `false`.
+
+The permutations calculation would take `O(n!)` time just to generate
+all possible permutations of the input list. Then I also need to do an
+`O(n)` check each time to verify whether the permutation is a solution.
+Where `n` is the number of strings in the input list, the overall runtime
+is `O(n * n!)`.
+
+## Code
+
+[Python](./stringsRearrangement.py)
+
+## Follow up
+
+Any better way to approach this problem? I think so..
+
+https://en.wikipedia.org/wiki/Hamiltonian_path_problem
+

day23/stringsRearrangement.py

@@ -0,0 +1,61 @@
+from itertools import permutations
+
+def stringsRearrangement(inputArray):
+    for perm in permutations(inputArray):
+        if neighborsDifferByOne(perm):
+            return True 
+    return False
+
+def neighborsDifferByOne(inputArray):
+    if len(inputArray) <= 1:
+        return True
+    return differByOne(inputArray[0], inputArray[1]) and neighborsDifferByOne(inputArray[1:])
+
+def differByOne(word, anotherWord):
+    differencesCount = 0
+    for i in xrange(len(word)):
+        if word[i] != anotherWord[i]:
+            differencesCount += 1
+        if differencesCount > 1:
+            return False
+
+    return differencesCount == 1
+
+def testDifferByOne():
+    assert not differByOne("", "")
+    assert not differByOne("a", "a")
+    assert not differByOne("aaa", "aaa")
+    assert not differByOne("abcdeff", "abcedff")
+    assert differByOne("a", "b")
+    assert differByOne("abc", "abb")
+    assert differByOne("abc", "bbc")
+    assert differByOne("abcdefg", "abcdefz")
+
+def testNeighborsDifferByOne():
+    assert neighborsDifferByOne([])
+    assert neighborsDifferByOne([""])
+    assert neighborsDifferByOne(["a", "b"])
+    assert neighborsDifferByOne(["a", "b", "c"])
+    assert neighborsDifferByOne(["ab", "bb"])
+    assert neighborsDifferByOne(["ab", "bb", "bc"])
+    assert neighborsDifferByOne(["ab", "bb", "bc", "ba"])
+    assert neighborsDifferByOne(["abc", "bbc", "bac", "bad"])
+    assert not neighborsDifferByOne(["a", "a"])
+
+def testStringsRearrangement():
+    assert stringsRearrangement([])
+    assert not stringsRearrangement(["aba", "bbb", "bab"])
+    assert stringsRearrangement(["ab", "bb", "aac"])
+    assert not stringsRearrangement(["qq", "qq", "qq"])
+    assert stringsRearrangement(["aaa", "aba", "aaa", "aba", "aaa"])
+    assert not stringsRearrangement(["ab", "ad", "ef", "eg"])
+    assert stringsRearrangement(["abc", "abx", "axx", "abx", "abc"])
+    assert stringsRearrangement(["f", "g", "a", "h"])
+
+def main():
+    testDifferByOne()
+    testNeighborsDifferByOne()
+    testStringsRearrangement()
+
+if __name__ == "__main__":
+    main()