Added binary conversions

Author: IanDoarn

pygorithm/__init__.py

@@ -57,11 +57,12 @@
 ]
 
 __all__ = [
+    'binary',
     'data_structures',
     'fibonacci',
     'math',
     'searching',
     'sorting',
     'string',
-    'pathfinding',
+    'pathfinding'
 ]

pygorithm/binary/__init__.py

@@ -0,0 +1,26 @@
+"""
+Collection or binary conversions and algorithms
+"""
+from . import base2_to_base10
+from . import base2_to_base16
+from . import base2_to_ascii
+from . import base10_to_base2
+from . import base10_to_base16
+from . import base16_to_base2
+from . import base16_to_base10
+from . import base16_to_ascii
+from . import ascii_to_base2
+from . import ascii_to_base16
+
+__all__ = [
+    'ascii_to_base2',
+    'ascii_to_base16',
+    'base2_to_base10',
+    'base2_to_base16',
+    'base2_to_ascii',
+    'base10_to_base2',
+    'base10_to_base16',
+    'base16_to_base10',
+    'base16_to_base2',
+    'base16_to_ascii'
+]

pygorithm/binary/ascii_to_base16.py

@@ -0,0 +1,29 @@
+"""
+ASCII to Hexadecimal
+
+Author: Ian Doarn
+"""
+from pygorithm.binary.ascii_to_base2 import convert_ascii_to_base2
+from pygorithm.binary.base2_to_base16 import convert_base2_to_base16
+from pygorithm.binary.base2_to_ascii import convert_base2_to_ascii
+
+
+def convert_ascii_to_base16(string, visualize=False):
+    """
+    Convert ascii to hexadecimal
+
+    :param string: string to convert
+    :param visualize: Show process
+    :param as_string: return value as string not array
+    :return: hex representation of given string
+    """
+    hex_array = []
+
+    for b_value in convert_ascii_to_base2(string):
+        if visualize:
+            print("{} -> {}".format(
+                convert_base2_to_ascii(b_value), convert_base2_to_base16(b_value)
+            ))
+        hex_array.append(convert_base2_to_base16(b_value))
+
+    return hex_array

pygorithm/binary/ascii_to_base2.py

@@ -0,0 +1,29 @@
+"""
+ASCII to Binary
+
+Author: Ian Doarn
+"""
+from pygorithm.binary.base10_to_base2 import convert_base10_to_base2
+
+
+def convert_ascii_to_base2(string, visualize=False, as_string=False):
+    """
+    Convert ascii string to binary
+
+    :param string: Ascii string
+    :param visualize: Show process
+    :param as_string: join strings with a space as one large value
+    :return: array of binary numbers, or entire string
+    """
+    _list = []
+    for x in string:
+        if visualize:
+            print("{} -> {} -> {}".format(
+                x, str(ord(x)),
+                str(convert_base10_to_base2(ord(x)))
+            ))
+        _list.append(str(convert_base10_to_base2(ord(x))))
+
+    if as_string:
+        return ' '.join(_list)
+    return _list

pygorithm/binary/base10_to_base16.py

@@ -0,0 +1,46 @@
+"""
+Convert decimal numbers to hexadecimal numbers
+
+Author: Ian Doarn
+"""
+
+
+hex_values = {
+    0: '0', 1: '1', 2: '2',
+    3: '3', 4: '4', 5: '5',
+    6: '6', 7: '7', 8: '8',
+    9: '9', 10: 'A', 11: 'B',
+    12: 'C', 13: 'D', 14: 'E',
+    15: 'F'
+}
+
+
+def convert_base10_to_base16(n, visualize=False):
+    """
+    Convert decimal number to hexadecimal
+
+    Divide the number by 16 and add the remainder
+    to a list, round down the value after division
+    and repeat till our value is 0
+
+    Reverse the results list, get each values respective
+    hex value using hex_values map
+
+    :param n: decimal number
+    :param visualize: Show process
+    :return: hexadecimal number
+    """
+    _list = []
+    while n != 0:
+        if visualize:
+            print("{} % 16 = {} -> hex = {}".format(
+                str(n), str(n % 16), hex_values[n % 16]
+            ))
+            _list.append(hex_values[n % 16])
+        n = int(n / 16)
+
+    if visualize:
+        print(_list)
+        print("reversed = " + str(_list[::-1]))
+
+    return ''.join(_list[::-1])

pygorithm/binary/base10_to_base2.py

@@ -0,0 +1,31 @@
+"""
+Base10 to Base2
+
+Convert decimal numbers to binary numbers
+
+Author: Ian Doarn
+"""
+
+
+def convert_base10_to_base2(n, visualize=False):
+    """
+    Divide each number by 2 using
+    the % operator.
+
+    Reverse the resulting list of numbers
+    and return the result
+
+    :param n: decimal number
+    :param visualize: Show process
+    :return: binary number
+    """
+    _list = []
+    while n > 0.5:
+        if visualize:
+            print("{} / 2 = {} || {} % 2 = {}".format(str(n), str(n / 2), str(n), str(n % 2)))
+        _list.append(n % 2)
+        n = int(n / 2)
+
+    # Reverse the list, turn each number to a string,
+    # join the string, and convert it back to an integer
+    return int(''.join([str(i) for i in _list[::-1]]))

pygorithm/binary/base16_to_ascii.py

@@ -0,0 +1,53 @@
+"""
+Hexadecimal to ASCII
+
+Author: Ian Doarn
+"""
+from pygorithm.binary.base16_to_base2 import convert_base16_to_base2
+from pygorithm.binary.base2_to_ascii import convert_base2_to_ascii
+
+
+def convert_base16_to_ascii(h_array, visualize=False):
+    """
+    Convert base16 array to ASCII string
+
+    Input must be a list of strings:
+    Example::
+
+    array = [
+        '74', '68', '65',
+        '20', '71', '75',
+        '69', '63', '6B',
+        '20', '62', '72',
+        '6F', '77', '6E',
+        '20', '66', '6F',
+        '78', '20', '6A',
+        '75', '6D', '70',
+        '73', '20', '6F',
+        '76', '65', '72',
+        '20', '74', '68',
+        '65', '20', '6C',
+        '61', '7A', '79',
+        '20', '64', '6F',
+        '67'
+    ]
+
+    result -> the quick brown fox jumps over the lazy dog
+
+    :param h_array: hex value array
+    :param visualize: Show process
+    :return: ASCII string
+    """
+    string = ''
+
+    for h_value in h_array:
+        if visualize:
+            print("{} -> {} -> {}".format(
+                h_value,
+                convert_base16_to_base2(h_value),
+                convert_base2_to_ascii(str(convert_base16_to_base2(h_value)))
+            ))
+
+        string += convert_base2_to_ascii(str(convert_base16_to_base2(h_value)))
+
+    return string

pygorithm/binary/base16_to_base10.py

@@ -0,0 +1,57 @@
+"""
+Hexadecimal to Decimal
+
+Author: Ian Doarn
+"""
+from math import pow
+
+hex_letter_values = {
+    '0': 0, '1': 1, '2': 2,
+    '3': 3, '4': 4, '5': 5,
+    '6': 6, '7': 7, '8': 8,
+    '9': 9, 'A': 10, 'B': 11,
+    'C': 12, 'D': 13, 'E': 14,
+    'F': 15
+}
+
+
+def convert_base16_to_base10(h, visualize=False):
+    """
+    Convert hexadecimal number to decimal number
+    
+    Send hex to a list and reverse. Evaluate each hex value
+    via hex_letter_values map. Enumerate the list,
+    
+    using the equation: value * 16 ^ index
+    
+    value is the hex char value: F -> 15
+    index is its position in the list: ['1', 'A', 'F'] F's index = 2
+    
+    Continue this for each hex letter until we reach the end of the list,
+    summing all evaluated values.
+    
+    :param h: hexadecimal number
+    :param visualize: Show process
+    :return: decimal number
+    """
+
+    # Check to see if '0x' is at the beginning and remove it
+    if h[0:2] == '0x':
+        hex_char_list = list(h[2:])[::-1]
+    else:
+        hex_char_list = list(h)[::-1]
+
+    value = 0
+
+    for i, v in enumerate(hex_char_list):
+        if visualize:
+            print("{} -> {} || {} * (16 ^ {}) = {}".format(
+                v, str(hex_letter_values[v]),
+                str(hex_letter_values[v]),
+                str(i),
+                str(hex_letter_values[v] * (pow(16, i)))
+            ))
+
+        value += hex_letter_values[v] * (pow(16, i))
+
+    return int(value)

pygorithm/binary/base16_to_base2.py

@@ -0,0 +1,34 @@
+"""
+Hexadecimal to Binary
+
+Author: Ian Doarn
+"""
+
+hex_binary_values = {
+    '0': '0000', '1': '0001', '2': '0010', '3': '0011',
+    '4': '0100', '5': '0101', '6': '0110', '7': '0111',
+    '8': '1000', '9': '1001', 'A': '1010', 'B': '1011',
+    'C': '1100', 'D': '1101', 'E': '1110', 'F': '1111'
+}
+
+
+def convert_base16_to_base2(h, visualize=False):
+    """
+    Convert hexadecimal to binary number
+
+    :param h: hexadecimal number
+    :param visualize: Show process
+    :return: binary number
+    """
+
+    hex_char_list = list(h)
+    _list = []
+
+    for value in hex_char_list:
+        if visualize:
+            print("{} -> {}".format(
+                value, hex_binary_values[value]
+            ))
+        _list.append(hex_binary_values[value])
+
+    return int(''.join(_list))

pygorithm/binary/base2_to_ascii.py

@@ -0,0 +1,34 @@
+"""
+Base2 to ASCII
+
+Author: Ian Doarn
+"""
+from pygorithm.binary.base2_to_base10 import convert_base2_to_base10
+
+
+def convert_base2_to_ascii(b, visualize=False):
+    """
+    Convert binary to ASCII
+
+    :param b: binary number or array
+    :param visualize: Show process
+    :return: ASCII String
+    """
+    binary = b
+    # Make sure give binary is a str array
+    if type(b) is str:
+        binary = b.split(' ')
+    elif type(b) is list:
+        binary = b
+
+    string = ''
+
+    for b_value in binary:
+        if visualize:
+            print("{} -> {} -> {}".format(
+                b_value, convert_base2_to_base10(int(b_value)),
+                chr(convert_base2_to_base10(int(b_value)))
+            ))
+        value = convert_base2_to_base10(int(b_value))
+        string += chr(value)
+    return string