Um diagrama de estado da pilha mostra como os valores em uma pilha são alterados na outra. Por exemplo, este é um diagrama de estado da pilha:

3 0 2 1 0

Isso significa que existe inicialmente uma pilha contendo 3 valores (o 3 peça). Estes valores são indexados de 0 a 2, com 0 no topo: 2 1 0. A próxima parte 0 2 1 0descreve o estado final da pilha: o valor que estava originalmente no topo da pilha também foi copiado para trás.

Essas transformações ocorrem em uma pilha que suporta vários tipos de dados:

• O tipo "value", que é originalmente o que está na pilha. Pode ser uma string, um número inteiro etc., mas seu valor não precisa ser conhecido.
• O tipo "lista", que é uma lista que contém valores de qualquer tipo de dados.

Para modelar essa transformação, as seguintes operações são permitidas:

• S: Troque os dois valores no topo da pilha: 2 1 0→2 0 1
• D: Duplique o valor no topo da pilha: 1 0→1 0 0
• R: Remova o valor superior da pilha. 2 1 0→2 1
• L: Transforme o valor superior em uma lista de um elemento que contém esse valor: 2 1 0→2 1 (0)
• C: Concatene as duas principais listas da pilha: 2 (1) (0)→2 (1 0)
• U: Coloque todos os valores de uma lista na pilha: 2 (1 0)→2 1 0

Eles são equivalentes aos comandos Underload~ : ! a * ^ , desde que nenhum outro comando seja usado.

S, D, R, E Lpode ser utilizado com quaisquer valores no topo da pilha, mas Ce Udeve ter listas no topo da pilha para a função. Um envio cujas sequências geradas tentam pré-executar operações inválidas (como Dem uma pilha vazia ou Uem uma não-lista) está errado e deve ser punido com correção.

Para resolver um diagrama de estado da pilha, encontre uma sequência de comandos que transformarão corretamente o estado inicial da pilha no novo. Por exemplo, uma solução para 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

Sua tarefa é escrever um programa que pega um diagrama de estado da pilha e gera uma solução.

Casos de teste

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

Isso é código-golfe , então a resposta mais curta e válida (em bytes) vence.

Python 3, 84 bytes

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

Uso:

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

Explicação: Para começar, duplicamos o zero e o agrupamos em uma lista:

DL -> 3 2 1 0 (0)

Esta é a nossa base. Agora vou explicar um algoritmo geral que se transforma ... 1 0 (x)em ... 1 0 (i x)um inteiro arbitrário i. Vou usar como exemplo i = 2e temos uma lista arbitrária (x). Começamos envolvendo nossa lista atual (x)em outra lista:

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

Agora, repetimos os seguintes itempos de sequência :

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

Agora estamos prontos para inserir os 2 na lista (x). Isso é o seguinte:

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)

Observe que continuamos pressionando novos números inteiros à esquerda. Então o primeiro(0) ficamos à direita.

Depois de inserir todos os números inteiros necessários na lista, removemos o restante da pilha trocando e removendo n time ( SR). Finalmente, descompactamos nossa lista e excluímos a primeira 0que inserimos para iniciar nossa lista ( UR).

CJam, 54 bytes

Apenas uma tradução da solução Python da orlp para o CJam. Não há nada novo aqui.

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

Explicação:

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