บทนำ

ความท้าทายนี้ได้รับแรงบันดาลใจจากGrimeซึ่งเป็นภาษาจับคู่รูปแบบ 2D ของฉัน โดยทั่วไปคุณจะได้รับ "ไวยากรณ์" ที่อธิบายกริดสองมิติของตัวอักษรและงานของคุณคือการสร้างกริดตามไวยากรณ์ นอกจากนี้ตารางควรมีขนาดเล็กที่สุดเท่าที่จะเป็นไปได้ในแง่อ่อน

อินพุต

ข้อมูลของคุณเป็นสตริงที่มีอักขระตัวพิมพ์เล็ก ASCII และสัญลักษณ์และ| -เพื่อความเรียบง่ายอินพุตไม่มีอักขระตัวพิมพ์เล็กซ้ำ ๆ สตริงเป็นข้อมูลจำเพาะสำหรับคลาสของกริดสี่เหลี่ยมของอักขระและแยกวิเคราะห์จากซ้ายไปขวาโดยใช้สแต็กดังนี้

• กำหนดอักขระตัวพิมพ์เล็กcกดไปที่สแต็กm×nกริดของอักขระcสำหรับใด ๆm, n ≥ 1สำหรับการใด ๆ
• ได้รับท่อ|, pop สองกริดAและBจากสแต็ค ( Bอยู่ชั้นบนสุด) และผลักดันตารางABได้โดยการเชื่อมโยงไปทางขวาของB Aสิ่งนี้ต้องการAและBมีความสูงเท่ากัน
• ได้รับยัติภังค์-, pop สองกริดAและBจากสแต็ค ( Bอยู่ชั้นบนสุด) และผลักดันตารางA/Bได้โดยการเชื่อมโยงที่ด้านล่างของB Aสิ่งนี้ต้องการAและBมีความกว้างเท่ากัน

รับประกันได้ว่าสำหรับตัวเลือกบางอย่างmและnทำในระหว่างกระบวนการแยกวิเคราะห์ (ซึ่งอาจแตกต่างกันสำหรับตัวอักษรแต่ละตัว), ข้อกำหนดการป้อนข้อมูลอย่างถูกต้องอธิบายสี่เหลี่ยมผืนผ้าบางอย่างซึ่งถูกทิ้งไว้บนกองในตอนท้าย

เอาท์พุต

เอาต์พุตของคุณเป็นตารางสี่เหลี่ยมของอักขระที่ระบุโดยอินพุต กริดต้องมีขนาดเล็กที่สุดในแง่ที่ว่าการลบแถวหรือคอลัมน์ใด ๆ จะทำให้มันไม่ถูกต้อง คุณสามารถส่งคืนสตริงที่คั่นด้วยการขึ้นบรรทัดใหม่ (โดยมีหรือไม่มีการขึ้นบรรทัดใหม่), อาร์เรย์ของอักขระ 2 มิติหรืออาร์เรย์ของสตริงแล้วแต่จำนวนใดจะเป็นรูปแบบที่สะดวกที่สุด

โปรดทราบว่าคุณไม่จำเป็นต้องดำเนินการอินพุตตามที่อธิบายไว้ข้างต้น สิ่งสำคัญเพียงอย่างเดียวคือผลลัพธ์ของคุณถูกต้อง

ตัวอย่าง

พิจารณาสเปค

par-s||e-

ก่อนอื่นเราเลือกที่จะกด1×2สี่เหลี่ยมpและ1×1สี่เหลี่ยมของaและr(เหตุผลนี้จะชัดเจนในภายหลัง) จากนั้นเราป๊อปอัพaและrสี่เหลี่ยมและผลักดันการเรียงต่อกันตามแนวตั้ง

a
r

ต่อไปเราจะกด1×2สี่เหลี่ยมsเปิดและสี่เหลี่ยมด้านบนแล้วกดการเรียงต่อกันในแนวนอน

as
rs

จากนั้นเราก็ปรากฎสี่เหลี่ยมนั้นและpสี่เหลี่ยมและผลักดันการต่อกัน

pas
prs

ในที่สุดเราก็กด3×1สี่เหลี่ยมจัตุรัสของeผุดขึ้นและสี่เหลี่ยมด้านบนแล้วกดการเรียงต่อกันตามแนวตั้ง

pas
prs
eee

นี่คือผลลัพธ์ของโปรแกรมหรืออย่างน้อยหนึ่งในความเป็นไปได้ สังเกตว่าถึงแม้ว่า

ppas
ppas
pprs
eeee

ถูกสร้างขึ้นโดยสเปคด้วยไม่ใช่เอาต์พุตที่ถูกต้องเนื่องจากแถวและคอลัมน์จำนวนมากสามารถลบออกได้

เป็นตัวอย่างที่ละเอียดยิ่งขึ้นให้พิจารณา

co|m|p|il|e|r|-

ข้อกำหนดนี้สร้างสี่เหลี่ยมผืนผ้า

comp
iler

ซึ่งเป็นผลลัพธ์ที่ถูกต้อง อย่างไรก็ตามมันก็สร้าง

commp
iiler

ซึ่งใช้ได้เช่นกันเนื่องจากไม่สามารถลบแถวหรือคอลัมน์เดียวโดยไม่ทำให้ถูกต้อง

กฎระเบียบ

คุณสามารถให้โปรแกรมเต็มหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต

กรณีทดสอบเพิ่มเติม

คุณสามารถใช้สิ่งเหล่านี้เพื่อทดสอบโปรแกรมของคุณ

Input:
a
Output:
a

Input:
co|mp|l|-ex|i|f|-y|
Example output:
cccoy
mplly
exify

Input:
ja-r|g-o|ni-|ze|d-|
Example output:
jronze
arondd
ggoidd

Input:
un|co|p-yr|i|gh-t-ab|-|le-||-
Example output:
unnnnnnn
coyriggl
ppyrihhe
ppyritte
ppyriabe

K, 123 110 ไบต์

ฉันใช้วิธีการที่คล้ายกันกับโซลูชันของ cardboard_box

r:{y,x#,*|y};h:{t:(#x)|#y;r[t-#x;x],'r[t-#y]y};a:{(,x .|2#y),2_ y};*(){(a[{+h[+x;+y]}]x;a[h]x;(,,y),x)"-|"?y}/

โปรแกรมนี้เป็นชุดของคำจำกัดความผู้ช่วยตามด้วยฟังก์ชั่นโดยปริยายซึ่งใช้สตริงเป็นอาร์กิวเมนต์ที่เหมาะสม การฟอร์แมตใหม่เพื่อให้สามารถอ่านได้และกำหนดฟังก์ชันสุดท้ายเป็นf:

r: {y,x#,*|y};                           / repeat last row x times
h: {t:(#x)|#y;r[t-#x;x],'r[t-#y;y]};     / append horizontal
v: {+h[+x;+y]};                          / append vertical
a: {(,x[y@1;y@0]),2_ y};                 / pop two values, concat

f: *(){:[y="-";a[v;x]; y="|";a[h;x]; (,,y),x]}/;

ใช้ตัวอย่าง:

  f "ja-r|g-o|ni-|ze|d-|"
("jronze"
 "aroidd"
 "ggoidd")

ผ่านการทดสอบโดยใช้ Kona แต่จะทำงานในหน่วยoKหากคุณแทนที่:คำจำกัดความfด้วย a$ - k5 เปลี่ยนไวยากรณ์ของ "cond"

จุดสำคัญคือการรับรู้ว่าการทำผนวกในแนวตั้งคือการเปลี่ยนจากการผนวกท้ายของการฝึกอบรมทั้งสอง (ดูคำจำกัดความv) ฉันคิดว่ายังมีห้องพักที่จะบีบตัวละครไม่กี่ตัวที่นี่ หากใครสนใจคำอธิบายโดยละเอียดเพิ่มเติมฉันสามารถให้ได้

แก้ไข:

อัพเดทโปรแกรมที่ด้านบนของรายการนี้ เวอร์ชันที่ไม่ถูกปรับแต่ง:

r: {y,x#,*|y};                           / repeat row x times
h: {t:(#x)|#y;r[t-#x;x],'r[t-#y;y]};     / append horizontal
v: {+h[+x;+y]};                          / append vertical
a: {(,x .|2#y),2_ y};                    / apply a concat
f: *(){(a[v]x;a[h]x;(,,y),x)"-|"?y}/;

การเพิ่มประสิทธิภาพความยาวที่โดดเด่นรวมถึงการใช้ "dot Apply" in aแทนที่ "cond" ด้วยการจัดทำดัชนีรายการในf(มีประสิทธิภาพน้อยลง แต่สั้นลง) และเปลี่ยนเงื่อนไขของแบบฟอร์มa[b;c]เป็นa[b]cที่อนุญาตโดยการจัดกลุ่ม เนื่องจากฉันไม่ได้ใช้ "cond" หรือ primitives ใด ๆ ที่แตกต่างระหว่าง k3 และ k5 อีกต่อไปเวอร์ชันนี้จึงใช้งานได้ใน oK โดยไม่มีการดัดแปลง

Prolog, 539 ไบต์

:-lib(ic).
:-lib(util).
b(A,B,C):-between(A,B,C).
g(S):-string_list(S,L),p(L,[]).
w(h(L,R):_:_,I,J):-w(L,I,J);L=_:W:_,X is I-W,w(R,X,J).
w(v(U,D):_:_,I,J):-w(U,I,J);U=_:_:H,Y is J-H,w(D,I,Y).
w(f(C):W:H,I,J):-b(1,W,I),b(1,H,J),char_code(S,C),put_char(S).
p([],[S]):-term_variables(S,V),S=_:X:Y,labeling(V),!,b(1,Y,J),(b(1,X,I),w(S,I,J);nl),fail.
p([124|T],[Q,Z|R]):-!,Q=_:WA:H,Z=_:WB:H,W #= WA+WB,p(T,[h(Z,Q):W:H|R]).
p([45|T],[Q,Z|R]):-!,Q=_:W:HA,Z=_:W:HB,H #= HA+HB,p(T,[v(Z,Q):W:H|R]).
p([C|T],R):-!,[H,W] #:: 1..100,p(T,[f(C):W:H|R]).

คำอธิบาย

เราเริ่มต้นด้วยภาคแสดงgซึ่งใช้สตริงแปลงเป็นรายการของตัวอักษรและเรียกp (แยกวิเคราะห์) ด้วยสแต็กที่ว่างเปล่าเป็นอาร์กิวเมนต์ที่สอง

เพรดิเคตpเรียกตัวเองซ้ำด้วยสแต็กที่แก้ไขอย่างเหมาะสม (มองหา[H|T]รูปแบบการทำลายและตัวสร้าง) เมื่อเรียกใช้บนเคสฐานซึ่งรายการอินพุตว่างจะpพิมพ์องค์ประกอบเฉพาะของสแต็ก หากสแต็กมีองค์ประกอบน้อยกว่าหนึ่งองค์ประกอบ ณ จุดนี้หมายความว่าเรามีสตริงอินพุตว่างสตริงอินพุตไม่ถูกต้องหรือข้อบกพร่อง (ด้วยสตริง emtpy, เพรดิเคตล้มเหลว (Prolog พูดว่าNo) แต่ไม่มีการพิมพ์อะไร ซึ่งก็โอเคเพราะเราไม่ควรพิมพ์อะไรสำหรับสตริงว่าง)

การแก้

สแต็กมีคำอธิบายของรูปสี่เหลี่ยมผืนผ้าที่สร้างขึ้นแสดงS:W:Hที่Sเป็นสัญลักษณ์แทนสี่เหลี่ยมผืนผ้าWความกว้างและHความสูงของมัน (หมายเหตุA:Bคือน้ำตาลซินแทคติกสำหรับ:(A,B)tuple ที่มี functor ชื่อ:มันสั้นกว่าการเขียนกว่า tuple พร้อมสัญลักษณ์นำหน้า)

กับ AและBรายละเอียดย่อยสี่เหลี่ยมผืนผ้าSสามารถเป็นได้ทั้ง:

• h(A,B) : concat แนวนอนของ A และ B
• v(A,B) : concat แนวตั้งของ A และ B
• f(C) : เติมด้วย C โดยที่ C คือรหัสอักขระ

ความกว้างและความสูงของเส้นตารางเป็นตัวแปรการตั้งโปรแกรมที่ จำกัด : ในระหว่างการต่อข้อมูลแนวตั้ง (การตอบสนองในแนวนอน) ความกว้าง (การตอบสนองความสูง) ของสี่เหลี่ยมที่จัดการนั้นจะถูกรวมเป็นหนึ่งในขณะที่ความสูง ความสูงของแต่ละ subgrid (ความกว้าง resp.)

ขั้นตอนการติดฉลากที่ส่วนท้ายของกระบวนการจะทำการติดตั้งตัวแปรในขณะที่เคารพข้อ จำกัด โดยใช้ค่าที่เป็นไปได้น้อยที่สุด (นี่เป็นคุณสมบัติของคำสั่งที่พยายามแก้ไขปัญหา)

ฉันอาจได้คำตอบที่สั้นกว่าโดยใช้เหตุผลเดียวกับที่ทำในคำตอบอื่น ๆ โดยไม่มีข้อ จำกัด แต่ตอนนี้มันสายเกินไปแล้ว

โปรดทราบว่าเนื่องจากโดเมนเริ่มต้นสำหรับตัวแปรถูกตั้งค่าไว้1..100จึงมีข้อ จำกัด เกี่ยวกับขนาดของกริดที่เป็นไปได้ ขอบเขตบนสามารถเปลี่ยนแปลงได้ถ้าจำเป็น ผลกระทบด้านประสิทธิภาพของสิ่งนี้คือมันอาจใช้เวลามากในการพิจารณาว่าโซลูชันเฉพาะไม่ยอมรับวิธีแก้ปัญหา ฉันพูดว่า " ทำได้ " เนื่องจากข้อ จำกัด มีแนวโน้มที่จะตัดการค้นหาแบบเอ็กซ์โปเนนเชียลอย่างมาก หากคุณพบสตริงอินพุตที่ยาก / ราคาแพงที่จะปฏิเสธโปรดแชร์

การพิมพ์

ส่วนการพิมพ์นั้นน่าสนใจเพราะมีอัลกอริทึมการหล่อเรย์บนโครงสร้าง: ฉันวนซ้ำแต่ละเซลล์ของกริดที่เกิดจากจุดหนึ่ง(1,1)ไปอีกจุดหนึ่ง(W,H)และเรียกภาคwแสดงเพื่อพิมพ์เนื้อหาของกริดในต้นไม้หลักที่ ตำแหน่งนี้ (แน่นอนว่าจะมีการพิมพ์บรรทัดใหม่หลังจากประมวลผลแต่ละบรรทัด)

ในwตำแหน่งสัมพันธ์กับกริดปัจจุบัน (ตารางรากกำหนดพิกัดสัมบูรณ์)

เมื่อพิมพ์h(A,B)โครงสร้างที่จุด(X,Y)ฉันไม่มีเงื่อนไขพิมพ์ในทั้งสองสาขา:

• ในตารางAที่จุด(X,Y)และ
• ในตารางBที่จุด(H,Y)ที่Hเป็นลบความกว้างของXA

leaf leaf ของกริดทรีf(C)ในที่สุดก็สามารถพิมพ์อักขระCได้หากตำแหน่งสัมพัทธ์อยู่ภายในกริดหรือไม่ต้องทำอะไรเลย นี่คือวิธีที่ฉันสามารถพิมพ์เนื้อหาของกริดไปยังสตรีมเอาท์พุทจากบนลงล่างจากซ้ายไปขวา ไม่มีการสร้างอาร์เรย์จริง

การทดสอบ

t("ja-r|g-o|ni-|ze|d-|").
t("un|co|p-yr|i|gh-t-ab|-|le-||-").
t("co|mp|l|-ex|i|f|-y|").
t("a").

tt :- t(X),nl,g(X).
tt.

วิ่งทดสอบ:

[eclipse] tt.

jronze
aronze
ggoidd

uuuuuuun
coyriggl
coyrihhl
coyrittl
ppyriabe

cccoy
mmply
exify

a

Yes (0.00s cpu)

Python 2.7, 259

z=zip
def p(a,b):
 s,l=sorted([a,b],key=len)
 s+=([s[-1]]*(len(l)-len(s)))
 return z(*(z(*a)+z(*b)))
g=lambda s,t=[]:s and(s[0]=='-'and g(s[1:],t[:-2]+[z(*p(z(*t[-2]),z(*t[-1])))])or(s[0]=='|'and g(s[1:],t[:-2]+[p(t[-2],t[-1])])or g(s[1:],t+[[s[0]]])))or t[0]

gเป็นฟังก์ชั่นที่ใช้สเปคและให้อาร์เรย์ของตัวละคร 2D หากคุณต้องการรุ่นที่ใช้งานง่ายให้เพิ่มบรรทัดนี้เพื่อให้ใช้ข้อกำหนดจาก stdin และพิมพ์กริด:

print'\n'.join(''.join(s)for s in g(raw_input()))

กรณีทดสอบ

Input:
a
Output:
a
==========
Input:
co|mp|l|-ex|i|f|-y|
Output:
coooy
mplly
exify
==========
Input:
ja-r|g-o|ni-|ze|d-|
Output:
jronze
aroidd
ggoidd
==========
Input:
un|co|p-yr|i|gh-t-ab|-|le-||-
Output:
unnnnnnn
coyriggl
ppyrihhe
ppyritte
ppyriabe

คำอธิบาย

กลยุทธ์คือง่ายๆถ้าตารางGที่ถูกต้องสำหรับสเปคSแล้วซ้ำคอลัมน์ขวาสุดของGยังช่วยให้สเปคที่ถูกต้องสำหรับSและเดียวกันเป็นจริงกับการทำซ้ำแถวด้านล่าง (ข้อพิสูจน์เรื่องนี้คือการเหนี่ยวนำโครงสร้างS) ดังนั้นเมื่อเราต้องการเชื่อมรูปสี่เหลี่ยมสองรูปเราสามารถผนวกคอลัมน์ / แถวสุดท้ายของรูปที่มีขนาดเล็กลงได้จนกว่าจะจับคู่กับขนาด (นี่คือสิ่งที่ฟังก์ชัน p ทำ)

Haskell, 388 367 352 ไบต์

data C=L{c::Char}|N{t::Int,w::Int,h::Int,l::C,r::C}
q=replicate
[]#[x]=x
(c:i)#(b:a:s)|c=='-'=i#(N 1(max(w a)$w b)(h a+h b)a b:s)|c=='|'=i#(N 2(w a+w b)(max(h a)$h b)a b:s)
(c:i)#s=i#(N 0 1 1(L c)(L c):s)
p i|t i==0=q(h i)$q(w i)$c$l i|t i==2=zipWith(++)(p(l i){h=h i})$p(r i){h=h i,w=w i-w(l i)}|1<2=p(l i){w=w i}++p(r i){w=w i,h=h i-h(l i)}
f=p.(#[])

การใช้งาน: f "par-s||e-"->["pas","prs","eee"]

ทดสอบการทำงานด้วยการพิมพ์ที่สวยงาม:

> putStr $ unlines $ f "par-s||e-"
pas
prs
eee

> putStr $ unlines $ f "co|m|p|il|e|r|-"
comp
iler

> putStr $ unlines $ f "a"
a

> putStr $ unlines $ f "co|mp|l|-ex|i|f|-y|"
coooy
mplly
exify

> putStr $ unlines $ f "ja-r|g-o|ni-|ze|d-|"
jronze
aroidd
ggoidd

> putStr $ unlines $ f "un|co|p-yr|i|gh-t-ab|-|le-||-"
unnnnnnn
coyriggl
ppyrihhe
ppyritte
ppyriabe

วิธีการทำงาน: ฟังก์ชั่น#แยกสายป้อนเข้าไปในโครงสร้างCซึ่งเป็นทั้งใบถือตัวอักษรที่จะพิมพ์หรือโหนดL สามารถก) การเข้าร่วมแบบเคียงข้างกัน ( ), b) การเข้าร่วมด้านบนสุด ( ) หรือ c) สแควร์ตัวอักษรเดี่ยว ( ) โหนดทั้งหมดมีฟิลด์ความกว้างและความสูงและลูกซ้ายและขวา หลังจากการวิเคราะห์คำให้พิมพ์โหนดรูทที่เหลือโดยการปรับขนาดซ้ำ (ความกว้าง x ความสูง) ของโหนดย่อยและการเชื่อมต่อNNt==2t==1t==0p

แก้ไข: เอาท์พุทเป็นรายการบรรทัดแทนที่จะพิมพ์สวย

JavaScript (ES6), 283 295

แก้ไขตอนนี้โซลูชัน JS (หนักมาก) อย่างน้อยสั้นกว่าสารละลาย Python (ค่อนข้างเล่นกอล์ฟได้) อ้างอิง

เช่นเดียวกับ cardboard_box เพียงแค่ทำซ้ำคอลัมน์ซ้ายสุดหรือแถวบนสุด

F=w=>(
s=[t=1,l='length'],
[for(c of w)(
  b=s[t],a=s[--t],
  c>'z'?
    s[t]=(G=(a,b,m=b[l]-a[l])=>m?m>0?G([a[0],...a],b):G(a,[b[0],...b]):a.map((r,i)=>r+b[i]))(a,b)
  :c<'a'?
    s[t]=a.map(r=>r[m=b[0][l]-r[l],0].repeat(m>0&&m)+r).concat(b.map(r=>r[0].repeat(m<0&&-m)+r))
  :s[t+=2]=[c]
)],
s[t].join('\n'))

Ungolfedนี่เป็นทางออกแรกของฉัน

F=sp=>{
  s=[]
  for(c of sp){
    a=s.pop(b=s.pop())
    if (c > 'z')
    {
      l = a.length
      m = b.length
      for(; l-m ;)
        l < m ? l = a.unshift(a[0]) : m = b.unshift(b[0])
      s.push(a.map((r,i) => r + b[i]))
    }
    else if (c < 'a')
    {
      l = a[0].length
      m = b[0].length
      s.push(
        a.map(r => r[0].repeat(l < m ? m-l : 0) + r)
        .concat(b.map( r => r[0].repeat( l > m ? l-m : 0) + r))
      )
    }
    else 
    {
      s.push(a,b,[c])
    }
  }
  return s.pop().join('\n')
}

ทดสอบในคอนโซล Firefox / FireBug

;['par-s||e-','co|m|p|il|e|r|-','co|mp|l|-ex|i|f|-y|',
 'ja-r|g-o|ni-|ze|d-|','un|co|p-yr|i|gh-t-ab|-|le-||-']
.forEach(w=>console.log(F(w)))

เอาท์พุต

pas
prs
eee

comp
iler

cccoy
mmply
exify

jronze
aronze
ggoidd

uuuuuuun
coyriggl
coyrihhl
coyrittl
ppyriabe

Python 3, 251 ไบต์

นี่คือคำตอบอ้างอิงที่ฉันสัญญาไว้ golfed อีกเล็กน้อย

T=lambda m:list(map(list,zip(*m)))
E=lambda a,b:a[:1]*(len(b)-len(a))+a
H=lambda a,b:[d+c for c,d in zip(E(a,b),E(b,a))]
s=[]
for k in input():s=k>"z"and[H(*s[:2])]+s[2:]or k<"a"and[T(H(*map(T,s[:2])))]+s[2:]or[[[k]]]+s
for r in s[0]:print("".join(r))

นี่เป็นโปรแกรมเต็มรูปแบบที่รับสตริงจาก STDIN และพิมพ์ไปยัง STDOUT วิธีการนั้นเหมือนกับของ cardboard_box: กดอาร์เรย์ 1x1 สำหรับตัวอักษรและแถวที่ซ้ำกันหากจำเป็นสำหรับการต่อข้อมูล

$ echo "par-s||e-" | python3 gr.py
pas
prs
eee

คำอธิบายโดยละเอียด

• Tสลับรายการที่กำหนด งานส่วนใหญ่ทำโดยการzip(*m)สลับแถวเป็นคอลัมน์ส่วนที่เหลือเป็นเพียงการแปลงผลลัพธ์เป็นรายการของรายการเนื่องจากzipส่งคืนตัวกำเนิดของสิ่งอันดับ
• E(a,b)ผลตอบแทนที่มีองค์ประกอบแรกของมันซ้ำแล้วซ้ำอีกครั้งพอที่จะตรงกับความยาวของa bโปรดทราบว่าคูณรายการจากจำนวนเชิงลบจะช่วยให้รายการที่ว่างเปล่าดังนั้นหากbจะสั้นกว่าผลตอบแทนนี้aa
• H(a,b)ส่งคืนการต่อข้อมูลแนวนอนของaและbอันที่สั้นกว่านั้นยาวตามEความจำเป็น
• s เป็นกอง
• ในforลูปเราวนซ้ำสตริงอินพุตและแทนที่sด้วยค่าใหม่: ถ้ามัน|(มากกว่าz) เราป๊อปอัพสองค่าและกดHถ้ามัน-(ต่ำกว่าa) เราป๊อปอัพสองค่าทรานส์ฟีดH , ย้ายอีกครั้งและผลักดันผลและมิฉะนั้นจะผลักอาร์เรย์ 1x1 ด้วยตัวอักษร
• sสุดท้ายเราพิมพ์องค์ประกอบแรกของ