Fission , 1328 989 887 797 byte
Jawaban ini agak lama tidak masuk akal (saya berharap kami memiliki daerah yang dapat dilipat ) ... jangan lupa untuk menggulir melewati ini dan menunjukkan jawaban lain beberapa cinta!
Mengerjakan kode ini adalah yang menginspirasi tantangan ini. Saya ingin menambahkan jawaban dalam Fission ke EOEIS, yang membawa saya ke urutan ini. Namun, sebenarnya mempelajari Fisi dan mengimplementasikan ini membutuhkan waktu beberapa minggu untuk mengerjakannya dan mematikannya. Sementara itu, urutannya benar-benar tumbuh pada saya jadi saya memutuskan untuk memposting tantangan terpisah untuk itu (ditambah, ini tidak akan terlalu jauh di bawah pohon pada EOEIS).
Jadi saya persembahkan kepada Anda, Monstrositas:
R'0@+\
/ Y@</ /[@ Y]_L
[? % \ / \ J
\$@ [Z/;[{+++++++++L
UR+++++++++>/;
9\ ; 7A9
SQS {+L /$ \/\/\/\/\/ 5/ @ [~ &@[S\/ \ D /8/
~4X /A@[ %5 /; & K } [S//~KSA /
3 \ A$@S S\/ \/\/\/ \/>\ /S]@A / \ { +X
W7 X X /> \ +\ A\ / \ /6~@/ \/
/ ~A\; +;\ /@
ZX [K / {/ / @ @ } \ X @
\AS </ \V / }SZS S/
X ;;@\ /;X /> \ ; X X
; \@+ >/ }$S SZS\+; //\V
/ \\ /\; X X @ @ \~K{
\0X / /~/V\V / 0W//
\ Z [K \ //\
W /MJ $$\\ /\7\A /;7/\/ /
4}K~@\ &] @\ 3/\
/ \{ }$A/1 2 }Y~K <\
[{/\ ;@\@ / \@<+@^ 1;}++@S68
@\ <\ 2 ; \ /
$ ;}++ +++++++L
%@A{/
M \@+>/
~ @
SNR'0YK
\ A!/
Itu mengharapkan bahwa tidak ada baris baru di input, jadi Anda mungkin ingin menyebutnya seperti echo -n 120 | ./Fission oeis256504.fis.
Tata letak mungkin masih bisa lebih efisien, jadi saya pikir masih ada banyak ruang untuk perbaikan di sini (misalnya, ini berisi 911 581 461 374 spasi).
Sebelum kita sampai pada penjelasan, catatan tentang pengujian ini: penerjemah resmi tidak sepenuhnya berfungsi sebagaimana mestinya. a) Mirror.cpptidak dikompilasi pada banyak sistem. Jika Anda mengalami masalah itu, cukup komentari baris yang menyinggung - komponen yang terpengaruh (cermin acak) tidak digunakan dalam kode ini. b) Ada beberapa bug yang dapat menyebabkan perilaku tidak terdefinisi (dan kemungkinan akan untuk program kompleks ini). Anda dapat menerapkan tambalan ini untuk memperbaikinya. Setelah Anda selesai melakukannya, Anda harus dapat mengkompilasi juru bahasa
g++ -g --std=c++11 *.cpp -o Fission
Fakta menyenangkan: Program ini menggunakan hampir setiap komponen Fission yang ditawarkan, kecuali untuk #(cermin acak), :(cermin setengah), -atau |(cermin polos), dan "(mode cetak).
Apa yang di Bumi?
Peringatan: Ini akan cukup lama ... Saya menganggap Anda benar-benar tertarik pada cara kerja Fission dan bagaimana seseorang dapat memprogramnya. Karena jika tidak, saya tidak yakin bagaimana saya bisa meringkas ini. (Namun, paragraf berikutnya memberikan deskripsi umum bahasa tersebut.)
Fission adalah bahasa pemrograman dua dimensi, di mana data dan aliran kontrol diwakili oleh atom yang bergerak melalui grid. Jika Anda pernah melihat atau menggunakan Marbelous sebelumnya, konsepnya seharusnya tidak asing lagi. Setiap atom memiliki dua sifat bilangan bulat: massa non-negatif dan energi yang berubah-ubah. Jika massa menjadi negatif, atom dikeluarkan dari grid. Dalam kebanyakan kasus, Anda dapat memperlakukan massa sebagai "nilai" atom dan energi sebagai semacam properti meta yang digunakan oleh beberapa komponen untuk menentukan aliran atom (yaitu sebagian besar saklar bergantung pada tanda energi). Saya akan melambangkan atom dengan (m,E), bila perlu. Di awal program, grid dimulai dengan sekelompok(1,0)atom dari mana pun Anda menempatkan pada empat komponen UDLR(di mana huruf menunjukkan arah atom bergerak pada awalnya). Papan tersebut kemudian diisi dengan sejumlah komponen yang mengubah massa dan energi atom, mengubah arahnya atau melakukan hal-hal lain yang lebih canggih. Untuk daftar lengkap, lihat halaman esolangs , tetapi saya akan memperkenalkan sebagian besar dari mereka dalam penjelasan ini. Poin penting lainnya (yang digunakan beberapa kali oleh program) adalah bahwa kisi-kisi itu toroidal: sebuah atom yang mengenai salah satu sisi muncul kembali di sisi yang berlawanan, bergerak ke arah yang sama.
Saya menulis program di beberapa bagian yang lebih kecil dan mengumpulkannya di bagian akhir, jadi begitulah saya akan menjelaskannya.
atoi
Komponen ini mungkin terlihat agak tidak menarik, tetapi bagus dan sederhana dan memungkinkan saya untuk memperkenalkan banyak konsep penting dari aritmatika dan aliran kontrol Fission. Oleh karena itu, saya akan melalui bagian ini dengan detail yang sangat teliti, sehingga saya dapat mengurangi bagian lain untuk memperkenalkan mekanik Fisi baru dan menunjukkan komponen tingkat yang lebih tinggi yang aliran kontrol detailnya Anda harus dapat mengikuti sendiri.
Fission hanya dapat membaca nilai byte dari karakter individual, bukan seluruh angka. Sementara itu praktik yang dapat diterima di sekitar sini, saya pikir ketika saya berada di sana, saya bisa melakukannya dengan benar dan mem-parsing bilangan bulat aktual di STDIN. Ini atoikodenya:
;
R'0@+\
/ Y@</ /[@ Y]_L
[? % \ / \ J
\$@ [Z/;[{+++++++++L
UR+++++++++>/;
O
Dua komponen terpenting dalam Fisi adalah reaktor fisi dan fusi. Reaktor fisi adalah salah satu dari V^<>(kode di atas menggunakan <dan >). Reaktor fisi dapat menyimpan atom (dengan mengirimkannya ke dalam irisan karakter), secara default (2,0). Jika sebuah atom mengenai puncak karakter, dua atom baru akan dikirim ke samping. Massa mereka ditentukan dengan membagi massa yang masuk dengan massa yang disimpan (mis. Separuh secara default) - atom yang pergi mendapatkan nilai ini, dan atom yang sedang berjalan mendapatkan sisa massa (yaitu massa yang disimpan dalam fisi) . Kedua atom yang keluar akan memiliki minus energi yang masukenergi yang tersimpan. Ini berarti kita dapat menggunakan reaktor fisi untuk aritmatika - baik untuk pengurangan dan pembagian. Jika reaktor fisi terkena dari situs, atom hanya dipantulkan secara diagonal dan kemudian akan bergerak ke arah puncak karakter.
Reaktor fusi adalah salah satu dari YA{}(kode di atas menggunakan Ydan {). Fungsinya mirip: mereka dapat menyimpan atom (default (1,0)) dan ketika dipukul dari apex dua atom baru akan dikirim ke sisi. Namun, dalam hal ini kedua atom akan identik, selalu mempertahankan energi yang masuk, dan mengalikan massa yang masuk dengan massa yang disimpan. Artinya, secara default, reaktor fusi hanya menduplikasi atom apa pun yang mencapai puncaknya. Ketika dipukul dari samping, reaktor fusi sedikit lebih rumit: atomnya jugadisimpan (terlepas dari memori lainnya) hingga sebuah atom menyentuh sisi yang berlawanan. Ketika itu terjadi, sebuah atom baru dilepaskan ke arah puncak yang massa dan energinya adalah jumlah dari dua atom lama. Jika atom baru mengenai sisi yang sama sebelum atom yang cocok mencapai sisi yang berlawanan, atom lama hanya akan ditimpa. Reaktor fusi dapat digunakan untuk mengimplementasikan penjumlahan dan perkalian.
Komponen sederhana lain yang ingin saya hindari adalah [dan ]yang mengatur masing-masing arah atom ke kanan dan kiri (terlepas dari arah masuk). Setara vertikal adalah M(turun) dan W(atas) tetapi mereka tidak digunakan untuk atoikode. UDLRjuga bertindak WM][setelah melepaskan atom awal mereka.
Pokoknya, mari kita lihat kode di sana. Program dimulai dengan 5 atom:
- The
Rdan Ldi bagian bawah hanya mendapatkan kenaikan massa mereka (dengan +) untuk menjadi (10,0)dan kemudian disimpan dalam fisi dan reaktor fusi, masing-masing. Kami akan menggunakan reaktor ini untuk mengurai input basis-10.
- Yang
Ldi sudut kanan atas mendapat massa dikurangi (dengan _) menjadi (0,0)dan disimpan di samping reaktor fusi Y. Ini untuk melacak angka yang kita baca - kita akan secara bertahap meningkatkan dan melipatgandakannya ketika kita membaca angka.
- Di
Rsudut kiri atas massa diatur ke kode karakter 0(48) dengan '0, kemudian massa dan energi ditukar dengan @dan akhirnya massa bertambah satu kali dengan +memberi (1,48). Ini kemudian dialihkan dengan cermin diagonal \dan /disimpan dalam reaktor fisi. Kami akan menggunakan 48pengurangan untuk mengubah input ASCII menjadi nilai aktual digit. Kami juga harus meningkatkan massa 1untuk menghindari pembagian dengan 0.
- Akhirnya,
Udi sudut kiri bawah adalah apa yang sebenarnya membuat semuanya bergerak dan awalnya hanya digunakan untuk aliran kontrol.
Setelah diarahkan ke kanan, atom kontrol menyentuh ?. Ini adalah komponen input. Itu membaca karakter dan mengatur massa atom ke nilai ASCII yang dibaca dan energi 0. Jika kita menekan EOF sebagai gantinya, energi akan disetel ke 1.
Atom berlanjut dan kemudian mengenai %. Ini adalah sakelar cermin. Untuk energi non-positif, ini bertindak seperti /cermin. Tetapi untuk energi positif itu bertindak seperti \(dan juga mengurangi energi dengan 1). Jadi saat kita membaca karakter, atom akan dipantulkan ke atas dan kita dapat memproses karakter. Tetapi ketika kita selesai dengan input, atom akan dipantulkan ke bawah dan kita dapat menerapkan logika berbeda untuk mengambil hasilnya. FYI, komponen yang berlawanan adalah &.
Jadi kita punya atom yang bergerak naik untuk saat ini. Apa yang ingin kita lakukan untuk setiap karakter adalah membaca nilai digitnya, menambahkannya ke total running kami dan kemudian mengalikan total running itu dengan 10 untuk mempersiapkan digit berikutnya.
Atom karakter pertama mengenai reaktor fusi (default) Y. Ini membagi atom dan kami menggunakan salinan kiri sebagai atom kontrol untuk kembali ke komponen input dan membaca karakter berikutnya. Salinan yang tepat akan diproses. Pertimbangkan kasus di mana kita telah membaca karakter 3. Atom kita akan seperti itu (51,0). Kami bertukar massa dan energi @, sehingga kami dapat menggunakan pengurangan reaktor fisi berikutnya. Reaktor mengurangi 48energi (tanpa mengubah massa), sehingga reaksinya mengeluarkan dua salinan (0,3)- energi sekarang sesuai dengan digit yang telah kita baca. Salinan ke atas hanya dibuang dengan ;(komponen yang hanya menghancurkan semua atom yang masuk). Kami akan terus bekerja dengan salinan yang turun. Anda harus mengikuti jalurnya melalui/dan \sedikit mirror.
The @sebelum massa reaktor fusi swap dan energi lagi, seperti yang kita akan menambahkan (3,0)total kami berjalan di Y. Perhatikan bahwa total yang berjalan itu sendiri akan selalu memiliki 0energi.
Sekarang Jadalah lompatan. Apa yang dilakukannya adalah melompati atom yang masuk ke depan dengan energinya. Jika itu 0, atom terus bergerak lurus. Jika itu 1akan melewati satu sel, jika 2itu akan melewati dua sel dan seterusnya. Energi dihabiskan dalam lompatan, sehingga atom selalu berakhir dengan energi 0. Karena total yang berjalan memang memiliki energi nol, lompatan diabaikan untuk saat ini dan atom diarahkan ke reaktor fusi {yang melipatgandakan massanya 10. Salinan ke bawah dibuang dengan ;sementara salinan ke atas dimasukkan kembali ke dalam Yreaktor sebagai total berjalan baru.
Hal di atas terus berulang (dengan cara pipa yang lucu di mana digit baru sedang diproses sebelum yang sebelumnya dilakukan) sampai kami menekan EOF. Sekarang %akan mengirim atom ke bawah. Idenya adalah untuk mengubah atom ini menjadi (0,1)sekarang sebelum memukul reaktor total yang sedang berjalan sehingga a) total tidak terpengaruh (nol massa) dan b) kita mendapatkan energi 1untuk melompati atom [. Kita dapat dengan mudah menjaga energi dengan $, yang meningkatkan energi.
Masalahnya adalah bahwa ?tidak me-reset massa ketika Anda menekan EOF sehingga massa masih akan menjadi karakter terakhir yang dibaca, dan energinya akan menjadi 0(karena %dikurangi 1kembali ke 0). Jadi kami ingin menyingkirkan massa itu. Untuk melakukan itu kita bertukar massa dan energi dengan @lagi.
Saya perlu untuk memperkenalkan salah satu komponen lagi sebelum menyelesaikan bagian ini: Z. Ini pada dasarnya sama dengan %atau &. Perbedaannya adalah ia membiarkan atom-atom berenergi positif melewati (sementara mengurangi energi) dan membelokkan atom berenergi positif 90 derajat ke kiri. Kita dapat menggunakan ini untuk menghilangkan energi atom dengan memutarnya terus menerus Z- segera setelah energi itu hilang, atom akan dibelokkan dan meninggalkan loop. Itulah pola ini:
/ \
[Z/
di mana atom akan bergerak ke atas begitu energinya nol. Saya akan menggunakan pola ini dalam satu bentuk atau lainnya beberapa kali di bagian lain dari program ini.
Jadi ketika atom meninggalkan loop kecil ini, itu akan (1,0)dan ditukar (0,1)dengan @sebelum memukul reaktor fusi untuk melepaskan hasil akhir dari input. Namun, total yang berjalan akan dimatikan dengan faktor 10, karena kami telah secara sementara mengalikannya dengan digit lain.
Jadi sekarang dengan energi 1, atom ini akan melewati [dan melompat ke dalam /. Ini membelokkannya ke dalam reaktor fisi yang telah kami siapkan untuk membagi dengan 10 dan memperbaiki multiplikasi asing kami. Sekali lagi, kita membuang satu setengah dengan ;dan menyimpan yang lain sebagai output (di sini diwakili dengan Oyang hanya akan mencetak karakter yang sesuai dan menghancurkan atom - dalam program penuh kita tetap menggunakan atom sebagai gantinya).
itoa
/ \
input -> [{/\ ;@
@\ <\
$ ;}++ +++++++L
%@A{/
M \@+>/
~ @
SNR'0YK
\ A!/
Tentu saja, kita juga perlu mengubah hasilnya kembali menjadi string dan mencetaknya. Untuk itulah bagian ini dibuat. Ini mengasumsikan bahwa input tidak tiba sebelum centang 10 atau lebih, tetapi dalam program lengkap yang mudah diberikan. Bit ini dapat ditemukan di bagian bawah program lengkap.
Kode ini memperkenalkan komponen Fisi baru yang sangat kuat: tumpukan K. Tumpukan awalnya kosong. Ketika sebuah atom dengan energi non-negatif mengenai tumpukan, atom hanya didorong ke tumpukan. Ketika sebuah atom dengan energi negatif mengenai tumpukan, massa dan energinya akan digantikan oleh atom di bagian atas tumpukan (yang karenanya muncul). Jika tumpukan kosong, arah atom terbalik dan energinya menjadi positif (yaitu dikalikan dengan -1).
Oke, kembali ke kode aktual. Gagasan itoasnipet adalah berulang kali mengambil inputo modulo 10 untuk menemukan digit berikutnya sementara integer-membagi input dengan 10 untuk iterasi berikutnya. Ini akan menghasilkan semua digit dalam urutan terbalik (dari paling tidak signifikan ke paling signifikan). Untuk memperbaiki urutan, kami mendorong semua digit ke tumpukan dan pada akhirnya mengeluarkannya satu per satu untuk mencetaknya.
Bagian atas dari kode melakukan perhitungan digit: the Lwith the pluses memberikan angka 10 yang kita klonkan dan masukkan ke dalam reaktor fisi dan fusi sehingga kita dapat membaginya dan mengalikannya dengan 10. Lingkaran dasarnya dimulai setelah [di sudut kiri atas . Nilai saat ini dibagi: satu salinan dibagi dengan 10, kemudian dikalikan dengan 10 dan disimpan dalam reaktor fisi, yang kemudian dipukul oleh salinan lain di puncak. Ini menghitung i % 10sebagai i - ((i/10) * 10). Perhatikan juga bahwa Amembagi hasil antara setelah pembagian dan sebelum penggandaan, sehingga kita dapat dimasukkan i / 10ke dalam iterasi berikutnya.
The %dibatalkan loop sekali variabel iterasi hits 0. Karena ini adalah lebih atau kurang sebuah do-while loop, kode ini akan bahkan bekerja untuk mencetak 0(tanpa menciptakan nol terkemuka sebaliknya). Setelah kami meninggalkan loop, kami ingin mengosongkan tumpukan dan mencetak digit. Sadalah kebalikan dari Z, jadi itu adalah saklar yang akan membelokkan atom yang masuk dengan energi non-positif 90 derajat ke kanan. Jadi atom benar-benar bergerak dari tepi dari Slurus ke ke Kuntuk melepaskan digit (perhatikan ~yang memastikan bahwa atom yang masuk memiliki energi -1). Digit itu bertambah dengan 48untuk mendapatkan kode ASCII dari karakter digit yang sesuai. The Amembagi digit untuk mencetak satu salinan dengan!dan masukkan salinan lainnya kembali ke Yreaktor untuk digit berikutnya. Salinan yang dicetak digunakan sebagai pemicu berikutnya untuk tumpukan (perhatikan bahwa cermin juga mengirimkannya ke tepian untuk memukul Mdari kiri).
Ketika tumpukan kosong, Kkehendak mencerminkan atom dan mengubah energinya menjadi +1, sehingga melewati lurus S. Nmencetak baris baru (hanya karena rapi :)). Dan kemudian atom berjalan R'0lagi untuk berakhir di sisi Y. Karena tidak ada atom lebih lanjut di sekitar, ini tidak akan pernah dirilis dan program berakhir.
Menghitung Angka Fisi: Kerangka Kerja
Mari kita sampai pada daging sebenarnya dari program ini. Kode ini pada dasarnya adalah port dari implementasi referensi Mathematica saya:
fission[n_] := If[
(div =
SelectFirst[
Reverse@Divisors[2 n],
(OddQ@# == IntegerQ[n/#]
&& n/# > (# - 1)/2) &
]
) == 1,
1,
1 + Total[fission /@ (Range@div + n/div - (div + 1)/2)]
]
di mana divjumlah bilangan bulat di partisi maksimal.
Perbedaan utama adalah bahwa kita tidak bisa berurusan dengan nilai setengah bilangan bulat di Fission jadi saya melakukan banyak hal dikalikan dua, dan tidak ada rekursi dalam Fission. Untuk mengatasinya, saya mendorong semua bilangan bulat di partisi dalam antrian untuk diproses nanti. Untuk setiap nomor yang kami proses, kami akan menambah penghitung dengan satu dan setelah antrian kosong, kami akan melepaskan penghitung dan mengirimkannya untuk dicetak. (Antrian,, Qberfungsi persis seperti K, hanya dalam urutan FIFO.)
Berikut ini kerangka kerja untuk konsep ini:
+--- input goes in here
v
SQS ---> compute div from n D /8/
~4X | /~KSA /
3 +-----------> { +X
initial trigger ---> W 6~@/ \/
4
W ^ /
| 3
^ generate range |
| from n and div <-+----- S6
| -then-
+---- release new trigger
Komponen baru yang paling penting adalah digit. Ini adalah teleporter. Semua teleporter dengan digit yang sama menjadi satu. Ketika sebuah atom mengenai teleporter apa pun, ia akan segera memindahkan teleporter berikutnya dalam grup yang sama, di mana selanjutnya ditentukan dalam urutan kiri-ke-kanan, atas-ke-bawah yang biasa. Ini tidak perlu, tetapi bantu tata letak (dan karenanya bermain golf sedikit). Ada juga Xyang hanya menduplikasi atom, mengirimkan satu salinan lurus ke depan dan yang lainnya mundur.
Sekarang Anda mungkin dapat memilah sebagian besar kerangka kerja sendiri. Pojok kiri atas memiliki antrian nilai yang masih harus diproses dan dirilis satu nper satu. Satu salinan nditeleportasi ke bawah karena kita memerlukannya ketika menghitung rentang, salinan lainnya masuk ke blok di bagian atas yang menghitung div(sejauh ini merupakan bagian terbesar dari kode). Setelah divdihitung, duplikat - satu salinan menambah penghitung di sudut kanan atas, yang disimpan di K. Salinan lainnya diteleportasi ke bawah. Jika divitu 1, kita menangkis ke atas segera dan menggunakannya sebagai pemicu untuk iterasi berikutnya, tanpa enqueuing nilai-nilai baru. Kalau tidak kita gunakan divdann pada bagian di bagian bawah untuk menghasilkan rentang baru (yaitu aliran atom dengan massa yang sesuai yang kemudian dimasukkan ke dalam antrian), dan kemudian lepaskan pemicu baru setelah rentang telah selesai.
Setelah antrian kosong, pelatuk akan dipantulkan, melewati langsung Sdan muncul kembali di sudut kanan atas, di mana ia melepaskan penghitung (hasil akhir) dari A, yang kemudian diteleportasikan ke itoavia 8.
Menghitung Angka Fisi: Tubuh Lingkaran
Jadi yang tersisa hanyalah dua bagian untuk menghitung divdan menghasilkan kisaran. Komputasi divadalah bagian ini:
;
{+L /$ \/\/\/\/\/ 5/ @ [~ &@[S\/ \
/A@[ %5 /; & K } [S/
\ A$@S S\/ \/\/\/ \/>\ /S]@A / \
X X /> \ +\ A\ / \ /
/ ~A\; +;\ /@
ZX [K / {/ / @ @ } \ X @
\AS </ \V / }SZS S/
X ;;@\ /;X /> \ ; X X
\@+ >/ }$S SZS\+; //\V
/ \\ /\; X X @ @ \~K{
\0X / /~/V\V / 0W//
\ Z [K \ //\
\ /\7\A /;7/\/
Anda mungkin sudah cukup melihat sekarang untuk memecahkan masalah ini dengan kesabaran. Rincian tingkat tinggi adalah ini: 12 kolom pertama atau lebih menghasilkan aliran pembagi 2n. 10 kolom berikutnya menyaring yang tidak memuaskan OddQ@# == IntegerQ[n/#]. 8 kolom berikutnya menyaring yang tidak memuaskan n/# > (# - 1)/2). Akhirnya kami mendorong semua pembagi yang valid pada tumpukan, dan setelah selesai kami mengosongkan seluruh tumpukan menjadi reaktor fusi (menimpa semua kecuali pembagi terbesar / terbesar) dan kemudian melepaskan hasilnya, diikuti dengan menghilangkan energinya (yang tidak -zero dari memeriksa ketimpangan).
Ada banyak jalan gila di sana yang tidak benar-benar melakukan apa pun. Secara dominan, \/\/\/\/kegilaan di atas ( 5s juga merupakan bagian dari itu) dan satu jalan di sekitar bawah (yang melewati 7s). Saya harus menambahkan ini untuk menghadapi beberapa kondisi balapan yang tidak menyenangkan. Fisi dapat menggunakan komponen penundaan ...
Kode yang menghasilkan rentang baru dari ndan divadalah ini:
/MJ $$\
4}K~@\ &] @\ 3/\
\{ }$A/1 2 }Y~K <\
\@ / \@<+@^ 1;}++@
2 ; \ /
Kami pertama kali menghitung n/div - (div + 1)/2(keduanya istilah lantai, yang menghasilkan hasil yang sama) dan menyimpan untuk nanti. Kemudian kami menghasilkan rentang dari divbawah ke 1dan menambahkan nilai yang tersimpan ke masing-masing.
Ada dua pola umum baru dalam kedua hal ini, yang harus saya sebutkan: Satu adalah SXatau ZXtekan dari bawah (atau versi yang diputar). Ini adalah cara yang baik untuk menduplikasi atom jika Anda ingin satu salinan berjalan lurus (karena mengarahkan output dari reaktor fusi kadang-kadang bisa rumit). The Satau Zberputar atom ke dalam Xdan kemudian berputar salinan kembali cermin ke arah asli propagasi.
Pola lainnya adalah
[K
\A --> output
Jika kita menyimpan nilai apa pun di dalam, Kkita dapat mengambilnya berulang kali dengan memukul Kdengan energi negatif dari atas. The Aduplikat nilai kita tertarik dan mengirimkan apa yang menyalin kembali tepat ke stack untuk waktu berikutnya kita membutuhkannya.
Yah, itu cukup tebal ... tetapi jika Anda benar-benar berhasil melewati ini, saya harap Anda mendapat gagasan bahwa Fission i͝s̢̘̗̗ ͢i̟nç̮̩r̸̭̬̱͔e̟̹̟̜͟d̙i̠͙͎̖͓̯b̘̠͎̭̰̼l̶̪̙̮̥̮y̠̠͎̺͜ ͚̬̮f̟͞u̱̦̰͍n͍ ̜̠̙t̸̳̩̝o ̫͉̙͠p̯̱̭͙̜͙͞ŕ̮͓̜o̢̙̣̭g̩̼̣̝r̤͍͔̘̟ͅa̪̜͇m̳̭͔̤̞ͅ ͕̺͉̫̀ͅi͜n̳̯̗̳͇̹.̫̞̲̞̜̳