Merge branch 'TheAlgorithms:master' into main

Author: tianyizheng02

Diff for: .pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
     -   id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.288
+    rev: v0.0.291
     hooks:
       - id: ruff
 

Diff for: ciphers/base32.py

@@ -1,42 +1,45 @@
-import base64
+"""
+Base32 encoding and decoding
 
+https://en.wikipedia.org/wiki/Base32
+"""
+B32_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
 
-def base32_encode(string: str) -> bytes:
+
+def base32_encode(data: bytes) -> bytes:
     """
-    Encodes a given string to base32, returning a bytes-like object
-    >>> base32_encode("Hello World!")
+    >>> base32_encode(b"Hello World!")
     b'JBSWY3DPEBLW64TMMQQQ===='
-    >>> base32_encode("123456")
+    >>> base32_encode(b"123456")
     b'GEZDGNBVGY======'
-    >>> base32_encode("some long complex string")
+    >>> base32_encode(b"some long complex string")
     b'ONXW2ZJANRXW4ZZAMNXW24DMMV4CA43UOJUW4ZY='
     """
-
-    # encoded the input (we need a bytes like object)
-    # then, b32encoded the bytes-like object
-    return base64.b32encode(string.encode("utf-8"))
+    binary_data = "".join(bin(ord(d))[2:].zfill(8) for d in data.decode("utf-8"))
+    binary_data = binary_data.ljust(5 * ((len(binary_data) // 5) + 1), "0")
+    b32_chunks = map("".join, zip(*[iter(binary_data)] * 5))
+    b32_result = "".join(B32_CHARSET[int(chunk, 2)] for chunk in b32_chunks)
+    return bytes(b32_result.ljust(8 * ((len(b32_result) // 8) + 1), "="), "utf-8")
 
 
-def base32_decode(encoded_bytes: bytes) -> str:
+def base32_decode(data: bytes) -> bytes:
     """
-    Decodes a given bytes-like object to a string, returning a string
     >>> base32_decode(b'JBSWY3DPEBLW64TMMQQQ====')
-    'Hello World!'
+    b'Hello World!'
     >>> base32_decode(b'GEZDGNBVGY======')
-    '123456'
+    b'123456'
     >>> base32_decode(b'ONXW2ZJANRXW4ZZAMNXW24DMMV4CA43UOJUW4ZY=')
-    'some long complex string'
+    b'some long complex string'
     """
-
-    # decode the bytes from base32
-    # then, decode the bytes-like object to return as a string
-    return base64.b32decode(encoded_bytes).decode("utf-8")
+    binary_chunks = "".join(
+        bin(B32_CHARSET.index(_d))[2:].zfill(5)
+        for _d in data.decode("utf-8").strip("=")
+    )
+    binary_data = list(map("".join, zip(*[iter(binary_chunks)] * 8)))
+    return bytes("".join([chr(int(_d, 2)) for _d in binary_data]), "utf-8")
 
 
 if __name__ == "__main__":
-    test = "Hello World!"
-    encoded = base32_encode(test)
-    print(encoded)
+    import doctest
 
-    decoded = base32_decode(encoded)
-    print(decoded)
+    doctest.testmod()

Diff for: ciphers/base85.py

@@ -1,30 +1,55 @@
-import base64
+"""
+Base85 (Ascii85) encoding and decoding
 
+https://en.wikipedia.org/wiki/Ascii85
+"""
 
-def base85_encode(string: str) -> bytes:
+
+def _base10_to_85(d: int) -> str:
+    return "".join(chr(d % 85 + 33)) + _base10_to_85(d // 85) if d > 0 else ""
+
+
+def _base85_to_10(digits: list) -> int:
+    return sum(char * 85**i for i, char in enumerate(reversed(digits)))
+
+
+def ascii85_encode(data: bytes) -> bytes:
     """
-    >>> base85_encode("")
+    >>> ascii85_encode(b"")
     b''
-    >>> base85_encode("12345")
+    >>> ascii85_encode(b"12345")
     b'0etOA2#'
-    >>> base85_encode("base 85")
+    >>> ascii85_encode(b"base 85")
     b'@UX=h+?24'
     """
-    # encoded the input to a bytes-like object and then a85encode that
-    return base64.a85encode(string.encode("utf-8"))
+    binary_data = "".join(bin(ord(d))[2:].zfill(8) for d in data.decode("utf-8"))
+    null_values = (32 * ((len(binary_data) // 32) + 1) - len(binary_data)) // 8
+    binary_data = binary_data.ljust(32 * ((len(binary_data) // 32) + 1), "0")
+    b85_chunks = [int(_s, 2) for _s in map("".join, zip(*[iter(binary_data)] * 32))]
+    result = "".join(_base10_to_85(chunk)[::-1] for chunk in b85_chunks)
+    return bytes(result[:-null_values] if null_values % 4 != 0 else result, "utf-8")
 
 
-def base85_decode(a85encoded: bytes) -> str:
+def ascii85_decode(data: bytes) -> bytes:
     """
-    >>> base85_decode(b"")
-    ''
-    >>> base85_decode(b"0etOA2#")
-    '12345'
-    >>> base85_decode(b"@UX=h+?24")
-    'base 85'
+    >>> ascii85_decode(b"")
+    b''
+    >>> ascii85_decode(b"0etOA2#")
+    b'12345'
+    >>> ascii85_decode(b"@UX=h+?24")
+    b'base 85'
     """
-    # a85decode the input into bytes and decode that into a human readable string
-    return base64.a85decode(a85encoded).decode("utf-8")
+    null_values = 5 * ((len(data) // 5) + 1) - len(data)
+    binary_data = data.decode("utf-8") + "u" * null_values
+    b85_chunks = map("".join, zip(*[iter(binary_data)] * 5))
+    b85_segments = [[ord(_s) - 33 for _s in chunk] for chunk in b85_chunks]
+    results = [bin(_base85_to_10(chunk))[2::].zfill(32) for chunk in b85_segments]
+    char_chunks = [
+        [chr(int(_s, 2)) for _s in map("".join, zip(*[iter(r)] * 8))] for r in results
+    ]
+    result = "".join("".join(char) for char in char_chunks)
+    offset = int(null_values % 5 == 0)
+    return bytes(result[: offset - null_values], "utf-8")
 
 
 if __name__ == "__main__":