DIRECTORY.md

@@ -716,7 +716,6 @@
   * [Lru Cache](other/lru_cache.py)
   * [Magicdiamondpattern](other/magicdiamondpattern.py)
   * [Maximum Subarray](other/maximum_subarray.py)
-  * [Maximum Subsequence](other/maximum_subsequence.py)
   * [Nested Brackets](other/nested_brackets.py)
   * [Password](other/password.py)
   * [Quine](other/quine.py)

maths/remove_digit.py

@@ -1,37 +0,0 @@
-def remove_digit(num: int) -> int:
-    """
-
-    returns the biggest possible result
-    that can be achieved by removing
-    one digit from the given number
-
-    >>> remove_digit(152)
-    52
-    >>> remove_digit(6385)
-    685
-    >>> remove_digit(-11)
-    1
-    >>> remove_digit(2222222)
-    222222
-    >>> remove_digit("2222222")
-    Traceback (most recent call last):
-    TypeError: only integers accepted as input
-    >>> remove_digit("string input")
-    Traceback (most recent call last):
-    TypeError: only integers accepted as input
-    """
-
-    if not isinstance(num, int):
-        raise TypeError("only integers accepted as input")
-    else:
-        num_str = str(abs(num))
-        num_transpositions = [list(num_str) for char in range(len(num_str))]
-        for index in range(len(num_str)):
-            num_transpositions[index].pop(index)
-        return max(
-            int("".join(list(transposition))) for transposition in num_transpositions
-        )
-
-
-if __name__ == "__main__":
-    __import__("doctest").testmod()

other/maximum_subsequence.py

@@ -1,42 +0,0 @@
-from collections.abc import Sequence
-
-
-def max_subsequence_sum(nums: Sequence[int] | None = None) -> int:
-    """Return the maximum possible sum amongst all non - empty subsequences.
-
-    Raises:
-      ValueError: when nums is empty.
-
-    >>> max_subsequence_sum([1,2,3,4,-2])
-    10
-    >>> max_subsequence_sum([-2, -3, -1, -4, -6])
-    -1
-    >>> max_subsequence_sum([])
-    Traceback (most recent call last):
-        . . .
-    ValueError: Input sequence should not be empty
-    >>> max_subsequence_sum()
-    Traceback (most recent call last):
-        . . .
-    ValueError: Input sequence should not be empty
-    """
-    if nums is None or not nums:
-        raise ValueError("Input sequence should not be empty")
-
-    ans = nums[0]
-    for i in range(1, len(nums)):
-        num = nums[i]
-        ans = max(ans, ans + num, num)
-
-    return ans
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
-
-    # Try on a sample input from the user
-    n = int(input("Enter number of elements : ").strip())
-    array = list(map(int, input("\nEnter the numbers : ").strip().split()))[:n]
-    print(max_subsequence_sum(array))

sorts/binary_insertion_sort.py

@@ -1,61 +0,0 @@
-"""
-This is a pure Python implementation of the binary insertion sort algorithm
-
-For doctests run following command:
-python -m doctest -v binary_insertion_sort.py
-or
-python3 -m doctest -v binary_insertion_sort.py
-
-For manual testing run:
-python binary_insertion_sort.py
-"""
-
-
-def binary_insertion_sort(collection: list) -> list:
-    """Pure implementation of the binary insertion sort algorithm in Python
-    :param collection: some mutable ordered collection with heterogeneous
-    comparable items inside
-    :return: the same collection ordered by ascending
-
-    Examples:
-    >>> binary_insertion_sort([0, 4, 1234, 4, 1])
-    [0, 1, 4, 4, 1234]
-    >>> binary_insertion_sort([]) == sorted([])
-    True
-    >>> binary_insertion_sort([-1, -2, -3]) == sorted([-1, -2, -3])
-    True
-    >>> lst = ['d', 'a', 'b', 'e', 'c']
-    >>> binary_insertion_sort(lst) == sorted(lst)
-    True
-    >>> import random
-    >>> collection = random.sample(range(-50, 50), 100)
-    >>> binary_insertion_sort(collection) == sorted(collection)
-    True
-    >>> import string
-    >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
-    >>> binary_insertion_sort(collection) == sorted(collection)
-    True
-    """
-
-    n = len(collection)
-    for i in range(1, n):
-        val = collection[i]
-        low = 0
-        high = i - 1
-
-        while low <= high:
-            mid = (low + high) // 2
-            if val < collection[mid]:
-                high = mid - 1
-            else:
-                low = mid + 1
-        for j in range(i, low, -1):
-            collection[j] = collection[j - 1]
-        collection[low] = val
-    return collection
-
-
-if __name__ == "__main__":
-    user_input = input("Enter numbers separated by a comma:\n").strip()
-    unsorted = [int(item) for item in user_input.split(",")]
-    print(binary_insertion_sort(unsorted))

strings/string_switch_case.py

@@ -1,108 +0,0 @@
-import re
-
-"""
-general info:
-https://en.wikipedia.org/wiki/Naming_convention_(programming)#Python_and_Ruby
-
-pascal case [ an upper Camel Case ]: https://en.wikipedia.org/wiki/Camel_case
-
-camel case: https://en.wikipedia.org/wiki/Camel_case
-
-kebab case [ can be found in general info ]:
-https://en.wikipedia.org/wiki/Naming_convention_(programming)#Python_and_Ruby
-
-snake case: https://en.wikipedia.org/wiki/Snake_case
-"""
-
-
-# assistant functions
-def split_input(str_: str) -> list:
-    """
-    >>> split_input("one two 31235three4four")
-    [['one', 'two', '31235three4four']]
-    """
-    return [char.split() for char in re.split(r"[^ a-z A-Z 0-9 \s]", str_)]
-
-
-def to_simple_case(str_: str) -> str:
-    """
-    >>> to_simple_case("one two 31235three4four")
-    'OneTwo31235three4four'
-    """
-    string_split = split_input(str_)
-    return "".join(
-        ["".join([char.capitalize() for char in sub_str]) for sub_str in string_split]
-    )
-
-
-def to_complex_case(text: str, upper: bool, separator: str) -> str:
-    """
-    >>> to_complex_case("one two 31235three4four", True, "_")
-    'ONE_TWO_31235THREE4FOUR'
-    >>> to_complex_case("one two 31235three4four", False, "-")
-    'one-two-31235three4four'
-    """
-    try:
-        string_split = split_input(text)
-        if upper:
-            res_str = "".join(
-                [
-                    separator.join([char.upper() for char in sub_str])
-                    for sub_str in string_split
-                ]
-            )
-        else:
-            res_str = "".join(
-                [
-                    separator.join([char.lower() for char in sub_str])
-                    for sub_str in string_split
-                ]
-            )
-        return res_str
-    except IndexError:
-        return "not valid string"
-
-
-# main content
-def to_pascal_case(text: str) -> str:
-    """
-    >>> to_pascal_case("one two 31235three4four")
-    'OneTwo31235three4four'
-    """
-    return to_simple_case(text)
-
-
-def to_camel_case(text: str) -> str:
-    """
-    >>> to_camel_case("one two 31235three4four")
-    'oneTwo31235three4four'
-    """
-    try:
-        res_str = to_simple_case(text)
-        return res_str[0].lower() + res_str[1:]
-    except IndexError:
-        return "not valid string"
-
-
-def to_snake_case(text: str, upper: bool) -> str:
-    """
-    >>> to_snake_case("one two 31235three4four", True)
-    'ONE_TWO_31235THREE4FOUR'
-    >>> to_snake_case("one two 31235three4four", False)
-    'one_two_31235three4four'
-    """
-    return to_complex_case(text, upper, "_")
-
-
-def to_kebab_case(text: str, upper: bool) -> str:
-    """
-    >>> to_kebab_case("one two 31235three4four", True)
-    'ONE-TWO-31235THREE4FOUR'
-    >>> to_kebab_case("one two 31235three4four", False)
-    'one-two-31235three4four'
-    """
-    return to_complex_case(text, upper, "-")
-
-
-if __name__ == "__main__":
-    __import__("doctest").testmod()