Finished tasks

Author: brabemi

.gitignore

@@ -0,0 +1 @@
+.vscode

1-egg_crush.py

@@ -0,0 +1,14 @@
+def height(n,m):
+    if m == 0 or n == 0:
+        return 0
+    if n>m:
+        n = m
+    bc = m
+    cnt = bc
+    for i in range(2, n+1):
+        bc = bc * (m-i+1) // i
+        cnt = (cnt + (bc % 998244353)) % 998244353
+    return cnt
+
+# print(height(80000, 100000))
+print(height(3000, 2**200))

2-ascii85.py

@@ -0,0 +1,20 @@
+import base64
+
+# def toAscii85(data):
+#     return '<~' + base64.a85encode(data.encode()).decode('ASCII') + '~>'
+
+# def fromAscii85(data):
+#     return base64.a85decode(data[2:-2].encode()).decode('ASCII')
+
+def toAscii85(data):
+    return '<~' + base64.a85encode(bytes([ord(c) for c in data])).decode('ascii') + '~>'
+
+def fromAscii85(data):
+    return ''.join([ chr(c) for c in base64.a85decode(data[2:-2].encode('ascii'))])
+
+print('test\x99'.encode('eascii'))
+
+# print(toAscii85('easy'), '<~ARTY*~>')
+# print(toAscii85('somewhat difficult'), '<~F)Po,GA(E,+Co1uAnbatCif~>')
+# print(fromAscii85('<~ARTY*~>'), 'easy')
+# print(fromAscii85('<~F)Po,GA(E,+Co1uAnbatCif~>'), 'somewhat difficult')

2-egg_crush.py

@@ -0,0 +1,90 @@
+import operator as op
+import functools
+import scipy.special
+
+def ncr(n, r):
+    r = min(r, n-r)
+    if r == 0: return 1
+    numer = functools.reduce(op.mul, range(n, n-r, -1))
+    denom = functools.reduce(op.mul, range(1, r+1))
+    return numer//denom
+
+def height_rec(n,m):
+    if m == 0 or n == 0:
+        return 0
+    if m == 1:
+        return 1
+    if n>m:
+        n = m
+    return height_rec(n-1, m-1) + 1 + height_rec(n, m-1)
+
+def height2(n,m):
+    if m == 0 or n == 0:
+        return 0
+    if n>m:
+        n = m
+    a = [0]*(m+1)
+    b = list(range(m+1))
+    b[0] = 0
+    for row in range(2,n+1):
+        a[row-1] = b[row-1]
+        for col in range(row,m+1-(n-row)):
+            a[col] = b[col-1] + 1 + a[col-1]
+        a, b = b, a
+
+    return b[m]
+
+def height3(n,m):
+    if m == 0 or n == 0:
+        return 0
+    if n>m:
+        n = m
+    a = [0]*(n+1)
+    a[n] = 1
+    op = 1
+    for row in range(m-1, 0, -1):
+        a[0] += (row+1)*a[1]
+        a[1] = a[2]
+        for col in range(2, n):
+            a[col] += a[col+1]
+            op += a[col]
+    return sum(a) + op
+
+def height(n,m):
+    if m == 0 or n == 0:
+        return 0
+    if n>m:
+        n = m
+
+    # bc -> https://en.wikipedia.org/wiki/Binomial_coefficient
+    # bc(m, 1)
+    bc = m
+    cnt = bc
+    for i in range(2, n+1):
+        # Hockey Stick Pattern - http://ptri1.tripod.com/
+        # bc(m, i) = sum(bc(x, i-1)) for x in [i-1..m-1]
+        bc = bc * (m-i+1) // i
+        cnt += bc
+    return cnt
+
+
+    # return sum(map(lambda r: ncr(m,r), range(1, n+1)))
+
+
+# print(height(2,14) == height_rec(2,14))
+# print(height(7,20) == height_rec(7,20))
+
+# print(height(17,2))
+
+print(height_rec(5,8), height(5,8))
+print(height_rec(5,11), height(5,11))
+print(height_rec(5,12), height(5,12))
+
+# print(height(7,500) == 1507386560013475)
+# print(height(237,500) == 431322842186730691997112653891062105065260343258332219390917925258990318721206767477889789852729810256244129132212314387344900067338552484172804802659)
+# print(height(477,500) == 3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127420959866658939578436425342102468327399)
+# print(height(2,10000))
+# print(height(3,10000))
+# print(height(2500-1000,2000))
+# print(height(9500,10000))
+# print(height(5,5000))

2-infinite_string.py

@@ -0,0 +1,24 @@
+def find_position(string):
+    
+
+
+print(find_position("456") , 3,"...3456...")
+print(find_position("454") , 79,"...444546...")
+print(find_position("455") , 98,"...545556...")
+print(find_position("910") , 8,"...7891011...")
+print(find_position("9100") , 188,"...9899100...")
+print(find_position("99100") , 187,"...9899100...")
+print(find_position("00101") , 190,"...9899100...")
+print(find_position("001") , 190,"...9899100...")
+print(find_position("00") , 190,"...9899100...")
+print(find_position("123456789") , 0)
+print(find_position("1234567891") , 0)
+print(find_position("123456798") , 1000000071)
+print(find_position("10") , 9)
+print(find_position("53635") , 13034)
+print(find_position("040") , 1091)
+print(find_position("11") , 11)
+print(find_position("99") , 168)
+print(find_position("667") , 122)
+print(find_position("0404") , 15050)
+print(find_position("58257860625") , 24674951477)

2-regexp_div7.py

@@ -0,0 +1,32 @@
+import re
+
+# REGEXP = '(0*|1(0(111|01)*(00|110))*(1|0(111|01)*10)(01*0(0|11(111|01)*10|(10|11(111|01)*(00|110))(0(111|01)*(00|110))*(1|0(111|01)*10)))*1)*'
+REGEXP = '\A((0|1(0(111|01)*(00|110))*(1|0(111|01)*10)(01*0(0|11(111|01)*10|(10|11(111|01)*(00|110))(0(111|01)*(00|110))*(1|0(111|01)*10)))*1)0*)+\Z'
+
+# for i in range(0, 10000):
+#     if (re.fullmatch(REGEXP, '{:b}'.format(i)) != None) != (i%7 == 0):
+#         print(i)
+
+rgx = re.compile(REGEXP)
+
+# num = 0
+
+# while bool(rgx.match(bin(num)[2:])) == (num%7 == 0):
+#     num += 1
+
+# print('Testing for: '+str(num))
+# print(bin(num)[2:])
+# print(bool(rgx.match(bin(num)[2:])),num%7 == 0)
+
+for num in range(0,50001):
+    if bool(rgx.match(bin(num)[2:])) != (num%7 == 0):
+        print('Testing for: '+str(num))
+        print(bin(num)[2:])
+        print(rgx.match(bin(num)[2:]),num%7 == 0)
+
+# *1(0(111|01)*(00|110))*(1|0(111|01)*10)
+# 01*0(0|11(111|01)*10|)
+# (10|11(111|01)*(00|110))(0(111|01)*(00|110))*(1|0(111|01)*10)
+
+# (0*1(0(111|01)*(00|110))*(1|0(111|01)*10)(01*0(0|11(111|01)*10|(10|11(111|01)*(00|110))(0(111|01)*(00|110))*(1|0(111|01)*10)))*1)*
+# (0*|1(0(111|01)*(00|110))*(1|0(111|01)*10)(01*0(0|11(111|01)*10|(10|11(111|01)*(00|110))(0(111|01)*(00|110))*(1|0(111|01)*10)))*1)*

3-atoms.py

@@ -0,0 +1,57 @@
+from collections import Counter
+
+BRC_MATCH = {'(': ')', '[': ']', '{': '}'}
+
+def parse_molecule(formula):
+    atoms = Counter()
+    elem, qnt, brc = formula[0], '', ''
+    if formula[0] in '([{':
+        elem = ''
+        brc = BRC_MATCH[formula[0]]
+
+    for c in formula[1:]:
+        if brc:
+            if c == brc:
+                brc = ''
+                elem = parse_molecule(elem)
+            else:
+                elem += c
+        elif 'A' <= c <= 'Z' or c in '([{':
+            if isinstance(elem, Counter):
+                atoms += Counter({key: val * (int(qnt) if qnt else 1) for key, val in elem.items()})
+            else:
+                atoms += Counter({elem: int(qnt) if qnt else 1})
+            elem, qnt = c, ''
+            if c in '([{':
+                elem = ''
+                brc = BRC_MATCH[c]
+        elif 'a' <= c <= 'z':
+            elem += c
+        elif '0' <= c <= '9':
+            qnt += c
+
+    if isinstance(elem, Counter):
+        atoms += Counter({key: val * (int(qnt) if qnt else 1) for key, val in elem.items()})
+    else:
+        atoms += Counter({elem: int(qnt) if qnt else 1})
+    return atoms
+
+
+
+def equals_atomically(obj1, obj2):
+    if len(obj1) != len(obj2):
+        return False
+    for k in obj1:
+        if obj1[k] != obj2[k]:
+            return False
+    return True
+
+
+print(equals_atomically(parse_molecule("(C5H5)Fe(CO)2CH3"),
+                              {'H': 2, 'O': 1}), "Should parse water")
+# print(equals_atomically(parse_molecule("H2O"),
+                            #   {'H': 2, 'O': 1}), "Should parse water")
+# print(equals_atomically(parse_molecule("Mg(OH)2"), {
+            # 'Mg': 1, 'O': 2, 'H': 2}), "Should parse magnesium hydroxide: Mg(OH)2")
+# print(equals_atomically(parse_molecule("K4[ON(SO3)2]2"), {
+            # 'K': 4,  'O': 14,  'N': 2,  'S': 4}), "Should parse Fremy's salt: K4[ON(SO3)2]2")

3-base64.py

@@ -0,0 +1,23 @@
+import base64
+
+def to_base_64(string):
+    return base64.b64encode(string.encode('ascii')).decode('ascii').replace('=', '')
+
+def from_base_64(string):
+    string += '=' * (len(string) % 4)
+    return base64.b64decode(string.encode('ascii')).decode('ascii')
+
+tests = [["this is a string!!","dGhpcyBpcyBhIHN0cmluZyEh"],
+    ["this is a test!","dGhpcyBpcyBhIHRlc3Qh"],
+    ["now is the time for all good men to come to the aid of their country.","bm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBtZW4gdG8gY29tZSB0byB0aGUgYWlkIG9mIHRoZWlyIGNvdW50cnku"],
+    ["1234567890  ", "MTIzNDU2Nzg5MCAg"],
+    ["ABCDEFGHIJKLMNOPQRSTUVWXYZ ", "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVog"],
+    ["the quick brown fox jumps over the white fence. ","dGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSB3aGl0ZSBmZW5jZS4g"],
+    ["dGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSB3aGl0ZSBmZW5jZS4","ZEdobElIRjFhV05ySUdKeWIzZHVJR1p2ZUNCcWRXMXdjeUJ2ZG1WeUlIUm9aU0IzYUdsMFpTQm1aVzVqWlM0"],
+    ["VFZSSmVrNUVWVEpPZW1jMVRVTkJaeUFna","VkZaU1NtVnJOVVZXVkVwUFpXMWpNVlJWVGtKYWVVRm5h"],
+    ["TVRJek5EVTJOemc1TUNBZyAg","VFZSSmVrNUVWVEpPZW1jMVRVTkJaeUFn"]]
+
+for test in tests:
+    result=to_base_64(test[0])
+    print(result == test[1])
+    print(from_base_64(result) == test[0])

3-calculator.py

@@ -0,0 +1,15 @@
+from decimal import Decimal
+import re
+
+class Calculator(object):
+    def evaluate(self, string):
+        # parts = ['Decimal(' + part + ')' if re.fullmatch(r'\d+(\.\d+)?', part) else part for part in string.split(' ')]
+        parts = map(lambda p: "Decimal('" + p + "')" if re.fullmatch(r'\d+(\.\d+)?', p) else p , string.split(' '))
+        code = ' '.join(parts)
+        print(code)
+
+        return float(eval(code))
+
+
+print(Calculator().evaluate("2 / 2 + 3 * 4 - 6"))
+print(Calculator().evaluate("1.1 * 2.2 * 3.3"))

3-did_you_mean.py

@@ -0,0 +1,41 @@
+class Dictionary:
+    def __init__(self,words):
+        self.words=words
+
+    def __levenshtein(self, s1, s2):
+        ''' https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#Python '''
+        if len(s1) < len(s2):
+            return self.__levenshtein(s2, s1)
+
+        # len(s1) >= len(s2)
+        if len(s2) == 0:
+            return len(s1)
+
+        previous_row = range(len(s2) + 1)
+        for i, c1 in enumerate(s1):
+            current_row = [i + 1]
+            for j, c2 in enumerate(s2):
+                insertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer
+                deletions = current_row[j] + 1       # than s2
+                substitutions = previous_row[j] + (c1 != c2)
+                current_row.append(min(insertions, deletions, substitutions))
+            previous_row = current_row
+
+        return previous_row[-1]
+
+    def find_most_similar(self,term):
+        word = None
+        diff = len(term)
+        for w in self.words:
+            tmp_diff = self.__levenshtein(term, w)
+            # print(term, w, tmp_diff, tmp_diff < diff)
+            if tmp_diff < diff:
+                diff = tmp_diff
+                word = w
+        return word
+
+words=['cherry', 'peach', 'pineapple', 'melon', 'strawberry', 'raspberry', 'apple', 'coconut', 'banana']
+test_dict=Dictionary(words)
+print(test_dict.find_most_similar('strawbery'),'strawberry')
+print(test_dict.find_most_similar('berry'),'cherry')
+print(test_dict.find_most_similar('aple'),'apple')

3-fibbonacci.py

@@ -0,0 +1,40 @@
+def my_matrix_multiply(a, b):
+    m0000 = a[0][0] * b[0][0]
+    # m0101 = m0110 = m1001 = m1010 = a[0][1] * b[1][0]
+    m0110 = m1001 = a[0][1] * b[1][0]
+    # m0001 = m0010 = a[0][0] * b[0][1]
+    m0001 = a[0][0] * b[0][1]
+    # m0111 = m1011 = a[0][1] * b[1][1]
+    m0111 = a[0][1] * b[1][1]
+    m1111 = a[1][1]*b[1][1]
+    return [
+        [m0000 + m0110, m0001 + m0111],
+        # [a[1][0]*b[0][0] + a[1][1]*b[1][0], a[1][0]*b[0][1] + a[1][1]*b[1][1]]
+        [m0001 + m0111, m1001 + m1111]
+    ]
+
+def fib(n):
+    q = 1
+    if n == 0:
+        return 0
+    if n < 0:
+        n = -1*n
+        if n % 2 == 0:
+            q = -1
+    matrix = [[1, 1], [1, 0]]
+    result = [[1, 0], [0, 1]]
+    for c in '{:b}'.format(n-1)[::-1]:
+        if c == '1':
+            result = my_matrix_multiply(result, matrix)
+        matrix = my_matrix_multiply(matrix, matrix)
+    return q * result[0][0]
+
+
+print(fib(0))
+print(fib(1))
+print(fib(2))
+print(fib(3))
+print(fib(17))
+# print(fib(1000000))
+print(fib(10))
+print(fib(-10))