Будем рассматривать только строчки, состоящие из заглавных латинских букв. Например, рассмотрим строку AAAABCCCCCDDDD. Длина этой строки равна 14. Поскольку строка состоит только из латинских букв, повторяющиеся символы могут быть удалены и заменены числами, определяющими количество повторений.
Таким образом, данная строка может быть представлена как 4AB5C4D. Длина такой строки 7. Описанный метод мы назовем упаковкой строки.

Напишите программу, которая берет упакованную строчку и восстанавливает по ней исходную строку.

Входные данные


Одна упакованная строка. В строке могут встречаться только конструкции вида nA, где n - количество повторений символа (целое число от 2 до 99), а A - заглавная латинская буква, либо конструкции вида A, то есть символ без числа, определяющего количество повторений. Максимальная длина строки не превышает 80.

Выходные данные

Выведите восстановленную строку. При этом строка должна быть разбита на строчки длиной ровно по 40 символов (за исключением последней, которая может содержать меньше 40 символов).

Примеры

Вход Выход
3A4B7D AAABBBBDDDDDDD
22D7AC18FGD DDDDDDDDDDDDDDDDDDDDDDAAAAAAACFFFFFFFFFF
FFFFFFFFGD
95AB AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAB

Для решения этой задачи мы напишем программу, которая принимает упакованную строку, распаковывает её в исходную строку и разбивает результат на строки длиной по 40 символов. Рассмотрим алгоритм подробно:

Алгоритм

1. Чтение входной строки: Входная строка содержит либо одиночные символы, либо конструкции вида nA, где n — количество повторений символа A.

2. Распаковка строки:

   • Используем регулярное выражение, чтобы разделить строку на группы: либо nA, либо одиночные буквы.
   • Для каждого совпадения:
     • Если есть число перед символом, дублируем символ n раз.
     • Если числа нет, оставляем символ как есть.

3. Разбиение на строки по 40 символов:

   • После распаковки исходной строки делим её на части длиной 40 символов с помощью индексации.

4. Вывод результата:

   • Каждую строку длиной до 40 символов выводим в виде отдельных строк.

Пример реализации на Python

python
import re
def unpack_and_split(packed_string):
    # Распаковка строки
    unpacked = ""
    pattern = r"(\d+)?([A-Z])"  # Регулярное выражение для nA или A
    matches = re.findall(pattern, packed_string)
    
    for count, char in matches:
        if count:  # Если есть число перед символом
            unpacked += char * int(count)
        else:  # Если только символ
            unpacked += char
    
    # Разбиение строки на части по 40 символов
    result = [unpacked[i:i+40] for i in range(0, len(unpacked), 40)]
    return result
# Пример входных данных
input_string = input().strip()
# Вызов функции и вывод результата
output_lines = unpack_and_split(input_string)
for line in output_lines:
    print(line)

Разбор примера

Вход:

3A4B7D

Шаги выполнения:

1. Регулярное выражение выделяет группы: ('3', 'A'), ('4', 'B'), ('7', 'D').
2. Распакованная строка: AAABBBBDDDDDDD.
3. Разбиваем строку на части по 40 символов:
   • AAABBBBDDDDDDD.

Выход:

AAABBBBDDDDDDD

Вход:

22D7AC18FGD

Шаги выполнения:

1. Регулярное выражение выделяет группы: ('22', 'D'), ('7', 'A'), ('C'), ('18', 'F'), ('G'), ('D').
2. Распакованная строка: DDDDDDDDDDDDDDDDDDDDDDAAAAAAACFFFFFFFFFFFFFFFFFGD.
3. Разбиваем строку на части по 40 символов:
   • DDDDDDDDDDDDDDDDDDDDDDAAAAAAACFFFFFFFFFF.
   • FFFFFFFFFGD.

Выход:

DDDDDDDDDDDDDDDDDDDDDDAAAAAAACFFFFFFFFFF
FFFFFFFFFGD

Особенности программы

1. Эффективность: Программа обрабатывает строку длиной до 80 символов за линейное время.
2. Гибкость: Работает как с одиночными буквами, так и с конструкциями вида nA.
3. Читаемость кода: Использование регулярных выражений упрощает обработку входных данных.

Этот подход можно использовать для любых строк, удовлетворяющих указанным условиям.