├── __init__.py ├── tests ├── __init__.py ├── test_task_19_single.py ├── test_task_21_single.py ├── test_task_20_single.py ├── test_task_19_multi.py ├── test_task_21_multi.py ├── test_task_20_multi.py ├── test_task_2.py └── test_task_15.py ├── task_19_single.py ├── task_15.py ├── task_19_multi.py ├── task_20_single.py ├── task_20_multi.py ├── task_21_single.py ├── task_21_multi.py ├── task_2.py └── .gitignore /__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/test_task_19_single.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_19_single 2 | 3 | 4 | def test_task_19_single(capfd): # sourcery skip: extract-duplicate-method 5 | task_19_single.ПОБЕДА = 68 6 | task_19_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 5] 7 | task_19_single.main() 8 | out = capfd.readouterr()[0].strip() 9 | assert out == "Answer: 3" 10 | 11 | task_19_single.ПОБЕДА = 48 12 | task_19_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 2] 13 | task_19_single.main() 14 | out = capfd.readouterr()[0].strip() 15 | assert out == "Answer: 12" 16 | 17 | task_19_single.ПОБЕДА = 42 18 | task_19_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 3, lambda x: x * 2] 19 | task_19_single.main() 20 | out = capfd.readouterr()[0].strip() 21 | assert out == "Answer: 11" 22 | -------------------------------------------------------------------------------- /tests/test_task_21_single.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_21_single 2 | 3 | 4 | def test_task_21_single(capfd): # sourcery skip: extract-duplicate-method 5 | task_21_single.ПОБЕДА = 68 6 | task_21_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 5] 7 | task_21_single.main() 8 | out = capfd.readouterr()[0].strip() 9 | assert out == "Answer: 8" 10 | 11 | task_21_single.ПОБЕДА = 48 12 | task_21_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 2] 13 | task_21_single.main() 14 | out = capfd.readouterr()[0].strip() 15 | assert out == "Answer: 18" 16 | 17 | task_21_single.ПОБЕДА = 42 18 | task_21_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 3, lambda x: x * 2] 19 | task_21_single.main() 20 | out = capfd.readouterr()[0].strip() 21 | assert out == "Answer: 16" 22 | -------------------------------------------------------------------------------- /tests/test_task_20_single.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_20_single 2 | 3 | 4 | def test_task_20_single(capfd): # sourcery skip: extract-duplicate-method 5 | task_20_single.ПОБЕДА = 68 6 | task_20_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 5] 7 | task_20_single.main() 8 | out = capfd.readouterr()[0].strip() 9 | assert out == "Answer: 912" 10 | 11 | task_20_single.ПОБЕДА = 48 12 | task_20_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 2] 13 | task_20_single.main() 14 | out = capfd.readouterr()[0].strip() 15 | assert out == "Answer: 1922" 16 | 17 | task_20_single.ПОБЕДА = 42 18 | task_20_single.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 3, lambda x: x * 2] 19 | task_20_single.main() 20 | out = capfd.readouterr()[0].strip() 21 | assert out == "Answer: 101719" 22 | -------------------------------------------------------------------------------- /tests/test_task_19_multi.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_19_multi 2 | 3 | 4 | def test_task_19_multi(capfd): # sourcery skip: extract-duplicate-method 5 | task_19_multi.ПОБЕДА = 77 6 | task_19_multi.ПЕРВАЯ_КУЧА = 7 7 | task_19_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 2] 8 | task_19_multi.main() 9 | out = capfd.readouterr()[0].strip() 10 | assert out == "Answer: 18" 11 | 12 | task_19_multi.ПОБЕДА = 61 13 | task_19_multi.ПЕРВАЯ_КУЧА = 3 14 | task_19_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 4] 15 | task_19_multi.main() 16 | out = capfd.readouterr()[0].strip() 17 | assert out == "Answer: 4" 18 | 19 | task_19_multi.ПОБЕДА = 82 20 | task_19_multi.ПЕРВАЯ_КУЧА = 4 21 | task_19_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 4] 22 | task_19_multi.main() 23 | out = capfd.readouterr()[0].strip() 24 | assert out == "Answer: 5" 25 | -------------------------------------------------------------------------------- /tests/test_task_21_multi.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_21_multi 2 | 3 | 4 | def test_task_21_multi(capfd): # sourcery skip: extract-duplicate-method 5 | task_21_multi.ПОБЕДА = 77 6 | task_21_multi.ПЕРВАЯ_КУЧА = 7 7 | task_21_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 2] 8 | task_21_multi.main() 9 | out = capfd.readouterr()[0].strip() 10 | assert out == "Answer: 30" 11 | 12 | task_21_multi.ПОБЕДА = 61 13 | task_21_multi.ПЕРВАЯ_КУЧА = 3 14 | task_21_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 4] 15 | task_21_multi.main() 16 | out = capfd.readouterr()[0].strip() 17 | assert out == "Answer: 13" 18 | 19 | task_21_multi.ПОБЕДА = 82 20 | task_21_multi.ПЕРВАЯ_КУЧА = 4 21 | task_21_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 4] 22 | task_21_multi.main() 23 | out = capfd.readouterr()[0].strip() 24 | assert out == "Answer: 18" 25 | -------------------------------------------------------------------------------- /tests/test_task_20_multi.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_20_multi 2 | 3 | 4 | def test_task_20_multi(capfd): # sourcery skip: extract-duplicate-method 5 | task_20_multi.ПОБЕДА = 77 6 | task_20_multi.ПЕРВАЯ_КУЧА = 7 7 | task_20_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 2] 8 | task_20_multi.main() 9 | out = capfd.readouterr()[0].strip() 10 | assert out == "Answer: 3134" 11 | 12 | task_20_multi.ПОБЕДА = 61 13 | task_20_multi.ПЕРВАЯ_КУЧА = 3 14 | task_20_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 4] 15 | task_20_multi.main() 16 | out = capfd.readouterr()[0].strip() 17 | assert out == "Answer: 1214" 18 | 19 | task_20_multi.ПОБЕДА = 82 20 | task_20_multi.ПЕРВАЯ_КУЧА = 4 21 | task_20_multi.ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 4] 22 | task_20_multi.main() 23 | out = capfd.readouterr()[0].strip() 24 | assert out == "Answer: 1619" 25 | -------------------------------------------------------------------------------- /task_19_single.py: -------------------------------------------------------------------------------- 1 | # region: input 2 | ПОБЕДА = 68 # Сумма, нужная для победы 3 | ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 5] # Операции (+1, +4, *5) 4 | # endregion: input 5 | # region: logic 6 | 7 | 8 | def main(): # sourcery skip: assign-if-exp, reintroduce-else 9 | def f(x: int, r: int = 1) -> bool: 10 | # Если кто-то выиграл раньше, чем нужный ход 11 | if r < 3 and x >= ПОБЕДА: 12 | # Этот случай нам не подходит 13 | return False 14 | 15 | # Если мы достигли нужного количества ходов 16 | if r == 3: 17 | # Нужно проверить, победил ли нужный нам игрок 18 | return x >= ПОБЕДА 19 | 20 | # Стратегия для наихудших ходов противника 21 | return any(f(op(x), r + 1) for op in ОПЕРАЦИИ) 22 | 23 | print("Answer:", next(x for x in range(1, ПОБЕДА) if f(x))) 24 | 25 | 26 | # endregion: logic 27 | 28 | if __name__ == "__main__": 29 | main() 30 | -------------------------------------------------------------------------------- /task_15.py: -------------------------------------------------------------------------------- 1 | import itertools 2 | 3 | # region: input 4 | ПЕРЕМЕННЫЕ = "x" # Список всех переменных без "A" 5 | 6 | 7 | def ФУНКЦИЯ(x: int, A: int) -> bool: 8 | """Логическая функция из условия""" 9 | return x & 51 == 0 or ((x & A == 0) ** (x & 41 == 0)) 10 | 11 | 12 | НАЙТИ_МАКСИМАЛЬНОЕ = False # True если нужно найти наибольшее A 13 | 14 | 15 | # endregion: input 16 | # region: logic 17 | 18 | 19 | def main(): 20 | maximum = 0 21 | for A in range(1000): 22 | for variables in itertools.product(range(1000), repeat=len(ПЕРЕМЕННЫЕ)): 23 | if not ФУНКЦИЯ(*variables, A=A): 24 | break 25 | else: 26 | if not НАЙТИ_МАКСИМАЛЬНОЕ: 27 | print("Answer:", A) 28 | break 29 | else: 30 | maximum = max(maximum, A) 31 | 32 | if НАЙТИ_МАКСИМАЛЬНОЕ: 33 | print("Answer:", maximum) 34 | 35 | 36 | # endregion: logic 37 | 38 | if __name__ == "__main__": 39 | main() 40 | -------------------------------------------------------------------------------- /task_19_multi.py: -------------------------------------------------------------------------------- 1 | # region: input 2 | ПОБЕДА = 77 # Сумма, нужная для победы 3 | ПЕРВАЯ_КУЧА = 7 # Кол-во камней в первой куче 4 | ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 2] # Операции (+1, *2) 5 | # endregion: input 6 | # region: logic 7 | 8 | 9 | def main(): 10 | def f(x: int, y: int, r: int = 1) -> bool: 11 | # Если кто-то выиграл раньше, чем нужный ход 12 | if r < 3 and x + y >= ПОБЕДА: 13 | # Этот случай нам не подходит 14 | return False 15 | 16 | # Если мы достигли нужного количества ходов 17 | if r == 3: 18 | # Нужно проверить, победил ли нужный нам игрок 19 | return x + y >= ПОБЕДА 20 | 21 | # Стратегия для наихудших ходов противника 22 | return any(f(op(x), y, r + 1) for op in ОПЕРАЦИИ) or any( 23 | f(x, op(y), r + 1) for op in ОПЕРАЦИИ 24 | ) 25 | 26 | print( 27 | "Answer:", 28 | next(x for x in range(1, ПОБЕДА - ПЕРВАЯ_КУЧА) if f(x, ПЕРВАЯ_КУЧА)), 29 | ) 30 | 31 | 32 | # endregion: logic 33 | 34 | if __name__ == "__main__": 35 | main() 36 | -------------------------------------------------------------------------------- /tests/test_task_2.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_2 2 | 3 | 4 | def test_task_2(capfd): # sourcery skip: extract-duplicate-method 5 | task_2.ИЗВЕСТНЫЕ = [[..., 0, 0, 0], [..., 0, ..., 0]] 6 | task_2.ПЕРЕМЕННЫЕ = "xyz" 7 | task_2.ФУНКЦИЯ = lambda x, y, z: (z == x) ** (x or y) 8 | task_2.main() 9 | out = capfd.readouterr()[0].strip() 10 | assert out == "Answer: xzy" 11 | 12 | task_2.ПЕРЕМЕННЫЕ = "xyzw" 13 | task_2.ИЗВЕСТНЫЕ = [ 14 | [1, 1, 1, 0, 1], 15 | [..., ..., 0, 0, 0], 16 | [..., 0, ..., ..., 0], 17 | ] 18 | task_2.ФУНКЦИЯ = lambda x, y, z, w: (((not y) ** w) and x ** y) ** (x != z) 19 | task_2.main() 20 | out = capfd.readouterr()[0].strip() 21 | assert out == "Answer: yzxw" 22 | 23 | task_2.ПЕРЕМЕННЫЕ = "xyzw" 24 | task_2.ИЗВЕСТНЫЕ = [ 25 | [1, ..., ..., 1, 0], 26 | [1, ..., ..., ..., 0], 27 | [..., 1, ..., 1, 0], 28 | ] 29 | task_2.ФУНКЦИЯ = lambda x, y, z, w: ((y**x) and (w**y)) or (z == (x or y)) 30 | task_2.main() 31 | out = capfd.readouterr()[0].strip() 32 | assert out == "Answer: ywzx" 33 | -------------------------------------------------------------------------------- /task_20_single.py: -------------------------------------------------------------------------------- 1 | # region: input 2 | ПОБЕДА = 68 # Сумма, нужная для победы 3 | ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 4, lambda x: x * 5] # Операции (+1, +4, *5) 4 | # endregion: input 5 | # region: logic 6 | 7 | 8 | def main(): # sourcery skip: assign-if-exp, reintroduce-else 9 | def f(x: int, r: int = 1) -> bool: 10 | # Если кто-то выиграл раньше, чем нужный ход 11 | if r < 4 and x >= ПОБЕДА: 12 | # Этот случай нам не подходит 13 | return False 14 | 15 | # Если мы достигли нужного количества ходов 16 | if r == 4: 17 | # Нужно проверить, победил ли нужный нам игрок 18 | return x >= ПОБЕДА 19 | 20 | # Стратегия для наихудших ходов противника 21 | cases = [f(op(x), r + 1) for op in ОПЕРАЦИИ] 22 | 23 | # Если ходим мы, то нужно, чтобы хотя бы один ход был победным 24 | # Если ходит противник, то нужно, чтобы все ходы были победными 25 | return any(cases) if r % 2 != 0 else all(cases) 26 | 27 | print("Answer:", "".join(str(x) for x in range(1, ПОБЕДА) if f(x))) 28 | 29 | 30 | # endregion: logic 31 | 32 | if __name__ == "__main__": 33 | main() 34 | -------------------------------------------------------------------------------- /task_20_multi.py: -------------------------------------------------------------------------------- 1 | # region: input 2 | ПОБЕДА = 77 # Сумма, нужная для победы 3 | ПЕРВАЯ_КУЧА = 7 # Кол-во камней в первой куче 4 | ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 2] # Операции (+1, *2) 5 | # endregion: input 6 | # region: logic 7 | 8 | 9 | def main(): 10 | def f(x: int, y: int, r: int = 1) -> bool: 11 | # Если кто-то выиграл раньше, чем нужный ход 12 | if r < 4 and x + y >= ПОБЕДА: 13 | # Этот случай нам не подходит 14 | return False 15 | 16 | # Если мы достигли нужного количества ходов 17 | if r == 4: 18 | # Нужно проверить, победил ли нужный нам игрок 19 | return x + y >= ПОБЕДА 20 | 21 | # Возможные исходы 22 | cases = [ 23 | *(f(op(x), y, r + 1) for op in ОПЕРАЦИИ), 24 | *(f(x, op(y), r + 1) for op in ОПЕРАЦИИ), 25 | ] 26 | 27 | # Если ход наш, то мы ищем, чтобы хотя бы один исход был победным 28 | # Если ход противника, то мы проверяем, чтобы все исходы подходили 29 | return all(cases) if r % 2 == 0 else any(cases) 30 | 31 | print( 32 | "Answer:", 33 | "".join(str(x) for x in range(1, ПОБЕДА - ПЕРВАЯ_КУЧА) if f(x, ПЕРВАЯ_КУЧА)), 34 | ) 35 | 36 | 37 | # endregion: logic 38 | 39 | if __name__ == "__main__": 40 | main() 41 | -------------------------------------------------------------------------------- /tests/test_task_15.py: -------------------------------------------------------------------------------- 1 | from RNE_CS import task_15 2 | 3 | 4 | def test_task_15(capfd): # sourcery skip: extract-duplicate-method 5 | task_15.ПЕРЕМЕННЫЕ = "x" 6 | task_15.ФУНКЦИЯ = lambda x, A: ((x & A != 0) ** (x & 12 == 0)) ** (x & 29 != 0) 7 | task_15.НАЙТИ_МАКСИМАЛЬНОЕ = False 8 | task_15.main() 9 | out = capfd.readouterr()[0].strip() 10 | assert out == "Answer: 17" 11 | 12 | task_15.ПЕРЕМЕННЫЕ = "x" 13 | task_15.ФУНКЦИЯ = lambda x, A: ((x & A != 0) ** (x & 17 == 0)) ** (x & 25 != 0) 14 | task_15.НАЙТИ_МАКСИМАЛЬНОЕ = False 15 | task_15.main() 16 | out = capfd.readouterr()[0].strip() 17 | assert out == "Answer: 8" 18 | 19 | task_15.ПЕРЕМЕННЫЕ = "x" 20 | task_15.ФУНКЦИЯ = lambda x, A: ((x & A != 0) ** (x & 33 == 0)) ** (x & 41 != 0) 21 | task_15.НАЙТИ_МАКСИМАЛЬНОЕ = False 22 | task_15.main() 23 | out = capfd.readouterr()[0].strip() 24 | assert out == "Answer: 8" 25 | 26 | task_15.ПЕРЕМЕННЫЕ = "x" 27 | task_15.ФУНКЦИЯ = lambda x, A: x & 51 == 0 or ((x & A == 0) ** (x & 41 == 0)) 28 | task_15.НАЙТИ_МАКСИМАЛЬНОЕ = False 29 | task_15.main() 30 | out = capfd.readouterr()[0].strip() 31 | assert out == "Answer: 0" 32 | 33 | task_15.ПЕРЕМЕННЫЕ = "x" 34 | task_15.ФУНКЦИЯ = lambda x, A: x & 51 == 0 or ((x & A == 0) ** (x & 41 == 0)) 35 | task_15.НАЙТИ_МАКСИМАЛЬНОЕ = True 36 | task_15.main() 37 | out = capfd.readouterr()[0].strip() 38 | assert out == "Answer: 41" 39 | -------------------------------------------------------------------------------- /task_21_single.py: -------------------------------------------------------------------------------- 1 | # region: input 2 | ПОБЕДА = 42 # Сумма, нужная для победы 3 | ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x + 3, lambda x: x * 2] # Операции (+1, +3, *2) 4 | # endregion: input 5 | # region: logic 6 | 7 | 8 | def main(): # sourcery skip: assign-if-exp, reintroduce-else 9 | def f(x: int, r: int = 1, guaranteed_win: bool = False) -> bool: 10 | # Если мы достигли нужного количества ходов и победили 11 | if ((r == 3) if guaranteed_win else (r in {3, 5})) and x >= ПОБЕДА: 12 | return True 13 | 14 | # Если мы достигли максимального хода, но не победили 15 | if ((r == 3) if guaranteed_win else (r == 5)) and x < ПОБЕДА: 16 | return False 17 | 18 | # Если кто-то выиграл раньше, чем нужный ход 19 | if ((r < 3) if guaranteed_win else (r < 5)) and x >= ПОБЕДА: 20 | # Этот случай нам не подходит 21 | return False 22 | 23 | # Стратегия для наихудших ходов противника 24 | cases = [f(op(x), r + 1, guaranteed_win=guaranteed_win) for op in ОПЕРАЦИИ] 25 | 26 | # Если ходим мы, то нужно, чтобы хотя бы один ход был победным 27 | # Если ходит противник, то нужно, чтобы все ходы были победными 28 | return any(cases) if r % 2 == 0 else all(cases) 29 | 30 | print( 31 | "Answer:", 32 | next(x for x in range(1, ПОБЕДА) if f(x) and not f(x, guaranteed_win=True)), 33 | ) 34 | 35 | 36 | # endregion: logic 37 | 38 | if __name__ == "__main__": 39 | main() 40 | -------------------------------------------------------------------------------- /task_21_multi.py: -------------------------------------------------------------------------------- 1 | # region: input 2 | ПОБЕДА = 77 # Сумма, нужная для победы 3 | ПЕРВАЯ_КУЧА = 7 # Кол-во камней в первой куче 4 | ОПЕРАЦИИ = [lambda x: x + 1, lambda x: x * 2] # Операции (+1, *2) 5 | # endregion: input 6 | # region: logic 7 | 8 | 9 | def main(): 10 | def f(x: int, y: int, r: int = 1, guaranteed_win: bool = False) -> bool: 11 | # Если мы выиграли на третьем или пятом ходе 12 | if ((r == 3) if guaranteed_win else (r in {3, 5})) and x + y >= ПОБЕДА: 13 | # Этот случай нам подходит 14 | return True 15 | 16 | # Если мы не выиграли к пятому ходу 17 | if ((r == 3) if guaranteed_win else (r == 5)) and x + y < ПОБЕДА: 18 | # Этот случай нам не подходит 19 | return False 20 | 21 | if ((r < 3) if guaranteed_win else (r < 5)) and x + y >= ПОБЕДА: 22 | # Мы победили не на 3 или 5 ходе, либо победил соперник 23 | return False 24 | 25 | # Возможные исходы 26 | cases = [ 27 | *(f(op(x), y, r + 1, guaranteed_win=guaranteed_win) for op in ОПЕРАЦИИ), 28 | *(f(x, op(y), r + 1, guaranteed_win=guaranteed_win) for op in ОПЕРАЦИИ), 29 | ] 30 | 31 | # Если ход наш, то мы ищем, чтобы хотя бы один исход был победным 32 | # Если ход противника, то мы проверяем, чтобы все исходы подходили 33 | return all(cases) if r % 2 != 0 else any(cases) 34 | 35 | print( 36 | "Answer:", 37 | next( 38 | x 39 | for x in range(1, ПОБЕДА - ПЕРВАЯ_КУЧА) 40 | if f(x, ПЕРВАЯ_КУЧА) and not f(x, ПЕРВАЯ_КУЧА, guaranteed_win=True) 41 | ), 42 | ) 43 | 44 | 45 | # endregion: logic 46 | 47 | if __name__ == "__main__": 48 | main() 49 | -------------------------------------------------------------------------------- /task_2.py: -------------------------------------------------------------------------------- 1 | import itertools 2 | 3 | # region: input 4 | 5 | # Переменные из условия в любом порядке 6 | ПЕРЕМЕННЫЕ = "xyzw" 7 | 8 | # Известные значения из условия (пустые клетки - ...) 9 | ИЗВЕСТНЫЕ = [ 10 | [1, 1, 1, 0, 1], 11 | [..., ..., 0, 0, 0], 12 | [..., 0, ..., ..., 0], 13 | ] 14 | 15 | 16 | def ФУНКЦИЯ(x: int, y: int, z: int, w: int) -> int: 17 | """Логическая функция из условия""" 18 | return int((((not y) ** w) and x ** y) ** ((not x) == (not not z))) 19 | 20 | 21 | # endregion: input 22 | # region: logic 23 | 24 | 25 | def main(): 26 | # Перебираем все возможные порядки, в которых могут располагаться переменные 27 | for order in itertools.permutations(ПЕРЕМЕННЫЕ): 28 | # Копируем маску локально 29 | patterns = ИЗВЕСТНЫЕ.copy() 30 | # Перебираем все возможные значения переменных 31 | for lst in itertools.product([0, 1], repeat=len(ПЕРЕМЕННЫЕ)): 32 | # Расставляем значения в соответствии с текущим порядком 33 | variables = dict(zip(order, lst)) 34 | # Считаем результат с текущими переменными 35 | variables["f"] = ФУНКЦИЯ(**variables) 36 | for pattern in patterns: 37 | # Проверяем, соответствует ли текущая строка с текущим порядком 38 | # переменных одному из шаблонов 39 | for pdigit, adigit in zip( 40 | pattern, map(lambda x: variables[x], (*order, "f")) 41 | ): 42 | if pdigit is not Ellipsis and pdigit != adigit: 43 | break 44 | else: 45 | # Если соответствует, убираем этот шаблон 46 | patterns.remove(pattern) 47 | break 48 | 49 | # Если мы нашли совпадения для всех шаблонов 50 | if not patterns: 51 | # Это ответ" 52 | print("Answer:", "".join(order)) 53 | 54 | 55 | # endregion: logic 56 | 57 | if __name__ == "__main__": 58 | main() 59 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | 131 | 132 | *__pycache__ 133 | *.pyc --------------------------------------------------------------------------------