12.01 Исполнитель «Редактор» – известная строка

Решение руками

Если в строке достаточно число двоек или четверок, то после того как тело цикла будет выполнено четыре раза, первые шестнадцать четверок заменятся на четыре двойки. При следующем выполнении цикла после первой команды эти четыре двойки заменятся на одну четверку, после чего процесс будет продолжаться: шестнадцать четверок заменятся на четыре двойки, а четыре двойки – на одну четверку. Становится ясно, что цикл преобразует шестнадцать четверок в одну четверку. После того как цикл повторяется 8 раз, у нас станет четверок и оставшиеся четверок, в общей сумме четверка. Шестнадцать из них заменятся на четыре двойки, затем эти четыре двойки заменятся на одну четверку получится строка , затем четыре четверки заменятся на двойку, получится строка 244 Так как в этой строке нет трех четверок и нет трех двоек условие цикла не выполнится, а выполнение программы на этом завершится.

Решение программой

s = ’4’ * 141
while ’444’ in s or ’222’ in s:
    if ’2222’ in s:
        s = s.replace(’2222’, ’4’, 1)
    elif ’4444’ in s:
        s = s.replace(’4444’, ’2’, 1)
print(s)

Идея решения:

По условию нам дана строка. Создадим ее в Python и будем обрабатывать ее с помощью цикла while, который выполняется до тех пор, пока выполняется хотя бы одно из условий:

Внутри цикла проверяем условия по порядку:

1) Сначала проверяем, есть ли в строке цифра «5». Если да, то заменяем первую найденную «5» на «77» единожды.

2) Если «5» нет, проверяем есть ли «77». Если да, то заменяем первую найденную пару «77» на одну «7» единожды.

3) Если нет ни «5», ни «77», проверяем есть ли «222». Если да, то заменяем первую найденную тройку «222» на одну «5» единожды.

После каждой замены цикл повторяется – снова проверяются все три условия.

В результате получаем строку, которая больше не изменяется по нашим правилам, и выводим ее на экран.

Решение программой:

# Создаем начальную строку: 10 пятерок + 30 семерок + 50 двоек
s = ’5’ * 10 + ’7’ * 30 + ’2’ * 50

# Цикл выполняется пока в строке есть хотя бы одна из комбинаций:
# - цифра ’5’
# - пара ’77’ (две семерки подряд)
# - тройка ’222’ (три двойки подряд)
while ’5’ in s or ’77’ in s or ’222’ in s:

    # Если есть хотя бы одна цифра ’5’
    if ’5’ in s:
        # Заменяем первую найденную ’5’ на ’77’
        # Параметр 1 означает замену только первого вхождения
        s = s.replace(’5’, ’77’, 1)

    # Иначе если нет ’5’, но есть пара ’77’
    elif ’77’ in s:
        # Заменяем первую найденную пару ’77’ на одну ’7’
        s = s.replace(’77’, ’7’, 1)

    # Иначе если нет ни ’5’, ни ’77’, но есть тройка ’222’
    elif ’222’ in s:
        # Заменяем первую найденную тройку ’222’ на одну ’5’
        s = s.replace(’222’, ’5’, 1)

# Выводим конечную строку
print(s)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 5 на 77. На протяжении всей работы программы оно будет выполняться до тех пор, пока пятерок не останется вообще. Для текущей же строки все пятерки заменятся парами семерок, которых будет в 2 раза больше, чем изначальное количество пятерок, т.е. 20.

Второе по приоритету действие - это замена пары семерок на одну семерку. Это действие перестанет выполняться, когда количество семерок станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество двоек.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 50 ближайшее к этому числу значение, кратное 3, т.е. 45.

Теперь снова вручную прогоним полученную строку.

Таким образом, в конце выполнения программа будет выведено 722.

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 5 на 77. На протяжении всей работы программы оно будет выполняться до тех пор, пока пятерок не останется вообще. Для текущей же строки все пятерки заменятся парами семерок, которых будет в 2 раза больше, чем изначальное количество пятерок, т.е. 20.

Второе по приоритету действие - это замена пары семерок на одну семерку. Это действие перестанет выполняться, когда количество семерок не станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество двоек.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 50 ближайшее к этому числу значение, кратное 3, т.е. 45.

Теперь снова вручную прогоним полученную строку.

Сумма цифр равна

Решение программой

s = ’5’ * 10 + ’7’ * 30 + ’2’ * 50
while ’5’ in s or ’77’ in s or ’222’ in s:
    if ’5’ in s:
        s = s.replace(’5’, ’77’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)
    elif ’222’ in s:
        s = s.replace(’222’, ’5’, 1)
print(sum(map(int, s)))

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 5 на 77. На протяжении всей работы программы оно будет выполняться до тех пор, пока пятерок не останется вообще. Для текущей же строки все пятерки заменятся парами семерок, которых будет в 2 раза больше, чем изначальное количество пятерок, т.е. 74.

Второе по приоритету действие - это замена пары семерок на одну семерку. Это действие перестанет выполняться, когда количество семерок не станет 1.

Теперь можно просчитать вручную, т.к. программа близка к завершению:

Таким образом, в конце выполнения программа будет выведено 722.

Решение программой

s = ’5’ * 37 + ’7’ * 56 + ’2’ * 5
while ’5’ in s or ’77’ in s or ’222’ in s:
    if ’5’ in s:
        s = s.replace(’5’, ’77’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)
    elif ’222’ in s:
        s = s.replace(’222’, ’5’, 1)
print(s)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 7 на 33. На протяжении всей работы программы оно будет выполняться до тех пор, пока семерок не останется вообще. Для текущей же строки все семерки заменятся парами троек, которых будет в 2 раза больше, чем изначальное количество семерок, т.е. 32.

Второе по приоритету действие - это замена пары троек на одну тройку. Это действие перестанет выполняться, когда количество троек станет 1.

Прогоним вручную по шагам программы полученную строку.

Таким образом, в конце выполнения программы будет выведено 388.

Решение программой

s = ’7’ * 16 + ’3’ * 1600 + ’8’ * 8
while ’7’ in s or ’33’ in s or ’888’ in s:
    if ’7’ in s:
        s = s.replace(’7’, ’33’, 1)
    elif ’33’ in s:
        s = s.replace(’33’, ’3’, 1)
    elif ’888’ in s:
        s = s.replace(’888’, ’7’, 1)
print(s)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 7 на 33. На протяжении всей работы программы оно будет выполняться до тех пор, пока семерок не останется вообще. Для текущей же строки все семерки заменятся парами троек, которых будет в 2 раза больше, чем изначальное количество семерок, т.е. 1000.

Второе по приоритету действие - это замена пары троек на одну тройку. Это действие перестанет выполняться, когда количество троек станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество восьмерок.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 280 ближайшее к этому числу значение, кратное 3, т.е. 276.

Теперь снова вручную прогоним полученную строку.

Таким образом, в конце выполнения программа будет выведено 38.

Решение программой

s = ’7’ * 500 + ’3’ * 120 + ’8’ * 280
while ’7’ in s or ’33’ in s or ’888’ in s:
    if ’7’ in s:
        s = s.replace(’7’, ’33’, 1)
    elif ’33’ in s:
        s = s.replace(’33’, ’3’, 1)
    elif ’888’ in s:
        s = s.replace(’888’, ’7’, 1)
print(s)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 4 на 66. На протяжении всей работы программы оно будет выполняться до тех пор, пока четверок не останется вообще. Для текущей же строки все четверки заменятся парами шестерок, которых будет в 2 раза больше, чем изначальное количество четверок, т.е. 690.

Второе по приоритету действие - это замена пары шестерок на одну шестерку. Это действие перестанет выполняться, когда количество шестерок станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество нулей.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 948 ближайшее к этому числу значение, кратное 3, т.е. 945.

Теперь снова вручную прогоним полученную строку.

Таким образом, в конце выполнения программы будет выведено 6.

Решение программой

s = ’4’ * 345 + ’6’ * 647 + ’0’ * 948
while ’4’ in s or ’66’ in s or ’000’ in s:
    if ’4’ in s:
        s = s.replace(’4’, ’66’, 1)
    elif ’66’ in s:
        s = s.replace(’66’, ’6’, 1)
    elif ’000’ in s:
        s = s.replace(’000’, ’4’, 1)
print(s)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 4 на 66. На протяжении всей работы программы оно будет выполняться до тех пор, пока четверок не останется вообще. Для текущей же строки все четверки заменятся парами шестерок, которых будет в 2 раза больше, чем изначальное количество четверок, т.е. 1526.

Второе по приоритету действие - это замена пары шестерок на одну шестерку. Это действие перестанет выполняться, когда количество шестерок станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество нулей.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 690 ближайшее к этому числу значение, кратное 3, т.е. 687.

Теперь снова вручную прогоним полученную строку.

Переведем 6 в двоичную систему счисления:

Решение программой

s = ’4’ * 763 + ’6’ * 153 + ’0’ * 690
while ’4’ in s or ’66’ in s or ’000’ in s:
    if ’4’ in s:
        s = s.replace(’4’, ’66’, 1)
    elif ’66’ in s:
        s = s.replace(’66’, ’6’, 1)
    elif ’000’ in s:
        s = s.replace(’000’, ’4’, 1)
result = s
binary_result = bin(int(result))[2:]
print(binary_result)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 9 на 11. На протяжении всей работы программы оно будет выполняться до тех пор, пока девяток не останется вообще. Для текущей же строки все девятки заменятся парами единиц, которых будет в 2 раза больше, чем изначальное количество девяток, т.е. 846.

Второе по приоритету действие - это замена пары единиц на одну единицу. Это действие перестанет выполняться, когда количество единиц станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество пятерок.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 980 ближайшее к этому числу значение, кратное 3, т.е. 975.

Теперь снова вручную прогоним полученную строку.

Решение программой

s = ’9’ * 423 + ’1’ * 762 + ’5’ * 980
while ’9’ in s or ’11’ in s or ’555’ in s:
    if ’9’ in s:
        s = s.replace(’9’, ’11’, 1)
    elif ’11’ in s:
        s = s.replace(’11’, ’1’, 1)
    elif ’555’ in s:
        s = s.replace(’555’, ’9’, 1)
result = s
print(result)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 9 на 11. На протяжении всей работы программы оно будет выполняться до тех пор, пока девяток не останется вообще. Для текущей же строки все девятки заменятся парами единиц, которых будет в 2 раза больше, чем изначальное количество девяток, т.е. 812.

Второе по приоритету действие - это замена пары единиц на одну единицу. Это действие перестанет выполняться, когда количество единиц станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество пятерок.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 707 ближайшее к этому числу значение, кратное 3, т.е. 702.

Теперь снова вручную прогоним полученную строку.

Решение программой

s = ’9’ * 406 + ’1’ * 188 + ’5’ * 707
while ’9’ in s or ’11’ in s or ’555’ in s:
    if ’9’ in s:
        s = s.replace(’9’, ’11’, 1)
    elif ’11’ in s:
        s = s.replace(’11’, ’1’, 1)
    elif ’555’ in s:
        s = s.replace(’555’, ’9’, 1)
print(s)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Самое приоритетное действие в цикле ПОКА – это замена 9 на 11. На протяжении всей работы программы оно будет выполняться до тех пор, пока девяток не останется вообще. Для текущей же строки все девятки заменятся парами единиц, которых будет в 2 раза больше, чем изначальное количество девяток, т.е. 812.

Второе по приоритету действие - это замена пары единиц на одну единицу. Это действие перестанет выполняться, когда количество единиц станет 1.

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

Итак, из мы получили значит выполнять те же действия большое количество раз не нужно, мы можем сразу снижать количество пятерок.

За один шаг количество уменьшилось на 3, значит нужно вычесть из 707 ближайшее к этому числу значение, кратное 3, т.е. 702.

Теперь снова вручную прогоним полученную строку.

Сумма цифр равна

Решение программой

s = ’9’ * 406 + ’1’ * 188 + ’5’ * 707
while ’9’ in s or ’11’ in s or ’555’ in s:
    if ’9’ in s:
        s = s.replace(’9’, ’11’, 1)
    elif ’11’ in s:
        s = s.replace(’11’, ’1’, 1)
    elif ’555’ in s:
        s = s.replace(’555’, ’9’, 1)
sum_digits = sum(int(digit) for digit in s)
print(sum_digits)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка До исчезновения всех пятерок программа будет за 1 итерацию заменять первую встреченную пару пятерок на одну семерку и уменьшать количество четверок на одну. За 5 итераций получится следующая строка:

Далее действия, которые происходили с пятерками, произойдут и с двойками. За следующие 4 итерации получится следующая строка:

Но после начала следующей итерации, последняя четверка не удалится, т.к. останется последняя, т.е. условие вхождения в цикл выполнено не будет. Тогда итерация закончится удалением одной из семерок из начала строки.

Таким образом, количество оставшихся семерок равно 19.

Решение программой

s = ’5’ * 10 + ’4’ * 10 + ’2’ * 10 + ’7’ * 10
while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’7’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’, 1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)
count_sevens = s.count(’7’)
print(count_sevens)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка До исчезновения всех пятерок программа будет за 1 итерацию заменять первую встреченную пару пятерок на одну семерку и уменьшать количество четверок на одну. За 5 итераций получится следующая строка:

Далее действия, которые происходили с пятерками, произойдут и с двойками. За следующие 4 итерации получится следующая строка:

Но после начала следующей итерации, последняя четверка не удалится, т.к. останется последняя, т.е. условие вхождения в цикл выполнено не будет. Тогда итерация закончится удалением одной из семерок из начала строки.

Сумма цифр равна

Решение программой

s = ’5’ * 10 + ’4’ * 10 + ’2’ * 10 + ’7’ * 10
while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’7’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’, 1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)
sum_of_digits = sum(int(digit) for digit in s)
print(sum_of_digits)

Аналитическое решение:

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка До исчезновения всех пятерок программа будет за 1 итерацию заменять первую встреченную пару пятерок на одну семерку и уменьшать количество четверок на одну. За 25 итераций получится следующая строка:

Далее действия, которые происходили с пятерками, произойдут и с двойками. В результате за следующие 24 итераций получится следующая строка:

Но после начала следующей итерации, последняя четверка не удалится, т.к. останется последняя, т.е. условие вхождения в цикл выполнено не будет. Тогда итерация закончится удалением одной из семерок из начала строки.

Сумма цифр равна

Программное решение:

s = ’5’ * 50 + ’4’ * 50 + ’2’ * 50 + ’7’ * 50
while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’7’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’ ,1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)
sm = sum(int(i) for i in s)
print(sm)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка

Условно первый блок программы – это исчезновение пятерок, и появление на их месте 10 двоек, и четверок. Это происходит за счет замены 2 пятерок на одну двойку, т.е. произойдет 10 замен, а также 10 раз 2 четверки заменятся на 1 (9 раз сотрется четверка). Стоит заметить, что последняя четверка не сотрется, вместо нее сотрется первая попавшаяся в строке семерка. В итоге получится следующая строка:

Далее все двойки, стоящие до четверки, заменятся на 7.

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

Похожие действия произойдут с группой двоек после четверки:

Как видно, после достижения отметки 28 в количестве двоек программа начинает их уменьшать, не затрагивая семерки. Таким образом после выполнения программы останется следующая строка:

Количество оставшихся семерок равно 39.

Решение программой

s = ’5’ * 20 + ’4’ * 10 + ’2’ * 30 + ’7’ * 40

while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’2’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’, 1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)

count_of_sevens = s.count(’7’)
print(count_of_sevens)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка

Условно первый блок программы – это исчезновение пятерок с четверками и появление на их месте 10 двоек. Это происходит за счет замены 2 пятерок на одну двойку, т.е. произойдет 10 замен, а также 10 раз 2 четверки заменятся на 1 (9 раз сотрется четверка). Стоит заметить, что последняя четверка не сотрется, вместо нее сотрется первая попавшаяся в строке семерка. В итоге получится следующая строка:

Далее все двойки, стоящие до четверки, заменятся на 7.

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

Похожие действия произойдут с группой двоек после четверки:

Как видно, после достижения отметки 28 в количестве двоек программа начинает их уменьшать, не затрагивая семерки. Таким образом после выполнения программы останется следующая строка:

Сумма цифр равна

Решение программой

s = ’5’ * 20 + ’4’ * 10 + ’2’ * 30 + ’7’ * 40

while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’2’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’, 1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)

sum_of_digits = sum(int(digit) for digit in s)
print(sum_of_digits)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка

Условно первый блок программы – это исчезновение пятерок с четверками и появление на их месте 30 двоек. Это происходит за счет замены 2 пятерок на одну двойку, т.е. произойдет 30 замен, а также 30 раз 2 четверки заменятся на 1 (29 раз сотрется четверка). Стоит заметить, что последняя четверка не сотрется, вместо нее сотрется первая попавшаяся в строке семерка. В итоге получится следующая строка:

Далее все двойки, стоящие до четверки, заменятся на 7.

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

Похожие действия произойдут с группой двоек после четверки:

Как видно, после достижения отметки 28 в количестве двоек программа начинает их уменьшать, не затрагивая семерки. Таким образом после выполнения программы останется следующая строка:

Количество оставшихся семерок равно 119.

Решение программой

s = ’5’ * 60 + ’4’ * 30 + ’2’ * 90 + ’7’ * 120

while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’2’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’, 1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)

count_of_sevens = s.count(’7’)
print(count_of_sevens)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка

Условно первый блок программы – это исчезновение пятерок с четверками и появление на их месте 30 двоек. Это происходит за счет замены 2 пятерок на одну двойку, т.е. произойдет 30 замен, а также 30 раз 2 четверки заменятся на 1 (29 раз сотрется четверка). Стоит заметить, что последняя четверка не сотрется, вместо нее сотрется первая попавшаяся в строке семерка. В итоге получится следующая строка:

Далее все двойки, стоящие до четверки, заменятся на 7.

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

Похожие действия произойдут с группой двоек после четверки:

Как видно, после достижения отметки 28 в количестве двоек программа начинает их уменьшать, не затрагивая семерки. Таким образом после выполнения программы останется следующая строка:

Сумма цифр равна

Решение программой

s = ’5’ * 60 + ’4’ * 30 + ’2’ * 90 + ’7’ * 120

while ’54’ in s or ’27’ in s:
    if ’55’ in s:
        s = s.replace(’55’, ’2’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’7’, 1)
    if ’44’ in s:
        s = s.replace(’44’, ’4’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’7’, 1)

sum_of_digits = sum(int(digit) for digit in s)
print(sum_of_digits)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Пока все четверки не заменятся количество двоек в два раза меньшее, чем изначальное количество четверок, они не перестанут исчезать. Вместе с ними исчезают и пятерки, не заменяясь ни на что. Стоит заметить, что на последней итерации вместо исчезновения последней пятерки произойдет исчезновение первой встреченной в строке двойки. В результате мы получим следующую строку:

Далее действия, которые происходили с четверками, произойдут и с семерками. В результате за следующие 40 итераций получится следующая строка:

Как можно заметить, в какой-то момент начала уменьшать количество семерок, не затрагивая количество двоек. Так будет происходить до момента исчезновения всех семерок. Остановимся на последних итерациях:

На этом программа остановится. Таким образом, количество оставшихся двоек равно 59.

Решение программой

s = ’7’ * 40 + ’2’ * 20 + ’4’ * 80 + ’5’ * 40

while ’45’ in s or ’72’ in s:
    if ’44’ in s:
        s = s.replace(’44’, ’2’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’2’, 1)
    if ’55’ in s:
        s = s.replace(’55’, ’5’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’2’, 1)

count_of_twos = s.count(’2’)
print(count_of_twos)

Решение руками

Для удобства будем использвовать следующие обозначения для количества одинаковых цифр, идущих подряд: где A - цифра, которая находится в строке, а B - количество этих цифр.

Изначально была строка Пока все четверки не заменятся количеством двоек в два раза меньшим, чем изначальное количество четверок, они не перестанут исчезать. Вместе с ними исчезают и пятерки, не заменяясь ни на что. Стоит заметить, что на последней итерации вместо исчезновения последней пятерки произойдет исчезновение первой встреченной в строке двойки. В результате мы получим следующую строку:

Далее действия, которые происходили с четверками, произойдут и с семерками. Покажем начало выполнения этого блока программы:

Как можно заметить, в какой-то момент программа начала уменьшать количество семерок, не затрагивая количество двоек. Так будет происходить до момента исчезновения всех семерок. Остановимся на последних итерациях:

На этом программа остановится. Сумма цифр в оставшейся после выполнения программы строке

Решение программой

s = ’7’ * 40 + ’2’ * 20 + ’4’ * 80 + ’5’ * 40

while ’45’ in s or ’72’ in s:
    if ’44’ in s:
        s = s.replace(’44’, ’2’, 1)
    elif ’77’ in s:
        s = s.replace(’77’, ’2’, 1)
    if ’55’ in s:
        s = s.replace(’55’, ’5’, 1)
    elif ’22’ in s:
        s = s.replace(’22’, ’2’, 1)

sum_of_digits = sum(int(digit) for digit in s)
print(sum_of_digits)