Yığın durumu diyagramı, bir yığındaki değerlerin diğerine nasıl değiştirildiğini gösterir. Örneğin, bu bir yığın durumu diyagramıdır:

3 0 2 1 0

Bu başlangıçta 3 değer ( 3parça) içeren bir yığın olduğu anlamına gelir . Bu değerler, en az 0 ile 0 ila 2 dizinlenmiştir: 2 1 0. Bir sonraki bölüm 0 2 1 0, yığının son durumunu açıklar: başlangıçta yığının üstünde bulunan değer de arkaya kopyalanır.

Bu dönüşümler, çeşitli veri türlerini destekleyen bir yığın üzerinde gerçekleşir:

• Başlangıçta yığında bulunan "değer" türü. Bu bir dize, tamsayı vb. Olabilir, ancak değerinin bilinmesine gerek yoktur.
• Herhangi bir veri türünün değerlerini içeren bir liste olan "liste" türü.

Bu dönüşümü modellemek için aşağıdaki işlemlere izin verilir:

• S: Yığının üstündeki iki değeri değiştirin: 2 1 0→2 0 1
• D: Yığının üstündeki değeri çoğaltın: 1 0→1 0 0
• R: Yığındaki en yüksek değeri kaldırın. 2 1 0→2 1
• L: En üst değeri, bu değeri içeren tek öğeli bir listeye dönüştürün: 2 1 0→2 1 (0)
• C: Yığındaki ilk iki listeyi birleştirin: 2 (1) (0)→2 (1 0)
• U: Bir listedeki tüm değerleri yığına yerleştirin: 2 (1 0)→2 1 0

Bunlar, başka hiçbir komut kullanılmadığı sürece Düşük Yük komutlarına eşdeğerdir ~ : ! a * ^.

S, D, RVe Lyığının üstüne herhangi bir değeri ile birlikte kullanılabilir, ancak Cve Uişlevine yığının en listelerinin olmalıdır. Olan Üretilen diziler (geçersiz şu işlemleri preform girişimi bir gönderme Dboş yığın halinde veya Uolmayan bir listede) olduğu yanlış olmalıdır ve cezalandırılan sabit.

Bir yığın durumu diyagramını çözmek için, ilk yığın durumunu doğru şekilde yenisine dönüştürecek bir komut dizisi bulun. Örneğin, çözümlerden 3: 0 2 1 0biri 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

Göreviniz, yığın durumu diyagramı alan ve çözüm üreten bir program yazmaktır.

Test Durumları

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

Bu kod golf , bu yüzden en kısa geçerli cevap (bayt cinsinden) kazanır.

Python 3, 84 bayt

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

Kullanımı:

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

Açıklama: Başlamak için sıfırı çoğaltarak bir listeye sarıyoruz:

DL -> 3 2 1 0 (0)

Bu bizim temelimiz. Şimdi genel bir algoritma açıklayacağız o dönüşler ... 1 0 (x)içine ... 1 0 (i x)keyfi tamsayı için i. Örnek olarak kullanacağım i = 2ve keyfi bir listemiz var (x). Mevcut listemizi (x)başka bir listeye sararak başlıyoruz :

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

Şimdi aşağıdaki sıra isürelerini tekrarlıyoruz :

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

Şimdi 2'yi listeye eklemeye hazırız (x). Bu şu şekildedir:

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)

Solda yeni tamsayıları itmeye devam ettiğimizi unutmayın. İlk (0)başladığımız yer sağda kalıyor.

İhtiyacımız olan her tamsayıyı listeye ekledikten sonra, n time ( SR) öğesini değiştirip kaldırarak yığının geri kalanını kaldırırız . Son olarak listemizi paketinden çıkarır ve listemizi 0başlatmak için ilk eklediğimizi sileriz ( UR).

CJam, 54 bayt

Orlp'nin Python çözümünden CJam'a bir çeviri. Burada yeni bir şey yok.

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

Açıklama:

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