Диаграмма состояния стека показывает, как значения одного стека меняются на другие. Например, это диаграмма состояний стека:

3 0 2 1 0

Это означает, что существует стек, изначально содержащий 3 значения ( 3часть). Эти значения проиндексированы от 0 до 2, с 0 на вершине: 2 1 0. Следующая часть 0 2 1 0описывает конечное состояние стека: значение, которое изначально было на вершине стека, также было скопировано на оборотную сторону.

Эти преобразования происходят в стеке, который поддерживает несколько типов данных:

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

Для моделирования этого преобразования разрешены следующие операции:

• S: Поменяйте местами два значения сверху стека: 2 1 0→2 0 1
• D: Дублируйте значение в верхней части стека: 1 0→1 0 0
• R: Удалить верхнее значение из стека. 2 1 0→2 1
• L: Превратить верхнее значение в одноэлементный список, содержащий это значение: 2 1 0→2 1 (0)
• C: Объединить два верхних списка в стеке: 2 (1) (0) →2 (1 0)
• U: Поместить все значения из списка в стек: 2 (1 0)→2 1 0

Это эквивалентно командам Underload~ : ! a * ^ , при условии, что никакие другие команды не используются.

S, D, RИ Lможет использоваться с любыми значениями на вершине стека, но Cи Uдолжны иметь списки на вершине стека функции. Представление которого генерируется последовательность попытка преформ недопустимых операций (например , Dна пустом стеке или Uна не-листе) является неправильным и должны быть наказано фиксировано.

Чтобы решить диаграмму состояния стека, найдите последовательность команд, которая будет правильно преобразовывать начальное состояние стека в новое. Например, одним из решений 3: 0 2 1 0является LSLCSLCULSLCLSLDCSC USLCU:

   2 1 0
L  2 1 (0)
S  2 (0) 1
L  2 (0) (1)
C  2 (0 1)
S  (0 1) 2
L  (0 1) (2)
C  (0 1 2)
U  0 1 2
L  0 1 (2)
S  0 (2) 1
L  0 (2) (1)
C  0 (2 1)
L  0 ((2 1))
S  ((2 1)) 0
L  ((2 1)) (0)
D  ((2 1)) (0) (0)
C  ((2 1)) (0 0)
S  (0 0) ((2 1))
C  (0 0 (2 1))
U  0 0 (2 1)
S  0 (2 1) 0
L  0 (2 1) (0)
C  0 (2 1 0)
U  0 2 1 0

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

Тестовые случаи

2 1 0       ->

3 2 0       -> SR

9           -> RRRRRRRRR

2 0 1 0     -> LSLCDCUR

2 0 1 1     -> SD

6 2         -> RRSRSRSR

5 0 1 2 3 4 -> LSLCSLCSLCSLCU

4 2 0 1 3 2 -> LSLCSLSCSLCULSLSCSLSCLSLDCSCUSLCU

Это код-гольф , поэтому выигрывает самый короткий действительный ответ (в байтах).

Python 3, 84 байта

lambda n,*s:"DLL"+"L".join(i*"SLSC"+"LSLSCDURLCULCULSC"for i in s[::-1])+n*"SR"+"UR"

Использование:

# Example: 4 2 0 1 3 2 -> LSLCSLSCSLCULSLSCSLSCLSLDCSCUSLCU
>>> f = lambda ...
>>> f(4, 2, 0, 1, 3, 2)
'DLLSLSCSLSCLSLSCDURLCULCULSCLSLSCSLSCSLSCLSLSCDURLCULCULSCLSLSCLSLSCDURLCULCULSCLLSLSCDURLCULCULSCLSLSCSLSCLSLSCDURLCULCULSCSRSRSRSRUR'

Пояснение: Для начала мы дублируем ноль и заключаем его в список:

DL -> 3 2 1 0 (0)

Это наша база. Теперь я объясню общий алгоритм, который превращается ... 1 0 (x)в ... 1 0 (i x)произвольное целое число i. Я буду использовать в качестве примера i = 2, и у нас есть произвольный список (x). Мы начнем с обертывания нашего текущего списка (x)в другой список:

L -> 3 2 1 0 ((x))

Теперь мы повторяем следующие iвремена последовательности :

SLSC -> 3 2 1 (0 (x))
SLSC -> 3 2 (1 0 (x))

Теперь мы готовы вставить 2 в список (x). Это идет следующим образом:

LSLSC -> 3 (2 (1 0 (x)))
DU -> 3 (2 (1 0 (x))) 2 (1 0 (x))
RLCU -> 3 2 (1 0 (x)) 2
LCU -> 3 2 1 0 (x) 2
LSC -> 3 2 1 0 (2 x)

Обратите внимание, что мы продолжаем вставлять новые целые числа слева. Итак, самый первый(0) мы начали, остается справа.

После того, как мы вставили в список каждое целое число, которое нам нужно, мы удаляем оставшуюся часть стека путем замены и удаления n time ( SR). Наконец мы распаковываем наш список и удаляем первый, который 0мы вставили, чтобы начать наш список ( UR).

CJam, 54 байта

Просто перевод с Python-решения orlp на CJam. Здесь нет ничего нового.

"DLL"q~("SR"*\W%{"SLSC"*"LSLSCDURLCULCULSC"+}%'L*\"UR"

Объяснение:

"DLL"                  e# Push string
q~                     e# Read input and evaluate
(                      e# Pop the first value
"SR"                   e# Push string
*                      e# Repeat string n times
\                      e# Swap (bring s to front)
W%                     e# Reverse
{                      e# For each:
  "SLSC"               e#   Push string
  *                    e#   Repeat i times
  "LSLSCDURLCULCULSC"+ e#   Append string to end
}%                     e# End
'L*                    e# Join with 'L'
\                      e# Swap (bring "SR"*n to front)
"UR"                   e# Push string
                       e# [Stack is implicitly output.]