Merge branch 'master' into add-heap-sort

abranhe · web-flow · commit 40b9fc46c8f4 · 2019-10-02T14:41:40.000-04:00
diff --git a/allalgorithms/sorting/shell_sort.py b/allalgorithms/sorting/shell_sort.py
@@ -0,0 +1,30 @@
+# -*- coding: UTF-8 -*-
+#
+# Shell Sort Algorithm
+# The All ▲lgorithms library for python
+#
+# Contributed by: Elias
+# Github: @eliasbayona
+#
+
+def shell_sort(arr): 
+    n = len(arr) 
+    h = int(n/2)
+
+
+    while h > 0: 
+        for i in range(h,n):
+            
+            temp = arr[i] 
+            j = i 
+
+            while  j >= h and arr[j-h] >temp: 
+                arr[j] = arr[j-h] 
+                j -= h 
+
+            arr[j] = temp 
+
+        h = int(h/2)
+        
+    return arr
+
diff --git a/allalgorithms/string/__init__.py b/allalgorithms/string/__init__.py
@@ -1,2 +1,3 @@
 from .palindrome_check import *
-
+from .is_unique import *
+from .hamming_dist import *
diff --git a/allalgorithms/string/hamming_dist.py b/allalgorithms/string/hamming_dist.py
@@ -0,0 +1,14 @@
+# -*- coding: UTF-8 -*-
+#
+# Binary search works for a sorted array.
+# The All ▲lgorithms library for python
+#
+# Contributed by: ninexball
+# Github: @ninexball
+#
+
+def hamming_dist(seq1: str, seq2: str) -> int:
+    """Compare hamming distance of two strings"""
+    if len(seq1) != len(seq2):
+        raise ValueError("length of strings are not the same")
+    return sum(c1 != c2 for c1, c2 in zip(seq1, seq2))
diff --git a/allalgorithms/string/is_unique.py b/allalgorithms/string/is_unique.py
@@ -0,0 +1,16 @@
+# -*- coding: UTF-8 -*-
+#
+# Check if a string has all unique characters.
+# The All ▲lgorithms library for python
+#
+# Contributed by: José E. Andrade Jr.
+# Github: @andradejunior
+#
+
+def is_unique(string_to_check):
+    character_set = set()
+    for character in string_to_check:
+        if character in character_set:
+            return False
+        character_set.add(character)
+    return True
diff --git a/docs/sorting/shell-sort.md b/docs/sorting/shell-sort.md
@@ -0,0 +1,29 @@
+# Selection Sort
+
+In computer science, shell sort improves upon insertion sort by moving out of order elements more than one position at a time. It has a best case O(n log n) time complexity, and for other cases, it depends on the gap sequence. According to Poonen Theorem, worst case complexity for shell sort is Θ(NlogN)^2/(log logN)^2) or Θ(NlogN)^2/log logN) or Θ(N(logN)^2) or something in between.
+## Install
+
+```
+pip install allalgorithms
+```
+
+## Usage
+
+```py
+from allalgorithms.sorting import shell_sort
+
+arr = [77, 2, 10, -2, 1, 7]
+
+print(shell_sort(arr))
+# -> [-2, 1, 2, 7, 10, 77]
+```
+
+## API
+
+### selection_sort(array)
+
+> Returns a sorted array
+
+##### Params:
+
+- `array`: Unsorted Array
diff --git a/docs/string/hamming-dist.md b/docs/string/hamming-dist.md
@@ -0,0 +1,32 @@
+# Hamming Distance
+
+In informatics, Hamming distance is the number of positions where the characters differ between two strings of equal length
+
+## Install
+
+```
+pip install allalgorithms
+```
+
+## Usage
+
+```
+>>> from allalgorithms.sorting import hamming_dist
+
+>>> hamming_dist("hello world", "hello wario")
+3
+```
+
+## API
+
+### hamming_dist(seq1, seq2)
+
+> Returns an integer
+
+> Raises a ValueError if strings are of unequal length
+
+##### Params:
+
+- `seq1`: first string to compare
+- `seq2`: second string to compare
+
diff --git a/docs/string/is-unique.md b/docs/string/is-unique.md
@@ -0,0 +1,36 @@
+# Is Unique
+
+This algorithms checks if a string has all unique characters in O(n) time.
+
+## Install
+
+```
+pip install allalgorithms
+```
+
+## Usage
+
+```py
+from allalgorithms.string import is_unique
+
+str = "abcdefg"
+
+print(is_unique(str)
+# -> True
+
+str = "test"
+
+print(is_unique(str)
+# -> False
+```
+
+## API
+
+### is_unique(string)
+
+> Return True if string has all unique characters, False otherwise
+
+##### Params:
+
+- `string`: Input String
+
diff --git a/readme.md b/readme.md
@@ -61,7 +61,7 @@ print(binary_search(arr, 3))
   - [Binary Search](https://python.allalgorithms.com/searches/binary-search)
   - [Fibonacci Search](https://python.allalgorithms.com/searches/fibonacci-search)
   - [Jump Search](https://python.allalgorithms.com/searches/jump-search)
-  
+
 - ### Sorting
   - [Bubble Sort](https://python.allalgorithms.com/sorting/bubble-sort)
   - [Cocktail Shaker Sort](https://python.allalgorithms.com/sorting/cocktail-shaker-sort)
@@ -75,7 +75,7 @@ print(binary_search(arr, 3))
 
 # Related
 
-- [allalgorithms-javascript](https://github.com/abranhe/allalgorithms-javascript): All ▲lgorithms Javascript library
+- [allalgorithms-js](https://github.com/abranhe/allalgorithms-js): All ▲lgorithms Javascript library
 
 # Maintainers
 
diff --git a/tests/test_sorting.py b/tests/test_sorting.py
@@ -10,6 +10,7 @@
     cocktail_shaker_sort,
     tree_sort,
     heap_sort
+    shell_sort,
 )
 
 
@@ -43,6 +44,8 @@ def test_heap_sort(self):
         heap_sort(array)
         self.assertEqual([-44, 1, 2, 3, 7, 19], array)
 
+    def test_shell_sort(self):
+        self.assertEqual([-44, 1, 2, 3, 7, 19], shell_sort([7, 3, 2, 19, -44, 1]))
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_string.py b/tests/test_string.py
@@ -1,6 +1,6 @@
 import unittest
 
-from allalgorithms.string import palindrome_check
+from allalgorithms.string import palindrome_check, is_unique
 
 
 class TestSorting(unittest.TestCase):
@@ -13,5 +13,14 @@ def test_palindrome_check(self):
         self.assertEqual(True, palindrome_check("Was it a car or a cat I saw?"))
         self.assertEqual(False, palindrome_check("How are you?"))
 
+    def test_is_unique(self):
+        self.assertEqual(True, is_unique("abcdefg"))
+        self.assertEqual(True, is_unique("1234567"))
+        self.assertEqual(True, is_unique("algorithms"))
+        self.assertEqual(False, is_unique("abcdefa"))
+        self.assertEqual(False, is_unique("abddefg"))
+        self.assertEqual(False, is_unique("12345567"))
+
+
 if __name__ == "__main__":
     unittest.main()
