Діаграма стану стека показує, як значення однієї стеки змінюються на іншу. Наприклад, це схема стану стека:

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

Це код-гольф , тому найкоротша відповідна відповідь (у байтах) виграє.

Пітон 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 час ( SR). Нарешті ми розпаковуємо наш список і видаляємо перший, який 0ми вставили, щоб почати наш список ( UR).

CJam, 54 байти

Просто переклад з програми Python на Cl. Тут немає нічого нового.

"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.]