พื้นหลัง

ในปี 1870 Émile Baudot ได้คิดค้นBaudot Codeซึ่งเป็นการเข้ารหัสอักขระที่มีความยาวคงที่สำหรับโทรเลข เขาออกแบบรหัสที่จะป้อนจากแป้นพิมพ์คู่มือด้วยปุ่มเพียงห้าปุ่ม สองมือดำเนินการด้วยมือซ้ายและสามมือขวา:

สิทธิดัชนีกลางและแหวนนิ้วมือทำงานผม , IIและ IIIปุ่มตามลำดับและดัชนีด้านซ้ายและนิ้วกลางดำเนิน IVและⅤ (ต่อจากนี้ไปฉันจะใช้เลขอารบิคตะวันตกของพวกเขาคือ 1ถึง5 ) อักขระจะถูกป้อนเป็นคอร์ด ในการป้อนตัวอักษร "C" ผู้ดำเนินการกด1 , 3และ4ปุ่มพร้อมกันโดยที่แขนแปรงหมุนจะอ่านแต่ละคีย์ตามลำดับและส่งกระแสไฟฟ้าหรือสำหรับปุ่มที่ไม่ได้กดลงจะไม่มีกระแสไฟฟ้า ผลที่ได้คือในแง่ที่ทันสมัย 5 บิตอย่างน้อยอย่างมีนัยสำคัญบิตแรกเข้ารหัสไบนารีซึ่งในตัวอย่างของเรา "C" 10110จะถูกเข้ารหัสเป็น

5 บิต

คุณอาจกำลังคิดว่า 5 บิตซึ่งสามารถแสดงสัญลักษณ์ที่ไม่ซ้ำกันมากที่สุดได้ไม่เกิน 32 ตัวนั้นไม่เพียงพอสำหรับตัวอักษรและตัวเลขภาษาอังกฤษทั้งหมดแม้กระทั่งการพูดถึงเครื่องหมายวรรคตอน Baudot มีอุบายแขนเสื้อของเขาแม้ว่า: ชุดอักขระของเขาเป็นจริงสองชุดที่แตกต่าง: ตัวอักษรและ ตัวเลขและเขากำหนดสองรหัสพิเศษเพื่อสลับระหว่างพวกเขา การเลื่อนตัวอักษรซึ่งเปลี่ยนไปใช้โหมดตัวอักษรเปิดใช้งานโดยการกดปุ่ม5เพียงอย่างเดียว ( 00001) และการเลื่อนรูปถูกเปิดใช้งานด้วย ปุ่ม4 ( 00010)

ท้าทาย

ความท้าทายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่ถอดรหัสการรับส่งสัญญาณของ Baudot

การส่งจริงจะเริ่มต้นด้วยบิตเริ่มต้นบางส่วนบวกเริ่มต้นและหยุดบิตก่อนและหลังอักขระแต่ละตัว แต่เราจะข้ามสิ่งเหล่านั้นและกังวลเฉพาะ 5 บิตที่ไม่ซ้ำกันสำหรับแต่ละอักขระ รูปแบบอินพุตและเอาต์พุตอธิบายไว้ด้านล่าง

รหัสของ Baudot

Baudot มีสองเวอร์ชั่นที่แตกต่างกัน: Continental และ UK พวกเราจะใช้เวอร์ชั่นของ UK ซึ่งไม่รวมถึงตัวอักษร "É" จากภาษาพื้นเมืองของ Baudot เราจะทิ้งสัญลักษณ์ทั้งหมดในเวอร์ชันสหราชอาณาจักรที่ไม่ใช่ตัวอักษร ASCII ที่พิมพ์ได้ คุณจะต้องถอดรหัสอักขระในตารางด้านล่างซึ่งทั้งหมดเป็นอักขระ ASCII ที่พิมพ์ได้ยกเว้นอักขระควบคุมสามตัวสุดท้ายที่อธิบายด้านล่างตาราง

คอลัมน์ "Ltr" แสดงตัวอักษรในโหมดตัวอักษรและ "รูป" แสดงตัวอักษรในโหมดรูป:

        Encoding             Encoding
Ltr Fig  12345       Ltr Fig  12345
--- --- --------     --- --- --------
 A   1   10000        P   +   11111
 B   8   00110        Q   /   10111
 C   9   10110        R   -   00111
 D   0   11110        S       00101
 E   2   01000        T       10101
 F       01110        U   4   10100
 G   7   01010        V   '   11101
 H       11010        W   ?   01101
 I       01100        X       01001
 J   6   10010        Y   3   00100
 K   (   10011        Z   :   11001
 L   =   11011        -   .   10001
 M   )   01011        ER  ER  00011
 N       01111        FS  SP  00010
 O   5   11100        SP  LS  00001
 /       11000

สามแถวสุดท้ายในคอลัมน์ด้านขวาคืออักขระควบคุม:

• ERคือลบออก Baudot เครื่องโทรเลขจะพิมพ์เครื่องหมายดอกจันเหมือนสัญลักษณ์สำหรับตัวละครตัวนี้ที่จะบอกผู้อ่านว่าตัวละครก่อนควรละเลย แต่เรากำลังจะเป็นยัง nicer ให้ผู้อ่านและจริงงด (ไม่ได้พิมพ์) ตัวละครก่อน มันทำหน้าที่เหมือนกันทั้งในโหมดจดหมายและรูป

• FSเป็นรูปกะ สิ่งนี้จะเปลี่ยนชุดอักขระจากตัวอักษรเป็นตัวเลข ถ้าตัวถอดรหัสอยู่ในโหมดรูปแล้ว FS จะถือว่าเป็นSpace (ดังนั้นSPในคอลัมน์ "Ltr") เมื่อตัวถอดรหัสอยู่ในโหมดรูปจะยังคงอยู่ในโหมดรูปจนกว่าจะได้รับอักขระ LS

• LSเป็นจดหมายกะ มันสลับชุดอักขระจากรูปเป็นตัวอักษร ถ้าถอดรหัสที่มีอยู่แล้วในโหมด Letter, LS จะถือว่าเป็นพื้นที่ เมื่ออยู่ในโหมดจดหมายตัวถอดรหัสจะยังคงอยู่ในโหมดตัวอักษรจนกระทั่งได้รับอักขระ FS

ตัวถอดรหัสจะเริ่มในโหมดตัวอักษรเสมอ

นี่คือตัวอย่างของการเลื่อนรูป, การเลื่อนจดหมายและช่องว่าง:

01011 10000 00100 00001 00010 10000 11100 00001 10101 11010
  M     A     Y   LS/SP FS/SP   1     5   LS/SP   T     H

MAY 15THนี้อัตราผลตอบแทนข้อความ อย่างที่คุณเห็น00001อักขระตัวแรก(ตัวอักษรเปลี่ยน / ช่องว่าง) ทำหน้าที่เป็นช่องว่างเนื่องจากตัวถอดรหัสอยู่ในโหมดตัวอักษรอยู่แล้ว ตัวอักษรถัดไป00010(Shift รูป / อวกาศ) 15สวิทช์ถอดรหัสไปที่โหมดรูปพิมพ์ จากนั้น00001จะปรากฏขึ้นอีกครั้ง แต่คราวนี้มันทำหน้าที่เป็นตัวหนังสือกะเพื่อให้ตัวถอดรหัสกลับมาอยู่ในโหมดจดหมาย

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

A,1,10000|E,2,01000|/,,11000|Y,3,00100|U,4,10100|I,,01100|O,5,11100|FS,SP,00010|J,6,10010|G,7,01010|H,,11010|B,8,00110|C,9,10110|F,,01110|D,0,11110|SP,LS,00001|-,.,10001|X,,01001|Z,:,11001|S,,00101|T,,10101|W,?,01101|V,',11101|ER,ER,00011|K,(,10011|M,),01011|L,=,11011|R,-,00111|Q,/,10111|N,,01111|P,+,11111

อินพุต

อินพุตจะเป็นสตริงอาร์เรย์หรือรายการของบิตตามลำดับอย่างน้อยที่สำคัญบิตแรก อักขระแต่ละตัวจะถูกแทนด้วยกลุ่มของ 5 บิต บิตอาจอยู่ในรูปแบบที่สมเหตุสมผลเช่นสตริงไบนารี, อาร์เรย์ของ0s และ1s, สตริงของ"0"และ"1" ตัวอักษร, ตัวเลขที่มีขนาดใหญ่มากเดี่ยว ฯลฯ ตราบใดที่มันแมปโดยตรงกับบิตของการส่ง

การส่งทุกครั้งจะมีอย่างน้อยหนึ่งกลุ่มที่พิมพ์ได้และสูงสุด 255 quintets (สามารถพิมพ์ได้หรืออย่างอื่น) เช่น 5–1,275 บิตรวม

อินพุตสามารถมีเพียงบิตของการส่งโดยมีข้อยกเว้นที่อนุญาตสองข้อ: จำนวน0บิตนำหน้าหรือต่อท้ายและ / หรือสำหรับอินพุตสตริงใด ๆบรรทัดใหม่ที่ต่อท้ายอาจเพิ่มการส่งผ่านได้ นำหน้าหรือต่อท้ายบิตหรือตัวละครไม่สามารถเพิ่มก่อนหรือหลังแต่ละกลุ่มได้เช่นคุณไม่สามารถแพ็ดแต่ละกลุ่มเป็น 8 บิต (หรือใช้แต่ละกลุ่มเป็นหมายเลขเดียวในอาร์เรย์ - ยกเว้นภาษาของคุณมีประเภทจำนวนเต็ม 5 บิต) หรือแยก quintets กับบิตใด ๆ "01111\n11100"เพิ่มเติมเช่น

ซองโน้ตและขอบ

1. การส่งจะมีเฉพาะอักขระในคอลัมน์ "Ltr" และ "Fig" ในตารางด้านบน คุณจะไม่ได้รับเช่น 01110ในโหมดรูปเพราะไม่อยู่ในคอลัมน์ "รูป"

2. สันนิษฐานว่าตัวถอดรหัสจะอยู่ในโหมดจดหมายเสมอเมื่อเริ่มต้นการส่งสัญญาณ อย่างไรก็ตามอักขระตัวแรกอาจเป็นอักขระ FS เพื่อสลับไปยังโหมดรูปได้ทันที

3. เมื่อตัวถอดรหัสอยู่ในโหมดจดหมายมันอาจได้รับตัวอักษร LS และเมื่ออยู่ในโหมดรูปก็อาจได้รับตัวอักษร FS ไม่ว่าในกรณีใดอักขระอวกาศจะต้องพิมพ์ (ดูผลลัพธ์)

4. อักขระ ER จะไม่เป็นตัวอักษรตัวแรกในการส่งและจะไม่ติดตาม LS, FS หรือ ER อื่นทันที

5. อักขระ FS อาจตามอักขระ LS ทันทีและในทางกลับกัน

6. อักขระ LS หรือ FS จะไม่ใช่อักขระสุดท้ายในการส่งใด ๆ

7. /และ-ตัวอักษรอาจจะได้รับในโหมดตัวอักษรอย่างใดอย่างหนึ่ง (รหัส11000และ10001ตามลำดับ) หรือโหมดรูป ( 10111 และ00111)

เอาท์พุต

เอาต์พุตอาจอยู่ในรูปแบบที่สมเหตุสมผลใด ๆ ซึ่งสมเหตุสมผลที่สุดคือ ASCII (หรือ UTF-8 ซึ่งอักขระที่แสดงทั้งหมดจะเหมือนกับ ASCII) โปรดระบุในคำตอบของคุณหากผลลัพธ์ของคุณอยู่ในการเข้ารหัสหรือรูปแบบอื่น

หมายเหตุ

• อักขระเว้นวรรค (ดู 3. ด้านบน) ควรเป็นพื้นที่ ASCII (0x20) หรือค่าที่เทียบเท่าของการเข้ารหัสของคุณนั่นคือสิ่งที่คุณจะได้รับเมื่อคุณกดแป้นเว้นวรรค

การชนะ

นี่คือรหัสกอล์ฟ รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ข้อ จำกัด

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

• ช่องว่างต่อท้ายและ / หรือขึ้นบรรทัดใหม่ต่อท้ายได้รับอนุญาต ช่องว่างนำหน้าหรืออักขระอื่น ๆ (ที่ไม่ได้เป็นส่วนหนึ่งของการส่งข้อมูล) จะไม่ได้รับอนุญาต

• คุณไม่สามารถใช้ฟังก์ชั่นในตัวหรือไลบรารีใด ๆ ที่ถอดรหัสรหัส Baudot (หรือลูกหลานของมันเช่น Murray Code, ITA-1 ฯลฯ )

กรณีทดสอบ

Input: 001101000010100111101110010101
Output: BAUDOT

Input: 11010010001001100011110111101111100
Output: HELLO

Input: 01011100000010000001000101000011100000011010111010
Output: MAY 15TH

Input: 0001000100010000001000001011101110011100101010010110101010001111100101
Output: 32 FOOTSTEPS

Input: 10110000110101011100111100001111011010000001101110
Output: GOLF

Input: 000100011000001111100000100010110111001100010110010000111111
Output: 8D =( :P

Input: 0000100001000010000100010001111011111011000011100010001
Output (4 leading spaces):     -/=/-

Pyth, 98 97 95 93 90 83 80 ไบต์

รหัสมีอักขระที่ไม่สามารถพิมพ์ได้ดังนั้นนี่คือxxdhexdump ที่ย้อนกลับได้:

00000000: 753f 7133 4a69 4832 5047 2b47 3f3c 334a  u?q3JiH2PG+G?<3J
00000010: 4040 6332 2e22 275a 75ae 5751 fb4e 3cd7  @@c2."'Zu.WQ.N<.
00000020: 02ce 8719 aac1 e0e0 fe1f 09e5 85bc a767  ...............g
00000030: 8e0c 1f47 508a cad1 1acb b26f 951e e5d6  ...GP......o....
00000040: 225a 4a2a 5c20 715a 3d5a 744a 637a 356b  "ZJ*\ qZ=ZtJcz5k

ลองออนไลน์ ชุดทดสอบ

ค่อนข้างนาน แต่ตารางการค้นหาใช้พื้นที่เกือบครึ่งหนึ่ง

สำหรับ 117 ไบต์ต่อไปนี้เป็นสิ่งเดียวกันโดยไม่พิมพ์ออกมา (ต้องการ ISO-8859-1):

u?q3JiH2PG+G?<3J@@c2."'Zu®WQûN<×\x02Î\x87\x19ªÁààþ\x1f\tå\x85¼§g\x8e\x0c\x1fGP\x8aÊÑ\x1a˲o\x95\x1eåÖ"ZJ*\ qZ=ZtJcz5k

หรือสำหรับ 93 ไบต์โดยไม่มีการบีบอัดบนตารางการค้นหา:

u?q3JiH2PG+G?<3J@@c2"OVDPYSBREXGMIWFNA-JKUTCQ/ZHL5'0+3;8-2;7);?;;1.6(4;9/;:;="ZJ*\ qZ=ZtJcz5k

JavaScript (ES6), 160 158 153 ไบต์

let f =
    
s=>s.replace(/.{5}/g,s=>(n='0b'+s-1)<2?m-n?(m^=1,''):' ':"? !YSBREXGMIWFNA-JKUTCQ/ZHLOVDP? ?!3 8-2 7) ?  1.6(4 9/ : =5'0+"[n+m*32],m=0).replace(/.!/g,'')

console.log(f("001101000010100111101110010101"));
console.log(f("11010010001001100011110111101111100"));
console.log(f("01011100000010000001000101000011100000011010111010"));
console.log(f("0001000100010000001000001011101110011100101010010110101010001111100101"));
console.log(f("10110000110101011100111100001111011010000001101110"));
console.log(f("000100011000001111100000100010110111001100010110010000111111"));
console.log(f("0000100001000010000100010001111011111011000011100010001"));

แบตช์306 304 ไบต์

@echo off
set/pc=
set r=
set d=! !!YSBREXGMIWFNA-JKUTCQ/ZHLOVDP!! !3!8-2!7)!?!!1.6(4!9/!:!=5'0+
set s=2
:l
set/an=(s^&32)+0%c:~,2%%%6*8+0x%c:~2,3%%%14
set c=%c:~5%
if %n%==%s% set/as^^=35&goto l
call set r=%%r%%%%d:~%n%,1%%
if %r:~-1%==! set r=%r:~,-2%&goto l
if not "%c%"=="" goto l
echo %r%

ใช้อินพุตบน STDIN เนื่องจากแบทช์ไม่มีการแปลงแบบไบนารีฉันจึงต้องทำการปลอมโดยใช้การแปลงฐานแปดและฐานสิบหก

• ตัวเลขสองตัวแรกถูกแปลงจากฐานแปด (ฉันไม่สามารถใช้ทศนิยมได้เนื่องจากตัวเลขตัวแรกอาจเป็น0) ค่าที่เป็นไปได้00, 01, และ10 11หลังสองมีค่า8และ9แต่ฉันต้องการ2หรือเพื่อให้ฉันใช้โมดูโลที่เหลือ36
• ตัวเลขสามหลักสุดท้ายจะถูกแปลงจากเลขฐานสิบหก ตัวเลขมีทั้ง14หรือ252ครั้งค่าที่ต้องการของพวกเขาเพื่อผมใช้โมดูโลที่เหลือ14( 252=14*18)
• c เป็นสตริงที่เข้ารหัส
• r คือผลลัพธ์ที่ได้
• d เป็นอาร์เรย์การถอดรหัส
• s คือดัชนี (คำนึงถึงสถานะการเปลี่ยนแปลงในบัญชี) ของตัวละครที่เปลี่ยนสถานะการเปลี่ยน
• nเป็นไบนาเด็มโค้ดถอดรหัสบวกบิต 5 ของsซึ่งจะเท่ากับสถานะกะซึ่งในกรณีที่สถานะการสลับถูกสลับหรือดัชนีในอาร์เรย์การถอดรหัสเพื่อค้นหาอักขระถัดไป (หรือ! เพื่อลบ)

PHP, 206 ไบต์

foreach(str_split($argv[1],5)as$s)($k="# f*YSBREXGMIWFNA-JKUTCQ/ZHLOVDP#l *3#8-2#7)#?##1.6(4#9/#:#=5'0+"[32*$f+bindec($s)])=="*"?array_pop($a):($k=="f"?$f=1:($k=="l"?$f=0:($k=="#"?:$a[]=$k)));echo join($a);

ชิป 1069 ไบต์

มันเป็นเรื่องใหญ่ แต่ก็สนุกดีที่จะเขียน

จะเข้าเป็นสตริงของ"1"'และ"0"' s (แม้ว่ามันจะดูที่ต่ำจริงๆเท่านั้น)

 AZZZZ,-o.AZZZZ  AZZZZ,o-.AZZZZ
*\\\\\]oo[\/\\\**//\\\]oo[/\\\\*
*\\\\/]oo[\/\\/**//\\/]oo[/\\\/*
*\\\//]oo[\/\//**//\//]oo[/\\//*
*\\\/\]oo[\/\/\**//\/\]oo[/\\/\*
*\\//\]oo[\///\**////\]oo[/\//\*
*\\///]oo[\////**/////]oo[/\///*
*\\/\/]oo[\//\/**///\/]oo[/\/\/*
*\\/\\]oo[\//\\**///\\]oo[/\/\\*
=
        o--------K-----o
      ,oo.   z---+~S  ,oo.
     ,LooR. !ZZZZ'   ,LooR.
    ,LLooRR.        ,LLooRR.
   ,LLLooRRR.      ,LLLooRRR.
  ,LLLLooRRRR.    ,LLLLooRRRR.
 ,LLLLLooRRRRR.  ,LLLLLooRRRRR. ,~Z
,LLLLLLooRRRRRR.,LLLLLLooRRRRRR.>m'
|||||||oo||||||||||||||oo||||||)/Rz.
xxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxx\^-^S
x)x))))))))))))xx)))))))))))))xx\g
xx)xxxxxxxxxxxxxxxxxxxxxxxxxxx))\f
xxxxxx))xxxxxxxxxxxxx)))))))))xx\e
xx)x))x)xxxxx))x)))))xxxxxxx)))x\d
xx))x))xxx)))xxxxx)))xxxx)))xx)x\c
xx)xx)xx))x))x)xx)xx)xx))x))x)xx\b
x)))))))x)xx)xxxx)x)xx)x)xx)xx)x\a
x)x)x))))))x)x))x)))x)))xx))x))x/f
x)x)x))))))x)x)xxx)xxxxxxxx)x)xx/e
xxxxxxxx))xxxxxx))))x)))xxx)x))x/d
xxxxx))xxxxx)x)xxx)xxx))xx))xx)x/c
xxx)xxx)xxxx)x)xxxxxx))xxx))x))x/b
x)xxx)x)x)xx)xxxxx))x)))xx))xxxx/a

ลองออนไลน์!

หมายเหตุ: การลบใช้อักขระแบ็คสเปซ ASCII ( \x08) ซึ่งหมายความว่าพวกเขาจะดูตลกใน TIO แต่พวกเขาดูดีพูด xterm

โครงสร้างพื้นฐาน

ที่ด้านบนเหนือ=เส้นคือตัวถอดรหัสอินพุต มันจะเปลี่ยนอินพุตให้เป็นหนึ่งใน 32 สัญญาณที่แยกกัน สิ่งเหล่านี้ถูกส่งมาจากสิ่งoที่อยู่เหนือสิ่ง=เหล่านี้

ภูเขารูปสามเหลี่ยมของLและRเพียงหมุนรูปแบบจากแถวแยกไปยังคอลัมน์ ตารางด้านล่างที่แปลแต่ละคอลัมน์เป็นอักขระเอาต์พุต สำหรับสัญญาณที่ไม่รู้จัก NUL ( \x00) จะถูกสร้างขึ้น สำหรับการเลื่อนแบบพิเศษแทนที่จะพิมพ์ตัวอักษรหยดเล็ก ๆ ทางด้านขวาจะเปลี่ยนโหมด

เคเบิลคาร์เหมือนสิ่งที่อยู่ระหว่างสองภูเขาระงับการพิมพ์ใด ๆ ระหว่างแต่ละกลุ่มมิฉะนั้นจะพยายามถอดรหัส quintets ที่ทับซ้อนกันทั้งหมดด้วย ลองแทนที่!ด้วยช่องว่างเพื่อดูด้วยตัวคุณเอง (การทำงานในโหมด verbose -vอาจเป็นที่สนใจเช่นกันที่นี่)

ฉันไม่แน่ใจว่าจะทำให้สิ่งเล็กลงในขณะนี้ได้อย่างไร มันค่อนข้างหนาแน่นสำหรับขนาดของมัน

รุ่น GNU, 334 + 1 = 335 ไบต์

+1 ไบต์สำหรับการ-rตั้งค่าสถานะ ใช้อินพุตบน STDIN

เมื่อมองถึงความท้าทายเก่า ๆ ฉันรู้ว่าสิ่งนี้จะค่อนข้างง่ายด้วยความสงบและดีสำหรับการฝึกฝน ฉันไม่ได้พยายามบีบอัดใด ๆ ดังนั้นตารางการค้นหาจึงเป็นรหัสมากกว่าครึ่ง

s|.*|#@&;01000E211000/%00100Y310100U401100I%11100O500010f 10010J601010G711010H%00110B810110C901110F%00001 l10001-.01001X%11001Z:00101S%10101T%01101W?11101V'00011<<10011K(01011M)11011L=00111R-10111Q/01111N%11111P+10000A111110D0|
:
s/@([01]{5})(.*;.*\1)(..)/\3@\2\3/
t
s/@;.*//
s/#f /@/
s/@ l/#/
s/#(.)./\1#/
s/@.(.)/\1@/
t
s/.<|[#@]//g

ลองออนไลน์!

คำอธิบาย

รหัสใช้งานได้ในสองขั้นตอน: อันดับแรกมันจะแทนที่แต่ละเลขฐานสอง 5 หลักด้วยอักขระสองตัว (ตัวอักษรและตัวเลข) ที่สอดคล้องกันจากตารางการค้นหา ตารางการค้นหาอยู่ในรูปแบบ𝟎𝟎𝟎𝟎𝟎𝐋𝐅𝟎𝟎𝟎𝟎𝟎𝐋𝐅…โดยที่𝟎เป็นเลขฐานสองและ𝐋และ𝐅เป็นตัวอักษรและตัวเลขที่สอดคล้องกันตามลำดับ %ย่อมาจากอักขระที่ขาดหายไป (ซึ่งอาจเป็นอักขระอื่นที่ไม่ใช่บรรทัดใหม่) FS/SPเป็นตัวแทนจากf<space>และเป็นSP/LS เป็นตัวแทนจาก<space>lER<<

จากนั้นผ่านแต่ละคู่ด้วย "เคอร์เซอร์" ที่ตรงกับโหมดปัจจุบัน - #สำหรับโหมดตัวอักษร@สำหรับโหมดรูป #เคอร์เซอร์เอาตัวละครที่สองของทั้งคู่แล้วความก้าวหน้าคู่ถัดไปและ@เอาคนแรกและความก้าวหน้า ในคำอื่น ๆ#A1B8จะกลายเป็นA#B8แล้วAB#และ@A1B8กลายเป็นแล้ว1@B8 18@เมื่อ#เคอร์เซอร์เผชิญหน้าf<space>จะลบมันและแทนที่ตัวเองกับ@เคอร์เซอร์และในทางกลับกันเมื่อเผชิญหน้า@<space>l

เมื่อไม่มีคู่ยังคงเคอร์เซอร์สุดท้ายจะถูกลบออกไปกับตัวละครใด ๆ <ตามมาด้วย

# Setup: Append a lookup table to the line.
# Also prepends "#" and "@" which we'll use as "cursors" later.
s|.*|#@&;01000E211000/%00100Y310100U401100I%11100O500010f 10010J601010G711010H%00110B810110C901110F%00001 l10001-.01001X%11001Z:00101S%10101T%01101W?11101V'00011<<10011K(01011M)11011L=00111R-10111Q/01111N%11111P+10000A111110D0|

# Phase 1
:
  # Using "@" as a "cursor", substitute for each run of 5 binary digits the
  # two corresponding characters from the lookup table.
  s/@([01]{5})(.*;.*\1)(..)/\3@\2\3/
  t   # Loop (branch to `:`) as long as substitutions are made.

s/@;.*//       # Delete the "@" and lookup table

# Phase 2
s/#f /@/       # FS (f ) in letter mode (#); delete and switch to figure mode (@ cursor).
s/@ l/#/       # LS ( l) in figure mode (@); delete and switch to letter mode (# cursor).
s/#(.)./\1#/   # Letter mode; replace pair with first of pair; advance cursor.
s/@.(.)/\1@/   # Figure mode; replace pair with second of pair; advance cursor.
t              # If any substitutions were made, branch (loop) to `:`.

# Teardown
s/.<|[#@]//g   # Delete characters followed by < (ER) and cursor.