Init commit 2

Author: Artsiom Tkachou

4statements.py

@@ -0,0 +1,38 @@
+import itertools
+
+
+def f1(x, y, z):
+    return (x, z + 2, z)
+
+
+def f2(x, y, z):
+    return (y + z * 2, y, z)
+
+
+def f3(x, y, z):
+    return (y - 3, y, z)
+
+
+def f4(x, y, z):
+    return (x, y, x + y)
+
+
+arr_fun = [f1, f2, f3, f4]
+
+
+def get_max():
+    max = float("-infinity")
+    result = []
+    for arr in itertools.permutations(arr_fun):
+        xyz = (1, 2, 3)
+        for fun in arr:
+            xyz = fun(*xyz)
+        if xyz[0] > max:
+            max = xyz[0]
+            result = arr
+    return max, result
+
+
+m, vector = get_max()
+print m
+print vector

aquareroot.py

@@ -0,0 +1,19 @@
+def squareroot(n):
+    if n < 0:
+        raise ValueError
+    if n == 1:
+        return 1
+    result = 1
+    for i in range(n / 2 + 1):
+        if i ** 2 == n:
+            return i
+        elif i ** 2 > n:
+            return i - 1
+    return result
+
+
+def squareroot2(n):
+    pass
+
+
+print(squareroot(1))

array_pair_sum.py

@@ -0,0 +1,18 @@
+def get_pairs_sum(array, sum):
+    array.sort()
+    result = []
+    s = 0
+    e = len(array) - 1
+    while s < e:
+        if array[s] + array[e] == sum:
+            result.append((array[s], array[e]))
+            s += 1
+        elif array[s] + array[e] < sum:
+            s += 1
+        else:
+            e -= 1
+    return result
+
+if __name__ == "__main__":
+    a = [2, 5, 7, 9, 4, 10, 13, 1]
+    print(get_pairs_sum(a, 14))

bash_cmd.py

@@ -0,0 +1,7 @@
+bashCommand = "ls"
+import subprocess
+process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+output = process.communicate()[0].split("\n")[:-1]
+print(output[0])
+for file in output:
+    print(file)

bin_search.py

@@ -0,0 +1,52 @@
+a = [1, 34, 76, 45, 97, 56, 79, 356, 579, 454, 578, 467, 786]
+a = sorted(a)
+
+
+def bin_search(iterable, target):
+    start = 0
+    end = len(iterable)
+
+    while end - start != 1:
+        guess = (end + start) / 2
+        if iterable[guess] == target:
+            return guess
+        elif iterable[guess] < target:
+            start = guess
+        else:
+            end = guess
+
+    return start, end
+
+
+class BinSearchArray(object):
+    def __init__(self):
+        self.container = []
+
+    def add(self, item):
+        index = self.bin_search_position(item)
+        self.container.insert(index, item)
+
+    def bin_search_position(self, target):
+        start = 0
+        end = len(self.container)
+        if start != end:
+            while end - start != 1:
+                guess = (end + start) / 2
+                if self.container[guess] == target:
+                    return guess
+                elif self.container[guess] < target:
+                    start = guess + 1
+                else:
+                    end = guess - 1
+        return start
+
+
+# print a
+# print bin_search(a, 0)
+
+search = BinSearchArray()
+search.add(3)
+search.add(1)
+search.add(2)
+
+print search.container

bin_search_tree_check.py

@@ -0,0 +1,20 @@
+class Node(object):
+    def __init__(self, val):
+        self.left, self.right, self.val = None, None, val
+
+
+MINUS_INF = float("-infinity")
+PLUS_INF = float("infinity")
+
+
+def check_tree(tree, min_val=MINUS_INF, max_val=PLUS_INF):
+    if tree is None:
+        return True
+
+    if not min_val <= tree.val <= max_val:
+        return False
+
+    return check_tree(tree.left, min_val, tree.val) and \
+           check_tree(tree.right, tree.val, max_val)
+
+

camel_case_matcher.py

@@ -0,0 +1,80 @@
+l = ["Hello", "World" "HelloMars", "HelloWorld", "HelloWorldMars", "HiHo"]
+
+patterns = ["H", "He", "HeW", "HeWo", "HeWor", "HeWorM"]
+# patterns = ["H", "HW", "Ho", "HeWorM", "He"]
+
+d = {
+    "HelloMars": ["Hello", "Mars"],
+    "HelloWorld": ["Hello", "World"],
+    "HelloWorldMars": ["Hello", "World", "Mars"],
+    "HiHo": ["Hi", "Ho"]
+}
+
+
+def split_camel_case(word):
+    result = []
+    start = 0
+    for i in range(1, len(word)):
+        if word[i].isupper():
+            result.append(word[start:i])
+            start = i
+    result.append(word[start:])
+    return result
+
+
+# for word in l:
+#     print split_camel_case(word)
+
+print '-----------'
+
+pat = "HeWorM"
+
+
+# print split_camel_case(pat)
+
+
+def generate_splitetd_dict(l):
+    result = {}
+    for word in l:
+        result[word] = split_camel_case(word)
+    return result
+
+
+# print generate_splitetd_dict(l)
+
+
+def get_classes(p, l):
+    pl = split_camel_case(p)
+    spl_d = generate_splitetd_dict(l)
+    for i in range(len(pl)):
+        for k, v in spl_d.items():
+            approved = False
+            for w_i in range(i, len(v)):
+                if v[w_i].startswith(pl[i]):
+                    approved = True
+            if not approved:
+                del spl_d[k]
+    return spl_d.keys()
+
+
+for pattern in patterns:
+    print pattern, get_classes(pattern, l)
+
+
+def word_mut(word):
+    result = []
+    for i in range(len(word)):
+        result.append(word[:i + 1])
+    return result
+
+
+def get_all_patterns(clazz):
+    words = split_camel_case(clazz)
+    result = []
+    for word in words:
+        result.append(word_mut(word))
+    return result
+
+
+print "---------"
+print get_all_patterns("HelloWorldMars")

check_balanced_parentheses.py

@@ -0,0 +1,22 @@
+def check(expr):
+    if len(expr) % 2 != 0:
+        return False
+    matcher = {("(", ")"), ("{", "}"), ("[", "]")}
+    opened = set([x[0] for x in matcher])
+    stack = []
+    for char in expr:
+        if char in opened:
+            stack.append(char)
+        else:
+            if len(stack) == 0:
+                return False
+            last = stack.pop()
+            if (last, char) not in matcher:
+                return False
+    return len(stack) == 0
+
+expr = "{()}"
+expr2 = "([{{{}}}])"
+
+print check(expr)
+print check(expr2)

chess_horse.py

@@ -0,0 +1,56 @@
+import collections
+
+
+def get_acceptable_steps(i, j):
+    template = {(i + 1, j - 2), (i + 1, j + 2), (i - 1, j - 2),
+                (i - 1, j + 2), (i + 2, j - 1), (i + 2, j + 1),
+                (i - 2, j + 1), (i - 2, j - 1)}
+    return {x for x in template if 0 <= x[0] <= 7 and 0 <= x[1] <= 7}
+
+
+def generate_horse_graph():
+    graph = collections.defaultdict(set)
+    for i in range(8):
+        for j in range(8):
+            graph[(i, j)] = graph[(i, j)] | get_acceptable_steps(i, j)
+
+    return dict(graph)
+
+
+def path(graph, start, goal):
+    paths = collections.deque([[start]])
+    extended = set()
+    while len(paths) != 0:
+        current_path = paths.popleft()
+        current_point = current_path[-1]
+        if current_point == goal:
+            return current_path
+        elif current_point in extended:
+            continue
+        extended.add(current_point)
+        transforms = graph[current_point]
+        for word in transforms:
+            if word not in current_path:
+                paths.append(current_path[:] + [word])
+    return []
+
+
+def bfs_paths(graph, start, goal):
+    queue = [(start, [start])]
+    while queue:
+        (vertex, path) = queue.pop(0)
+        for next in graph[vertex] - set(path):
+            if next == goal:
+                yield path + [next]
+            else:
+                queue.append((next, path + [next]))
+
+
+graph = generate_horse_graph()
+# print graph
+sp = (0, 0)
+ep = (4, 3)
+
+# print path(graph, sp, ep)
+gen = bfs_paths(graph, sp, ep)
+print gen.next()

cli_scelet.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python
+
+# This script is a template for writing CLI commands in python.
+
+# Note using "#!/usr/bin/env python" above will
+# cause the system to register the name (in ps etc.)
+# as "python" rather than the command name
+# (as "python" is passed to exec by env).
+
+import sys
+
+
+# The following exits cleanly on Ctrl-C,
+# while treating other exceptions as before.
+def cli_exception(type, value, tb):
+    if not issubclass(type, KeyboardInterrupt):
+        sys.__excepthook__(type, value, tb)
+
+
+if sys.stdin.isatty():
+    sys.excepthook = cli_exception
+
+# The following demonstrates common option argument processing
+import os
+
+
+def Usage():
+    print "Usage: %s [OPTION] [PATHS]" % os.path.split(sys.argv[0])[1]
+    print "    --name=value    whatever"
+    print "    --help          display help"
+
+
+import getopt
+
+try:
+    lOpts, lArgs = getopt.getopt(sys.argv[1:], "", ["help", "name="])
+
+    if len(lArgs) == 0:
+        lArgs = [os.getcwd()]
+
+    if ("--help", "") in lOpts:
+        Usage()
+        sys.exit(None)
+
+    name = None
+    for opt in lOpts:
+        if opt[0] == "--name":
+            name = opt[1]
+            print "name =", name
+
+except getopt.error, msg:
+    print msg
+    print
+    Usage()
+    sys.exit(2)
+
+print "processing", lArgs
+print "Ctrl-C to exit"
+sys.stdin.readline()

cli_template.py

@@ -0,0 +1,14 @@
+A0 = dict(zip(('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, 5)))
+print A0
+A1 = range(10)
+print A1
+A2 = sorted([i for i in A1 if i in A0])
+print A2
+A3 = sorted([A0[s] for s in A0])
+print A3
+A4 = [i for i in A1 if i in A3]
+print A4
+A5 = {i: i * i for i in A1}
+print A5
+A6 = [[i, i * i] for i in A1]
+print A6