Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIAi2 WildChat-4.8M (AI2)

привет почему данный код не может выдать даже одну итерацию from functools import…

  1. User

    привет почему данный код не может выдать даже одну итерацию from functools import lru_cache

    def deepmoves(rocksbefore): if rocksbefore % 2 == 0: return rocksbefore * 1.5 if rocksbefore % 2 != 0: return rocksbefore * 2

    def moves(rocksbefore): return rocksbefore+1, deepmoves(rocksbefore)

    def play(rocksingame): if rocksingame >= 84: return 'W' if any(play(m) == 'W' for m in moves(rocksingame)): return 'P1' if all(play(m) == 'P1' for m in moves(rocksingame)) : return 'B2'

    for s in range(1,100): print(s, play(s))

  2. Assistant

    Из кода видно, что вы пытаетесь реализовать некую игру, но есть проблема, которая приводит к зацикливанию вашей программы. Функция play рекурсивно вызывает сама себя для каждого следующего значения камней в игре (rocksingame), но не имеет достаточно эффективных условий для прекращения рекурсии до достижения условия окончания игры (когда количество камней rocksingame равно или превышает 84).

    Рассмотрим, почему рекурсия не прерывается:

    1. Функция deepmoves может умножить количество камней на 1.5 или 2, это значит, что количество камней может расти очень быстро.

    2. В функции moves вы возвращаете кортеж из двух элементов: rocksbefore+1 и deepmoves(rocksbefore). Однако, deepmoves может возвращать нецелое количество камней в результате умножения на 1.5. Это приводит к тому, что вы передаете нецелые числа в функцию play, что, скорее всего, не соответствует вашим намерениям.

    Чтобы исправить эти проблемы и протестировать код, вы можете ввести механизм кэширования результатов рекурсивных вызовов функции play с помощью декоратора lru_cache. Это ускорит выполнение программы и позволит избежать повторного вычисления для одних и тех же значений. Кроме того, следует округлять результат deepmoves до ближайшего целого числа, чтобы количество камней всегда оставалось целым.

    Пример исправленного кода:

    from functools import lru_cache
    
    @lru_cache(maxsize=None)
    def deepmoves(rocksbefore):
        if rocksbefore % 2 == 0: return int(rocksbefore * 1.5)
        if rocksbefore % 2 != 0: return rocksbefore * 2
    
    @lru_cache(maxsize=None)
    def play(rocksingame):
        if rocksingame >= 84: return 'W'
        if any(play(m) == 'W' for m in moves(rocksingame)): return 'P1'
        if all(play(m) == 'P1' for m in moves(rocksingame)): return 'B2'
        return 'Unknown'
    
    def moves(rocksbefore):
        return rocksbefore + 1, deepmoves(rocksbefore)
    
    for s in range(1, 100):
        # Очистим кэш перед каждым новым вызовом, чтобы избежать неправильного кэширования
        play.cache_clear()
        deepmoves.cache_clear()
        print(s, play(s))
    

    Благодаря добавлению @lru_cache(maxsize=None), функция play запоминает результаты предыдущих вычислений, и в случае повторного вызова с теми же аргументами результат будет взят из кэша, что позволит избежать бесконечной рекурсии. Кроме того, добавлен вызов play.cache_clear() перед каждым новым вызовом play(s) в цикле, чтобы гарантировать, что результаты не будут некорректно использованы для разных начальных значений s.

  3. Assistant

    Если у вас есть какой-то конкретный вопрос или проблема, по которой вы хотите получить помощь, пожалуйста, дайте мне знать, и я постараюсь вам помочь!

  4. User

    почему данный код очень долго не может дать ответ @lru_cache(None) def moves(rocksbefore): return rocksbefore+1, rocksbefore*2 def play(rocksingame): if rocksingame >= 84: return 'W' if any(play(m) == 'W' for m in moves(rocksingame)): return 'P1' if all(play(m) == 'P1' for m in moves(rocksingame)) : return 'B2' else: return 'a lot of calls'

    print(play(2))

  5. Assistant

    Проблема со скоростью выполнения этого кода заключается в его структуре и рекурсивной природе. Каждый вызов функции play может порождать ещё два вызова той же функции, что приводит к экспоненциальному росту общего количества вызовов при увеличении параметра rocksingame. Экспоненциальный рост числа вызовов является характерным для проблем, в которых используется рекурсивный перебор без эффективной отсечки или мемоизации промежуточных результатов.

    Кэширование с помощью @lru_cache применено не к функции play, а к функции moves, которая проста и выполняется быстро, так что вы не получаете корректной выгоды от мемоизации в правильном месте. Ключевая функция play, которая порождает множество рекурсивных вызовов, не кешируется.

    В данном случае, чтобы улучшить производительность, стоит использовать декоратор lru_cache с функцией play, чтобы кешировать результаты её вызовов. Это позволит избежать повторного вычисления игрового исхода для одинакового количества камней. Итак, применим lru_cache к функции play:

    from functools import lru_cache
    
    @lru_cache(None)
    def play(rocksingame):
        if rocksingame >= 84: return 'W'
        if any(play(m) == 'W' for m in moves(rocksingame)): return 'P1'
        if all(play(m) == 'P1' for m in moves(rocksingame)): return 'B2'
        return 'a lot of calls'
    
    def moves(rocksbefore):
        return rocksbefore+1, rocksbefore*2
    
    print(play(2))
    

    Теперь, когда lru_cache применён к функции play, вы должны увидеть значительное увеличение скорости выполнения, поскольку множество дублирующихся рекурсивных вызовов будет кешироваться, и функция будет возвращать сохранённые ранее результаты вместо того, чтобы снова и снова вычислять их.

  6. User

    Объясни мне как данный код узнаёт о том какое было значение last и зачем мне добавлять это в список

    def moves(h): x, last = h a = [] if last != '+1': a.append((x+1, '+1'))

  7. Assistant

    Данный код в функции moves определяет возможные "ходы" из текущего состояния h, которое является кортежем из двух элементов (x, last). Выражение x, last = h присваивает первый элемент кортежа переменной x и второй элемент переменной last.

    Судя по контексту, x представляет текущее состояние игры (например, количество камней), а last (последний ход) – это строка, которая указывает, какой ход был сделан для достижения этого состояния из предыдущего ('+1' если было прибавлено 1 камень).

    В переменной a, скорее всего, хранится список возможных ходов, и код проверяет, не был ли последний ход равен строке '+1'. Если не был, то в список a добавляется кортеж с новым состоянием игры (x+1, '+1'), где x+1 – это игровое состояние после хода, увеличенного на 1, а строка '+1' – метка, указывающая на то, как было достигнуто это состояние.

    Добавление этой информации о последнем ходе в список может быть полезно для того, чтобы избегать повторения одного и того же хода в последовательности или просто чтобы хранить историю всех сделанных ходов. Это может быть необходимо для логики игры, анализа или любой другой задачи, где информация о последовательности шагов имеет значение.

    Итак, переменная a в коде используется для запоминания того, какие ходы доступны из текущего состояния, исключая те ходы, которые уже были сделаны ранее (в данном случае, исключается повторное увеличение на 1, если последний ход был именно таким).