Feature/sequences (#12)

* Longest unique characters sequence length

Added get longest unique characters sequences length function.
Added test cases for the function.

* Updated documentation

* Added sum strings

Added implementation of "sum strings" challenge.
The function gets two numbers as strings and return their sum as string.
Test cases are added as well.

* Updated sum of strings implementation

Added more tests.
Updated function implementation to include edge cases coverage.

Author: shorodilov

src/sequences/func.py

@@ -63,6 +63,8 @@ def get_longest_palindrome(origin: str) -> str:
     :return: the longest palindrome
     :rtype: str
 
+    Usage examples:
+
     >>> assert get_longest_palindrome("ABBABBC") == "BBABB"
 
     """
@@ -141,6 +143,18 @@ def get_fibonacci_number(idx: int) -> int:
     :return: a sequence's member
     :rtype: int
 
+    The Fibonacci number is a number from the Fibonacci sequence, in which
+    each number is the sum of the two preceding ones. This sequence commonly
+    starts from 0 and 1: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...
+
+    Usage examples:
+
+    >>> assert get_fibonacci_number(0) == 0
+    >>> assert get_fibonacci_number(1) == 1
+    >>> assert get_fibonacci_number(2) == 1
+    >>> assert get_fibonacci_number(3) == 2
+    >>> assert get_fibonacci_number(4) == 3
+
     """
 
     if idx <= 0:
@@ -150,3 +164,92 @@ def get_fibonacci_number(idx: int) -> int:
         return 1
 
     return get_fibonacci_number(idx - 1) + get_fibonacci_number(idx - 2)
+
+
+def get_longest_uniq_length(origin: str) -> int:
+    """Return the length of the longest on sequence of unique characters
+
+    Usage examples:
+    
+    >>> assert get_longest_uniq_length("abcdefg") == 7
+    >>> assert get_longest_uniq_length("abcacba") == 3
+
+    :param origin: original sequences
+    :type origin: str
+
+    :return: the length of the longest unique characters sequence
+    :rtype: int
+
+    """
+
+    length: int = 0
+
+    size: int = len(origin)
+    left_idx: int = 0
+
+    for right_idx in range(size):
+        while origin[right_idx] in origin[left_idx:right_idx]:
+            left_idx += 1
+        length = max(length, right_idx - left_idx + 1)
+
+    return length
+
+
+def get_sum_of_strings(number_1: str, number_2: str) -> str:
+    """Return the sum of two numbers of string type as string
+
+    :param number_1: first number
+    :type number_1: str
+    :param number_2: second number
+    :type number_2: str
+
+    :return: the sum of two numbers
+    :rtype: str
+
+    Valid input is a string of any length containing numeric characters from
+    0 to 9. Empty strings are allowed as well and should be considered as 0.
+
+    Usage examples:
+
+    >>> assert get_sum_of_strings("123", "456") == "579"
+    >>> assert get_sum_of_strings("099", "001") == "100"
+    >>> assert get_sum_of_strings("", "10") == "10"
+    >>> assert get_sum_of_strings("", "") == "0"
+
+    """
+
+    # remove leading zeros
+    for digit in number_1:
+        if digit != "0":
+            break
+        number_1 = number_1[1::]
+    for digit in number_2:
+        if digit != "0":
+            break
+        number_2 = number_2[1::]
+
+    if not number_1 or not number_2:
+        return number_1 or number_2 or "0"
+
+    result: str = ""
+    size: int = max(len(number_1), len(number_2))
+
+    # reverse numbers
+    number_1, number_2 = number_1[::-1], number_2[::-1]
+
+    # make strings of the same lengths
+    while len(number_1) < size:
+        number_1 += "0"
+    while len(number_2) < size:
+        number_2 += "0"
+
+    carry: int = 0
+    for digit_1, digit_2 in zip(number_1, number_2):
+        sum_of_digits = int(digit_1) + int(digit_2) + carry
+        result += str(sum_of_digits % 10)
+        carry = sum_of_digits // 10
+
+    if carry:
+        result += str(carry)
+
+    return result[::-1]

tests/sequences/test_func.py

@@ -62,3 +62,36 @@ def test_fibonacci_number_getter():
     assert sequences.get_fibonacci_number(2) == 1
     assert sequences.get_fibonacci_number(3) == 2
     assert sequences.get_fibonacci_number(9) == 34
+
+
+# noinspection SpellCheckingInspection
+def test_get_longest_uniq_sequence_length():
+    assert sequences.get_longest_uniq_length("abcdefg") == 7
+    assert sequences.get_longest_uniq_length("abcacba") == 3
+    assert sequences.get_longest_uniq_length("hwccjayhiszbmomlqkem") == 11
+
+
+def test_sum_of_strings():
+    assert sequences.get_sum_of_strings("123", "456") == "579"
+    assert sequences.get_sum_of_strings("123", "789") == "912"
+    assert sequences.get_sum_of_strings("99", "1") == "100"
+
+
+def test_sum_of_strings_big_numbers():
+    x, y, test_value = "490053634", "20846201", "510899835"
+    assert sequences.get_sum_of_strings(x, y) == test_value
+
+    x, y, test_value = "616526149", "364644330", "981170479"
+    assert sequences.get_sum_of_strings(x, y) == test_value
+
+
+def test_sum_of_strings_leading_zeros():
+    assert sequences.get_sum_of_strings("009", "000001") == "10"
+    assert sequences.get_sum_of_strings("020", "000000") == "20"
+    assert sequences.get_sum_of_strings("000", "000000") == "0"
+
+
+def test_sum_of_strings_empty():
+    assert sequences.get_sum_of_strings("123", "") == "123"
+    assert sequences.get_sum_of_strings("", "456") == "456"
+    assert sequences.get_sum_of_strings("", "") == "0"