เขียนโปรแกรมจำลองเครื่องทัวริง

เพื่อความง่ายเราสามารถสมมติสถานะเป็นจำนวนเต็มสัญลักษณ์เป็นอักขระถ่านสัญลักษณ์ว่างเท่ากับช่องว่าง

5-tuple ในรูปแบบของสถานะปัจจุบัน, สัญลักษณ์อินพุต, สถานะถัดไป, สัญลักษณ์เอาต์พุต, ทิศทาง (ซ้ายหรือขวา) ลำดับไม่จำเป็น แต่ระบุว่าถ้าคุณสลับ

เครื่องต้องหยุดเมื่อถึงสถานะที่ไม่รู้จักไม่อนุญาตให้มีเงื่อนไขหยุดชะงักอื่น ๆ

เทปไม่มีที่สิ้นสุดในทั้งสองทิศทางและคุณสามารถอ่านอักขระว่างได้เสมอ

อินพุต: เทปเริ่มต้นสถานะเริ่มต้นและโปรแกรม คุณมีอิสระที่จะอ่านข้อมูลจากที่ใดก็ได้ในรูปแบบที่คุณต้องการ

เอาท์พุท: เทปหลังจากการดำเนินการของโปรแกรม

ต้องมี: โปรแกรมตัวอย่างที่ทำงานบนโปรแกรมจำลองการทำงานของคุณ

นี่คือโค๊ดโคฟเพื่อให้รหัสที่สั้นที่สุดชนะ

ฉันจะโพสต์การใช้งานและโปรแกรมตัวอย่างในอีกไม่กี่ชั่วโมงข้างหน้า

GolfScript, 92 ตัวอักษร

~:m;n\+{:^.n?)>1<]m{2<1$=},.{~2>~^n/~1>[@\+]n*1$%n/~\1$1<+[\1>.!{;" "}*]n*\%@}{;;^0}if}do n-

เครื่องทัวริงใน GolfScript นานกว่าที่ตั้งใจไว้มาก ยังคงเล่นรอบกับการเป็นตัวแทนที่แตกต่างกันของเทป

บรรทัดแรกของอินพุตคือสถานะดั้งเดิมบรรทัดที่สองของเทปเริ่มต้นตามด้วยอาร์เรย์ของช่วงการเปลี่ยนภาพ (ด้วยสถานะปัจจุบันของคำสั่งสัญลักษณ์อินพุตสถานะถัดไปทิศทางสัญลักษณ์เอาต์พุต)

ตัวอย่าง ( มีออนไลน์ด้วย )

> 0
> '101'
> [[0 '0' 0 1 '0']
>  [0 '1' 0 1 '1']
>  [0 ' ' 1 -1 ' ']
>  [1 '0' 2 1 '1']
>  [1 '1' 3 -1 '0']
>  [3 '0' 2 1 '1']
>  [3 ' ' 2 1 '1']
>  [3 '1' 3 -1 '0']] 

110 

GNU อยู่กับ-r- 133 117 111 93 ตัวอักษร

ใช่ sed กำลังทำให้สมบูรณ์ GNU sed และ-r(Extended regexps) เป็นเพียงการบันทึกอักขระไม่กี่ตัวเท่านั้นมันเป็นการเปลี่ยนแปลงเพียงเล็กน้อยในการทำงานกับ POSIX sed

:s
s/^(.*@)(.*)>(.)(.*#\1\3([^@]*@)(..))/\5\2\6>\4/
T
s/(..)l>|r>/>\1/
s/>@/@> /
s/>#/> #/
bs

รูปแบบอินพุตคือ

[initial state]@[non-empty tape with > marking head position]#[state]@[input symbol][next state]@[output symbol][direction l or r]#...

คั่น@, #และตัวอักษรหัว>ไม่สามารถนำมาใช้เป็นสัญลักษณ์บนเทป ป้ายกำกับของรัฐไม่สามารถมีหรือ@ >#

มันจะเรียกใช้โปรแกรมทั้งหมดในอินพุตหนึ่งรายการต่อบรรทัด

ตัวอย่าง:

มาร์โกเป็นⁿขⁿโปรแกรม

อินพุต

0@>aaabbb#0@a1@ r#0@ 4@ r#1@a1@ar#1@b1@br#1@ 2@ l#2@b3@ l#2@a5@al#3@b3@bl#3@a3@al#3@ 0@ r#4@ 5@Tr

เอาท์พุต

5@    T>  #0@a1@ r#0@ 4@ r#1@a1@ar#1@b1@br#1@ 2@ l#2@b3@ l#2@a5@al#3@b3@bl#3@a3@al#3@ 0@ r#4@ 5@Tr

สวัสดีมาร์โก! โปรแกรม

อินพุต

0@> #0@ 1@Hr#1@ 2@er#2@ 3@lr#3@ 4@lr#4@ 5@or#5@ 6@!r

เอาท์พุต

6@Hello!> #0@ 1@Hr#1@ 2@er#2@ 3@lr#3@ 4@lr#4@ 5@or#5@ 6@!r

ดังนั้นฉันมาสายนิดหน่อย แต่แค่คิดว่าฉันจะออกจากที่นี่ ...

เครื่องทัวริงจำลองเครื่องทัวริง: 370 ไบต์?

ที่นี่ฉันใช้โครงสร้างทัวริงที่ใช้ในกระดาษ 2479ของเขา ฉันกำลังใช้หนึ่งสัญลักษณ์ = หนึ่งไบต์รวมถึง m-configs และการดำเนินการ

╔═══════════════╦═══════╦═══════════════════╦═══════════════╗
║    m-config    ║ Symbol ║     Operations      ║ Final m-config ║
╠═══════════════╬═══════╬═══════════════════╬═══════════════╣
║ currentCommand ║ Any    ║ L                   ║ currentCommand ║
║                ║ *      ║ MR                  ║ readCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ nextCommand    ║ Any    ║ L                   ║ nextCommand    ║
║                ║ *      ║ E  R  R  R  P* R    ║ readCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommand    ║ P      ║ R                   ║ readCommandP   ║
║                ║ M      ║ R                   ║ readCommandM   ║
║                ║ G      ║ R                   ║ readCommandG   ║
║                ║ E      ║ R                   ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandP   ║ 0      ║                     ║ MHP0           ║
║                ║ 1      ║                     ║ MHP1           ║
║                ║ e      ║                     ║ MHPe           ║
║                ║ x      ║                     ║ MHPx           ║
║                ║ None   ║                     ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandM   ║ R      ║                     ║ MHMR           ║
║                ║ L      ║                     ║ MHML           ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandG   ║ 1      ║                     ║ G2<1           ║
║                ║ 2      ║                     ║ G2<2           ║
║                ║ 3      ║                     ║ G2<3           ║
║                ║ 4      ║                     ║ G2<4           ║
║                ║ 5      ║                     ║ G2<5           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<1           ║ int(1) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G21            ║
║                ║ *      ║ E  L                ║ G2<1           ║
║                ║ @      ║ E  L                ║ G2<1           ║
║                ║ Any    ║ L                   ║ G2<1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<2           ║ int(2) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G22            ║
║                ║ *      ║ E  L                ║ G2<2           ║
║                ║ @      ║ E  L                ║ G2<2           ║
║                ║ Any    ║ L                   ║ G2<2           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<3           ║ int(3) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G23            ║
║                ║ *      ║ E  L                ║ G2<3           ║
║                ║ @      ║ E  L                ║ G2<3           ║
║                ║ Any    ║ L                   ║ G2<3           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<4           ║ int(4) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G24            ║
║                ║ *      ║ E  L                ║ G2<4           ║
║                ║ @      ║ E  L                ║ G2<4           ║
║                ║ Any    ║ L                   ║ G2<4           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<5           ║ int(5) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G25            ║
║                ║ *      ║ E  L                ║ G2<5           ║
║                ║ @      ║ E  L                ║ G2<5           ║
║                ║ Any    ║ L                   ║ G2<5           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G21            ║ int(1) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G21            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G22            ║ int(2) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G22            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G23            ║ int(3) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G23            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G24            ║ int(4) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G24            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G25            ║ int(5) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G25            ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS            ║ ^      ║ R                   ║ TS             ║
║                ║ Any    ║ R                   ║ GTS            ║
╠----------------╬--------╬---------------------╬----------------╣
║ TS             ║ 0      ║                     ║ RL0            ║
║                ║ 1      ║                     ║ RL1            ║
║                ║ e      ║                     ║ RLe            ║
║                ║ x      ║                     ║ RLx            ║
║                ║ None   ║                     ║ RLNone         ║
╠----------------╬--------╬---------------------╬----------------╣
║ RL0            ║ @      ║ R  R                ║ GTS0           ║
║                ║ Any    ║ L                   ║ RL0            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RL1            ║ @      ║ R  R                ║ GTS1           ║
║                ║ Any    ║ L                   ║ RL1            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLe            ║ @      ║ R  R                ║ GTSe           ║
║                ║ Any    ║ L                   ║ RLe            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLx            ║ @      ║ R  R                ║ GTSx           ║
║                ║ Any    ║ L                   ║ RLx            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLNone         ║ @      ║ R  R                ║ GTSNone        ║
║                ║ Any    ║ L                   ║ RLNone         ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS0           ║ 0      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTS0           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS1           ║ 1      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTS1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSe           ║ e      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSe           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSx           ║ x      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSx           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSNone        ║ _      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHP0           ║ ^      ║ R                   ║ Print0         ║
║                ║ Any    ║ R                   ║ MHP0           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHP1           ║ ^      ║ R                   ║ Print1         ║
║                ║ Any    ║ R                   ║ MHP1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPe           ║ ^      ║ R                   ║ Printe         ║
║                ║ Any    ║ R                   ║ MHPe           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPx           ║ ^      ║ R                   ║ Printx         ║
║                ║ Any    ║ R                   ║ MHPx           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPNone        ║ ^      ║ R                   ║ PrintNone      ║
║                ║ Any    ║ R                   ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHMR           ║ ^      ║ R  R                ║ MHR            ║
║                ║ Any    ║ R                   ║ MHMR           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHML           ║ ^      ║ L                   ║ MHL            ║
║                ║ Any    ║ R                   ║ MHML           ║
╠----------------╬--------╬---------------------╬----------------╣
║ Print0         ║ ^      ║ R                   ║ Print0         ║
║                ║ None   ║ P0                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Print0         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Print1         ║ ^      ║ R                   ║ Print1         ║
║                ║ None   ║ P1                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Print1         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Printx         ║ ^      ║ R                   ║ Printx         ║
║                ║ None   ║ Px                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Printx         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Printe         ║ ^      ║ R                   ║ Printe         ║
║                ║ None   ║ Pe                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Printe         ║
╠----------------╬--------╬---------------------╬----------------╣
║ PrintNone      ║ ^      ║ R                   ║ PrintNone      ║
║                ║ None   ║                     ║ nextCommand    ║
║                ║ Any    ║ E                   ║ PrintNone      ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHL            ║ ^      ║ R  R                ║ MHL            ║
║                ║ [      ║                     ║ SBL            ║
║                ║ Any    ║ L  P^ R  R  E       ║ nextCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHR            ║ ^      ║ R  R                ║ MHR            ║
║                ║ ]      ║                     ║ SBR            ║
║                ║ None   ║ P^ L  L  E          ║ nextCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBR            ║ ]      ║ E  R  R  P]         ║ currentCommand ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBL            ║ ]      ║ R                   ║ SBLE           ║
║                ║ Any    ║ R                   ║ SBL            ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBLE           ║ [      ║                     ║ currentCommand ║
║                ║ None   ║ L                   ║ SBLE           ║
║                ║ Any    ║ E  R  R  P] L       ║ SBLE           ║
╚═══════════════╩═══════╩═══════════════════╩═══════════════╝

นี่คือตัวอย่างหนึ่งของทัวริงจากกระดาษด้านบนสำหรับเครื่องของฉัน:

['<', None, 1, '0', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '1', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      'e', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      'x', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '_', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',

             None, 2, '1', None, 'M', 'R', None, 'P', 'x', None, 'M', 'L', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '0', None, 'G', '3',

             None, 3, '0', None, 'M', 'R', None, 'M', 'R', None, 'G', '3',
                      '1', None, 'M', 'R', None, 'M', 'R', None, 'G', '3',
                      '_', None, 'P', '1', None, 'M', 'L', None, 'G', '4',

             None, 4, 'x', None, 'E', 'E', None, 'M', 'R', None, 'G', '3',
                      'e', None, 'M', 'R', None, 'G', '5',
                      '_', None, 'M', 'L', None, 'M', 'L', None, 'G', '4',

             None, 5, '0', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      '1', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      'e', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      'x', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      '_', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
        None, '[', '^', None, ']', None]

ลองออนไลน์! (ใช้ Python 3 เป็นล่าม) - แก้ไข: ฉันเพิ่งตรวจสอบ TIO และดูเหมือนจะใช้งานไม่ได้จริง ... ลองใช้กับเครื่องของคุณและมันก็น่าจะใช้ได้ดี (หวังว่า) มันทำในเหมือง

APL (110)

(มันไม่สั้นเลย ... )

0(''⍞){×⍴X←0~⍨⍺∘{x y S T s m t←⍺,⍵⋄S T≡x,⊃⊃⌽y:s,⊂(⊃y){m:(¯1↓⍺)(⍵,⍨¯1↑⍺)⋄(⍺,⊃⍵)(1↓⍵)}t,1↓⊃⌽y⋄0}¨⍵:⍵∇⍨⊃X⋄,/⊃⌽⍺}⎕

มันอ่านสองบรรทัดจากคีย์บอร์ด: อันแรกคือโปรแกรมและที่สองคือเทปเริ่มต้น

รูปแบบคือ

(in-state in-tape out-state movement out-tape) 

และพวกเขาทั้งหมดควรอยู่ในบรรทัดเดียวกัน 'การเคลื่อนไหว' คือ 0 เพื่อเลื่อนไปทางขวาและ 1 เพื่อเลื่อนไปทางซ้าย

ตัวอย่างโปรแกรม (แทรกตัวแบ่งบรรทัดเพื่อความชัดเจนควรอยู่ในหนึ่งบรรทัด)

(0 ' ' 1 0 '1')
(0 '1' 0 0 '1')
(1 '1' 1 0 '1')
(1 ' ' 2 1 ' ')
(2 '1' 3 1 ' ')

โปรแกรมเพิ่มตัวเลขสองหมายเลขพร้อมกันตัวอย่างเช่น:

in:  1111 111
out: 1111111

ตัวอย่างที่ 2 (ดัดแปลงมาจากโปรแกรมการเพิ่มเลขฐานสองจากรายการของ Marco Martinelli):

(0 '0' 0 0 '0')
(0 '1' 0 0 '1')
(0 ' ' 1 1 ' ')
(1 '0' 2 0 '1')
(1 '1' 3 1 '0')
(3 '0' 2 0 '1')
(3 ' ' 2 0 '1')
(3 '1' 3 1 '0')

Python 101 189 152 142

a=dict(zip(range(len(b)),b))
r=eval(p)
i=s=0
while 1:
 c=a.get(i,' ')
 s,m,a[i]=r[s,c]
 if 0==m:exit([x[1]for x in sorted(a.items())])
 i=i+m

b และ p เป็นอินพุต b คือเทปเริ่มต้น p เข้ารหัสกฎเป็น (การแสดงสตริงของ) a dict จาก tuple (ในรัฐ, ในเทป) ถึง (นอกรัฐ, ย้ายหัว, ออกเทป) tuple . หากการย้ายเป็น 0 โปรแกรมเสร็จสิ้น 1 จะย้ายไปทางขวาและ -1 เป็นการย้ายไปทางซ้าย

b="aaba"

p="""{(0, 'a'): (1, 1, 'a'),
      (0, 'b'): (0, 1, 'b'),
      (1, 'a'): (1, 1, 'a'),
      (1, 'b'): (0, 1, 'b'),
      (1, ' '): (1, 0, 'Y'),
      (0, ' '): (0, 0, 'N')}"""

โปรแกรมตัวอย่างนี้ทดสอบว่าตัวอักษรตัวสุดท้ายของสตริง (ก่อนเทปเปล่า) คือ 'a' ถ้าเป็นเช่นนั้นจะเขียน 'Y' ที่ท้ายสตริง (ช่องว่างแรก)

แก้ไข 1:

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

แก้ไข 2:

ขอบคุณ Strigoides สำหรับการปรับปรุงอย่างมาก

แก้ไข 3:

ฉันทำให้มันไม่จำเป็นดังนั้น 0 เพราะเอาท์พุทจะออกจากสถานที่เหมือนเดิม ฉันลบสิ่งนี้เพราะเราสามารถเขียนผลลัพธ์เช่นเดียวกับอินพุต

ป.ล. (205) (156) (150) (135)

<<
>>begin
/${stopped}def([){add dup{load}${exit}if}def
0 A{1 index{load}${pop( )}if
get{exec}${exit}if}loop
3{-1[pop}loop{1[print}loop

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

ประหยัดพิเศษด้วยการทำให้ทุกชื่อรัฐสามารถทำงานได้ดังนั้นจึงโหลดอัตโนมัติ

Ungolfed ด้วยโปรแกรม "Hello" แบบฝัง พิเศษ 52 ตัวอักษรซื้อวนเพื่ออ่านเทปจาก stdingsnd -q tm.psทำงานด้วย

%!
<<
    /A<<( ){dup(H)def 1 add B}>>
    /B<<( ){dup(e)def 1 add C}>>
    /C<<( ){dup(l)def 1 add D}>>
    /D<<( ){dup(l)def 1 add E}>>
    /E<<( ){dup(o)def 1 add F}>>
>>begin %ds: int-keys=tape name-keys=prog
0 A %pos state
{ %loop
    1 index{load}stopped{pop( )}if  %pos state tape(pos)
    get    {exec}stopped{exit  }if  %new-pos new-state
} loop
% Loop from tape position 0 to left until left tape end is found
0{                                  %pos
  -1 add                            %new-pos
  dup{load}stopped{exit}if          %new-pos tape(new-pos)
  pop                               %new-pos tape(new-pos)
}loop
% Move to the right and print all chars until right end is hit
{                                   %pos
  1 add                             %new-pos
  dup{load}stopped{exit}if          %new-pos tape(new-pos)
  print                             %new-pos tape(new-pos)
}loop

ดังนั้นรูปแบบตารางคือ

/in-state<<in-tape{dup out-tape def movement add out-state}
           in-tape2{dup out-tape2 def movement2 add out-state2}>>

ที่in-stateเป็นชื่อเฉพาะ, in-tapeและout-tapeมีตัวอักษร (เช่น. จำนวนเต็มหรือการแสดงออกซึ่งจำนวนเต็มผลผลิต) movementคือ-1สำหรับซ้ายหรือ1ผู้มีสิทธิและout-stateเป็นปฏิบัติการชื่อ การin-tapeเปลี่ยนหลายครั้งสำหรับสถานะเดียวกันจะต้องรวมกันดังกล่าวข้างต้น

C (ยังไม่ได้เล่นกอล์ฟ)

ฉันคิดว่าฉันไม่สามารถชนะด้วยสิ่งนี้ได้ แต่มันก็สนุกที่จะได้ทำงาน นี่คือความจริงมากขึ้นในขณะนี้ว่ามันใช้งานได้จริง :)

ยกเว้นมันจะไม่มีที่สิ้นสุดในทิศทางเดียวเท่านั้น ฉันคิดว่ามันต้องใช้เทปลบเช่นกัน เฮ้อ ....

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

#include<stdio.h>
int main(int c, char**v){
    int min=0,max=0;
    int pos=0,qi;sscanf(v[1],"%d",&qi);
    FILE*tab=fopen(v[2],"r");
    FILE*tape=fopen(v[3],"r+");
    setbuf(tape,NULL);
    do {
        min = pos<min? pos: min;
        max = pos>max? pos: max;
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        int c = fgetc(tape), qt=qi-1,qr;
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        char x = c==EOF?' ':c, xt=x-1,xr,d[2];
        if (x == '\n') x = ' ';
printf("%d '%c' %d (%d)\n", qi, x, pos, (int)ftell(tape));
        while((qt!=qi)||(xt!=x)){
            fscanf(tab, "%d '%c' %d '%c' %1[LRN]", &qt, &xt, &qr, &xr, d);
            if (feof(tab)){
                goto HALT;
            }
printf("%d '%c' %d '%c' %s\n", qt, xt, qr, xr, d);
        }
        qi=qr;
        rewind(tab);
        fputc(xr,tape);
        pos+=*d=='L'?-1:*d=='R'?1:0;
    } while(1);
HALT:
printf("[%d .. %d]:\n", min, max);
    for (pos = min; pos <= max; pos++){
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        //printf("%d ",pos);
        putchar(fgetc(tape));
        //puts("");
    }
    return qi;
}

และนี่คือการทดสอบ:

522(1)04:33 AM:~ 0> cat bab.tm
0 'a' 0 'b' R
0 'b' 0 'a' R
523(1)04:33 AM:~ 0> echo aaaaa > blank; make tm ; tm 0 bab.tm blank; echo; cat blank
make: `tm' is up to date.
0 'a' 0 (0)
0 'a' 0 'b' R
0 'a' 1 (2)
0 'a' 0 'b' R
0 'a' 2 (4)
0 'a' 0 'b' R
0 ' ' 3 (6)
0 'a' 0 'b' R
0 'b' 0 'a' R
[0 .. 3]:
bbbÿ
babab

โปรแกรมส่งสัญญาณออกเทปตามลำดับ แต่ไฟล์แสดงถึงด้านลบและด้านบวกสลับกัน

Groovy 234 228 154 153 149 139 124

n=[:];i=0;t={it.each{n[i++]=it};i=0};e={p,s->a=p[s,n[i]?:' '];if(a){n[i]=a[1];i+=a[2];e(p,a[0])}else n.sort()*.value.join()}

จัดรูปแบบเพื่อให้อ่านง่าย

n=[:];
i=0;
t={it.each{n[i++]=it};i=0};
e={p,s->
    a=p[s,n[i]?:' '];
    if(a){
        n[i]=a[1];
        i+=a[2];
        e(p,a[0])
    }else n.sort()*.value.join()
}

t คือฟังก์ชันที่ตั้งค่าเทป e เป็นฟังก์ชันที่ประเมินโปรแกรม

ตัวอย่างที่ 1 - พิมพ์ "Hello!" บนเทป :)

t('')
e([[0,' ']:[1,'H',1],
   [1,' ']:[2,'e',1],
   [2,' ']:[3,'l',1],
   [3,' ']:[4,'l',1],
   [4,' ']:[5,'o',1],
   [5,' ']:[6,'!',1]],0)

ตัวอย่างที่ 2 - ปล่อยให้ T บนเทปถ้าสตริงเริ่มต้นอยู่ในรูปแบบของⁿ b ⁿให้หยุดเป็นอย่างอื่น

t('aaabbb')
e([[0,'a']:[1,' ',1],
   [0,' ']:[4,' ',1],
   [1,'a']:[1,'a',1],
   [1,'b']:[1,'b',1],
   [1,' ']:[2,' ',-1],
   [2,'b']:[3,' ',-1],
   [2,'a']:[5,'a',-1],
   [3,'b']:[3,'b',-1],
   [3,'a']:[3,'a',-1],
   [3,' ']:[0,' ',1],
   [4,' ']:[5,'T',1]],0)

ตัวอย่างที่ 3 - การเพิ่มขึ้นของเลขฐานสอง

t('101')
e([[0,'0']:[0,'0',1],
   [0,'1']:[0,'1',1],
   [0,' ']:[1,' ',-1],
   [1,'0']:[2,'1',1],
   [1,'1']:[3,'0',-1],
   [3,'0']:[2,'1',1],
   [3,' ']:[2,'1',1],
   [3,'1']:[3,'0',-1]],0)

ในตัวอย่างที่ 1 หมายถึงเลื่อนไปทางขวาและ -1 หมายถึงเลื่อนไปทางซ้าย