ความท้าทายที่ฉันคิดว่าจะเจ๋งมากคือการทำล่ามสำหรับภาษาทัวริงที่คุณเลือก

กฎง่าย ๆ :

1. คุณสามารถใช้ภาษาใดก็ได้ในการสร้างล่ามนี้แม้ว่ามันจะใหม่กว่าความท้าทายนี้ก็ตาม
2. คุณสามารถใช้ภาษาทัวริงที่สมบูรณ์ได้ตราบใดที่มันไม่เหมือนกับภาษาที่คุณเขียนด้วย
3. คุณอาจไม่เพียงแค่ประเมินโค้ดตัวอย่างเช่นใช้ฟังก์ชัน eval
4. คำอธิบายของวิธีการที่คุณเข้าหานี้จะดี แต่ไม่จำเป็น
5. นี้จะได้คะแนนเป็นไบต์
6. การส่งแต่ละครั้งจะต้องทำงานอย่างเต็มที่ซึ่งหมายความว่าทุกคุณสมบัติที่คุณเลือกภาษาจะต้องมีอยู่

ที่จะใส่เพียงแค่:

งานของคุณคือการสร้างล่ามที่ใช้งานได้สำหรับภาษาทัวริงที่สมบูรณ์ด้วยภาษาที่คุณเลือก

โชคดี!

Brachylog (2) → ปัญหาการโพสต์ข้อความ , 9 ไบต์

~h=∋ᵐ\cᵐ=

ลองออนไลน์!

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

โปรแกรมในลิงค์ TIO ด้านบนคือ[["a","baa"],["ab","aa"],["bba","bb"]]สิ่งที่ฉันคัดลอกมาจาก Wikipedia วิธีการแก้ปัญหา (ซึ่งโปรแกรมพบอย่างรวดเร็วเป็นธรรม) ["bbaabbbaa","bbaabbbaa"]เป็น

คำอธิบาย

นี่เป็นเพียงการแปลโดยตรงของปัญหาการโพสต์จดหมายถึง Brachylog

~h=∋ᵐ\cᵐ=
~h         Find {the shortest possible} list which starts with {the input}
  =        and for which all elements are equal
   ∋ᵐ      such that taking an element of each element,
     \cᵐ   and concatenating elements in corresponding positions,
        =  produces a list all of whose elements are equal.

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

เยลลี่ → "เพิ่มขั้นต่ำในการย้ายข้อมูล", 5 4 ไบต์

+"Ṃẞ

ลองออนไลน์! (เรียกใช้หนึ่งรอบซ้ำเท่านั้นเพื่อหลีกเลี่ยงการหมดเวลา)

โครงสร้างทัวริงที่สมบูรณ์แบบง่าย ๆ : เราใช้เมทริกซ์จตุรัสเป็นโปรแกรมและวนซ้ำตลอดไปโดยระบุแถวที่เล็กที่สุดในพจนานุกรมแล้วเพิ่มแต่ละองค์ประกอบของแถวแรกโดยองค์ประกอบแรกของเล็กสุดที่มีขนาดเล็กแต่ละองค์ประกอบของแถวที่สอง โดยองค์ประกอบที่สองของ lexicographically ที่เล็กที่สุดและอื่น ๆ (โปรแกรมเยลลี่คือ " +"เพิ่มองค์ประกอบที่สอดคล้องกัน {ของอินพุตและ} Ṃขั้นต่ำ {ของดั้งเดิม}, ẞลูป" นี่คือไบต์ที่สั้นกว่าโปรแกรมก่อนหน้าของฉันZ+ṂZßซึ่งทำสิ่งเดียวกันฉันเห็นได้ชัดว่าฉันควรมุ่งเน้นไปที่การเล่นกอล์ฟ เยลลี่ไม่ใช่แค่เล่นกอล์ฟในภาษาที่นำมาใช้)

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

Mathematica ตีความเกมแห่งชีวิตของ Conway ขนาด 64 ไบต์

CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&

เกมแห่งชีวิตของคอนเวย์เป็นที่รู้กันว่าทัวริงสมบูรณ์; และออโตมาร์เซลลูล่าร์ถือเป็นความลุ่มหลงอย่างแท้จริง CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}เป็นกฎที่แปลงอาร์เรย์สองมิติเป็น 0 วินาทีและ 1 วินาทีตามขั้นตอนเดียวของเกมแห่งชีวิตของ Conway (ฉันคิดว่าพฤติกรรมเริ่มต้นคืออาร์เรย์นี้ล้อมรอบขอบของมันดังนั้นจึงเป็นพรูแยก) ~Nest~##&เปลี่ยนกฎนี้เป็นฟังก์ชั่นที่เมื่อได้รับสถานะบอร์ดเริ่มต้น (ขนาดใด ๆ ) และจำนวนเต็มnเป็นข้อโต้แย้งเอาท์พุท ผลของnการวนซ้ำของกฎของเกมแห่งชีวิต

เพื่อความเพลิดเพลินของคุณเองคุณสามารถใช้เวอร์ชันที่ปิดไว้

b = RandomInteger[1,{50,50}];
Manipulate[ArrayPlot[
  CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&
    [b, n] ]
, {{n,0}, 0, 100, 1}]

และเลื่อนผ่าน 100 รุ่นบนกระดาน 50x50

TurtlèdตีความCT , 49 ไบต์

ฉันอาจจะเล่นกอล์ฟนี้

นอกจากนี้สิ่งนี้จะไม่ส่งผลใด ๆ ที่เป็นประโยชน์ มันจะหยุดถ้าหากโปรแกรม CT ที่กำหนดหยุดทำงาน

นี่คือสิ่งที่ฉันทำเมื่อสักครู่ที่ผ่านมาจริง ๆ แล้ว (กอล์ฟบางตอนนี้)

!-l[*+.r_]' !l[ l]r[ u.(;d' u)d(1[ r].[ l])( r)+]

มันทำงานอย่างไร:

Turtlèdใช้เซลล์กริด เมื่อฉันพูดว่า "เขียนบางอย่างบนกริด" ฉันหมายถึงว่ากลุ่มของอักขระที่ต่อเนื่องกันถูกวางไว้บนกริด ตัวอย่าง

[ ][ ][ ][ ][ ][ ][ ]
[ ][H][E][L][L][O][ ]
[ ][ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ][ ][ ]

เข้าสู่โปรแกรม

ข้อมูลถูกป้อนเข้าก่อน:

!-l[*+.r_]' 

นี่คือโปรแกรม cat เป็นหลัก มันเขียนอินพุตลงบนกริด

ดังนั้นคำสั่งจะถูกป้อนเข้า:

!

มันทำอะไรกับคำสั่งเหล่านี้:

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

โปรแกรมนี้ทำงานอย่างไร หลังจากป้อนคำสั่งแล้วตัวชี้เทอร์เทิล / กริดจะเลื่อนกลับไปที่บิตซ้ายสุดของ datastring จากนั้นจะเข้าสู่วง

[ u.(;d' u)d(1[ r].[ l])( r)+]

สิ่งที่มันทำในลูปนี้คือมันเลื่อนขึ้นจาก datastring ซ้ายสุดและเขียนอักขระคำสั่งปัจจุบัน (u.) ถ้ามันเป็น; จุดสิ้นสุดของการผลิตมันจะเลื่อนลงและลบบิตข้อมูลด้านซ้ายสุดที่อยู่ด้านล่างและเลื่อนกลับขึ้น ( (;d' u)) จากนั้นไม่ว่าจะด้วยวิธีใดก็จะลดลงหนึ่ง ( d) หากบิตที่ไม่ได้ถูกลบก็หมายความว่าจะต้องตรวจสอบว่าจะคัดลอกบิตจากคำสั่งในตอนท้าย ดังนั้นถ้าตัวละครนี้ที่เป็นหรือเป็น databit ซ้ายสุดคือ 1 มันจะย้ายไปที่ปลายด้านขวาสุดของสตริงข้อมูลคัดลอกบิตจากสตริงคำสั่งและย้ายกลับไปยังพื้นที่ด้านซ้ายของข้อมูลซ้ายสุด บิต ( (1[ r].[ l])) ตอนนี้มันอยู่ที่ databit ซ้ายสุดซึ่งเป็นศูนย์หรือซ้ายของ databit ซ้ายสุด ดังนั้นเราจะย้ายไปทางขวาถ้าในพื้นที่ (( r)) จากนั้นตัวชี้คำสั่งจะเพิ่มขึ้นดังนั้นเราจะเขียนคำสั่งถัดไปในการวนซ้ำถัดไปของลูป หากไม่มีการบันทึกข้อมูลอีกต่อไปหมายความว่าเราจะอยู่ในที่ว่างและการวนซ้ำจะสิ้นสุดลง มิฉะนั้นเราจะทำการวิ่งวนซ้ำ

Perl → ตัวแปรโปรแกรมเมอร์ระดับสามดาว , 26 + 1 = 27 ไบต์

++$a[$a[$a[$_]]]for@F;redo

ลองออนไลน์! (ลิงก์นี้มีส่วนหัวที่ออกจากโปรแกรมหลังจากมีการทำซ้ำตามจำนวนที่กำหนด (เพื่อให้ TIO ไม่ได้หมดเวลา) และพิมพ์สถานะภายในทุกการทำซ้ำ (เพื่อให้สามารถทำสิ่งที่สังเกตได้)

ทำงานด้วย-a(การลงโทษ 1 ไบต์ในขณะที่คุณสามารถใส่มันก่อนที่-M5.010จะผลิต-aM5.010)

โดยเฉพาะอย่างยิ่งสิ่งนี้ใช้โปรแกรมเมอร์ระดับสามดาวซึ่งคำสั่งถูกคั่นด้วยช่องว่างและไม่อนุญาตให้ใส่ข้อคิดเห็นในไฟล์โดยไม่มีส่วนขยาย I / O (การเปลี่ยนแปลงเหล่านี้สร้างความแตกต่างไม่แตกต่างจากภาษาทัวริงสมบูรณ์) ไม่มีหลักฐานของทัวริงสมบูรณ์สำหรับโปรแกรมเมอร์สามดาวออนไลน์ แต่มันเป็นทัวริงสมบูรณ์ (ฉันได้แบ่งปันหลักฐานร่างของทัวริง - ความสมบูรณ์กับผู้เขียนโปรแกรมอื่น แต่หยุดทำงานกับภาษาเมื่อฉันค้นพบว่าจริง ๆ แล้วมันเป็นโปรแกรมที่ค่อนข้างง่ายเมื่อคุณได้รับการกระตุ้นครั้งแรก)

โปรแกรมไม่ต้องการคำอธิบายมากนัก Three Star Programmer มีสเปคที่ง่ายมากและนี่เป็นการแปลโดยตรงของมัน จุดที่บอบบางเท่านั้น: @Fคืออินพุตไปยังโปรแกรมในรูปแบบอาร์เรย์ (นี่คือผลลัพธ์ของ-a); และredoจะทำซ้ำโปรแกรมทั้งหมดเนื่องจากอยู่ในลูปโดยปริยาย (ซึ่งเป็นผลมาจาก-a)

แอสเซมบลี x86 (ไวยากรณ์ของ Intel / MASM) -Brainfuck 2127 ไบต์

ยังสามารถเล่นกอล์ฟได้

.386
.model flat,stdcall
.stack 4096
include \masm32\include\masm32.inc
includelib \masm32\lib\masm32.lib
ExitProcess proto,dwExitCode:dword
.data
bfsrc BYTE 200 dup(0) 
bfcells BYTE 100 dup(0) 
loopStack DD 5 dup(0) 
charBuf BYTE 5 dup(0) 
newline BYTE 10,0 
prompt BYTE "$",0 
hr BYTE 50 dup('-'),0 
space BYTE ' ',0
.code
EvalBf proc
    start:
    invoke StdOut, addr prompt
    invoke StdIn, addr bfsrc,200
    cmp bfsrc,0
    je exit
    mov eax,0 
    mov ebx,0 
    mov ecx,0 
    processInstruction:
    cmp BYTE PTR bfsrc[ebx], '+'
    je plus
    cmp BYTE PTR bfsrc[ebx], '-'
    je minus
    cmp BYTE PTR bfsrc[ebx], '>'
    je fwd
    cmp BYTE PTR bfsrc[ebx], '<'
    je back
    cmp BYTE PTR bfsrc[ebx], '['
    je open
    cmp BYTE PTR bfsrc[ebx], ']'
    je close
    cmp BYTE PTR bfsrc[ebx], '.'
    je dot
    jmp processNextInstruction
    plus:
    inc BYTE PTR bfcells[eax]
    jmp processNextInstruction
    minus:
    dec BYTE PTR bfcells[eax]
    jmp processNextInstruction
    fwd:
    inc eax
    jmp processNextInstruction
    back:
    dec eax
    jmp processNextInstruction
    open:
    mov loopStack[ecx*4],ebx
    inc ecx
    jmp processNextInstruction
    close:
    dec ecx
    cmp BYTE PTR bfcells[eax], 0
    je processNextInstruction
    mov ebx,loopStack[ecx*4]
    inc ecx
    jmp processNextInstruction
    dot:
    mov dl, BYTE PTR bfcells[eax]
    mov BYTE PTR charBuf[0], dl
    mov BYTE PTR charBuf[1],0anything
    push eax
    push ecx
    invoke StdOut, addr charBuf
    pop ecx
    pop eax
    jmp processNextInstruction
    processNextInstruction:
    inc ebx
    cmp BYTE PTR bfsrc[ebx], 0
    je done
    jmp processInstruction
    done:
    invoke StdOut, addr newline
    mov eax, 0
    printNext:
    cmp eax, 100
    jge reset
    push eax
    invoke dwtoa, BYTE PTR bfcells[eax], addr charBuf
    invoke StdOut, addr charBuf
    invoke StdOut, addr space
    pop eax
    inc eax
    jmp printNext
    reset:
    invoke StdOut, addr newline
    invoke StdOut, addr hr
    invoke StdOut, addr newline
    jmp start

    exit:
    invoke ExitProcess,0
EvalBf endp
end EvalBf

Pipตีความระบบแท็กแบบวงกลมขนาด 16 ไบต์

YqWyyPBg@++vXPOy

นำการผลิตของระบบแท็กเป็นอาร์กิวเมนต์บรรทัดคำสั่งและสตริงข้อมูลเริ่มต้นจาก stdin

รหัสข้างต้นค่อนข้างยากที่จะตรวจสอบเพราะมันไม่ได้สร้างผลลัพธ์ใด ๆ (ดังนั้นพฤติกรรมที่สังเกตได้เพียงอย่างเดียวคือ "ยุติ" เทียบกับ "ไม่ยุติ") ดังนั้นนี่คือรุ่นที่ไม่อัปโหลดที่ส่งออกสายข้อมูลหลังจากแต่ละขั้นตอนและยังยกเลิกหลังจาก 20 ขั้นตอนดังนั้น TIO จึงไม่ต้องจัดการกับเอาต์พุตจำนวนมากจากลูปที่ไม่มีที่สิ้นสุด: ลองออนไลน์!

ระบบแท็กวงจร

ระบบแท็กไซคลิกเป็นรูปแบบการคำนวณที่เรียบง่าย แต่สมบูรณ์แบบทัวริง พวกเขาประกอบด้วยรายการของโปรดักชั่นที่กำหนดการดำเนินงานเกี่ยวกับข้อมูลสตริง โปรดักชั่นและสตริงข้อมูลประกอบด้วย 1 และ 0

ในแต่ละขั้นตอนอักขระซ้ายสุดของสตริงข้อมูลจะถูกลบออก

• หากอักขระคือ 1 การผลิตปัจจุบันจะถูกต่อท้ายทางด้านขวาของสตริงข้อมูล
• หากตัวละครเป็น 0 จะไม่มีการต่อท้าย

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

คำอธิบาย

                  g is list of cmdline args; v is -1 (implicit)
 q                Read a line of stdin for the data string
Y                 and yank it into the y variable
  Wy              While data string is nonempty:
       g@++v       Retrieve the next production from g (using cyclic indexing)
             POy   Pop the first character of y
            X      String-multiply: result is the production if the first character of y
                   was 1, or empty string if it was 0
    yPB            Push that string to the back end of y

ฟังก์ชัน Collatz ทั่วไปที่ทำซ้ำ -> Python 2, 46 ไบต์

a,b,x,m=input()
while-~x%m:x=x/m*a[x%m]+b[x%m]

เรียกใช้ฟังก์ชันนี้ด้วยรายการ m-1 a และ b's ค่าเริ่มต้น x และตัวหาร m ซึ่งเรียกว่า "โปรแกรม" สำหรับ IGCF แทนที่จะใช้อาเรย์ที่สามเพื่อระบุโมดูลัสที่จะหยุดนี่จะหยุดเมื่อใดก็ตามที่โมดูลัสเป็น m-1 การทำให้เข้าใจง่ายนี้หมายถึงอาจต้องใช้ความพยายามพิเศษในการแปลงโปรแกรม Fractran ที่กำหนดให้เป็นตัวแปรนี้ แต่มันจะบันทึกสองสามไบต์ในล่าม

ลองออนไลน์! TIO นี้สาธิตวิธีเพิ่ม 5 + 5 ด้วยภาษานี้ โปรแกรม a = [3], b = [0], m = 2 ทำการเพิ่มเติมและเริ่มต้นด้วย 7776 = 2 ^ 5 * 3 ^ 5 ในที่สุดก็ให้ผลตอบแทน 59049 = 3 ^ 10

ResPlicate variant -> Python 2, 47 ไบต์

l=input()
while l:l=l[2+l[0]:]+l[2:2+l[0]]*l[1]

ฟังก์ชั่นนี้ตีความตัวแปรของ ResPlicate

• ซึ่งโปรแกรมเป็นรายการไพ ธ อนของความยาวคู่พร้อมองค์ประกอบคู่ที่ดัชนีสม่ำเสมอ
• โดยไม่มี I / O
• ซึ่งพยายามที่จะคัดลอกค่ามากกว่าที่มีอยู่ในส่วนที่เหลือของคิวเพียงแค่คัดลอกส่วนที่เหลือของคิว (เช่นบิตที่คัดลอกจะไม่ถูกเติมด้วยศูนย์กับความยาวที่ต้องการ)

การเปลี่ยนแปลงครั้งล่าสุดหมายความว่าบางโปรแกรม ResPlicate (ซึ่งตรงตามเงื่อนไขแรก) จะไม่ทำงานเหมือนกันในตัวแปรนี้ แต่โชคดีที่ล่าม BCT ไม่ต้องการฟังก์ชันการทำงานที่ถูกลบและภาษายังคงเป็น TC

ลองออนไลน์! TIO นี้มีการพิมพ์เพื่อแสดงว่ามันทำงานได้และส่วนหัวที่ฆ่าโปรแกรมหลังจาก 1 วินาทีและตัวอย่างที่จัดการเพื่อสร้างผลลัพธ์มากกว่า TIO สามารถจัดการในหนึ่งวินาที

Perl -a →เครื่องI / Dขนาด 24 ไบต์

$p=$a[$p]+=$_ for@F;redo

ลองออนไลน์! (มีส่วนหัวที่พิมพ์สถานะภายในและหยุดหลังจากทำซ้ำ 10 ครั้งเพื่อให้สามารถสังเกตพฤติกรรมได้)

เกี่ยวกับภาษา

ฉันใช้เวลาสองสามวันที่ผ่านมาในการทำงานกับเครื่องI / Dซึ่งเป็นหนึ่งในแนวคิดล่าสุดของฉันสำหรับภาษาการเขียนโปรแกรมที่ง่ายมาก การทำงานดังต่อไปนี้: ที่เก็บข้อมูลประกอบด้วย RAM ที่ไม่ได้ จำกัด โดยเริ่มจากศูนย์ทั้งหมด แต่ละองค์ประกอบสามารถเก็บจำนวนเต็มไม่ จำกัด (แม้ว่าในทางปฏิบัติโปรแกรมเครื่อง I / D ส่วนใหญ่จะเก็บเฉพาะจำนวนเต็มเล็กน้อยในส่วนใหญ่และใช้ประโยชน์จากจำนวนเต็มที่ไม่ จำกัด เป็นวิธีการระบุที่อยู่ของเซลล์ที่มีที่อยู่ขนาดใหญ่เท่านั้น) นอกจากนี้ยังมีตัวชี้ข้อมูลซึ่งชี้ไปที่เซลล์ (เช่นเก็บที่อยู่เป็นเซลล์) ตอนแรกมันยังเป็นศูนย์

มีเพียงสองคำสั่ง:

• I: เพิ่มตัวชี้ข้อมูลให้ชี้ไปที่เซลล์ (ตัวชี้ข้อมูลยังคงไม่เปลี่ยนแปลง)
• D: อ้างอิงตัวชี้ข้อมูลอีกครั้งเช่นอ่านค่าของเซลล์ที่ตัวชี้ข้อมูลชี้ไปที่ จากนั้นเก็บค่าผลลัพธ์ที่คุณอ่านกลับเข้าไปในตัวชี้ข้อมูล

การดำเนินการเพียงแค่รันโปรแกรมในลูปซ้ำ ๆ ตลอดไป

มันค่อนข้างน่าแปลกใจที่ภาษานี้เรียบง่ายแบบทัวริงดังนั้นฉันจึงพยายามพิสูจน์มัน นี่คือหลักฐาน มันค่อนข้างคล้ายกับ (แต่ง่ายกว่า) การพิสูจน์สำหรับ Three Star Programmer, ภาษาที่คล้ายกันมาก (และอันที่จริง, การส่งนี้ใช้ OISC "shell" พื้นฐานเดียวกันรอบโปรแกรม, แตกต่างกันในการใช้งานจริงเท่านั้น)

เกี่ยวกับโปรแกรม

การใช้

อินพุตควรถูกกำหนดให้กับอินพุตมาตรฐานและเป็นโปรแกรมเครื่อง I / D ที่ไม่มีข้อคิดเห็นและใช้ไวยากรณ์ RLE / OISC (เครื่อง I / D มีไวยากรณ์ที่เทียบเท่ากันสองแบบที่แตกต่างกัน แต่สำหรับ golfiness โปรแกรมนี้สนับสนุนหนึ่งในนั้นเท่านั้น) ในไวยากรณ์นี้โปรแกรมคือลำดับของตัวเลขเป็นทศนิยมแสดงถึงความยาวของการรันIคำสั่งระหว่างDคำสั่ง (คุณสามารถระบุDคำสั่งติดต่อกันสองคำสั่งขึ้นไปได้โดยวางคำสั่ง "run of 0 Iคำสั่ง" ไว้ระหว่างคำสั่งดังนั้นไวยากรณ์จึงเป็นคำทั่วไป

คำอธิบาย

สามารถเห็นได้จากโปรแกรมสิ่งนี้ไม่ได้ใช้งานIและDคำสั่งทีละรายการ อันที่จริงแล้วมันเป็นล่ามที่มีประสิทธิภาพสูงสุด (เล็กน้อยมาก) (ล้วนๆเพราะมันสั้นกว่าที่จะเขียนด้วยวิธีนี้) กุญแจสำคัญคือการเห็นว่าการรันคำสั่งnทีเพิ่มขึ้นจะเพิ่มเป้าหมายของตัวชี้ข้อมูลnครั้งเช่นเพิ่มnเข้ากับมัน และการรันคำสั่งที่เพิ่มขึ้น 0 สามารถทำได้ด้วยวิธีนี้เนื่องจากการเพิ่ม 0 ไปยังหน่วยความจำไม่มีผล ดังนั้นการดำเนินการที่เราใช้จริงคือการสลับกันระหว่างการดำเนินการระยะ -of- Is Dและ หรือกล่าวอีกนัยหนึ่ง "เพิ่มnไปยังค่าที่ชี้โดยตัวชี้ข้อมูล (เก็บไว้ในค่าที่ชี้ไปตามตัวชี้ข้อมูล) จากนั้นอ่านค่าที่ชี้ไปยังตัวชี้ข้อมูลและเก็บไว้ในตัวชี้ข้อมูล "นั่นชัดเจนกว่าความต้องการมาก เป็นและเราสามารถทำให้สิ่งนี้ง่ายขึ้นเพื่อ "เพิ่มnให้กับค่าที่ชี้โดยตัวชี้ข้อมูลจากนั้นเก็บค่านั้นทั้งในเป้าหมายของตัวชี้ข้อมูลและตัวชี้ข้อมูล"

ดังนั้นสิ่งสำคัญสำหรับโปรแกรมของเรา เรากำลังใช้อาร์เรย์$aเพื่อเก็บ RAM และ$pเป็นตัวชี้ข้อมูล (การจัดทำดัชนีลงในอาร์เรย์):

$p=$a[$p]+=$_
         + $_  add {the run length}
   $a[$p]      to the element of $a pointed to by $p
   $a[$p] =    storing the result back into that element
$p=            and also in the pointer itself

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

ในที่สุดสิ่งที่เราต้องทำคือการวางโปรแกรมนี้ลงในสองสามลูป การfor@Fวนซ้ำรวมกับ-aตัวเลือกบรรทัดคำสั่งจะวนซ้ำไปตามฟิลด์ของอินพุตมาตรฐาน (นิยามเริ่มต้นของ "ฟิลด์" ที่นี่จะแยกบนช่องว่าง) redoห่วงจะวางโปรแกรมทั้งหมดในวงโดยปริยาย (นอกเหนือสะดวกอ่านเข้ามาตรฐาน) ซึ่งจะทำให้โปรแกรมทำงานในวงซ้ำ ๆ ตามที่กำหนดโดยความหมายของเครื่อง I / D ที่

เยลลี่ →ระบบ2 แท็ก 8 ไบต์

µḢị⁴⁸;Ḋß

ลองออนไลน์!

ฉันมีความโปรดปรานในการใช้ภาษาที่ใช้ประโยชน์ได้จริง แต่คิดว่าฉันก็อาจจะพยายามที่จะเอาชนะงานต้นฉบับในขณะที่ฉันอยู่ที่นั่น

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

ยกตัวอย่างเช่นวิกิพีเดียให้เห็นตัวอย่างของระบบแท็กหนึ่ง { a, b, c}, { a→ bc, b→ a, c→ aaa} กับสตริงเริ่มต้นaaa; ในรูปแบบการป้อนข้อมูลนี้ว่า,[1,1,1] [[2,3],[1],[1,1,1]](ระบบแท็กไม่มีไวยากรณ์ที่ตายตัวและนี่เป็นวิธีที่สมเหตุสมผลในการทำ)

ลิงก์ TIO มีการเพิ่มṄ("เขียนสถานะภายในและบรรทัดใหม่ไปยัง stdout") เพื่อแสดงว่าโปรแกรมใช้งานได้จริง

คำอธิบาย

µḢị⁴⁸;Ḋß
           {implicit: initialise internal state from first argument}
µ          Disregard the second command-line argument by default
 Ḣ         Take the first element, removing it from the internal state
  ị⁴       Use the value to index into the second argument
    ⁸;     Prepend (the rest of) the internal state
      Ḋ    Discard the first element of the internal state
       ß   Loop forever

มีการนำ BF / P "ไปใช้ในเครื่องทัวริงขนาด 842 ไบต์

ตารางการเปลี่ยนแปลง (เชื่อมโยงเนื่องจากความยาว)

ตารางการเปลี่ยนรุ่นที่ตีกอล์ฟน้อย

ทัวริงเครื่องจำลองฉันใช้

แน่นอนว่านี่จะไม่ชนะรางวัลใด ๆ เป็นระยะเวลานาน แต่เป็นสิ่งที่ฉันอยากทำมาตลอดเพราะ BF นั้นคล้ายกับทัวริงแมชชีน แต่ละเซลล์เก็บค่าจาก-0x0 0xFความกว้างของเว็บไซต์ทัวริงนั้นกว้างพอที่จะไม่เบราว์เซอร์ของคุณ ,และ.ฟังก์ชั่น (input และ output) ไม่ได้กำหนดไว้เพื่อให้มันเป็นบิตมากขึ้นเช่น P" กว่า BF จริง

หากต้องการเรียกใช้ให้วางตารางการเปลี่ยนแปลงลงในเครื่องจำลองการทัวริงตั้งค่าอินพุตเป็นรหัส BF บางส่วนและกดเรียกใช้

เทปของ TM เก็บทั้งรหัส BF และข้อมูล BF โดยมีช่องว่างตรงกลาง มันจะติดตามตำแหน่งของมันในรหัสโดยการดัดแปลงตัวละครที่มันกำลังทำงานอยู่ ( [-> (, ฯลฯ ) และตำแหน่งของมันในข้อมูลที่มี^ด้านหน้าของเซลล์ เมื่อมันอ่านตัวอักษรคำสั่งมันจะเคลื่อนที่จนกว่ามันจะกระทบกับคาเร็ต, เคลื่อนที่หนึ่งเซลล์ไปทางขวาและทำหน้าที่ตามความเหมาะสม จากนั้นจะกลับไปค้นหาอักขระคำสั่ง "แก้ไข" หนึ่งรายการในรหัส BF และย้ายไปยังอักขระถัดไปทำซ้ำกระบวนการทั้งหมด เมื่อรหัสไม่ทำงานก็จะหยุดทำงาน

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

รุ่นที่ตีกอล์ฟและไม่ได้รับการตีกอล์ฟนั้นเหมือนกันในแง่ของวิธีการทำงาน แต่รุ่นที่ไม่ได้รับการตีพิมพ์นั้นมีชื่อที่เป็นมิตรต่อมนุษย์มากกว่าและแบ่งออกเป็นส่วนต่างๆ

การใช้งานเครื่องจักรทัวริง (2,3) , 236 205 ไบต์ ( 46 31 น้อยกว่าหากคุณไม่สนใจอินพุตที่น่าอึดอัดใจ)

ขอบคุณ Appleshell สำหรับ -11 ไบต์, VisualMelon สำหรับ -12 ไบต์และ Johan du Toit สำหรับ -7 ไบต์

CeilingCat ทำรุ่นที่ใช้เพียง 144 ไบต์ดูที่นี่

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

#define c char
j;i;k;c s,d[256];c main(){c*p=d+128;gets(d);
for(;k<256&&d[k];)d[k++]-=48;for(;++j<256;)
{c t=*p;*p=-t*t+(2-s)*t+1+s;p+=(s^t==0)*2-1;s=s?t%2:!t%3;
for(i=0;++i<256;)printf("%d",d[i]);puts("");}}

ลองออนไลน์!

วิธีใช้: ป้อนสตริงสูงสุด 256 รายการค่าศูนย์และ twos เพื่อเริ่มต้นเทป ค่าเริ่มต้นใด ๆ จะเป็นศูนย์ (ค่าอื่นที่ไม่ใช่ 0, 1 และ 2 อาจทำให้เกิดพฤติกรรมที่ไม่ได้กำหนด) โปรแกรมจะวนซ้ำกว่า 256 ขั้น จำนวนขั้นตอนที่วนซ้ำสามารถเพิ่มขึ้นได้โดยการแก้ไขโค้ด แต่แน่นอนว่าต้องใช้อักขระมากขึ้น

มันเป็นรายการที่ค่อนข้างยาว แต่นี่เป็นครั้งแรกที่ฉันทำอย่างใดอย่างหนึ่งและฉันไม่ได้ใช้ภาษากอล์ฟโดยเฉพาะ ฉันสนุกมากแม้ว่ามันจะนานกว่าที่ฉันคาดไว้ก็ตาม

ไบต์จำนวนมากมาจากการจัดการกับอินพุตและเอาต์พุตและฉันสูญเสียทั้ง 42 ไบต์โดยทำให้ยอมรับ 0, 1 และ 2 แทน NUL, SOH, STX (หากต้องการเปลี่ยนให้ลบk;จากด้านหน้าและfor(;k<256&&d[k];)d[k++]-=48;จากบรรทัดที่สอง)

ตาราง transistion โดยเฉพาะอย่างยิ่งบรรทัด*p=-t*t+(2-s)*t+1+s;(ซึ่งกำหนดค่าบนเทป) อาจถูกบีบอัดได้มากขึ้นเช่นกัน

Rödaกำลังใช้งานFractran , 114 112 106 ไบต์

บันทึก 1 ไบต์ด้วย @fergusq ด้วยการจัดเรียงพารามิเตอร์ใหม่

f&n,a{x=1{x=0;(a/" ")()|[_/`/`]|[parseInteger(_[0],_1[1])]|{|q,w|{n*=q/w;x=1}if[n%w<1,x<1]}_,_}while[x>0]}

ลองออนไลน์!

f reference_to_input programเรียกใช้ฟังก์ชันเช่นดังนั้น: inputการส่งออกจะถูกเก็บไว้ในสถานที่ของ

Clojure, 82 81 ไบต์ (เครื่องจักรทัวริง)

ปรับปรุง: t{} sถูกลบออกจากพื้นที่

#(loop[p 0 t{}s 1](if-let[[S M N](%[(or(t p)0)s])](recur(+ p M)(assoc t p S)N)t))

ใช้เครื่องทัวริงเป็นวนรอบส่งคืนเทปเมื่อถึงสถานะหยุดทำงาน ในกฎการเปลี่ยนสถานะนี้จะระบุโดย ommitting สถานะการเปลี่ยนแปลง settins นี้Nไปnilและต่อมาจะยกเลิกเป็นการเปลี่ยนแปลงรัฐที่เกี่ยวข้องจะไม่พบจากอินพุตกัญชาแผนที่if-let %จริงๆแล้วค่าใด ๆ สำหรับสถานะนี้จะทำเช่น:abort0 หรือ -1

Ungolfed กับตัวอย่างที่ 3 รัฐ 2 สัญลักษณ์ช่องคลอดไม่ว่างจากวิกิพีเดีย

(def f #(loop[pos 0 tape {} state 1]
          (if-let [[sym move next-state](%[(get tape pos 0)state])]
            (do (println [pos tape state])
                (recur(+ pos move)(assoc tape pos sym)next-state))
            tape)))

(f {[0 1] [1  1 2]
    [0 2] [1 -1 1]
    [0 3] [1 -1 2] 
    [1 1] [1 -1 3]
    [1 2] [1  1 2]
    [1 3] [1  1]})

{0 1, 1 1, -1 1, -2 1, -3 1, 2 1}

ลองมันออนไลน์

ในแกนหลักเดียวของ 6700K สิ่งนี้จะรันช่องสัญญาณไม่ว่าง 5 สถานะ (47.1 ล้านก้าว) ในเวลาประมาณ 29 วินาทีหรือ 1.6 ล้านขั้นตอน / วินาที

M → เคล็ดลับ 4 ไบต์

Ṅ×ịß

ลองออนไลน์!

ลิงก์ TIO เพิ่มส่วนท้ายเพื่อเรียกใช้ฟังก์ชันด้วยตัวอย่างโปรแกรม Tip ที่แสดงในหน้า Esolang ("wrapper อัตโนมัติ" ของ M เพื่อเรียกใช้ฟังก์ชั่นราวกับว่าพวกเขาเป็นโปรแกรมที่ไม่สามารถจัดการหมายเลขเหตุผลหรือจุดคงที่หรืออย่างน้อย ไม่ทราบวิธีที่จะบอกวิธีการดังนั้นฉันต้องทำให้ฟังก์ชั่นเป็นโปรแกรมเต็มรูปแบบด้วยมือเพื่อให้สามารถเรียกใช้)

นี่จะพิมพ์เอาต์พุตดีบักที่มีประโยชน์ โปรแกรมไม่สามารถเขียนใน 3 ไบต์ใน M เพราะโปรแกรมที่ประกอบด้วยสาม dyads ทำให้เกิดกรณีพิเศษใน parser ดังนั้นฉันต้องเพิ่มคำสั่งพิเศษเพื่อหลีกเลี่ยงกรณีพิเศษ ทำให้มันṄ(พิมพ์ขึ้นบรรทัดใหม่) อย่างน้อยก็มีวัตถุประสงค์ที่เป็นประโยชน์

ı$i=\sqrt{-1}$

ห้ามใช้ I / O (นอกเหนือจากหยุด / ไม่หยุด) I / O เป็นส่วนเสริมของเคล็ดลับ (ไม่ใช่ส่วนหนึ่งของภาษานั้น) และไม่จำเป็นต้องใช้สำหรับทัวริง

คำอธิบาย / พื้นหลัง

Ṅ×ịß
Ṅ     Print {the left argument} and a newline; also resolves a parser ambiguity
  ị   {The left argument}th element of {the right argument}, wrapping on OoB
 ×    Multiply {the left argument} by {the chosen element}
   ß  Recursive call; arguments: {the product} and {the same right argument}

[1,2,3][1,2,3,1,2,3,1,2,3,…]$rx+s$ซึ่งเป็นพหุนามและ "การแปลงฐาน" builtin ที่ภาษากอล์ฟจำนวนมากมีจริง ๆ แล้วผู้ประเมินพหุนามมีวัตถุประสงค์ทั่วไปในการปลอมตัว ดังนั้นสิ่งที่เราต้องทำคือทำดัชนีในรายการของตัวเลข, แปลงฐานพวกมันแล้วเราก็เสร็จแล้วใช่ไหม?

$x$$x$

ḅ$x\oplus(x\otimes y)$$x\otimes y$${\oplus}$. แน่นอนว่าเราสามารถแทนที่พฤติกรรมการผูกมัดกับทุกสิ่งที่เราต้องการได้ แต่นั่นจะมีค่าใช้จ่ายทั้งไบต์และรายการภาษากอล์ฟสำหรับคำถามนี้เริ่มสั้นลงจนมีจำนวนมาก

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

$s$

และแน่นอนการแปลงฐานแตกต่าง ( ḅ) คูณ ( ×) เป็นสับเปลี่ยนและทำให้มันไม่สำคัญสิ่งที่สั่งการขัดแย้งที่มีอยู่ใน. ดังนั้นสิ่งที่เราต้องเขียนถูก×ịแล้ววางโปรแกรมเป็น recursion อนันต์กับß, และเรามีภาษาทัวริงที่สมบูรณ์ ขวา?

$(x\odot y)\oplus(x\otimes y)$¹×ịß¹¹Ṅ เป็นตัวเลือกที่ดีเพราะสร้างผลลัพธ์การดีบักที่มีประโยชน์

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

การตีความ Brainfuck, 187 ไบต์

t[999],*p=t,c,i,l;f(char*t){for(i=0;c=t[i];i++){c^62?c^60?c^43?c^45?c^46?c^44?c^91:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;if(c==93&&*p)for(l=1;l>0;)c=t[--i],c==91?l--:c==93?l++:0;}}

ลองออนไลน์

Lua ตีความ Brainf ***, 467 ไบต์

b,r,a,i,n,s=0,io.read,{0},1,1,"><+-.,[]"c,f=r(),{function()n=n+1;a[n]=a[n]or 0;end,function()n=n-1;a[n]=a[n]or 0;end,function()a[n]=a[n]+1;end,function()a[n]=a[n]-1;end,function()io.write(string.char(a[n]))end,function()a[n]=io.read():byte()end,function()i=a[n]~=0 and i or c:find("]",i)end,function()if a[n]~=0 then b,x=1,""repeat i=i-1 x=c:sub(i,i)b=x=="["and b-1 or x=="]"and b+1 or b until b==0 and x=="["end end}repeat f[s:find(c:sub(i,i),1,1)]()i=i+1 until i>#c

ฉันรู้ว่ายังมีบางสิ่งบางอย่างลดลงฉันสามารถทำในภายหลัง แต่นี่คือที่ผ่านแรกของฉันสิ้นสุดลง ใช้โค้ด brainf จากอินพุตมาตรฐาน

CJam → ResPlicate Variant, 15 14 13 ไบต์

^{-1 ไบต์ขอบคุณ @ ais523}

l~{(/((*+e_}h

ตัวแปรนั้นเหมือนกันกับคำตอบนี้ยกเว้นว่าจำนวนรายการที่นำออกจากคิวจะน้อยกว่าหมายเลขบนสุดของคิว

l~{ ... }hส่วนหนึ่งใช้เวลาเพียงอาร์เรย์เป็น input และทำซ้ำจนกว่าอาร์เรย์ที่เป็นที่ว่างเปล่า

คำอธิบายสำหรับการวนรอบหลัก:

    e# Stack:             | [3 2 1 1 2 2 2 1]
(   e# Pop first element: | [2 1 1 2 2 2 1] 3
/   e# Split chunks:      | [[2 1 1] [2 2 2] [1]]
(   e# Pop first:         | [[2 2 2] [1]] [2 1 1]
(   e# Pop first:         | [[2 2 2] [1]] [1 1] 2
*   e# Repeat array:      | [[2 2 2] [1]] [1 1 1 1]
+   e# Concatenate:       | [[2 2 2] [1] 1 1 1 1]
e_  e# Flatten:           | [2 2 2 1 1 1 1 1]

ชิป 20 + 3 = 23 ไบต์ (กฎ 110)

AZZ
>}/a
`)\'E~Zte*f

+3 สำหรับธง -z

ลองออนไลน์!

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

การใช้งานนี้รับอินพุตและเอาต์พุตที่กำหนดในรูปแบบของ ASCII 0s และ1s ตรรกะที่นี่มีดังนี้:

p := value of left neighbor cell    AZZ
q := value of current cell          AZ
r := value of right neighbor cell   A

q' := ((r xor q) and p) or          >}/a
      ((r or q) and ~p)             `)\'

ส่วนที่เหลือขององค์ประกอบสำหรับการดูแลทำความสะอาด: e*fทำให้เกิดการส่งออกเป็นตัวเลข ASCII และE~Ztยุติการดำเนินการสองไบต์หลังจากอินพุตหมด (เนื่องจากความกว้างเติบโต 2 แต่ละรุ่น)

Clojure, 75 ไบต์ (ระบบแท็กวงจร)

Update 1: แทนที่ด้วยsome?nil?

การปรับปรุงที่ 2: แก้ไขที่หายไปในสาขาอื่นของSif s

#(loop[[p & P](cycle %)[s & S]%2](if(nil? s)S(recur P(if s(concat S p)S))))

ใช้ระบบแท็ก cyclicส่งคืนnilหากโปรแกรมหยุดทำงานวนซ้ำไปเรื่อย ๆ Clojure จริงๆส่องที่นี่กับลำดับอนันต์ขี้เกียจ (เช่นวงจร ) และdestructuring คนและเลขศูนย์จะถูกระบุว่าเป็นค่าจริงและเท็จ เมื่อข้อมูลสตริงหมดจะกลายเป็นsnil

Ungolfed:

(def f #(loop[[p & P] (cycle %) [s & S] %2 i 5]
          (do
            (pprint [p (concat [s] S)])
            (if (and (some? s) (pos? i))
              (recur P (if s (concat S p) S) (dec i))))))

ตัวอย่างผลลัพธ์:

(f [[false]] [true true])
[[false] (true true)]
[[false] (true false)]
[[false] (false false)]
[[false] (false)]
[[false] (nil)]

(f [[false true true] [true false] [true false true]] [true])
[[false true true] (true)]
[[true false]      (false true true)]
[[true false true] (true true)]
[[false true true] (true true false true)]
[[true false]      (true false true false true true)]
[[true false true] (false true false true true true false)]

JavaScript ตีความกฎ 110 , 131 ไบต์ (99 ไบต์หรือ 28 ไบต์?)

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}
c=(l,n)=>!n?l:c(b(0+l+0),n-1)

ที่คุณสามารถดูรหัสกำหนด 3 ฟังก์ชั่นa, และb cบางทีอาจเป็นไปได้ที่จะบันทึกไบต์ด้วยการรวมเข้าด้วยกันใน 1 ฟังก์ชั่น (ฉันไม่เห็นวิธี) แต่ก็ดีที่มีแยกจากกันเพราะแต่ละคนตอบสนองความท้าทายนี้แล้วในแง่หนึ่ง

ฟังก์ชั่นaใช้ตัวเลข 3 ตัวเป็นอินพุตและคำนวณพหุนามแปลก ๆ ของมัน เมื่อตัวเลขทั้งสามนี้เป็น0หรือ1พวกเขาสามารถมองเห็นผึ้งเป็นกฎเซลล์ 110 ความเท่าเทียมกันของผลลัพธ์ของaสามารถถูกมองว่าเป็นค่าของเซลล์กลางในรุ่นต่อไป ดังนั้นในบางแง่ฟังก์ชั่นง่าย ๆ นี้เป็นล่ามกฎ 110 '(28 ไบต์):

a=(p,q,r)=>(q+r+q*r+p*q*r)%2

จากนั้นเราสามารถสร้างฟังก์ชั่นใหม่bที่ประเมินaในทุกตัวอักษรของสตริงของคนและศูนย์ นี่bคือวิธีที่ดีกว่าaล่าม Rule 110 การ mod 2 หลังจากการประเมินผลของวงเล็บบันทึก (99 ไบต์):

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}

ในการคำนวณฟังก์ชั่นจริง ๆ ด้วย Rule 110 ผู้ใช้จะต้องระบุสถานะเริ่มต้นและจำนวนรุ่นหลังจากนั้นเอาต์พุตจะ 'ปรากฏ' เราสามารถสร้างฟังก์ชั่นที่สามcที่รับสตริงของค่าหนึ่งและศูนย์และจำนวนเต็มบวกnจากนั้นประเมินค่าbบนสตริงคูณnด้วย เช่นนี้เราสามารถเห็นได้ว่า Rule 110 เป็นภาษาการเขียนโปรแกรมโดยที่โปรแกรมเป็นสถานะเริ่มต้นและตัวเลขnและผลลัพธ์เป็นสถานะหลังจากnรุ่น cตอนนี้ฟังก์ชั่นเป็นล่ามจริงสำหรับภาษาการเขียนโปรแกรมนั้นดังนั้นรหัสสุดท้ายสำหรับความท้าทายนี้คือสิ่งที่ฉันนำเสนอข้างต้น

JS -> Newline 854 ไบต์

(function(d){var b=0;var n=!0;var c=[];var h=[];var e=0;var l=[];var m=0;var f=2;var a=0;var g=!1;var k=function(a){if(a===1)return!1;if(a%2===0&&a!==2)return!1;if(a%3===0&&a!==3)return!1;if(a%5===0&&a!==5)return!1;if(a%7===0&&a!==7)return!1;for(var b=7;b<d.round(d.sqrt(a))+1;b++)if(a%b===0)return!1;return f=a,!0;};var j=0;var i=0;var o=function(q){var o=d.__split(q,'\n');d.println(o);for(var n=0;n<o.length;n++)if(n>=f^2&&n<=f+1^2&&k(n)){f=n;for(var p=0;p<o[n].length;p++){if(o[n]==='+'&&(a+=c[b],b++),o[n]==='-')if(g===!0&&a<=0)break;else a-=c[b],b++;if(o[n]==='*'&&(a*=c[b],b++),o[n]==='/'&&(a/=c[b],b++),o[n]==='s'&&(a=d.sqrt(a)),o[n]==='%'&&(a%=c[b],b++),o[n]==='a'&&l.push(a),o[n]==='g'&&(a=c[b],b++),o[n]==='q'&&c.push(a),o[n]==='i'&&a++,o[n]==='d')if(g===!0&&a<=0)break;else a--;o[n]==='r'&&(g=!0),o[n]==='w'&&(g=!1),o[n]==='['&&(j=n),o[n]===']'&&a>0&&(n=j,h[e]--),o[n]==='{'&&(i=n),o[n]==='}'&&h[e]>0&&(n=i,h[e]--),m=a,o[n]==='k'&&e++;}}};});

Super golfed ต้องขอบคุณ google

Clojure 87 ไบต์ (กฎ 110)

เครดิตสำหรับรหัสพาริตีจะไปที่ Jens Renders! ฉันกำลังดิ้นรนจริงๆเกี่ยวกับวิธีการแสดงนี้และฉันจะไปกับการแปลง[p q r]จากเลขฐานสองเป็นจำนวนเต็มและใช้ตารางการค้นหา

#(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%)

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

ตัวอย่าง:

(def f #(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%))

(pprint (take 5 (f '(0 0 0 0 0 1 1 1 0 0 1 0 0))))
((0 0 0 0 0 1 1 1 0 0 1 0 0)
 (0 0 0 0 1 1 0 1 0 1 1 0 0)
 (0 0 0 1 1 1 1 1 1 1 1 0 0)
 (0 0 1 1 0 0 0 0 0 0 1 0 0)
 (0 1 1 1 0 0 0 0 0 1 1 0 0))

APL (Dyalog) → ตัวแปรFractran , 15 ไบต์

(⊃0~⍨××0=1|×)⍣≡

ลองออนไลน์!

ฟังก์ชั่นใช้ในการปันส่วนเป็นรายการของตัวเลขมากกว่าสองรายการที่มีตัวเศษและส่วนและผลลัพธ์ผลลัพธ์หากโปรแกรมสิ้นสุด สิ่งนี้ใช้ตัวแปรของ Fractran ที่มีเหตุผล 1/1 (= 1) ในตอนท้ายของโปรแกรม 1 ไม่มีผลต่อทัวริงสมบูรณ์ (เท่าที่ฉันเข้าใจ) เพราะอินพุตไปยังโปรแกรมจะลดลงในวันที่ 1 เมื่อไม่มีการปันส่วนอื่นทำงานและเมื่อมีการป้อนข้อมูลจะไม่เปลี่ยนแปลง นี่ใช้เพื่อให้ฟังก์ชันรู้ได้ว่าเมื่อใดจะสิ้นสุด

ลิงก์ TIO จะเรียกใช้ฟังก์ชันสำหรับการวนซ้ำ 2 ครั้ง (เพื่อให้คุณเห็นผลลัพธ์เป็นโปรแกรมที่ไม่สิ้นสุด) ในอินพุตแรกและรันอินพุตที่สองจนกว่าจะเสร็จสิ้นหลังจากนั้นจะส่งคืนเอาต์พุต

(⊃0~⍨××0=1|×)⍣≡ รับรายการปันส่วนเป็นอาร์กิวเมนต์ด้านซ้ายเรียกว่า⊣และอินพุตเป็นอาร์กิวเมนต์ที่ถูกต้องจะเรียกว่า⊢

(⊃0~⍨××0=1|×) ฟังก์ชั่นรถไฟ

• 1|×รับส่วนหลังจุดทศนิยม (โมดูโล 1) ของผลิตภัณฑ์×ของ⊣และ⊢

• 0= มันเท่ากับ 0 หรือไม่

• ×× ทวีคูณผลลัพธ์ด้วย⊣× wherever ไม่ว่าจำนวนตรรกยะ×ไม่ใช่จำนวนเต็มมันจะถูกแทนที่ด้วย 0

• 0~⍨ ลบ 0 ทั้งหมด

• ⊃ รับองค์ประกอบแรก

⍣วนซ้ำจนกว่า≡อินพุตไม่เปลี่ยนแปลงโปรดทราบว่าผลลัพธ์ของการ(⊃0~⍨××0=1|×)ใช้ซ้ำเป็นอินพุตดังนั้นหากหยุดการเปลี่ยนแปลง (เนื่องจากผลลัพธ์ 1 เมื่อสิ้นสุด) โปรแกรมจะหยุด

JavaScript: แลมบ์ดาแคลคูลัส ( 123 114)

แสดงโดยใช้ Debruijn Indicies ใน Duples

V=function b(c,d){if(!isNaN(c)){for(;--c;)d=d[1];return d[0]}return 0==c[0]?e=>b(c[1],[e,d]):b(c[0],d)(b(c[1],d))}

ตัวรวม S คือ [0, [0, [0, [[3, 1], [2, 1]]]]]

เคคือ [0, [0, 2]]

ฉันเป็น [0, 1]

แก้ไข: โกน 9 ไบต์โดยแทนที่"number"==typeof cด้วย!isNaN(c)

APL (Dyalog Unicode) , 15 ไบต์^SBCS

โปรแกรมเต็มรูปแบบที่ใช้ตัวจัดการออโตมาตาเซลลูลาร์แบบมิติเดียวทั่วไป ซึ่งรวมถึงกฎข้อ 110ที่ทัวริงสมบูรณ์ พร้อมต์ stdin สำหรับสถานะเริ่มต้นจำนวนการวนซ้ำ (หรือ≡เพื่อดำเนินการต่อไปจนถึงเสถียรหรือ{⍵≡⎕←⍺}เพื่อแสดงค่ากลางทั้งหมดจนกระทั่งเสถียร) และการตั้งค่ากฎ

⎕∊⍨∘(⊢∘⊂⌺3)⍣⎕⊢⎕

ลองออนไลน์! (4 ซ้ำของกฎข้อ 110)

⎕ พรอมต์สำหรับสถานะเริ่มต้นและ

⊢ ให้ผลผลิตนั้น (แยกสถานะออกจากจำนวนการวนซ้ำ)

⍣⎕ แจ้งจำนวนการวนซ้ำและใช้ฟังก์ชันต่อไปนี้หลาย ๆ ครั้ง:

 (... ) ใช้ฟังก์ชัน tacit ต่อไปนี้:

  ⌺3 รับย่านที่มีความยาว -3 ทั้งหมด (พร้อมข้อมูลว่าอยู่ที่ขอบ) หรือไม่และใช้ฟังก์ชัน tacit ต่อไปนี้กับแต่ละคู่:

   ⊂ ล้อมรอบพื้นที่ใกล้เคียง

   ∘ และ

   ⊢ ให้ผลว่า (ทิ้งข้อมูลเกี่ยวกับการอยู่ที่ขอบ)

 ∘ แล้วก็

 ∊⍨ ตรวจสอบว่าพวกเขาเป็นสมาชิกของ

 ⎕ พรอมต์สำหรับรายการของย่านที่นำไปสู่การอยู่ในการทำซ้ำต่อไป