Tantangan yang saya pikir akan sangat keren adalah membuat penerjemah untuk bahasa Turing-lengkap yang Anda pilih.

Aturannya sederhana:

1. Anda dapat menggunakan bahasa apa pun untuk membuat juru bahasa ini meskipun itu lebih baru dari tantangan ini.
2. Anda dapat menggunakan bahasa lengkap Turing selama tidak sama dengan yang Anda tulis.
3. Anda tidak dapat hanya mengevaluasi kode misalnya menggunakan fungsi eval.
4. Penjelasan tentang bagaimana Anda mendekati ini akan menyenangkan tetapi tidak diperlukan.
5. Ini akan dinilai dalam byte.
6. Setiap pengiriman harus sepenuhnya berfungsi yang berarti bahwa setiap fitur yang bahasa pilihan Anda harus ada.

Sederhananya:

Tugas Anda adalah membuat penerjemah yang berfungsi untuk semua bahasa Turing-lengkap dengan bahasa apa pun yang Anda pilih.

Semoga berhasil!

Brachylog (2) → Posting masalah korespondensi , 9 byte

~h=∋ᵐ\cᵐ=

Cobalah online!

Input adalah daftar daftar string. (Dalam masalah korespondensi Post seperti yang didefinisikan di Wikipedia, daftar bagian dalam masing-masing memiliki dua elemen, walaupun program ini sebenarnya dapat menangani generalisasi untuk sejumlah elemen.) solusi ditemukan. Masalah Post korespondensi diketahui mampu mensimulasikan mesin Turing, dan dengan demikian solusi brute-forcing untuk itu adalah Turing lengkap. Jika dijalankan sebagai fungsi, bukan program, itu sebenarnya menghasilkan output yang bermakna juga.

Program di tautan TIO di atas adalah [["a","baa"],["ab","aa"],["bba","bb"]], yang saya salin dari Wikipedia. Solusinya (yang ditemukan oleh program cukup cepat) adalah ["bbaabbbaa","bbaabbbaa"].

Penjelasan

Ini cukup banyak hanya terjemahan langsung dari masalah korespondensi Post ke 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.

Pada dasarnya, kami membuat daftar yang mengulangi salinan input (sesedikit mungkin, yang berarti bahwa kami tidak melewatkan kemungkinan apa pun saat memaksa), ambil satu elemen dari setiap salinan, lalu gabungkan elemen terkait (seperti dalam korespondensi Post) masalah).

Jelly → "Tambahkan minimum untuk transpos", 5 4 byte

+"Ṃẞ

Cobalah online! (hanya menjalankan satu iterasi, untuk menghindari timeout)

Konstruksi Turing-complete yang sangat sederhana: kita mengambil matriks persegi sebagai sebuah program, dan mengulang selamanya, mengidentifikasi baris terkecil secara leksikografis, kemudian meningkatkan setiap elemen dari baris pertama dengan elemen pertama dari terkecil secara leksikografis, setiap elemen dari baris kedua oleh elemen kedua terkecil secara leksikografis, dan sebagainya. (Program Jelly adalah " +"menambahkan elemen yang sesuai {dari input dan} Ṃminimum {dari aslinya}, ẞloop"; ini adalah byte yang lebih pendek dari program saya sebelumnya Z+ṂZß, yang melakukan hal yang persis sama. Jelas saya seharusnya fokus pada golf Jelly, bukan hanya bermain-main dengan bahasa yang diterapkan.)

Bahasa yang dihasilkan adalah Turing-lengkap untuk alasan yang sama seperti Kanguru. Elemen pertama dari setiap baris bertindak seperti jumlah lompatan (meskipun alih-alih jumlah lompatan dari setiap perintah berkurang ketika dilewati, kami malah meningkatkan jumlah lewati setiap perintah saat dijalankan, dan mencari perintah dengan jumlah lompatan terendah sebagai gantinya daripada perintah dengan nol lewati hitungan; ini datang ke hal yang sama). Kami memastikan bahwa elemen pertama ini lebih tinggi dari elemen lain (yang mewakili berapa kali setiap perintah muncul di multiset masing-masing perintah), sehingga memastikan bahwa baris pertama tidak pernah minimum; sisa baris pertama bisa menjadi sampah. Satu-satunya masalah yang tersisa adalah memodelkan cara yang memerintahkan dengan jumlah lompatan yang sama dijalankan secara berurutan, tetapi kita dapat melakukannya dengan mengalikan semua jumlah lompatan dengan konstanta besar, kemudian menambahkan "awal" kecil. lewati hitungan ke kolom pertama untuk berfungsi sebagai tiebreak. Ini memberi kita tiebreak dari "perintah pertama yang tidak berjalan berjalan", bukan "perintah yang tidak berjalan berjalan secara siklis secara berurutan", tetapi konstruksi kelengkapan Turing untuk Kanguru tidak peduli dengan perbedaan ini.

Mathematica menafsirkan Permainan Kehidupan Conway, 64 byte

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

Permainan Kehidupan Conway dikenal sebagai Turing lengkap; dan automata seluler adalah obsesi Stephen Wolfram yang paling sejati. CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}adalah aturan yang mengubah susunan dua dimensi dari 0s dan 1s menurut satu langkah dari Conway's Game of Life. (Saya pikir perilaku default adalah bahwa array ini membungkus ujung-ujungnya, jadi benar-benar torus diskrit.) ~Nest~##&Mengubah aturan ini menjadi fungsi yang, ketika diberi status papan awal (dari dimensi apa pun) dan bilangan bulat nsebagai argumen, menghasilkan hasil niterasi dari aturan Game of Life.

Untuk kesenangan Anda sendiri, Anda bisa menggunakan versi yang dibungkus

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}]

dan gulir jalan Anda melalui 100 generasi pada papan 50x50.

Turtlèd menafsirkan CT , 49 byte

Saya mungkin bisa bermain golf ini

Juga, ini tidak menghasilkan sesuatu yang berguna. itu hanya berhenti jika dan hanya jika program CT yang diberikan berhenti.

ini yang saya buat beberapa waktu lalu sebenarnya (kemudian golf beberapa sekarang)

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

Bagaimana itu bekerja:

Turtlèd menggunakan sel-sel kotak. Ketika saya mengatakan "tulis sesuatu di grid" Maksud saya sekelompok karakter yang berdekatan ditempatkan di grid. contoh

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

ke dalam program

data dimasukkan terlebih dahulu:

!-l[*+.r_]' 

ini pada dasarnya adalah program kucing. itu menulis input ke grid.

kemudian perintah dimasukkan:

!

apa fungsinya dengan perintah-perintah ini:

perintah ini adalah "produksi". jika bit data paling kiri adalah 1, itu menyalin produksi ke akhir string data. jika tidak, tidak ada yang terjadi. kemudian bit data paling kiri dihapus, dan menggunakan produksi berikutnya dengan bit data paling kiri berikutnya. program berhenti ketika tidak ada bit dalam data string. Cara untuk melakukan produksi ini adalah dengan menangani bit dan akhir produksi secara terpisah. inilah yang dilakukan oleh program kami. secara terpisah menyalin bit dari string perintah ke akhir string data, dan secara terpisah menghapus bit dari datastring

ke bagaimana program ini melakukannya. setelah memasukkan perintah, penyu / penunjuk grid bergerak kembali ke bit paling kiri dari datastring. kemudian masuk ke dalam satu lingkaran

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

apa yang dilakukannya di loop ini, apakah bergerak naik dari datastring paling kiri, dan menuliskan karakter perintah saat ini (u.). jika;; akhir produksi, bergerak ke bawah dan menghapus bit data paling kiri di bawahnya dan bergerak kembali ke atas ( (;d' u)). lalu, bagaimanapun, ia bergerak ke bawah satu ( d). jika bit di sana tidak dihapus, itu berarti ia harus memeriksa apakah akan menyalin sedikit dari perintah di akhir. jadi, jika karakter ini adalah databit paling kiri atau adalah 1, itu akan pindah ke ujung kanan dari string data, menyalin bit dari string perintah, dan pindah kembali ke ruang kiri dari data paling kiri bit ( (1[ r].[ l])). sekarang, itu adalah pada databit paling kiri, yang merupakan nol, atau kiri dari databit paling kiri. jadi, kita bergerak ke kanan jika di suatu tempat (( r)). kemudian, penunjuk perintah bertambah sehingga kita akan menuliskan perintah berikutnya dalam iterasi loop berikutnya. Jika tidak ada lagi datastring, ini berarti kita akan berada di spasi dan loop akan berakhir. kalau tidak kita jalankan kembali loop.

Perl → varian Programmer Tiga Bintang , 26 + 1 = 27 byte

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

Cobalah online! (Tautan ini berisi tajuk yang keluar dari program setelah sejumlah iterasi (sehingga TIO tidak kehabisan waktu), dan untuk mencetak keadaan internal setiap iterasi (sehingga ia melakukan sesuatu yang dapat diamati).)

Jalankan dengan -a(penalti 1 byte, karena Anda dapat memasangnya sebelum -M5.010untuk menghasilkan -aM5.010).

Secara khusus, ini mengimplementasikan Three Star Programmer di mana perintah dipisahkan oleh spasi dan tidak ada komentar yang diizinkan dalam file, tanpa ekstensi I / O. (Perubahan-perubahan ini tidak ada bedanya dengan kelengkapan Turing bahasa, jelas.) Tidak ada bukti kelengkapan Turing untuk Programmer Bintang Tiga daring, tetapi Turing-lengkap (saya telah membagikan bukti sketsa Turing-nya) -completeness dengan esoprogrammer lain, tetapi berhenti bekerja pada bahasa ketika saya menemukan bahwa itu sebenarnya cukup mudah untuk diprogram begitu Anda sudah mendapatkan kejutan asli).

Program ini tidak terlalu membutuhkan penjelasan; Programmer Tiga Bintang memiliki spesifikasi yang sangat sederhana, dan ini adalah terjemahan langsungnya. Satu-satunya titik halus: @Fadalah input ke program dalam bentuk array (ini merupakan konsekuensi dari -a); dan redoakan mengulangi seluruh program karena berada dalam loop implisit (juga konsekuensi dari -a).

perakitan x86 (Intel sintaks / MASM) -Brainfuck 2127 byte.

Masih bisa bermain golf

.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 menginterpretasikan sistem tag siklik , 16 byte

YqWyyPBg@++vXPOy

Mengambil produksi sistem tag sebagai argumen baris perintah dan string data awal dari stdin.

Kode di atas agak sulit untuk diverifikasi karena tidak menghasilkan output apa pun (sehingga perilaku yang hanya dapat diamati adalah "mengakhiri" vs. "tidak mengakhiri"). Oleh karena itu, inilah versi yang tidak diklik yang mengeluarkan string data setelah setiap langkah, dan juga berakhir setelah 20 langkah sehingga TIO tidak harus berurusan dengan banyak output dari loop tak terbatas: Coba online!

Sistem tag siklik

Sistem tag Cyclic adalah model komputasi Turing-complete yang sangat sederhana namun lengkap . Mereka terdiri dari daftar produksi yang menentukan operasi pada string data . Produksi dan string data terdiri dari 1 dan 0.

Pada setiap langkah, karakter paling kiri dari string data dihapus.

• Jika karakternya 1, produksi saat ini ditambahkan ke sisi kanan string data.
• Jika karakternya 0, tidak ada yang ditambahkan.

Dalam kedua kasus, produksi saat ini bergerak ke produksi berikutnya dalam daftar, secara siklis: jika kita berada di produksi terakhir, kita berputar ke yang pertama. Eksekusi berlanjut hingga string data kosong.

Penjelasan

                  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

Fungsi Iterated Generalized Collatz -> Python 2, 46 byte

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

Sebut fungsi ini dengan daftar m-1 a dan b, nilai awal x, dan pembagi m, yang secara kolektif merupakan "program" untuk IGCF. Alih-alih mengambil array ketiga untuk menunjukkan moduli mana yang akan berhenti, ini hanya berhenti setiap kali modulus m-1. Penyederhanaan ini berarti mungkin diperlukan usaha ekstra untuk mengubah program Fractran yang diberikan menjadi varian ini, tetapi ini menghemat beberapa byte dalam interpreter.

Cobalah online! TIO ini menunjukkan cara menambahkan 5 + 5 dengan bahasa ini. Program a = [3], b = [0], m = 2 melakukan penambahan, dan dimulai dengan 7776 = 2 ^ 5 * 3 ^ 5 akhirnya menghasilkan 59049 = 3 ^ 10.

Varian RESPlicate -> Python 2, 47 byte

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

Fungsi ini menafsirkan varian ResPlicate

• di mana program adalah daftar python dengan panjang genap dengan elemen genap pada indeks genap.
• tanpa I / O.
• untuk yang mencoba menyalin nilai lebih dari yang ada di sisa antrian cukup menyalin sisa antrian (yaitu, bit yang disalin tidak diisi dengan nol dengan panjang yang diperlukan).

Perubahan terakhir berarti bahwa beberapa program ResPlicate (yang memenuhi syarat pertama) tidak akan berperilaku sama dalam varian ini, tetapi untungnya, penerjemah BCT tidak memerlukan fungsionalitas yang dihapus, dan bahasa tetap TC.

Cobalah online! TIO ini memiliki cetakan yang terjepit di dalamnya untuk menunjukkan bahwa ia berfungsi dan tajuk yang membunuh program setelah 1 detik dan contoh yang mengelola untuk menghasilkan lebih banyak keluaran daripada yang dapat ditangani TIO dalam satu detik itu.

Perl -a → mesin I / D , 24 byte

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

Cobalah online! (berisi tajuk yang mencetak keadaan internal dan berhenti setelah 10 iterasi, sehingga perilaku dapat diamati)

Tentang bahasanya

Saya telah menghabiskan beberapa hari terakhir bekerja pada mesin I / D , salah satu ide terbaru saya untuk bahasa pemrograman yang sangat sederhana. Ini berfungsi sebagai berikut: penyimpanan data terdiri dari RAM yang tidak terikat, awalnya semua nol. Setiap elemen dapat menyimpan integer yang tidak terikat (meskipun dalam praktiknya, sebagian besar program mesin I / D hanya akan menyimpan integer kecil di sebagian besar dari mereka, dan memanfaatkan integer yang tidak terikat hanya sebagai cara menangani sel dengan alamat yang besar). Ada juga penunjuk data, yang menunjuk ke sel (mis. Menyimpan alamat sebagai sel); awalnya juga nol.

Hanya ada dua perintah:

• I: Menambahkan sel yang ditunjuk oleh pointer data. (Penunjuk data itu sendiri tetap tidak berubah.)
• D: Dereferensi pointer data, yaitu membaca nilai sel yang menunjuk pointer data. Kemudian simpan nilai yang dihasilkan yang Anda baca kembali ke penunjuk data.

Eksekusi hanya menjalankan program berulang kali, selamanya.

Cukup mengejutkan bahwa bahasa yang sederhana ini adalah Turing-complete, jadi saya telah berusaha membuktikannya. Inilah buktinya . Ini sangat mirip dengan (tetapi lebih sederhana dari) bukti untuk Program Tiga Bintang, bahasa yang sangat mirip (dan pada kenyataannya, pengajuan ini menggunakan "shell" OISC dasar yang sama di sekitar program, berbeda hanya dalam instruksi aktual yang diterapkan).

Tentang program ini

Pemakaian

Input harus diberikan pada input standar, dan merupakan program mesin I / D tanpa komentar, dan menggunakan sintaks RLE / OISC. (Mesin I / D memiliki dua sintaks yang sama dan ekuivalen, tetapi untuk golfiness program ini hanya mendukung salah satunya). Dalam sintaksis ini, suatu program adalah urutan angka dalam desimal, yang mewakili lamanya menjalankan Iperintah di antara Dperintah. (Anda dapat menentukan dua atau lebih Dperintah berturut-turut dengan menempatkan " Iperintah 0 dijalankan " di antaranya, sehingga sintaksnya sepenuhnya umum.)

Penjelasan

Seperti yang dapat dilihat dari program, ini tidak mengimplementasikan Idan Dmemerintahkan secara individual. Bahkan, itu adalah penerjemah yang mengoptimalkan (sangat sedikit) (murni karena lebih pendek untuk menulis dengan cara ini). Kuncinya adalah untuk melihat bahwa menjalankan n perintah kenaikan increment target pointer data n kali, yaitu menambahkan n untuk itu; dan menjalankan 0 perintah kenaikan juga dapat diimplementasikan dengan cara ini, karena menambahkan 0 ke memori tidak berpengaruh. Jadi operasi yang sebenarnya kita implementasikan adalah bergantian antara mengimplementasikan run-of- Idan a D. Atau dengan kata lain, "tambah nke nilai yang ditunjuk oleh penunjuk data (menyimpannya kembali dalam nilai yang ditunjuk oleh penunjuk data), kemudian membaca nilai yang ditunjuk oleh penunjuk data dan menyimpannya di penunjuk data ". Itu jelas lebih bertele-tele daripada yang dibutuhkan menjadi, dan kita lebih lanjut dapat menyederhanakan ini untuk "menambahkan n ke nilai yang ditunjuk oleh pointer data, kemudian menyimpan nilai itu baik dalam target pointer data dan pointer data itu sendiri".

Sehingga menjadikan inti dari program kami. Kami menggunakan array $auntuk menyimpan RAM, dan $psebagai penunjuk data (mengindeks ke dalam array):

$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

Dengan mudah, Perl mengartikan elemen array yang tidak diinisialisasi sebagai 0 ketika mereka diperlakukan seperti angka, sehingga array akan malas diinisialisasi ke nol untuk kita tanpa kode eksplisit untuk itu yang diperlukan. (Salah satu masalah potensial adalah akurasi numerik ketika angka menjadi besar; namun, itu hanya akan terjadi jika jumlah array yang digunakan melebihi ruang alamat mesin (bilangan bulat Perl cukup besar untuk menampung pointer), sesuatu yang tidak bisa terjadi pada mesin yang diidealkan.)

Akhirnya, yang perlu kita lakukan adalah menempatkan program ini ke dalam beberapa loop. The for@FLoop, dikombinasikan dengan -aopsi baris perintah, akan loop atas bidang input standar (definisi default "lapangan" di sini akan dibagi pada spasi). The redoLoop akan menempatkan seluruh program dalam loop implisit (selain, nyaman, pembacaan input standar), yang akan menyebabkan program untuk berjalan dalam lingkaran berulang-ulang, seperti yang dipersyaratkan oleh semantik mesin I / D.

Jelly → sistem 2-Tag , 8 byte

µḢị⁴⁸;Ḋß

Cobalah online!

Saya memiliki karunia yang disukai bahasa praktis, tetapi saya pikir saya mungkin juga mencoba untuk memenangkan tugas asli ketika saya berada di sana (karena saya tidak bisa memenangkan hadiah saya sendiri).

Menerapkan varian sistem tag tanpa status penghentian, karena tidak diperlukan untuk kelengkapan Turing. Negara-negara diberi nomor dari 1, berturut-turut, dan string awal datang sebelum program.

Sebagai contoh, Wikipedia memberi contoh sistem tag { a, b, c}, { a→ bc, b→ a, c→ aaa} dengan string awal aaa; dalam format masukan ini, itu [1,1,1], [[2,3],[1],[1,1,1]]. (Sistem tag tidak memiliki sintaks tetap, dan ini sepertinya cara yang masuk akal untuk melakukannya.)

TIO memiliki tautan yang ditambahkan Ṅ("tulis status internal dan baris baru ke stdout") untuk menunjukkan bahwa program tersebut ternyata berfungsi.

Penjelasan

µḢị⁴⁸;Ḋß
           {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 "diimplementasikan dalam Mesin Turing, 842 byte

Tabel transisi (ditautkan karena panjangnya)

Tabel transisi, versi kurang golf

Simulator Turing Machine yang saya gunakan

Ini jelas tidak akan memenangkan penghargaan lama, tapi itu adalah sesuatu yang selalu ingin saya lakukan, karena BF sangat mirip dengan Mesin Turing. Setiap sel menyimpan nilai dari 0x0- 0xF. Namun lebarnya sejauh ini situs web Turing Machine dapat berjalan tanpa merusak browser Anda. Fungsi ,dan .(input dan output) tidak didefinisikan, jadi sedikit lebih seperti P "daripada BF yang sebenarnya.

Untuk menjalankannya, tempel tabel transisi ke dalam simulator Turing Machine, atur input ke beberapa kode BF, dan tekan run.

Rekaman TM menyimpan kode BF dan data BF, dengan satu spasi di tengah. Itu melacak posisinya dalam kode dengan memodifikasi karakter yang sedang berjalan ( [-> (, dll) dan posisinya dalam data dengan ^di depan sel. Setelah membaca karakter perintah, itu bergerak sampai menyentuh tanda sisipan, memindahkan satu sel ke kanan, dan melakukan fungsi yang sesuai. Kemudian kembali, mencari salah satu karakter perintah "dimodifikasi" dalam kode BF, dan pindah ke yang berikutnya, mengulangi seluruh proses. Setelah kehabisan kode, itu terhenti.

Cara terbaik untuk memahami cara kerjanya adalah dengan menjalankan versi yang tidak diserang, menempatkannya pada mode langkah, dan menonton garis mana yang mengarah ke yang lain dan apa yang dilakukan setiap negara bagian / blok garis.

Versi golf dan ungolfed persis sama dalam hal cara kerjanya, tetapi versi ungolfed memiliki lebih banyak nama yang ramah manusia dan dipecah menjadi beberapa bagian.

C mengimplementasikan (2,3) Mesin Turing , 236 205 byte ( 46 31 lebih sedikit jika Anda tidak peduli dengan input yang canggung)

Terima kasih kepada Appleshell untuk -11 byte, VisualMelon untuk -12 byte, dan Johan du Toit untuk -7 byte.

CeilingCat membuat versi yang hanya menggunakan 144 byte, lihat di sini .

(Saya telah menambahkan beberapa jeda baris di sini sehingga Anda tidak perlu menggulir, tetapi biasanya sebagian besar akan dihapus)

#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("");}}

Cobalah online!

Untuk menggunakan: Masukkan string hingga 256 yang, nol, dan dua untuk menginisialisasi rekaman itu. Nilai yang tidak diinisialisasi akan menjadi nol. (Nilai selain 0, 1, dan 2 dapat menyebabkan perilaku tidak terdefinisi.) Program akan mengulangi lebih dari 256 langkah. Jumlah langkah yang diulanginya dapat ditingkatkan dengan memodifikasi kode, tetapi jelas itu membutuhkan lebih banyak karakter.

Ini entri yang cukup panjang, tetapi ini adalah pertama kalinya saya melakukan salah satu dari ini dan saya tidak menggunakan bahasa golf khusus. Saya bersenang-senang, meskipun ternyata lebih lama dari yang saya harapkan.

Banyak byte dari berurusan dengan input dan output, dan saya kehilangan seluruh 42 byte dengan membuatnya menerima 0, 1, dan 2 bukannya NUL, SOH, STX. (Untuk mengubahnya, hapus k;dari depan dan for(;k<256&&d[k];)d[k++]-=48;dari baris kedua.)

Tabel transistion, terutama garis *p=-t*t+(2-s)*t+1+s;(yang menetapkan nilai-nilai pada rekaman itu) mungkin dapat dikompresi juga.

Röda menerapkan Fractran , 114 112 106 bytes

1 byte disimpan berkat @fergusq dengan mengatur ulang parameter

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]}

Cobalah online!

Memanggil fungsi seperti: f reference_to_input program. Output akan disimpan di lokasi input.

Clojure, 82 81 byte (Mesin Turing)

Pembaruan: menghapus spasi dari 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))

Menerapkan Mesin Turing sebagai loop, mengembalikan kaset saat keadaan terhenti tercapai. Dalam aturan transisi negara ini ditunjukkan dengan mengabaikan keadaan transisi. Ini settins Nuntuk nildan selanjutnya if-letakan batalkan sebagai transisi negara terkait tidak ditemukan dari input hash-peta %. Sebenarnya nilai apa pun untuk keadaan ini akan dilakukan, seperti :abort, 0 atau -1.

Tidak disatukan dengan contoh berang-berang sibuk 2-simbol 3-negara dari Wikipedia .

(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}

Cobalah online .

Pada inti tunggal 6700K, ini menjalankan berang-berang sibuk 2-simbol 5-negara (47,1 juta langkah) dalam waktu sekitar 29 detik, atau 1,6 juta langkah / detik.

M → Kiat , 4 byte

Ṅ×ịß

Cobalah online!

TIO link menambahkan footer untuk memanggil fungsi dengan contoh program Tip yang ditampilkan pada halaman Esolang ("pembungkus otomatis" M untuk memanggil fungsi seolah-olah mereka program tidak dapat menangani angka-angka rasional atau titik tetap, atau setidaknya saya berlindung tidak tahu bagaimana cara mengatakannya, jadi saya perlu membuat fungsi menjadi program lengkap dengan tangan untuk dapat menjalankannya.)

Ini sebenarnya mencetak hasil debug berguna; program tidak dapat ditulis dalam 3 byte dalam M karena program yang terdiri dari tepat tiga diad memicu kasus khusus di parser, jadi saya harus menambahkan perintah tambahan untuk menghindari kasus khusus. Membuatnya Ṅ(mencetak dengan baris baru) setidaknya memberinya tujuan yang bermanfaat.

ı$i=\sqrt{-1}$

Tidak menerapkan I / O (selain berhenti / tidak berhenti). I / O adalah ekstensi untuk Tip (bukan bagian dari bahasa itu sendiri), dan tidak diperlukan untuk kelengkapan Turing.

Penjelasan / latar belakang

Ṅ×ịß
Ṅ     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$, yang merupakan polinomial, dan "konversi basis" yang dibangun oleh banyak bahasa golf sebenarnya adalah penilai polinom tujuan umum yang menyamar. Jadi yang harus kita lakukan adalah mengindeks ke daftar daftar digit, basis-konversi mereka, dan kita selesai, kan?

$x$$x$

ḅ$x\oplus(x\otimes y)$$x\otimes y$${\oplus}$. Tentu, kita bisa mengganti perilaku rantai ke hampir semua yang kita inginkan, tapi itu akan menghabiskan seluruh byte, dan entri bahasa golf untuk pertanyaan ini menjadi sangat singkat sehingga satu byte sangat banyak.

Jadi saya melihat ke belakang dan mengevaluasi kembali sedikit. Apakah ada operasi yang dapat kita gunakan daripada evaluasi polinomial? Idealnya, yang komutatif, jadi kita tidak perlu khawatir tentang urutan argumen? Segera setelah itu, saya menyadari bahwa fungsi Collatz lebih kompleks daripada yang seharusnya.

$s$

Dan tentu saja, tidak seperti konversi basis ( ḅ), multiplikasi ( ×) bersifat komutatif, dan dengan demikian tidak masalah urutan urutan argumen. Jadi yang perlu kita tulis adalah ×ị, dan kemudian menempatkan program ke dalam rekursi tak terbatas dengan ß, dan kami memiliki bahasa lengkap Turing. Kanan?

$(x\odot y)\oplus(x\otimes y)$¹×ịß¹¹Ṅ adalah pilihan yang baik karena menghasilkan keluaran debug yang bermanfaat.

Apakah tiga byte mungkin? Kecuali saya kehilangan sesuatu, tidak dengan pilihan implementasi dan implementasi bahasa yang spesifik ini, tetapi pada titik ini sepertinya sepertinya mungkin, karena ada begitu banyak cara untuk melakukannya dalam empat dan begitu banyak Turing-complete bahasa yang bisa Anda terapkan.

C menafsirkan Brainfuck, 187 byte

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;}}

Cobalah online

Lua menafsirkan Brainf ***, 467 bytes

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

Saya tahu masih ada beberapa pelangsingan yang bisa saya lakukan nanti, tetapi disinilah pass pertama saya berakhir. Mengambil kode brainf dari input standar.

CJam → ResPlicate Variant, 15 14 13 byte

^{-1 byte terima kasih kepada @ ais523}

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

Variannya sama dengan yang ada di jawaban ini , kecuali bahwa jumlah item yang diambil dari antrian adalah satu kurang dari jumlah teratas pada antrian.

Bagian l~{ ... }hhanya mengambil array sebagai input dan mengulangi sampai array kosong.

Penjelasan untuk loop utama:

    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]

Chip , 20 + 3 = 23 byte (Aturan 110)

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

+3 untuk bendera -z

Cobalah online!

Pengajuan ini tidak sempurna, karena Chip belum (belum) memiliki kemampuan pengulangan, jadi output harus dilewatkan sebagai input untuk mensimulasikan beberapa generasi, dengan sesuatu seperti ini (tentu saja, Anda dapat menjalankan loop itu tanpa batas, dan Chip dapat menangani input panjang yang sewenang-wenang, jadi kombinasi ini Turing Lengkap).

Implementasi ini mengambil input dan memberikan output dalam bentuk ASCII 0dan 1s. Logikanya di sini adalah sebagai berikut:

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)             `)\'

Sisa elemen adalah untuk housekeeping: e*fmenyebabkan output angka ASCII, dan E~Ztmengakhiri eksekusi dua byte setelah input habis (karena lebar tumbuh 2 setiap generasi).

Clojure, 75 byte (Sistem tag Cyclic)

Pembaruan 1: diganti some?dengan nil?.

Pembaruan 2: Memperbaiki yang hilang Sdi cabang lain di if s.

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

Menerapkan sistem tag siklik , kembali niljika program berhenti, berulang-ulang jika tidak. Clojure benar-benar bersinar di sini dengan urutan malas yang tak terbatas (seperti siklus ) dan perusakan . Yang dan nol ditunjukkan sebagai nilai benar dan salah. Ketika string data habis smenjadi nil.

Tidak Disatukan:

(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))))))

Contoh hasil:

(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 menafsirkan Aturan 110 , 131 byte (99 byte ?, 28 byte?)

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)

Seperti yang Anda lihat, kode ini mendefinisikan 3 fungsi a,, bdan c. Mungkin dimungkinkan untuk menyimpan byte dengan menggabungkannya dalam 1 fungsi (saya tidak melihat caranya), tapi ada baiknya terpisah karena masing-masing sudah memenuhi tantangan ini dalam beberapa hal.

Fungsi amengambil 3 angka sebagai input dan menghitung beberapa polinomial aneh dari mereka. Ketika 3 angka ini 0atau 1mereka dapat dilihat sebagai Aturan 110 sel. Paritas output akemudian dapat dilihat sebagai nilai sel tengah pada generasi berikutnya. Jadi dalam arti tertentu, fungsi sederhana ini sudah menjadi 'penerjemah' Aturan 110 (28 byte):

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

Kami kemudian dapat membuat fungsi baru byang mengevaluasi asetiap karakter dari string satu dan nol. Ini bkemudian, dengan cara yang lebih baik daripada a, seorang penerjemah Aturan 110. Mengambil mod 2 setelah evaluasi kurung hemat (99 byte):

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}

Untuk benar-benar menghitung fungsi dengan Aturan 110, pengguna harus menentukan keadaan awal dan jumlah generasi setelah mana output akan 'muncul'. Kita dapat membuat fungsi ketiga cyang mengambil string satu dan nol, dan bilangan bulat positif n, yang kemudian dievaluasi bpada string, nkali. Seperti ini kita benar-benar dapat melihat Aturan 110 sebagai bahasa pemrograman, di mana program adalah keadaan awal dan angka n, dan hasilnya adalah keadaan setelah nbeberapa generasi. Fungsi csekarang menjadi penerjemah aktual untuk bahasa pemrograman sehingga kode akhir untuk tantangan ini adalah apa yang saya sajikan di atas.

JS -> Newline 854 byte

(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 golf berkat Google.

Clojure, 87 byte (Aturan 110)

Kredit untuk kode paritas jatuh ke Jens Render! Saya benar-benar berjuang tentang cara mengekspresikan ini dan saya akan pergi dengan mengubah [p q r]dari biner ke integer dan menggunakan tabel pencarian.

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

partitionDestrukturisasi di sini dan Clojure membuat aplikasi logika cukup sederhana. Fungsi ini mengembalikan urutan keadaan yang tak terbatas, sehingga pemanggil bertanggung jawab atas takesebanyak yang mereka butuhkan atau hanya nthuntuk melompat ke keadaan tertentu. Jika bantalan dengan nol adalah dua elemen dan bukan hanya satu maka pita akan terus tumbuh, menghindari masalah batas. Sekarang tetap lebar aslinya.

Contoh:

(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) → Varian fraktran , 15 byte

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

Cobalah online!

Fungsi mengambil dalam rasional sebagai daftar angka daripada dua daftar yang berisi pembilang dan penyebut, dan output hasilnya jika program berakhir. Ini mengimplementasikan varian Fractran yang memiliki 1/1 rasional (= 1) di akhir program. Angka 1 tidak memiliki efek pada kelengkapan Turing (sejauh yang saya mengerti) karena input ke program hanya mendarat pada 1 ketika tidak ada rasional lainnya bekerja, dan ketika itu terjadi, input tidak berubah. Ini hanya digunakan agar fungsi tahu kapan harus mengakhiri.

TIO link menjalankan fungsi untuk 2 iterasi (sehingga Anda dapat melihat output karena program tidak berakhir) pada input pertama, dan menjalankan input kedua hingga selesai, setelah itu mengembalikan output.

(⊃0~⍨××0=1|×)⍣≡ mengambil daftar rasional sebagai argumen kiri, untuk disebut sebagai ⊣, dan input sebagai argumen yang tepat, disebut sebagai to

(⊃0~⍨××0=1|×) kereta fungsi

• 1|×dapatkan bagian setelah titik desimal (modulo 1) dari produk ×⊣ dan ⊢

• 0= apakah ini sama dengan 0?

• ×× kalikan hasil ini dengan ⊣ × ⊢, di mana pun × rasional ⊢ bukan bilangan bulat, itu diganti dengan 0

• 0~⍨ hapus semua 0s

• ⊃ dapatkan elemen pertama

⍣loop sampai ≡input tidak berubah, perhatikan bahwa hasil (⊃0~⍨××0=1|×)digunakan kembali sebagai input, jadi jika itu berhenti berubah (sebagai hasil dari 1 di akhir) program berhenti

JavaScript: Kalkulus Lambda ( 123 114)

Diwakili menggunakan Kebijakan Debruijn di 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))}

Combinator S adalah [0, [0, [0, [[3, 1], [2, 1]]]]]

K adalah [0, [0, 2]]

Saya adalah [0, 1]

Edit: Dicukur 9 byte dengan menggantinya "number"==typeof cdengan!isNaN(c)

APL (Dyalog Unicode) , 15 byte ^SBCS

Program lengkap yang mengimplementasikan pelaksana otomat seluler satu dimensi yang digeneralisasi. Ini termasuk Aturan 110 yang Turing lengkap. Anjurkan stdin untuk keadaan awal, jumlah iterasi (atau ≡untuk melanjutkan hingga stabil atau {⍵≡⎕←⍺}untuk menampilkan semua nilai perantara hingga stabil), dan atur aturan.

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

Cobalah online! (4 iterasi Aturan 110)

⎕ meminta status awal dan

⊢ menghasilkan itu (memisahkan negara dari jumlah iterasi)

⍣⎕ meminta jumlah iterasi dan menerapkan fungsi berikut yang berkali-kali:

 (... ) terapkan fungsi diam-diam berikut:

  ⌺3 dapatkan semua lingkungan panjang-3 (dengan info apakah mereka ada di tepi) dan terapkan fungsi diam-diam berikut untuk setiap pasangan:

   ⊂ lampirkan lingkungan

   ∘ dan

   ⊢ menghasilkan itu (membuang info tentang berada di tepi)

 ∘ kemudian

 ∊⍨ periksa apakah mereka anggota

 ⎕ meminta daftar lingkungan yang mengarah pada iterasi berikutnya