Một sơ đồ trạng thái ngăn xếp cho thấy cách các giá trị trên một ngăn xếp được thay đổi thành khác. Ví dụ, đây là sơ đồ trạng thái ngăn xếp:

3 0 2 1 0

Điều này có nghĩa là có một ngăn xếp ban đầu chứa 3 giá trị ( 3phần). Các giá trị này được lập chỉ mục từ 0 đến 2, với 0 ở đầu : 2 1 0. Phần tiếp theo 0 2 1 0mô tả trạng thái cuối cùng của ngăn xếp: giá trị ban đầu ở trên cùng của ngăn xếp cũng đã được sao chép vào mặt sau.

Những biến đổi này xảy ra trên một ngăn xếp có hỗ trợ cho một số loại dữ liệu:

• Loại "giá trị", là loại ban đầu trên ngăn xếp. Đây có thể là một chuỗi, số nguyên, v.v. nhưng giá trị của nó không cần phải biết.
• Loại "danh sách", là danh sách chứa các giá trị của bất kỳ loại dữ liệu nào.

Để mô hình chuyển đổi này, các hoạt động sau được cho phép:

• S: Hoán đổi hai giá trị trên đầu ngăn xếp: 2 1 0→2 0 1
• D: Sao y giá trị trên đầu ngăn xếp: 1 0→1 0 0
• R: Xóa giá trị hàng đầu trên ngăn xếp. 2 1 0→2 1
• L: Biến giá trị hàng đầu thành danh sách một thành phần có chứa giá trị đó: 2 1 0→2 1 (0)
• C: Nối hai danh sách hàng đầu trên ngăn xếp: 2 (1) (0)→2 (1 0)
• U: Đặt tất cả các giá trị từ danh sách lên ngăn xếp: 2 (1 0)→2 1 0

Chúng tương đương với các lệnh Underload~ : ! a * ^ , với điều kiện là không có lệnh nào khác được sử dụng.

S, D, R, Và Lcó thể được sử dụng với bất kỳ giá trị trên đỉnh của ngăn xếp, nhưng Cvà Uphải có danh sách trên đỉnh của ngăn xếp hoạt động. Một đệ trình có trình tự được tạo ra cố gắng tạo ra các hoạt động không hợp lệ (như Dtrên một ngăn xếp trống hoặc Utrên một danh sách không) là sai và phải bị trừng phạt .

Để giải quyết sơ đồ trạng thái ngăn xếp, hãy tìm một chuỗi các lệnh sẽ chuyển đổi chính xác trạng thái ngăn xếp ban đầu thành trạng thái mới. Ví dụ: một giải pháp cho 3: 0 2 1 0là 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

Nhiệm vụ của bạn là viết một chương trình lấy sơ đồ trạng thái ngăn xếp và đưa ra giải pháp.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất (tính bằng byte) sẽ thắng.

Python 3, 84 byte

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

Sử dụng:

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

Giải thích: Để bắt đầu, chúng tôi nhân đôi số 0 và gói nó trong một danh sách:

DL -> 3 2 1 0 (0)

Đây là cơ sở của chúng tôi. Bây giờ tôi sẽ giải thích một thuật toán chung biến ... 1 0 (x)thành ... 1 0 (i x)số nguyên tùy ý i. Tôi sẽ sử dụng làm ví dụ i = 2, và chúng tôi có một số danh sách tùy ý (x). Chúng tôi bắt đầu bằng cách gói danh sách hiện tại của chúng tôi (x)vào một danh sách khác:

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

Bây giờ chúng tôi lặp lại các ilần trình tự sau :

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

Bây giờ chúng tôi đã sẵn sàng để chèn 2 vào danh sách (x). Điều này diễn ra như sau:

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)

Lưu ý rằng chúng tôi tiếp tục đẩy số nguyên mới ở bên trái. Vì vậy, lần đầu tiên (0)chúng tôi bắt đầu với ở bên phải.

Sau khi chúng tôi đã chèn mọi số nguyên chúng tôi cần vào danh sách, chúng tôi sẽ loại bỏ phần còn lại của ngăn xếp bằng cách hoán đổi và xóa n time ( SR). Cuối cùng, chúng tôi giải nén danh sách của chúng tôi và xóa cái đầu tiên 0chúng tôi chèn để bắt đầu danh sách của chúng tôi ( UR).

CJam, 54 byte

Chỉ cần một bản dịch từ giải pháp Python của orlp sang CJam. Không có gì mới ở đây.

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

Giải trình:

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