Add some String solution (#359)

* Add unique morse

* Add judge_circle

* Add strong password

* Add caesar cipher

* Add contain string

* Add count binary substring

* Fix conflict

Author: Hai Hoang Dang

README.md

@@ -287,6 +287,9 @@ If you want to uninstall algorithms, it is as simple as:
     - [unique_morse](algorithms/strings/unique_morse.py)
     - [judge_circle](algorithms/strings/judge_circle.py)
     - [strong_password](algorithms/strings/strong_password.py)
+    - [caesar_cipher](algorithms/strings/caesar_cipher.py)
+    - [contain_string](algorithms/strings/contain_string.py)
+    - [count_binary_substring](algorithms/strings/count_binary_substring.py)
 - [tree](algorithms/tree)
     - [bst](algorithms/tree/tree/bst)
         - [array2bst](algorithms/tree/bst/array2bst.py)

algorithms/strings/__init__.py

@@ -24,3 +24,6 @@
 from .unique_morse import *
 from .judge_circle import *
 from .strong_password import *
+from .caesar_cipher import *
+from .contain_string import *
+from .count_binary_substring import *

algorithms/strings/caesar_cipher.py

@@ -0,0 +1,19 @@
+
+"""
+Julius Caesar protected his confidential information by encrypting it using a cipher.
+Caesar's cipher shifts each letter by a number of letters. If the shift takes you
+past the end of the alphabet, just rotate back to the front of the alphabet.
+In the case of a rotation by 3, w, x, y and z would map to z, a, b and c.
+Original alphabet:      abcdefghijklmnopqrstuvwxyz
+Alphabet rotated +3:    defghijklmnopqrstuvwxyzabc
+"""
+def caesar_cipher(s, k):
+    result = ""
+    for char in s:
+        n = ord(char)
+        if 64 < n < 91:
+            n = ((n - 65 + k) % 26) + 65
+        if 96 < n < 123:
+            n = ((n - 97 + k) % 26) + 97
+        result = result + chr(n)
+    return result

algorithms/strings/contain_string.py

@@ -0,0 +1,25 @@
+"""
+Implement strStr().
+
+Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
+
+Example 1:
+Input: haystack = "hello", needle = "ll"
+Output: 2
+
+Example 2:
+Input: haystack = "aaaaa", needle = "bba"
+Output: -1
+Reference: https://leetcode.com/problems/implement-strstr/description/
+"""
+def contain_string(haystack, needle):
+    if len(needle) == 0:
+        return 0
+    if len(needle) > len(haystack):
+        return -1
+    for i in range(len(haystack)):
+        if len(haystack) - i < len(needle):
+            return -1
+        if haystack[i:i+len(needle)] == needle:
+            return i
+    return -1

algorithms/strings/count_binary_substring.py

@@ -0,0 +1,33 @@
+"""
+Give a string s, count the number of non-empty (contiguous) substrings that have
+ the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively.
+
+Substrings that occur multiple times are counted the number of times they occur.
+Example 1:
+Input: "00110011"
+Output: 6
+Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
+
+Notice that some of these substrings repeat and are counted the number of times they occur.
+
+Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.
+
+Example 2:
+Input: "10101"
+Output: 4
+Explanation: There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.
+Reference: https://leetcode.com/problems/count-binary-substrings/description/
+"""
+def count_binary_substring(s):
+    cur = 1
+    pre = 0
+    count = 0
+    for i in range(1, len(s)):
+        if s[i] != s[i - 1]:
+            count = count + min(pre, cur)
+            pre = cur
+            cur = 1
+        else:
+            cur = cur + 1
+    count = count + min(pre, cur)
+    return count

tests/test_strings.py

@@ -26,7 +26,10 @@
     word_squares,
     convert_morse_word, unique_morse,
     judge_circle,
-    strong_password
+    strong_password,
+    caesar_cipher,
+    contain_string,
+    count_binary_substring
 )
 
 import unittest
@@ -401,5 +404,22 @@ def test_strong_password(self):
         self.assertEqual(3, strong_password(3,"Ab1"))
         self.assertEqual(1, strong_password(11,"#Algorithms"))
 
+class TestCaesarCipher(unittest.TestCase):
+    def test_caesar_cipher(self):
+        self.assertEqual("Lipps_Asvph!", caesar_cipher("Hello_World!", 4))
+        self.assertEqual("okffng-Qwvb", caesar_cipher("middle-Outz", 2))
+
+class TestContainString(unittest.TestCase):
+    def test_contain_string(self):
+        self.assertEqual(-1, contain_string("mississippi", "issipi"))
+        self.assertEqual(0, contain_string("Hello World", ""))
+        self.assertEqual(2, contain_string("hello", "ll"))
+
+class TestCountBinarySubstring(unittest.TestCase):
+    def test_count_binary_substring(self):
+        self.assertEqual(6, count_binary_substring("00110011"))
+        self.assertEqual(4, count_binary_substring("10101"))
+        self.assertEqual(3, count_binary_substring("00110"))
+
 if __name__ == "__main__":
     unittest.main()