Problems/Theory

Author: DimDob

Algorithms/Permutations algorithm.py

@@ -0,0 +1,15 @@
+def permute(idx, elements):
+    if idx >= len(elements):
+        print(elements)
+        return
+    permute(idx + 1, elements)
+
+    for i in range(idx + 1, len(elements)):
+        elements[idx], elements[i] = elements[i], elements[idx]
+        permute(idx + 1, elements)
+        elements[idx], elements[i] = elements[i], elements[idx]
+
+
+
+elements = ['A', 'B', 'C']
+permute(0, elements)

Algorithms/Polinomical algorithm.py

@@ -0,0 +1,15 @@
+class Polinomical:
+    def __init__(self, arg, data: list):
+        self.arg = arg
+        self.data = data
+
+    def eval_polynomial(self):
+        return sum((current_el*self.arg**idx for idx,current_el in enumerate(self.data)))
+
+
+    def multiply_by_one_term(self):
+        return [0]*self.arg + [self.arg*idx for idx in self.data]
+
+obj = Polinomical(3, [1,2,3])
+print(obj.eval_polynomial())
+print(obj.multiply_by_one_term())

Algorithms/__init__.py

@@ -0,0 +1,24 @@
+class Fibonacci:
+    def __init__(self, n):
+        self.n = n
+        self.sequence = [1, 1]
+        self.iterations = len(self.sequence)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.iterations == self.n:
+            print(self.sequence)
+            raise StopIteration
+
+        a = self.sequence[-2]
+        b = self.sequence[-1]
+
+        a, b = b, a+b
+        self.sequence.append(b)
+
+        self.iterations += 1
+
+
+obj = list(Fibonacci(10))

DecoratorsIterators/10(Fibonacci sequence using iterator-object).py

@@ -0,0 +1,15 @@
+class Polinomical:
+    def __init__(self, arg, data: list):
+        self.arg = arg
+        self.data = data
+
+    def eval_polynomial(self):
+        return sum((current_el*self.arg**idx for idx,current_el in enumerate(self.data)))
+
+
+    def multiply_by_one_term(self):
+        return [0]*self.arg + [self.arg*idx for idx in self.data]
+
+obj = Polinomical(3, [1,2,3])
+print(obj.eval_polynomial())
+print(obj.multiply_by_one_term())

DecoratorsIterators/8(Polinomical algorithm).py

@@ -0,0 +1,13 @@
+class MyClass:
+    def __init__(self, vals):
+        if not isinstance(vals, list):
+            return
+        self.vals = vals
+
+    def __add__(self, other):
+        return self.vals + other
+
+obj_1 = [1,2,3]
+obj_2 = [4,5,6]
+print(obj_1.__add__(obj_2))
+print(obj_1 + [1,7,5])

DecoratorsIterators/__add__method.py

@@ -0,0 +1,23 @@
+class MyClass:
+    def __init__(self, val):
+        if not isinstance(val, list):
+            return
+        self.val = val
+
+    @property
+    def val(self):
+        return self.__val
+
+    @val.setter
+    def val(self, value: list):
+
+        self.__val = [x for x in value if type(x) == str]
+
+    def __str__(self):
+        res = ''
+        for el in self.val:
+            res += el[0]
+        return res
+
+obj = MyClass([1, 2, "Hello", 'i', ' ', "i", "'", 4, 'm', 3, 4, ' ', 'D', 'i', 'm', 4, 'i', 6, 7, 't', 'h', 'e', 'r'])
+print(obj)

DecoratorsIterators/__init__.py

@@ -0,0 +1,25 @@
+class MyClass:
+    def __init__(self, one: list, two:list):
+        self.one = one
+        self.two = two
+
+
+    def get_two(self):
+        return self.two
+
+    def __getitem__(self, item):
+        if item < 0 or item > len(self.one):
+            return 0
+        if item == 'one':
+            return self.one[item]
+        return self.two[item]
+
+
+
+
+    def __setitem__(self, key, value):
+        self.one[key] = value
+        return self.one[key]
+
+obj_one = MyClass([1, 2, 3], [3,4,5])
+x = obj_one.one[4] + obj_one.two[1]

DecoratorsIterators/decorators-getterAndSetter.py

@@ -0,0 +1,20 @@
+class Odd:
+    def __init__(self, n):
+        self.n = n
+        self.iteration = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        while self.iteration <= self.n:
+            current_number = self.iteration
+            self.iteration += 1
+            if not current_number % 2 == 0:
+                return current_number
+        else:
+            raise StopIteration
+
+
+obj = Odd(5)
+print(list(obj))

DecoratorsIterators/getitem_attr.py

@@ -0,0 +1,26 @@
+class MyClass:
+    def __init__(self, number):
+        self.number = number
+
+    def __add__(self, other):
+        return self.number + other
+
+    def __sub__(self, other):
+        return self.number - other
+
+    def __rsub__(self, other):
+        return abs(self.number - other)
+
+    def __mul__(self, other):
+        return self.number * other
+
+    def __truediv__(self, other):
+        return self.number / other
+
+obj = MyClass(5)
+print(obj + 5)
+print(obj - 4)
+print(8 - obj)
+print(obj * 5)
+print(obj / 2)
+

DecoratorsIterators/iterator_object.py

@@ -0,0 +1,33 @@
+class Person:
+    def __init__(self, name):
+        self.name = name
+
+    def show(self):
+        return self.name
+
+
+class Student(Person):
+    def __init__(self, name, faculty_number):
+        super().__init__(name)
+        self.faculty_number = faculty_number
+
+    def show(self):
+        return f"Student has name: {self.name} and faculty number: {self.faculty_number}"
+
+
+class Teacher(Person):
+    def __init__(self, name, subject):
+        super().__init__(name)
+        self.subject = subject
+
+    def show(self):
+        return f"Teacher {self.name} has subject {self.subject}"
+
+
+p = Person('Ivan')
+s = Student('Kaloyan', 'f95532')
+t = Teacher('Asen', 'mathematics')
+
+print(p.show())
+print(s.show())
+print(t.show())

DecoratorsIterators/other_special_methods.py

@@ -0,0 +1,19 @@
+class MyClass:
+    def __init__(self, integer, string_type, is_float):
+        self.integer = integer
+        self.string_type = string_type
+        self.is_float = is_float
+
+    def __int__(self):
+        return f'Type of {self.integer} is of class int.'
+
+    def __str__(self):
+        return f"Type of '{self.string_type}' is of class str."
+
+    def __float__(self):
+        return f"Type of {self.is_float} is of class float."
+
+obj = MyClass(1, 'hello', 5.1)
+print(obj.__int__())
+print(obj.__str__())
+print(obj.__float__())

DecoratorsIterators/show_method.py

@@ -0,0 +1,45 @@
+class MyClass:
+    def __init__(self, values):
+        if not isinstance(values, list):
+            return
+        self.values = values
+
+    def __len__(self, other):
+        diff = abs(len(self.values) - len(other.values))
+        if len(self.values) < len(other.values):
+            for _ in range(diff):
+                self.values.append(0)
+            return self.values
+        for _ in range(diff):
+            other.values.append(0)
+        return other.values
+
+    def __eq__(self, other):
+        return self.values[0] == other.values[0]
+
+    def __ne__(self, other):
+        return bool(self.values[1] != other.values[1])
+
+    def __lt__(self, other):
+        return bool(self.values[2] < other.values[2])
+
+    def __gt__(self, other):
+        return bool(self.values[3] > other.values[3])
+
+    def __ge__(self, other):
+        return bool(self.values[4] >= other.values[4])
+
+    def __le__(self, other):
+        return bool(self.values[5] <= other.values[5])
+
+
+
+obj_1 = MyClass([1,2,3,4])
+obj_2 = MyClass([1,6,7,8, 3, 7])
+obj_1.__len__(obj_2)
+print(obj_1 == obj_2)
+print(obj_1 != obj_2)
+print(obj_1 < obj_2)
+print(obj_1 > obj_2)
+print(obj_1 >= obj_2)
+print(obj_1 <= obj_2)

DecoratorsIterators/special_attrs_datatype.py

@@ -0,0 +1,100 @@
+import math
+
+
+def valid_command(command_input):
+    if command_input == 'up' or command_input == 'down' or command_input == 'left' or command_input == 'right':
+        return True
+    return False
+
+def movement(row, col, current_input):
+
+    if current_input == "up":
+        if 0 <= row -1 < size:
+            row = row-1
+        else:
+            if row - 1 == -1:
+                row = size - 1
+    elif current_input == 'down':
+        if 0 <= row + 1 < size:
+            row += 1
+        else:
+            row = 0
+    elif current_input == 'left':
+        if 0 <= col - 1 < size:
+            col -= 1
+        else:
+            col = size - 1
+    elif current_input == 'right':
+        if 0 <= col + 1 < size:
+            col += 1
+        else:
+            col = 0
+
+    return row,col
+
+
+size = int(input())
+
+matrix = [[x for x in input().split()] for _ in range(size)]
+
+player_position = []
+walls_positions = []
+for row in range(size):
+    for col in range(size):
+        if matrix[row][col] == 'P':
+            player_position.append((row,col))
+        elif matrix[row][col].isnumeric():
+            matrix[row][col] = int(matrix[row][col])
+
+        elif matrix[row][col] == 'X':
+            walls_positions.append((row,col))
+
+total_collected_coins = 0
+win = False
+current_row = player_position[0][0]
+current_col = player_position[0][1]
+
+path_taken = [(current_row,current_col)]
+
+
+while True:
+    if total_collected_coins >= 100:
+        win = True
+        break
+    command = input()
+    if valid_command(command):
+        next_row, next_col = movement(current_row, current_col, command)
+        path_taken.append((next_row, next_col))
+        if (next_row,next_col) in walls_positions:
+            total_collected_coins = math.floor(total_collected_coins/2)
+            break
+        else:
+            if path_taken.count((next_row,next_col)) == 1:
+                if type(matrix[next_row][next_col]) == int:
+                    current_coins = matrix[next_row][next_col]
+                    total_collected_coins += current_coins
+                    matrix[current_row][current_col] = matrix[next_row][next_col]
+                    matrix[next_row][next_col] = 'P'
+                    current_row,current_col = next_row,next_col
+            else:
+                if matrix[next_row][next_col] != 'X':
+                    matrix[current_row][current_col] = matrix[next_row][next_col]
+                    matrix[next_row][next_col] = 'P'
+                    current_row, current_col = next_row, next_col
+                else:
+                    break
+
+    else:
+        pass
+
+if win:
+    print(f"You won! You've collected {math.floor(total_collected_coins)} coins.")
+else:
+    print(f"Game over! You've collected {math.floor(total_collected_coins)} coins.")
+
+
+print(f"Your path:")
+for item in path_taken:
+    print(list(item))
+
+