pie: ultimate lint with Ruff

pie/Matrix_dz.py

@@ -84,15 +84,11 @@ def findpivot(matr, r, c):  # нахождение "опорного элеме
     def kill(self, r, c, rr):  # r,c - опорный элемент,rr - строка, с которой работаем
         if rr != r:
             lol = -1 * self.matr[rr][c] / self.matr[r][c] + 1
-            self.matr[rr] = list(
-                map(lambda x, y: x + lol * y, self.matr[rr], self.matr[r])
-            )
+            self.matr[rr] = list(map(lambda x, y: x + lol * y, self.matr[rr], self.matr[r]))
 
         for i in range(rr + 1, self.rows):
             lol = -1 * self.matr[i][c] / self.matr[rr][c]
-            self.matr[i] = list(
-                map(lambda x, y: x + lol * y, self.matr[i], self.matr[rr])
-            )
+            self.matr[i] = list(map(lambda x, y: x + lol * y, self.matr[i], self.matr[rr]))
 
     def Triangular(self):
         count = 0
@@ -200,8 +196,10 @@ def __str__(self):
 matrix_array2 = []  # массив радиус-векторов уже тех точек, которые мы найдем
 
 reflection = Matrix(
-    2, 2, [[0, 1], [1, 0]]
-)  # задаем матрицу отражения относительно нашей оси (ось под наклоном 45 градусов к оси Ох)
+    2,
+    2,
+    [[0, 1], [1, 0]],
+)  # задаем матрицу отражения относительно нашей оси (ось под наклоном 45 градусов к оси Ox)
 
 # получение нужных точек и их отображение на графике
 for i in range(10):

pie/complex_dz.py

@@ -1,101 +1,95 @@
+from __future__ import annotations
+
 from math import atan, cos, pi, sin, sqrt
 
 
 class C_numb:
-    def __init__(self, real=1, im=0):
+    def __init__(self, real: float = 1.0, im: float = 0.0):
         self.real = real
         self.im = im
-        self.mod = sqrt(real**2 + im**2)
+        self.mod: float = sqrt(real**2 + im**2)
 
         if real > 0 and im >= 0:
-            self.arg = atan(im / real)
+            self.arg: float = atan(im / real)
 
         elif real > 0 and im < 0:
-            self.arg = atan(im / real) + 2 * pi
-
-        elif real < 0 and im >= 0:
-            self.arg = atan(im / real) + pi
+            self.arg: float = atan(im / real) + 2 * pi
 
-        elif real < 0 and im < 0:
-            self.arg = atan(im / real) + pi
+        elif real < 0:
+            self.arg: float = atan(im / real) + pi
 
         elif real == 0:
             if im < 0:
-                self.arg = 2 * pi - 0, 5 * pi
+                self.arg: float = 2 * pi - 0
 
             elif im > 0:
-                self.arg = pi * 0, 5
+                self.arg: float = pi * 0
 
-    def __add__(self, a):
+    def __add__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
             return C_numb(self.real + a.real, self.im + a.im)
-        else:
-            return C_numb(self.real + a, self.im)
 
-    def __radd__(self, a):
+        return C_numb(self.real + a, self.im)
+
+    def __radd__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
             return C_numb(self.real + a.real, self.im + a.im)
-        else:
-            return C_numb(self.real + a, self.im)
 
-    def __mul__(self, a):
+        return C_numb(self.real + a, self.im)
+
+    def __mul__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
-            return C_numb(
-                self.real * a.real - self.im * a.im, self.real * a.im + self.im * a.real
-            )
-        else:
-            return C_numb(self.real * a, self.im * a)
+            return C_numb(self.real * a.real - self.im * a.im, self.real * a.im + self.im * a.real)
+
+        return C_numb(self.real * a, self.im * a)
 
-    def __rmul__(self, a):
+    def __rmul__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
-            return C_numb(
-                self.real * a.real - self.im * a.im, self.real * a.im + self.im * a.real
-            )
-        else:
-            return C_numb(self.real * a, self.im * a)
+            return C_numb(self.real * a.real - self.im * a.im, self.real * a.im + self.im * a.real)
 
-    def con(self):
+        return C_numb(self.real * a, self.im * a)
+
+    def con(self) -> C_numb:
         return C_numb(self.real, -1 * self.im)
 
-    def __truediv__(self, a):
+    def __truediv__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
             num = self * a.con()
             denom = (a * a.con()).real
-            result = num * (denom ** (-1))
-            return result
-        else:
-            return self * (a ** (-1))
+            return num * (denom ** (-1))
+
+        return self * (a ** (-1))
 
-    def __sub__(self, a):
+    def __sub__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
             return C_numb(self.real - a.real, self.im - a.im)
-        else:
-            return C_numb(self.real - a, self.im)
 
-    def __rsub__(self, a):
+        return C_numb(self.real - a, self.im)
+
+    def __rsub__(self, a: float | C_numb) -> C_numb:
         if isinstance(a, C_numb):
             return C_numb(self.real - a.real, self.im - a.im)
-        else:
-            return C_numb(self.real - a, self.im)
 
-    def __pow__(self, a):
+        return C_numb(self.real - a, self.im)
+
+    def __pow__(self, a: float) -> C_numb:
         return C_numb(
             (self.mod**a) * (cos(atan(a * self.arg))),
             (self.mod**a) * (sin(atan(a * self.arg))),
         )
 
-    def rad(self, a):
+    def rad(self, a: int) -> list[str]:
         resultc = []
         for j in range(a):
             resultc += [
                 str((self.mod ** (1 / a)) * (cos(atan((self.arg + 2 * pi * j) / a))))
                 + "+"
                 + str((self.mod ** (1 / a)) * (sin(atan((self.arg + 2 * pi * j) / a))))
-                + "i"
+                + "i",
             ]
         return resultc
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.real) + "+" + str(self.im) + "i"
 
 

pie/integral_dz.py

@@ -1,17 +1,18 @@
 # algorithms for oint
 
+from collections.abc import Callable
 from math import pi
 
 
-def integral_rectangles(function, left, right, n):
+def integral_rectangles(function: Callable[[float], float], left: int, right: int, n: int) -> float:
     dx = (right - left) / n
-    integral = 0
+    integral = 0.0
     for i in range(n):
         integral += function((2 * left + dx * i + dx * (i + 1)) / 2) * dx
     return integral
 
 
-def integral_parabolas(function, left, right, n):
+def integral_parabolas(function: Callable[[float], float], left: int, right: int, n: int) -> float:
     dx = (right - left) / n
     integral = 0
     for i in range(n):
@@ -23,15 +24,15 @@ def integral_parabolas(function, left, right, n):
     return integral
 
 
-def integral_trapezoids(function, left, right, n):
+def integral_trapezoids(function: Callable[[float], float], left: int, right: int, n: int) -> float:
     dx = (right - left) / n
     integral = 0
     for i in range(n):
         integral += (dx / 2) * (function(left + dx * i) + function(left + dx * (i + 1)))
     return integral
 
 
-def f(x):
+def f(x: float) -> float:
     return 1 / (1 + x**2)
 
 

pie/mcko.py

@@ -1,64 +1,59 @@
 # Решения нескольких задач из следующего комплекта:
 # https://mcko.ru/uploads/documents/informatika_-10-klass_komplekt_1-91f3befffaba6eed.zip
 
-
-"""Номер 2:
-Автомат обрабатывает натуральное число N по следующему алгоритму:
-1) Строится двоичная запись числа N.
-2) К полученной записи дописываются разряды по следующему принципу:
-если число чётное, то справа дописывается 10, если нечётное – слева
-дописывается 1 и справа 00.
-3) Результат переводится в десятичную систему и выводится на экран.
-В результате работы автомата на экране появилось число, большее 107.
-Для какого наименьшего N данная ситуация возможна? В ответе найденное
-число N запишите в десятичной системе.
-"""
+from pathlib import Path
 
 
 def n2(n: int) -> int:
+    """Номер 2:
+    Автомат обрабатывает натуральное число N по следующему алгоритму:
+    1) Строится двоичная запись числа N.
+    2) К полученной записи дописываются разряды по следующему принципу:
+    если число чётное, то справа дописывается 10, если нечётное – слева
+    дописывается 1 и справа 00.
+    3) Результат переводится в десятичную систему и выводится на экран.
+    В результате работы автомата на экране появилось число, большее 107.
+    Для какого наименьшего N данная ситуация возможна? В ответе найденное
+    число N запишите в десятичной системе.
+    """
     m = str(bin(n)[2:])
-    if n % 2 == 0:
-        m = f"{m}10"
-    else:
-        m = f"1{m}00"
+    m = f"{m}10" if n % 2 == 0 else f"1{m}00"
     m = int(m, 2)
     if m > 107:
         return n
-    else:
-        return n2(n + 1)
-
 
-"""Номер 10:
-Редактор получает на вход строку цифр и преобразовывает её. Редактор
-может выполнять две команды, в обеих командах v и w обозначают цепочки
-цифр.
-заменить (v, w) Эта команда заменяет в строке первое слева вхождение
-цепочки v на цепочку w.
-нашлось (v) Эта команда проверяет, встречается ли цепочка v в строке
-исполнителя Редактор. Если она встречается, то команда
-возвращает логическое значение «истина», в противном
-случае возвращает значение «ложь». Строка при этом
-не изменяется.
-Дана программа для исполнителя Редактор:
-НАЧАЛО
-ПОКА нашлось (35) ИЛИ нашлось (355) ИЛИ нашлось (3444)
- ЕСЛИ нашлось (35)
- ТО заменить (35, 4)
- ИНАЧЕ
- ЕСЛИ нашлось (355)
- ТО заменить (355, 4)
- ИНАЧЕ заменить (3444, 3)
- КОНЕЦ ЕСЛИ
- КОНЕЦ ЕСЛИ
-КОНЕЦ ПОКА
-КОНЕЦ
-Какая строка получится в результате применения приведённой выше
-программы к строке вида 3…34…4 (6 троек и 75 четвёрок)? В ответе
-запишите полученную строку.
-"""
+    return n2(n + 1)
 
 
 def n10() -> str:
+    """Номер 10:
+    Редактор получает на вход строку цифр и преобразовывает её. Редактор
+    может выполнять две команды, в обеих командах v и w обозначают цепочки
+    цифр.
+    заменить (v, w) Эта команда заменяет в строке первое слева вхождение
+    цепочки v на цепочку w.
+    нашлось (v) Эта команда проверяет, встречается ли цепочка v в строке
+    исполнителя Редактор. Если она встречается, то команда
+    возвращает логическое значение «истина», в противном
+    случае возвращает значение «ложь». Строка при этом
+    не изменяется.
+    Дана программа для исполнителя Редактор:
+    НАЧАЛО
+    ПОКА нашлось (35) ИЛИ нашлось (355) ИЛИ нашлось (3444)
+     ЕСЛИ нашлось (35)
+     ТО заменить (35, 4)
+     ИНАЧЕ
+     ЕСЛИ нашлось (355)
+     ТО заменить (355, 4)
+     ИНАЧЕ заменить (3444, 3)
+     КОНЕЦ ЕСЛИ
+     КОНЕЦ ЕСЛИ
+    КОНЕЦ ПОКА
+    КОНЕЦ
+    Какая строка получится в результате применения приведённой выше
+    программы к строке вида 3…34…4 (6 троек и 75 четвёрок)? В ответе
+    запишите полученную строку.
+    """
     s = "333333444444444444444444444444444444444444444444444444444444444444444444444444444"
     while "35" in s or "355" in s or "3444" in s:
         if "35" in s:
@@ -70,39 +65,35 @@ def n10() -> str:
     return s
 
 
-"""Номер 11:
-Операнды арифметического выражения записаны в системе счисления с основанием 12.
-154x3_12 + 1x365_12
-В записи чисел переменной x обозначена неизвестная цифра из алфавита
-двенадцатеричной системы счисления. Определите значение x, при котором
-значение данного арифметического выражения кратно 13. Для найденного
-значения x вычислите частное от деления значения арифметического
-выражения на 13 и укажите его в ответе в десятичной системе счисления.
-Основание системы счисления в ответе указывать не нужно.
-"""
-
-
 def n11() -> int:
+    """Номер 11.
+    Операнды арифметического выражения записаны в системе счисления с основанием 12.
+    154x3_12 + 1x365_12
+    В записи чисел переменной x обозначена неизвестная цифра из алфавита
+    двенадцатеричной системы счисления. Определите значение x, при котором
+    значение данного арифметического выражения кратно 13. Для найденного
+    значения x вычислите частное от деления значения арифметического
+    выражения на 13 и укажите его в ответе в десятичной системе счисления.
+    Основание системы счисления в ответе указывать не нужно.
+    """
     for i in range(12):
         num1, num2 = int(f"154{i:X}3", 12), int(f"1{i:X}365", 12)
         if (num1 + num2) % 13 == 0:
             return (num1 + num2) // 13
     return 0
 
 
-"""Номер 12:
-В файле 12.txt содержится последовательность целых чисел. Элементы
-последовательности могут принимать целые значения от –100 000 до 100 000
-включительно. Пусть N – минимальное число в последовательности,
-НЕ кратное 15. Определите количество пар элементов последовательности,
-в которых оба числа кратны N. В ответе запишите количество найденных пар,
-затем максимальную из сумм элементов таких пар. В данной задаче под парой
-подразумевается два идущих подряд элемента последовательности.
-"""
-
-
 def n12() -> tuple:
-    with open("12.txt") as f:
+    """Номер 12:
+    В файле 12.txt содержится последовательность целых чисел. Элементы
+    последовательности могут принимать целые значения от -100 000 до 100 000
+    включительно. Пусть N - минимальное число в последовательности,
+    НЕ кратное 15. Определите количество пар элементов последовательности,
+    в которых оба числа кратны N. В ответе запишите количество найденных пар,
+    затем максимальную из сумм элементов таких пар. В данной задаче под парой
+    подразумевается два идущих подряд элемента последовательности.
+    """
+    with Path.open("12.txt") as f:
         data = [int(line.strip()) for line in f]
 
     min_ = min(filter(lambda x: x % 15 != 0, data))
@@ -112,8 +103,7 @@ def n12() -> tuple:
         t1, t2 = data[i], data[i + 1]
         if t1 % min_ == 0 and t2 % min_ == 0:
             count += 1
-            if t1 + t2 > max_:
-                max_ = t1 + t2
+            max_ = max(t1 + t2, max_)
 
     return count, max_