Pyke, 5 karakter
0h.CE
Ini mampu menghasilkan angka yang sangat besar, mengubahnya menjadi string dan kemudian mengevaluasinya sebagai kode Pyke.
Penjelasan kode:
0- Tambahkan 0 ke tumpukan. Ini diperlukan untuk memulai nomor
h- Menambah nomor sebelumnya. Dengan mengulangi jumlah ini sembarang kali, Anda dapat membuat angka yang jauh lebih besar. Pyke mendukung bignum seperti yang tertulis dalam Python, yang menggunakannya sebagai default.
.C- Ubah angka menjadi string menggunakan algoritma berikut: ( Tautan Github )
def to_string(num):
string = ""
while num > 256:
num, new = divmod(num, 256)
string = chr(new) + string
string = chr(num) + string
return string
Pada titik ini, kita dapat membuat jumlah string dan bilangan alami sewenang-wenang di Pyke dengan nilai arbitrer. Angka dapat dibuat dalam bentuk yang sesuai dengan regex 0(h)*dan string dapat dibuat dengan 0(h)*.C. Mereka dapat terjalin satu sama lain untuk menciptakan campuran string dan integer yang berubah-ubah.
E- Mengevaluasi string sebagai kode Pyke. Ini menggunakan lingkungan yang sama dengan kode Pyke yang sudah berjalan sehingga akan berbagi hal-hal seperti input.
Mencoba bukti bahwa Pyke Turing Lengkap.
Salah satu cara paling sederhana untuk menunjukkan bahasa adalah menyelesaikan turing adalah dengan mengimplementasikan Brainf * ck di dalamnya. Ini mungkin jauh lebih sulit di Pyke daripada banyak bahasa lain karena itu daftar dan operasi kamus cukup banyak tidak ada karena kurangnya membutuhkan mereka di area Pyke dirancang untuk dijalankan: kode-golf .
Pertama-tama kita membuat interpreter untuk brainf * ck dan menyandikannya menggunakan algoritma kami di atas untuk membuat angka dan kemudian menyatakan angka itu dengan 0dan h. Kami kemudian membuat string yang berisi kode untuk dijalankan dengan cara yang persis sama. Jika kita berhenti di situ, kita akan memiliki tumpukan sebagai
string containing brainf*ck code
string containing brainf*ck interpreter
Ini berarti kode harus dalam bentuk yang berlawanan karena tumpukan Pyke adalah yang pertama keluar terakhir.
Sekarang untuk bagian yang menyenangkan: penerjemah brainf * ck dengan 216 byte kekalahan!
Q~B"><ht.,".:=B;Z]1=L;W~Bo@D=c"ht"{I~c~LZ@EZ]1~LR3:=L)~c\,qIz.oZ]1~LR3:=L)~c\.qI~LZ@.CpK)~c"<>"{I~c"<>""th".:ZE=ZZ1_qI0=Z~L0"":0]10:=L)Z~LlqI~L~Ll"":1_]10:=L))~c\[qI~LZ@0qI\]~B~o>@~o+h=o))~c\]qI~o\[~B~o<_@-t=o)~o~BlN
Coba di sini!
Jika Anda ingin mencoba kode dalam bentuk setengah jadi tetapi dapat diedit, coba di sini!
Untuk mengonversi dari string menjadi angka, Anda dapat menggunakan kode Python berikut:
def conv(string, t=0):
t *= 256
t += ord(string[0])
if len(string) != 1:
return conv(string[1:], t)
return t
Solusi terakhir (hampir) dapat dicoba di sini!
Penjelasan dari Brainf * ck interpreter
Pertama mari kita pisahkan program menjadi beberapa bagian:
Q~B"><ht.,".:=B;Z]1=L; - The initialisation part
Q~B"><ht.,".: - input.replace("><+-.,[]", "><ht.,")
- replace the characters in brainf*ck with some modified ones.
- this means we can `eval` the add and subtract bits easily.
=B; - set `B` to this.
- The `B` variable contains the instructions
Z]1=L; - set `L` to [0]
- `L` contains the stack, initialised with 0
W~Bo@D=c !code! ~o~BlN - The main loop
W - do
~Bo@D=c - c=B[o++]
- the c variable is used to store the current character.
~o~BlN - while
~o - o
N - ^ != V
~Bl - len(B)
- this stops the program running once it's finished.
"ht"{I~c~LZ@EZ]1~LR3:=L) - The bit that does incrementing and decrementing
"ht"{I ) - if c in "ht"
~LZ@ - L[Z]
- `Z` contains the current stack pointer
~c E - eval current character with ^ as an argument
- returns the contents of `Z` either incremented or decremented
Z]1~LR3:=L - L[Z] = ^
~c\,qIz.oZ]1~LR3:=L) - The code for output
~c\,qI ) - if character == ",":
z.o - ord(input)
Z]1~LR3:=L - L[Z] = ^
~c\.qI~LZ@.CpK) - The code for input
~c\.qI ) - if c == ".":
~LZ@ - L[Z]
.C - chr(^)
pK - print(^)
~c"<>"{I~c"<>""th".:ZE=Z - main part
~c"<>"{I - if "<>" in c:
~c"<>""th".: - c.replace("<>", "th")
ZE=Z - Z = eval(char, Z)
Z1_qI0=Z~L0"":0]10:=L) - lower bound check
Z1_qI ) - if Z == -1:
0=Z - Z = 0
~L0"": - L.insert("", 0)
0]10:=L - L[0] = 0
Z~LlqI~L~Ll"":1_]10:=L) - upper bound check
Z~LlqI ) - if Z == len(L):
~Ll"": - L.insert("", len(L))
~L 1_]10:=L - L[-1] = 0
~c\[qI~LZ@0qI\]~B~o>@~o+h=o)) - Code for `[`
~c\[qI ) - if c == "[":
~LZ@0qI ) - if L[Z] == 0:
~B~o> - B[o:]
\] @ - ^.find("]")
~o+h=o - o = o + ^ + 1
- Dan ] :
~c\]qI~o\[~B~o<_@-t=o) - Code for `]`
~c\]qI ) - if c == "]":
~B~o<_ - reversed(B[:o])
\[ @ - ^.find("[")
~o -t=o - o = o - ^ -1