Golf Anda quine untuk kebaikan!

204

Menggunakan bahasa pilihan Anda, main golf quine .

Sebuah Quine adalah program komputer non-kosong yang tidak mengambil input dan menghasilkan salinan kode sumbernya sendiri sebagai satu-satunya output.

Tanpa kecurangan - itu artinya Anda tidak bisa hanya membaca file sumber dan mencetaknya. Juga, dalam banyak bahasa, file kosong juga merupakan quine: yang juga tidak dianggap quine.

Tanpa kueri kesalahan - sudah ada tantangan terpisah untuk kueri kesalahan.

Poin untuk:

  • Kode terkecil (dalam byte)
  • Solusi yang paling dikaburkan / tidak jelas
  • Menggunakan bahasa esoteris / tidak jelas
  • Berhasil menggunakan bahasa yang sulit untuk bermain golf

Cuplikan Stack berikut dapat digunakan untuk mendapatkan tampilan cepat dari skor saat ini di setiap bahasa, dan dengan demikian untuk mengetahui bahasa mana yang memiliki jawaban yang ada dan target seperti apa yang harus Anda kalahkan:

Tampilkan cuplikan kode

code-golf quine Rafe Kettler
sumber
4
Apakah Anda tidak bermaksud, "Golf Anda kuda untuk kebaikan yang lebih besar!"
Mateen Ulhaq
50
@muntoo ini lakon "Belajarkan Anda Haskell untuk Great Good".
Rafe Kettler

Jawaban:

106

Hexagony , panjang sisi 17 16, 816 705 byte

180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.

Cobalah online!

Inilah yang terlihat seperti dilipat:

                1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
               8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
              3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
             1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
            2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
           8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
          5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
         0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
        3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
       5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
      3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
     8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
    8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
   1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
  0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
 " . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
  . . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
   . " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
    . . . . . . . . . . . . . . . . . . . . < . " . . . . .
     " . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
      . . . . . . . = . = . . . . . . . _ . < . " . . . .
       . " . " . > . > . ; . ' . = . : . \ . > . . . . .
        . . . . . . . . . . . . . . . . . . < . " . . .
         " . " . > . \ . ' . % . ' . < . # . > . . . .
          . . . . . . . . . . . _ . . . . . < . " . .
           . " . " . > . # . # . > . < . # . > . . .
            . . . . . . . . . . . . = . = . < . " .
             " . " . > . # . \ . ' . R . / . > . .
              . . . . . . . . . . . . . . . < . "
               . ! . . . . . . . . . . . / . > .
                . . . . . . . . . . . . . . . .

Ah well, ini cukup rollercoaster emosional ... Saya berhenti menghitung berapa kali saya beralih antara "haha, ini gila" dan "tunggu, jika saya melakukan ini seharusnya benar-benar bisa dilakukan". Kendala yang dikenakan pada kode oleh aturan tata letak Hexagony adalah ... parah.

Dimungkinkan untuk mengurangi panjang sisi sebesar 1 atau 2 tanpa mengubah pendekatan umum, tetapi itu akan sulit (hanya sel dengan #saat ini tidak digunakan dan tersedia untuk decoder). Saat ini saya juga sama sekali tidak tahu bagaimana pendekatan yang lebih efisien, tetapi saya yakin ada. Saya akan memikirkan hal ini selama beberapa hari ke depan dan mungkin mencoba bermain golf dengan panjang satu sisi, sebelum saya menambahkan penjelasan dan segalanya.

Yah setidaknya, saya sudah membuktikan itu mungkin ...

Beberapa skrip CJam untuk referensi saya di masa depan:

Martin Ender
sumber
51
Sayang pete apa ini.
Conor O'Brien
2
Berapa lama untuk membuat ini?
Adnan
3
@AndN Saya telah bermain-main dengan konsep untuk "templat" umum sejak kemarin sekarang dan kemudian (yang tidak melibatkan pengujian yang sebenarnya ... hanya mengetik beberapa hal pada kotak 7x7 dan melihat apakah itu bisa bekerja .. Saya mungkin membuang setengah lusin pendekatan yang sudah ada). Pengkodean yang sebenarnya kemudian dilakukan malam ini ... mungkin 3 jam, kataku.
Martin Ender
10
Kata-kata tidak dapat menjelaskan betapa terkejutnya saya ketika melihat ini beraksi dengan Esoteric IDE langkah demi langkah ... Kepada siapa mungkin ingin memahami ini, Hexagon ini mengkodekan bagian "decoder" menjadi integer yang dicetak dengan !dan kemudian dengan mirror /pada baris terakhir ke-2 memasuki decoder untuk mencetak kode decoder untuk menyelesaikan quine. Ini memiliki penggunaan yang ajaib <dan >yang bertuliskan bilangan bulat sangat besar multiline dan membangun area untuk menyimpan decoder. Saya benar-benar ingin tahu "lusinan pendekatan" apa yang sedang dipertimbangkan?
Sunny Pun
3
Penjelasan? ---
MD XF
77

MySQL, 167 karakter

SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));

Tepat sekali. :-)

Saya benar-benar menulis ini sendiri. Awalnya diposting di situs saya .

TehShrike
sumber
72

GolfScript, 2 byte

1

(note trailing newline) Ini mendorong angka 1 ke tumpukan. Di akhir program, GolfScript mencetak semua item dalam tumpukan (tanpa spasi di antaranya), lalu mencetak baris baru.

Ini adalah quine sejati (seperti yang tercantum dalam pertanyaan), karena sebenarnya mengeksekusi kode; tidak hanya "membaca file sumber dan mencetaknya" (tidak seperti pengiriman PHP).

Untuk contoh lain, inilah program GolfScript untuk dicetak 12345678:

9,(;
  1. 9: tekan 9 ke tumpukan
  2. ,: mengkonsumsi 9 sebagai argumen, dorong array [0 1 2 3 4 5 6 7 8]ke tumpukan
  3. (: mengkonsumsi array sebagai argumen, dorong array [1 2 3 4 5 6 7 8]dan item 0ke stack
  4. ;: buang item atas tumpukan

Tumpukan sekarang berisi array [1 2 3 4 5 6 7 8]. Ini akan ditulis ke output standar tanpa spasi antara elemen, diikuti oleh baris baru.

Chris Jester-Young
sumber
18
Atau PowerShell, atau PHP :-)
Joey
6
Anda tidak kembali ke masa lalu dan memberikan ide kepada penemu untuk menciptakan GolfScript, bukan?
Mateen Ulhaq
78
Secara teknis, 1bukan quine di GolfScript: itu output 1\n, di mana \nmenunjukkan baris baru. Namun, program dua-char 1\n adalah quine.
Ilmari Karonen
17
Program one-char \nmungkin juga?
Lynn
10
@ Nama samaran quine secara harfiah adalah program yang mencetak sumbernya sendiri. Saya tidak berpikir ada pembatasan sembarang pada "struktur".
Hugo Zink
71

Brain-Flak , 9.8e580 1.3e562 9.3e516 12818 11024 4452 4332 4240 4200 4180 3852 3656 3616 3540 2485 + 3 = 2488 byte

Sekarang cocok di alam semesta yang bisa diamati!

(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>

Cobalah online!

Penjelasan

Quine ini berfungsi seperti kebanyakan Quine dalam bahasa esoteris; ini memiliki dua bagian encoder dan decoder. Encoder adalah semua tanda kurung di awal dan decoder adalah bagian yang lebih kompleks di bagian paling akhir.

Cara naif pengkodean program adalah dengan menempatkan nilai ASCII dari setiap karakter dalam dekoder ke stack. Ini bukan ide yang sangat bagus karena Brain-Flak hanya menggunakan 8 karakter ( ()<>[]{}) sehingga Anda akhirnya membayar beberapa byte untuk mengkodekan informasi yang sangat sedikit. Gagasan yang lebih cerdas, dan yang digunakan sampai sekarang adalah untuk menetapkan masing-masing dari 8 kawat gigi ke angka yang jauh lebih kecil (1-8) dan mengonversinya ke nilai ASCII dengan dekoder kami. Ini bagus karena harganya tidak lebih dari 18 byte untuk mengkodekan karakter yang bertentangan dengan 252 sebelumnya.

Namun program ini tidak melakukan keduanya. Itu bergantung pada fakta bahwa program Brain-Flak semua seimbang untuk menyandikan 8 kawat gigi dengan angka hingga 5. Ia mengkodekan mereka sebagai berikut.

(       -> 2
<       -> 3
[       -> 4
{       -> 5
),>,],} -> 1

Semua kurung kurawal diberikan 1 karena kita dapat menggunakan konteks untuk menentukan yang mana yang perlu kita gunakan dalam skenario tertentu. Ini mungkin terdengar seperti tugas yang menakutkan untuk program Brain-Flak, tetapi sebenarnya tidak. Ambil contoh pengkodean berikut dengan kurung terbuka yang diterjemahkan dan kurung dekat diganti dengan .:

(.
((..
<([.{...

Mudah-mudahan Anda dapat melihat bahwa algoritme ini cukup sederhana, kami membaca dari kiri ke kanan, setiap kali kami menemukan penahan terbuka, kami mendorong penahan dekat ke tumpukan imajiner dan ketika kami menjumpai, .kami memunculkan nilai teratas dan meletakkannya di tempat .. Pengkodean baru ini menyelamatkan kita sejumlah besar byte dalam encoder sementara kita hanya kehilangan beberapa byte pada decoder.

Penjelasan tingkat rendah

Bekerja dalam proses

Sriotchilism O'Zaic
sumber
25
Saya pikir Anda menang untuk solusi terpanjang untuk tantangan kode-golf ...
Mego
18
Baru saja membuat golf tunggal terbesar dalam sejarah PPCG Tidak. 9,8e580 masih mengesankan.
Dennis
19
+1 untuk pas ke alam semesta yang dapat diamati. Juga, dengan TIO Nexus, permalink harus sesuai dengan jawabannya. tio.run/nexus/…
Dennis
3
... golf sangat besar ...
Destructible Lemon
3
Saya pikir Anda menang untuk memotong sebagian besar byte
Christopher
68

Prelude , 5157 4514 2348 1761 1537 664 569 535 423 241 214 184 178 175 169 148 142 136 133 byte

Terima kasih kepada Sp3000 untuk menghemat 3 byte.

Ini agak lama ... (oke, masih panjang ... setidaknya itu mengalahkan quine Brainfuck C # terpendek yang diketahui tentang tantangan ini sekarang) tapi itu quine pertama yang saya temukan sendiri (kiriman Lua dan Julia saya benar-benar hanya terjemahan dari teknik standar quine ke bahasa lain) dan sejauh yang saya tahu tidak ada yang menulis quine di Prelude sejauh ini, jadi saya sebenarnya cukup bangga dengan ini. :)

7( -^^^2+8+2-!( 6+ !
  ((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)

Jumlah digit yang besar itu hanyalah sebuah pengkodean dari kode inti, itulah sebabnya quine begitu panjang.

Digit yang menyandikan quine telah dibuat dengan skrip CJam ini .

Ini membutuhkan penerjemah yang memenuhi standar, yang mencetak karakter (menggunakan nilai sebagai kode karakter). Jadi, jika Anda menggunakan juru bahasa Python, Anda harus mengaturnya NUMERIC_OUTPUT = False.

Penjelasan

Pertama, beberapa kata tentang Prelude: setiap baris dalam Prelude adalah "suara" terpisah yang memanipulasi tumpukannya sendiri. Tumpukan ini diinisialisasi ke jumlah 0 tak hingga. Program ini dieksekusi kolom demi kolom, di mana semua perintah dalam kolom dieksekusi "secara bersamaan" berdasarkan negara stack sebelumnya. Digit didorong ke tumpukan secara individual, sehingga 42akan mendorong a 4, lalu a 2. Tidak ada cara untuk mendorong angka yang lebih besar secara langsung, Anda harus menambahkannya. Nilai dapat disalin dari tumpukan yang berdekatan dengan vdan ^. Loop gaya Brainfuck dapat diperkenalkan dengan tanda kurung. Lihat tautan di informasi utama untuk informasi lebih lanjut.

Ini adalah ide dasar quine: pertama kita dorong banyak digit ke stack yang mengkodekan inti quine. Inti kata kemudian mengambil angka-angka itu, menerjemahkannya untuk mencetak dirinya sendiri dan kemudian mencetak angka-angka seperti yang muncul dalam kode (dan trailing )).

Ini sedikit rumit oleh kenyataan bahwa saya harus membagi inti lebih dari beberapa baris. Awalnya saya memiliki pengkodean di awal, tetapi kemudian diperlukan untuk mengisi garis lain dengan jumlah spasi yang sama. Inilah sebabnya mengapa skor awal semuanya sangat besar. Sekarang saya telah menempatkan pengkodean di bagian akhir, tetapi ini berarti bahwa saya pertama-tama harus melewatkan inti, kemudian mendorong angka, dan melompat kembali ke awal dan melakukan pencetakan.

Pengkodean

Karena kode hanya memiliki dua suara, dan dan adjacency adalah siklik, ^dan videntik. Itu bagus karena vsejauh ini memiliki kode karakter terbesar, jadi menghindarinya dengan selalu menggunakan ^membuat penyandian menjadi lebih sederhana. Sekarang semua kode karakter berada dalam kisaran 10 hingga 94, inklusif. Ini berarti saya dapat menyandikan setiap karakter dengan tepat dua digit desimal. Namun ada satu masalah: beberapa karakter, terutama linefeed, memiliki nol dalam representasi desimal mereka. Itu masalah karena nol tidak mudah dibedakan dari bagian bawah tumpukan. Untungnya ada perbaikan sederhana untuk itu: kami mengimbangi kode karakter dengan 2, jadi kami memiliki kisaran 12 hingga 96, inklusif, yang masih cocok dengan nyaman dalam dua digit desimal. Sekarang dari semua karakter yang dapat muncul dalam program Prelude,0memiliki 0 dalam representasinya (50), tetapi kami benar-benar tidak perlu 0sama sekali. Jadi itulah pengkodean yang saya gunakan, mendorong setiap digit satu per satu.

Namun, karena kami bekerja dengan tumpukan, representasi didorong mundur. Jadi jika Anda melihat akhir dari pengkodean:

...9647344257

Membagi menjadi pasangan dan mundur, lalu kurangi dua, dan kemudian cari kode karakter:

57 42 34 47 96
55 40 32 45 94
 7  (     -  ^

di mana 32sesuai dengan spasi. Inti melakukan transformasi ini, dan kemudian mencetak karakter.

Inti

Jadi mari kita lihat bagaimana angka-angka ini diproses. Pertama, penting untuk dicatat bahwa tanda kurung yang cocok tidak harus berada pada baris yang sama di Prelude. Hanya ada satu tanda kurung per kolom, sehingga tidak ada ambiguitas di mana tanda kurung menjadi satu. Secara khusus, posisi vertikal tanda kurung tutup selalu tidak relevan - tumpukan yang diperiksa untuk menentukan apakah loop berakhir (atau dilewati seluruhnya) akan selalu menjadi yang memiliki (.

Kami ingin menjalankan kode persis dua kali - pertama kali, kami melewatkan inti dan mendorong semua angka di akhir, kedua kalinya kami menjalankan inti. Faktanya, setelah kita menjalankan inti, kita akan mendorong semua angka itu lagi, tetapi karena loop berakhir setelah itu, ini tidak relevan. Ini memberikan kerangka berikut:

7(
  (                   )43... encoding ...57)

Pertama, kita dorong a 7ke suara pertama - jika kita tidak melakukan ini, kita tidak akan pernah memasuki loop (untuk kerangka itu hanya penting bahwa ini bukan nol ... mengapa khusus 7kita akan lihat nanti) . Lalu kita memasuki loop utama. Sekarang, suara kedua berisi loop lain. Pada pass pertama, loop ini akan dilewati karena tumpukan kedua kosong / hanya berisi 0s. Jadi kami melompat langsung ke pengkodean dan mendorong semua angka itu ke tumpukan. The 7kita didorong ke stack pertama masih ada, sehingga berulang lingkaran.

Kali ini, ada juga 7pada stack kedua, jadi kami memasukkan loop pada suara kedua. Putaran pada suara kedua dirancang sedemikian rupa sehingga tumpukan kosong lagi di akhir, sehingga hanya berjalan sekali. Ini juga akan menghabiskan tumpukan pertama ... Jadi ketika kita meninggalkan loop pada suara kedua, kita mendorong semua digit lagi, tetapi sekarang 7pada tumpukan pertama telah dibuang, sehingga loop utama berakhir dan program berakhir.

Selanjutnya, mari kita lihat loop pertama di inti aktual. Melakukan sesuatu secara bersamaan dengan (atau )cukup menarik. Saya telah menandai lingkaran di sini dengan =:

-^^^2+8+2-!
(#^#(1- )#)
 ==========

Itu berarti kolom yang berisi (tidak dianggap sebagai bagian dari loop (karakter di sana hanya dieksekusi sekali, dan bahkan jika loop dilewati). Tetapi kolom yang berisi ) adalah bagian dari loop dan dijalankan sekali pada setiap iterasi.

Jadi kita mulai dengan satu -, yang mengubah 7tumpukan pertama menjadi -7... lagi, lebih lanjut tentang itu nanti. Adapun loop yang sebenarnya ...

Loop berlanjut sementara tumpukan angka belum dikosongkan. Ini memproses dua digit sekaligus. Tujuan dari loop ini adalah untuk memecahkan kode pengodean, mencetak karakter, dan pada saat yang sama menggeser tumpukan angka ke suara pertama. Jadi bagian ini dulu:

^^^
#^#

Kolom pertama memindahkan 1 digit ke suara pertama. Kolom kedua menyalin 10 digit ke suara pertama sementara juga menyalin kembali 1 digit ke suara kedua. Kolom ketiga bergerak yang menyalin kembali ke suara pertama. Itu berarti suara pertama sekarang memiliki 1 digit dua kali dan 10 digit di antaranya. Suara kedua hanya memiliki salinan 10 digit lainnya. Itu berarti kita dapat bekerja dengan nilai-nilai di atas tumpukan dan pastikan ada dua salinan yang tersisa di tumpukan pertama untuk nanti.

Sekarang kita memulihkan kode karakter dari dua digit:

2+8+2-!
(1- )#

Bagian bawah adalah lingkaran kecil yang hanya mengurangi 10 digit menjadi nol. Untuk setiap iterasi kami ingin menambahkan 10 ke atas. Ingat bahwa yang pertama 2bukan bagian dari loop, jadi loop body sebenarnya +8+2yang menambahkan 10 (menggunakan 2dorongan sebelumnya) dan mendorong yang lain 2. Jadi ketika kita selesai dengan loop, tumpukan pertama sebenarnya memiliki basis- Nilai 10 dan lainnya 2. Kami kurangi 2 dengan -memperhitungkan offset dalam pengodean dan mencetak karakter dengan !. The #hanya membuang nol pada akhir loop bawah.

Setelah loop ini selesai, tumpukan kedua kosong dan tumpukan pertama menampung semua digit dalam urutan terbalik (dan a -7di bagian bawah). Sisanya cukup sederhana:

( 6+ !
8(1-)8)#

Ini adalah loop kedua dari inti, yang sekarang mencetak kembali semua digit. Untuk melakukannya, kita perlu 48 setiap digit untuk mendapatkan kode karakter yang benar. Kami melakukan ini dengan loop sederhana yang menjalankan 8waktu dan menambahkan 6setiap waktu. Hasilnya dicetak dengan !dan 8pada akhirnya adalah untuk iterasi berikutnya.

Jadi bagaimana dengan -7? Ya, 48 - 7 = 41yang merupakan kode karakter ). Sihir!

Akhirnya, ketika kita selesai dengan loop itu kita membuang, 8kita hanya mendorong dengan #untuk memastikan bahwa kita meninggalkan loop luar pada suara kedua. Kami mendorong semua digit lagi dan program berakhir.

Martin Ender
sumber
1
Mendengarkan Hello World di Fugue sekarang ... cukup menarik.
Robert Fraser
19
Martin, kamu harus berhenti di suatu tempat.
seequ
3
Saya suka bahwa ini memiliki lebih dari 5000 byte golf secara keseluruhan, ditambah pengakuan untuk Sp3000 untuk menghemat 3 dari mereka.
Kamil Drakari
2
@ KamilDrakari Itu adalah 3 byte terakhir, jadi ini cukup besar. ;)
Martin Ender
57

Hexagony , panjang sisi 11, 314 byte

164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q

Cobalah online!

Versi yang lebih lama:

Hexagony , panjang sisi 11, 330 byte

362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/

Cobalah online!

Encoder: Cobalah online!

Program ini kira-kira setara dengan kode Python ini: Coba online!

Kode dibuka:

           3 6 2 0 0 3 5 1 1 5 5
          3 4 2 0 9 6 1 4 2 3 7 6
         6 2 6 1 4 2 6 2 5 2 5 3 9
        0 4 8 6 3 6 5 2 3 9 5 9 4 6
       8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
      0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
     4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
    4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
   5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
  . / : { ; + ' = 1 P ' % ' a { : . . \ .
 . . . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . . . \ 
   . . . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . . . \     
       . . . . . . . . . . . . . . \      
        . . . . . . . . . . . . . \       
         ! $ > < . . . . . . . . \        
          . . @ > { ? 2 ' % < . .         
           . . . . : ; ; 4 Q / .

Dua .s membutuhkan 1 bit. Setiap karakter lain membutuhkan 1 bit dan basis-97 digit.

Penjelasan

Klik pada gambar untuk ukuran lebih besar. Setiap bagian penjelasan memiliki kode Python yang sesuai untuk membantu pemahaman.

Bagian data

Alih-alih struktur kompleks yang digunakan dalam beberapa jawaban lain (dengan <, "dan beberapa hal lain), saya hanya membiarkan IP melewati bagian bawah.

Data

Pertama, IP dijalankan melalui banyak angka dan no-op's ( .) dan mirror ( \). Setiap digit ditambahkan ke nomor dalam memori, sehingga pada akhirnya nilai memori sama dengan angka pada awal program.

mem = 362003511...99306179

! mencetaknya,

stdout.write(str(mem))

dan $melompat melalui yang berikutnya >.

Mulai dari <. Jika nilai memori memsalah ( <= 0, yaitu, kondisi mem > 0tidak terpenuhi), kami telah selesai mencetak program, dan harus keluar. IP akan mengikuti jalur atas.

Keluar

(biarkan IP berjalan di seluruh dunia selama sekitar 33 perintah sebelum memukul @(yang mengakhiri program) karena meletakkannya di tempat lain menimbulkan beberapa byte tambahan)

Jika itu benar, kita mengikuti jalan yang lebih rendah, dialihkan beberapa kali dan menjalankan beberapa perintah lagi sebelum mencapai persyaratan lain.

# Python                    # Hexagony
# go to memory cell (a)     # {
a = 2                       # ?2
# go to memory cell (b)     # '
b = mem % a                 # %

Sekarang memori terlihat seperti ini:

Mem1

Jika nilainya benar:

if b > 0:

kode berikut dijalankan:

# Python                    # Hexagony
b = ord('Q')                # Q
b = b*10+4                  # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256))    # ;
stdout.write(chr(b%256))    # ;

Lihat penjelasan rinci tentang Q4di MartinEnder ini HelloWorld Hexagony jawaban . Singkatnya, kode ini mencetak .dua kali.

Awalnya saya berencana untuk mencetak ini . sekali. Ketika saya menemukan ini (mencetak .dua kali) dan menerapkannya, sekitar 10 digit disimpan.

Kemudian,

b = mem // a                # :

Berikut adalah fakta penting yang saya sadari yang menyelamatkan saya sekitar 14 digit: Anda tidak perlu berada di tempat Anda memulai.

Untuk memahami apa yang saya katakan, mari kita analogi BF. (lewati ini jika Anda sudah mengerti)

Diberi kode

while a != 0:
    b, a = a * 2, 0
    a, b = b, 0
    print(a)

Dengan asumsi kita membiarkan amenjadi nilai sel saat ini dan bmenjadi nilai sel kanan, terjemahan langsung dari ini ke BF adalah:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
    >[-<+>]       # a, b = b, 0
    <.            # print(a)
]

Namun, perhatikan bahwa kita tidak perlu berada pada posisi yang sama sepanjang waktu selama program. Kita dapat membiarkan nilai amenjadi apa pun kita di awal setiap iterasi, lalu kita memiliki kode ini:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
                  # implicitly let (a) be at the position of (b) now
    .             # print(a)
]

yang beberapa byte lebih pendek.

Juga, perilaku pembungkus sudut juga menyelamatkan saya dari memiliki \cermin di sana - tanpanya saya tidak akan bisa masuk ke digit (+2 digit untuk \dirinya sendiri dan +2 digit untuk tidak berpasangan .di sebelah kanannya, belum lagi bendera)

(detail:

  • IP memasuki sudut kiri bawah, menuju ke kiri
  • Itu bisa melengkung ke sudut kanan, masih kepala kiri
  • Bertemu a \ yang mencerminkannya, sekarang ia mengarah ke kanan
  • Pergi ke sudut dan mendapatkan melengkung lagi ke sudut kiri bawah

)

Jika nilai (dari operasi mod 2 di atas) adalah falsy (nol), maka kita mengikuti jalur ini:

# Python                 # Hexagony   # Memory visualization after execution
b = mem // a             # :          # click here
base = ord('a') # 97     # a
y = b % base             # '%
offset = 33              # P1
z = y + offset           # ='+
stdout.write(chr(z))     # ;          # click here
mem = b // base          # {:         # click here

Saya tidak akan menjelaskan terlalu rinci di sini, tetapi offset sebenarnya tidak tepat 33, tetapi kongruen dengan 33mod 256. Dan chrmemiliki implisit % 256.

pengguna202729
sumber
3
Sobat, itu banyak larangan
Jo King
26
Saya tertawa pada "Untuk memahami apa yang saya katakan, mari kita analogi [BrainFuck]." Hanya di PPCG ... :)
Lynn
2
Saya menggulir seperti 3 kali ke bagian atas jawaban untuk mengangkatnya, hanya untuk mengetahui bahwa saya sudah melakukannya ...
NieDzejkob
2
310 byte dengan memanfaatkan ruang baru dari mempersingkat nomor
Jo King
2
308 byte dengan mengambil lebih banyak ruang
Jo King
46

Vim, 11 byte

q"iq"qP<Esc>hqP
  • iq"qP<Esc>: Masukkan secara manual duplikat teks yang harus berada di luar rekaman.
  • q"dan hqP: Catat bagian dalam langsung ke ""register yang tidak disebutkan namanya , sehingga dapat ditempelkan di tengah. Ini hadalah satu-satunya reposisi yang diperlukan; jika Anda memasukkannya ke dalam makro, itu akan ditempelkan ke hasilnya.

Sunting

Catatan tentang rekaman dengan q": Daftar yang tidak disebutkan namanya ""adalah hal yang lucu. Ini sebenarnya bukan register yang benar seperti yang lain, karena teks tidak disimpan di sana. Ini sebenarnya adalah penunjuk ke beberapa register lain (biasanya "-untuk menghapus tanpa baris baru, "0untuk menarik, atau "1untuk menghapus dengan baris baru). q"melanggar aturan; sebenarnya menulis untuk "0. Jika Anda ""sudah menunjuk ke beberapa register selain "0, q"akan menimpa "0tetapi ""tidak berubah. Ketika Anda memulai Vim baru, ""secara otomatis menunjuk "0, sehingga Anda baik-baik saja dalam hal itu.

Pada dasarnya, Vim aneh dan bermasalah.

udioica
sumber
tunggu, mengapa ini tidak berhasil bagiku
Destructible Lemon
@DestructibleWatermelon Tidak bisa mengatakan dengan pasti, tetapi satu penjelasan yang paling mungkin. Mungkin seharusnya sudah ada dalam artikel sebelumnya, karena dapat membuat orang pergi. Baca hasil edit.
udioica
Anda mungkin harus meletakkan sesuatu tentang seberapa mendesak yatau sesuatu sebelum berlari dapat membantu
Destructible Lemon
Mengapa Anda tidak menggunakan ␛untuk menunjukkan menekan tombol <Esc>? Bagian dari Blok Unicode
mbomb007
4
@ mbomb007 <Esc>Notasi adalah standar dalam pemetaan Vim ( :help <>) dan itulah yang digunakan vimgolf.com. Setiap vimgolfer yang berpengalaman akan digunakan untuk membacanya. Adapun unicode, saya harus menyipitkan mata untuk membaca huruf-huruf kecil, dan mereka mengaburkan metode mengetiknya dan mencari file bantuan.
udioica
44

Cubix , 20 byte

3434Qu$v@!<"OOw\o;/"

Hampir \o/ ...

Bersih :

    3 4
    3 4
Q u $ v @ ! < "
O O w \ o ; / "
    . .
    . .

Cobalah online

Coba di sini !

Catatan tambahan

Cerita latar belakang

Setelah terkesan dengan membaca jawaban hebat dari @ ais523 ini, saya mulai berpikir untuk bermain golf lebih lanjut. Lagi pula, ada beberapa no-ops di sana, dan itu tidak terasa sangat terkompresi. Namun, karena teknik yang digunakan oleh jawabannya (dan juga milik saya), membutuhkan kode untuk menjangkau garis penuh, penghematan setidaknya 12 byte diperlukan. Ada satu komentar dalam penjelasannya yang benar-benar membuat saya berpikir:

Pada subjek golf turun quine ini lebih lanjut, [...] itu perlu [...] beberapa cara lain untuk mewakili permukaan atas kubus [...]

Kemudian, tiba-tiba, ketika saya berdiri dan berjalan pergi untuk mengambil sesuatu untuk diminum, saya tersadar: Bagaimana jika program tersebut tidak menggunakan kode karakter, melainkan angka untuk mewakili wajah teratas? Ini sangat pendek jika nomor yang kami cetak memiliki 2 digit. Cubix memiliki 3 petunjuk satu-byte untuk mendorong angka dua digit: N, Sdan Q, yang mendorong 10,32 dan 34masing-masing, jadi ini harus cukup Golfy, pikirku.

Komplikasi pertama dengan ide ini adalah bahwa bagian atas sekarang dipenuhi dengan angka-angka yang tidak berguna, jadi kita tidak bisa menggunakannya lagi. Komplikasi kedua adalah bahwa permukaan atas memiliki ukuran yang merupakan ukuran kubus, dan itu harus memiliki ukuran genap, jika tidak satu nomor juga akan berakhir pada posisi awal dari penunjuk instruksi, yang mengarah ke tumpukan yang tercemar. Karena komplikasi ini, kode saya harus sesuai dengan ukuran kubus 2 (yang dapat berisi 'hanya' 24 byte, jadi saya harus bermain golf setidaknya 21 byte). Juga, karena wajah atas dan bawah tidak dapat digunakan, saya hanya memiliki 16 byte efektif.

Jadi saya mulai dengan memilih nomor yang akan menjadi setengah dari wajah teratas. Saya mulai dengan N(10), tetapi itu tidak berhasil karena pendekatan yang saya ambil untuk mencetak semuanya. Either way, saya mulai lagi dan menggunakan S(32) untuk beberapa alasan. Itu memang menghasilkan quine yang tepat, atau begitulah menurut saya. Semuanya bekerja dengan sangat baik, tetapi tanda kutipnya hilang. Kemudian, saya sadar bahwaQ (34) akan sangat berguna. Bagaimanapun, 34 adalah kode karakter dari kutipan ganda, yang memungkinkan kita untuk menyimpannya di stack, menghemat (2, dalam tata letak yang saya gunakan saat itu) byte yang berharga. Setelah saya mengubah rute IP sedikit, yang tersisa hanyalah latihan untuk mengisi kekosongan.

Bagaimana itu bekerja

Kode dapat dibagi menjadi 5 bagian. Saya akan membahasnya satu per satu. Perhatikan bahwa kami menyandikan wajah tengah dalam urutan terbalik karena model tumpukan adalah first-in-last-out.

Langkah 1: Mencetak wajah bagian atas

Instruksi yang tidak relevan telah digantikan oleh no-ops ( .). IP memulai baris ketiga, di paling kiri, menunjuk ke timur. Tumpukan itu (jelas) kosong.

    . .
    . .
Q u . . . . . .
O O . . . . . .
    . .
    . .

IP berakhir di posisi paling kiri di baris keempat, menunjuk ke barat, akan membungkus ke posisi paling kanan di jalur yang sama. Instruksi yang dijalankan adalah (tanpa karakter aliran kontrol):

QOO
Q   # Push 34 (double quotes) to the stack
 OO # Output twice as number (the top face)

Tumpukan hanya berisi 34, mewakili karakter terakhir dari sumber.

Langkah 2: Encode baris keempat

Bit ini melakukan apa yang Anda harapkan: enkode baris keempat. IP dimulai pada kuotasi ganda di akhir baris itu, dan menuju ke barat sambil mendorong kode karakter dari setiap karakter yang didudukinya hingga menemukan kuotasi ganda yang cocok. Kutipan ganda yang cocok ini juga merupakan karakter terakhir pada baris keempat, karena IP membungkus lagi ketika mencapai tepi kiri.

Secara efektif, IP telah memindahkan satu posisi ke kiri, dan tumpukan sekarang berisi representasi dari baris keempat dalam kode karakter dan urutan terbalik.

Langkah 3: Dorong kutipan lain

Kita perlu mendorong kutipan lain, dan cara apa yang lebih baik daripada mendaur ulang Qdi awal program dengan mendekatinya dari kanan? Ini memiliki bonus tambahan bahwa IP langsung berjalan ke kutipan yang menyandikan baris ketiga.

Inilah versi bersih untuk langkah ini. Instruksi yang tidak relevan telah digantikan oleh no-ops lagi, no-ops yang dijalankan telah digantikan oleh tagar ( #) untuk tujuan ilustrasi dan IP dimulai pada karakter terakhir pada baris keempat.

    . .
    . .
Q u $ . . . . .
. . w \ . . / .
    . #
    . #

IP berakhir pada baris ketiga pada instruksi pertama, akan membungkus ke ujung garis itu karena menunjuk ke barat. Instruksi berikut (tidak termasuk aliran kontrol) dieksekusi:

$uQ
$u  # Don't do anthing
  Q # Push the double quote

Kutipan ganda ini mewakili yang ada di akhir baris ketiga.

Langkah 4: Pengkodean baris ketiga

Ini berfungsi persis sama dengan langkah 2, jadi silakan lihat di sana untuk penjelasan.

Langkah 5: Cetak tumpukan

Tumpukan sekarang berisi baris keempat dan ketiga, dalam urutan terbalik, jadi yang perlu kita lakukan sekarang adalah mencetaknya. IP dimulai pada instruksi kedua dari belakang pada baris ketiga, bergerak ke barat. Inilah bagian yang relevan dari kubus (sekali lagi, bagian yang tidak relevan telah digantikan oleh no-ops).

    . .
    . .
. . . v @ ! < .
. . . \ o ; / .
    . .
    . .

Ini adalah loop, seperti yang mungkin Anda lihat / harapkan. Tubuh utama adalah:

o;
o  # Print top of stack as character
 ; # Delete top of stack

Loop berakhir jika item teratas adalah 0, yang hanya terjadi ketika tumpukan kosong. Jika loop berakhir, @dieksekusi, mengakhiri program.

Luke
sumber
Seandainya aku bisa lebih memilih ini
MickyT
Hadiah selalu diterima ;-)
Luke
42

Javascript ES6 - 21 byte

$=_=>`$=${$};$()`;$()

Saya menyebut quine ini "The Bling Quine."

Terkadang, Anda harus bermain golf dengan gaya.

Mama Fun Roll
sumber
Apakah !$=_=>`!$=${$}()`()Anda menghemat 2 byte?
Downgoat
Invalid assignment left hand side. Semoga berhasil :(
Mama Fun Roll
1
@ TùxCräftîñg menghilangkan tanda kurung di sekitar liter templat hanya bekerja pada fungsi prototipe asli, seperti Array.prototype.join.
Mama Fun Roll
2
Hmm, tidak yakin. Saya menulis ini lebih dari setahun yang lalu (itu dianggap sah), dan saya belum mengikuti perubahan aturan quine terlalu dekat. Namun, menambahkan alertatau console.logsetelah fungsi panah dan membungkus string template dalam tanda kurung akan berhasil.
Mama Fun Roll
3
Juga jika Anda menjalankan ini di konsol, itu menimpa $ (fungsi jQuery) di situs ini, dan fungsi upvote tidak akan berfungsi lagi. :)
Steven Palinkas
41

Brainf * ck (755 karakter)

Ini didasarkan dari teknik yang dikembangkan oleh Erik Bosman (ejbosman di cs.vu.nl). Perhatikan bahwa "ESineine Quine!" teks sebenarnya diperlukan untuk menjadi quine!

->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
ESultanik
sumber
13
Itu cara yang cerdas untuk melakukannya.
Peter Olson
13
Bagaimana cara kerjanya?
haskeller bangga
3
@proudhaskeller IIRC, bagian sebelum ESultanik's Quine!mengatur memori sebagai stack encoding ESultanik's Quine!dan seterusnya, dengan dua byte memori untuk setiap karakter (nilai ASCII offset dari 0x1F). Bit kode terakhir melewati memori, pertama secara pemrograman mereproduksi ++>+++…kode untuk setiap karakter, kemudian benar-benar mencetak karakter.
ESultanik
4
@CatsAreFluffy Mereka diharuskan menjadi quine! Meskipun benar bahwa mereka dapat dihapus, kita juga harus mengubah kode sebelumnya untuk mempertahankan properti quine.
ESultanik
1
Itu benar. Juga baris baru diperlukan.
CalculatorFeline
36

Hexagony , panjang sisi 15 14 13 12, 616 533 456 383 byte

Setelah beberapa hari bermain golf dengan hati-hati, mengatur ulang putaran dan memulai lagi, akhirnya saya berhasil menurunkannya ke segi 12 segi enam.

1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>

Cobalah online!

Dibuka:

            1 8 4 5 7 1 1 7 2 4 0 0
           4 9 9 4 0 1 7 6 6 0 7 4 5
          3 2 4 8 0 0 7 8 3 5 4 2 8 1
         0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
        3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
       6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
      5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
     8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
    3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
   5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
  9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
           ! ' < . \ = 6 , ' / > . .
            . . . . . . . . . . . .

Meskipun tidak terlihat seperti kode Hexagony yang paling golf, jenis pengkodean yang saya gunakan dioptimalkan untuk menjalankan no-ops yang lebih lama, yang merupakan sesuatu yang seharusnya Anda hindari.

Penjelasan

Ini mengalahkan jawaban Hexagony sebelumnya dengan menyandikan no-ops ( .) dengan cara yang berbeda. Sementara jawaban itu menghemat ruang dengan membuat setiap karakter lainnya menjadi ., saya akan menyandikan nomornya no-op. Ini juga berarti sumbernya tidak harus dibatasi.

Di sini saya menggunakan pengkodean basis 80, di mana angka-angka di bawah 16 menunjukkan berjalannya no-ops, dan angka antara 16 dan 79 mewakili kisaran 32 ( !) hingga 95 ( _) (Saya baru saja menyadari bahwa saya bermain golf semua _keluar dari saya kode lol). Beberapa pseudocode Pythonic:

i = absurdly long number
print(i)
base = 80
n = i%base
while n:
    if n < 16:
        print("."*(16-n))
    else:
        print(ASCII(n+16))
    i = i//base
    n = i%base

Jumlahnya dikodekan di paruh pertama segi enam, dengan semua 

" " > 
 " " > 
  ... etc

di sisi kiri dan

 > ,
< "
 >
< "
... etc

di sisi kanan mengarahkan pointer untuk mengkodekan angka menjadi satu sel. Ini diambil dari jawaban Martin Ender (terima kasih), karena saya tidak tahu cara yang lebih efisien.

Kemudian memasuki bagian bawah melalui ->:

       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
     ->    ! ' < . \ = 6 , ' / > . .

!mencetak nomor dan 'menavigasi ke sel memori kanan sebelum memulai loop. P='%mods angka sekarang dengan 80. Jika hasilnya 0, naik ke terminating @, lain turun dan buat sel di sebelah hasil mod dengan nilainya -16.

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
                      /
                     /

Setel sel ke (nilai mod + -16). Jika nilai itu negatif, naik di percabangan>+'\ , jika tidak turun.

Jika nilainya positif:

 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .

Pointer berakhir di ;-< yang mengatur sel ke (nilai mod - -16) dan mencetaknya.

Nilai negatif:

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .

Turun ke > ) <bagian yang memulai loop. Ini dia terisolasi:

     . . > ) < $ = < . .
      . . . . . . . . .
       \ ' Q 4 ; = " /

Yang mengeksekusi kode 'Q4;="=yang mencetak a .(terima kasih lagi kepada Martin Ender, yang menulis sebuah program untuk menemukan kombinasi angka-huruf untuk karakter) dan bergerak kembali ke sel awal. Ia kemudian menambahkan ( )) sel nilai mod dan loop lagi, sampai nilai mod positif.

Ketika itu selesai, ia bergerak ke atas dan bergabung dengan bagian lain di:

 " " > . / < $ ; - < . . .
            \
             \

Pointer kemudian bergerak kembali ke awal loop yang lebih besar lagi

 " " > . / <--
  . . . = =
   . " " > ' 
    . . . = = 
     . " " > :
      . . . . .
       " " > \ ' . .
        . . . . . . .
         . . " " > P = ' % < . > . . .

Ini dijalankan ='=:'yang membagi angka saat ini dengan 80 dan menavigasi ke sel yang benar.

Versi lama (Panjang sisi 13)

343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""

Cobalah online!

Saya pasti bisa bermain golf di sisi lain, tetapi saya harus meninggalkannya sampai besok karena sudah larut. Ternyata saya tidak sabar dan tidak bisa menunggu sampai besok. Mungkin sisi lain bisa bermain golf? :( ahhhhhhhhh aku berhasil!

Saya bahkan bermain golf beberapa digit tambahan dengan basis pengkodean 77, tetapi tidak terlalu penting, karena memiliki bytecount yang sama.

Jo King
sumber
13
Ini luar biasa. Gagasan untuk encoding run-length hybrid ini sangat rapi. :) Ingatkan saya untuk memberi Anda hadiah jika saya lupa.
Martin Ender
35

PostScript, 20 karakter

Singkat dan sah. 20 karakter termasuk mengikuti baris baru.

(dup == =)
dup == =
KirarinSnow
sumber
33

Cubix , 45 byte

.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"

Anda dapat menguji kode ini di sini .

Program ini cukup sulit untuk diikuti, tetapi untuk memiliki kesempatan untuk melakukannya, kita perlu mulai dengan mengembangkannya menjadi sebuah kubus, seperti yang dilakukan oleh juru bahasa Cubix:

      . . .
      . . >
      . . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
      . . .
      . . .
      . . .

Ini adalah quine gaya Befunge, yang bekerja dengan mengeksploitasi pembungkus untuk membuat string literal "membungkus" kode yang dapat dieksekusi (dengan hanya satu " tanda, kode tersebut ada di dalam dan di luar kutipan pada saat yang sama, sesuatu yang menjadi mungkin ketika Anda memiliki program yang nonlinier dan nonplanar). Perhatikan bahwa ini sesuai dengan definisi kami tentang quine yang tepat, karena dua dari tanda kutip ganda tidak mengkodekan diri mereka sendiri, melainkan dihitung kemudian melalui penggunaan aritmatika.

Tidak seperti Befunge, kami menggunakan empat string di sini, bukan satu. Inilah cara mereka didorong ke tumpukan;

  1. Program dimulai di bagian atas tepi kiri, ke kanan; belok kanan dua kali ( R), menjadikannya ke kiri di sepanjang garis ketiga dan terakhir yang membungkus seluruh kubus. Kutipan ganda cocok dengan dirinya sendiri, jadi kami mendorong seluruh baris ketiga ke tumpukan ke belakang. Kemudian eksekusi berlanjut setelah penawaran ganda.

  2. The uperintah melakukan U-turn ke kanan, sehingga hal berikutnya kita menjalankan adalah dari '"seterusnya pada garis tengah. Itu mendorong a "ke stack. Melanjutkan untuk membungkus, kami memukul <dekat sisi kiri kubus dan bangkit kembali. Ketika mendekati dari arah ini, kita melihat "perintah sederhana , tidak '", sehingga seluruh baris kedua didorong ke tumpukan di atas baris ketiga dan kutipan ganda.

  3. Kita mulai dengan mendorong !ke stack ( '!) dan menambahkannya ( )); ini menghasilkan kuotasi ganda tanpa memerlukan kuotasi ganda dalam kode sumber kami (yang akan mengakhiri string). Cermin ( \) mencerminkan arah eksekusi ke utara; lalu Wperintah tersebut bergerak ke kiri. Ini membuat kita naik ke atas pada kolom ketujuh, yang karena ini adalah sebuah kubus, membungkus ke kiri pada baris ketiga, lalu ke bawah pada kolom ketiga. Kami menekan R, untuk berbelok ke kanan dan ke kiri di sepanjang baris atas; lalu $lompati Rmelalui tempat kita memasuki program, jadi eksekusi membungkus "di akhir baris, dan kita menangkap baris pertama dalam sebuah string dengan cara yang sama seperti yang kita lakukan untuk yang kedua dan ketiga.

  4. The ^perintah mengirim kami ke utara sampai kolom kesebelas, yang (memungkinkan untuk kubus pembungkus) ke selatan di kelima. Satu-satunya hal yang kita temui di sana adalah !(lewati jika bukan nol; bagian atas tumpukan memang bukan nol), yang melompati operintah, secara efektif membuat kolom kelima sepenuhnya kosong. Jadi kita membungkus kembali ke uperintah, yang sekali lagi berbalik, tetapi kali ini kita tinggal di kolom terakhir ke selatan, yang membungkus ke kolom keempat ke utara. Namun, kami menekan kuotasi ganda selama belokan U, jadi kami menangkap seluruh kolom keempat dalam sebuah string, dari bawah ke atas. Tidak seperti kebanyakan tanda kutip ganda dalam program, yang ini tidak menutup sendiri; alih-alih, ditutup oleh "sudut kanan atas, artinya kita menangkap string sembilan karakter ...>......

Jadi tata letak tumpukan sekarang, dari atas ke bawah: kolom keempat; baris teratas; "; baris tengah; "; baris bawah. Masing-masing diwakili pada tumpukan dengan karakter pertama terdekat bagian atas tumpukan (Cubix mendorong string di balik urutan ini, seperti yang dilakukan Befunge, tetapi setiap kali IP bergerak dalam arah yang berlawanan dengan arah membaca alami, jadi itu efektif terbalik dua kali). Dapat dicatat bahwa isi tumpukan hampir identik dengan program asli (karena kolom keempat, dan bagian utara / atas kubus, berisi karakter yang sama dalam urutan yang sama; jelas, itu dirancang seperti itu dengan sengaja).

Langkah selanjutnya adalah mencetak isi tumpukan. Setelah semua dorongan, IP mengarah ke utara pada kolom keempat, sehingga menyentuh di >sana dan memasuki lingkaran ketat >>o;?(yaitu "belok timur, belok timur, keluaran sebagai karakter, pop, belok kanan jika positif"). Karena baris ketujuh penuh dengan NOP, maka ?akan dibungkus kembali ke yang pertama >, jadi ini secara efektif mendorong seluruh isi tumpukan ( ?adalah no-op pada tumpukan kosong). Kami hampir mencetak seluruh program! Sayangnya, itu belum selesai; kami kehilangan penawaran ganda di bagian akhir.

Setelah loop berakhir, kita merefleksikan ke garis tengah, bergerak ke barat, melalui sepasang cermin. (Kami menggunakan "sisi lain" \cermin sebelumnya; sekarang kami menggunakan sisi barat daya. /Cermin belum pernah digunakan sebelumnya.) Kami bertemu '!, jadi kami menekan tanda seru (yaitu 33; kami menggunakan ASCII dan Cubix tidak membedakan antara integer dan karakter) ke stack. (Mudahnya, ini sama dengan !yang digunakan untuk melewati operintah sebelumnya.) Kami menemukan sepasang Rperintah dan menggunakannya untuk membuat putaran U "manual" ( Rperintah kedua di sini digunakan sebelumnya untuk mencapai yang pertama baris, jadi sepertinya paling alami untuk mencocokkan Rperintah lain di sampingnya.Wperintah, untuk menghindar ke kiri. Langkah samping menabrak tepat ke >perintah pada baris kedua, memantul eksekusi kembali tepat di tempat itu. Jadi kita melangkah ke kiri lagi, tapi kali ini kita akan ke selatan, jadi perintah berikutnya untuk mengeksekusi adalah )(menambahkan tanda seru menjadi tanda kutip ganda), diikuti oleh o(untuk menampilkannya). Akhirnya, eksekusi membungkus sepanjang baris kedelapan ke kolom kedua, di mana ia menemukan a @untuk keluar dari program.

Saya minta maaf untuk apostrof nyasar di baris ketiga. Itu tidak melakukan apa pun dalam versi program ini; itu adalah bagian dari ide sebelumnya yang saya miliki tetapi ternyata tidak perlu. Namun, begitu saya mendapatkan quine yang berfungsi, saya hanya ingin mengirimkannya daripada mengacaukannya lebih jauh, terutama karena menghapusnya tidak akan mengubah jumlah byte. Mengenai masalah golf di quine ini lebih lanjut, tidak akan mengejutkan saya jika ini mungkin pada 3 × 3 dengan hanya menggunakan lima baris pertama, tapi saya tidak bisa melihat cara yang jelas untuk melakukan itu, dan itu perlu bahkan pengemasan yang lebih ketat dari semua aliran kontrol bersama-sama dengan beberapa cara lain untuk mewakili permukaan atas kubus (atau memodifikasi algoritma sehingga dapat terus menggunakan kolom keempat meskipun sekarang akan panjangnya sepuluh atau sebelas karakter) .


sumber
Kerja bagus, ini skor yang sangat mengesankan. Saya suka bagaimana Anda menyandikan wajah bagian atas. :)
Martin Ender
Ini luar biasa! Jika itu akan membantu, cara lain untuk mendorong "adalah Q.
ETHproductions
1
Wow! Saya tidak pernah meskipun saya akan melihat quine cubix!
FlipTack
3
Saya tidak punya waktu untuk membaca penjelasannya kemarin, tetapi sekarang saya sudah ... Hanya ... WOW. Saya tidak percaya berapa banyak karakter yang digunakan untuk dua atau bahkan tiga tujuan yang sangat berbeda. Ini mungkin program Cubix paling keren yang pernah saya lihat.
Produksi ETH
Penjelasan yang bagus.
Robert Fraser
33

Python 2, 30 byte

_='_=%r;print _%%_';print _%_

Diambil dari sini

hallvabo
sumber
1
+1, Anda mengalahkan solusi serupa saya jadi saya menghapusnya. Perlu dicatat bahwa ini hanya berfungsi dalam Python 2.
nyuszika7h
2
Ini terlihat aneh dengan nama variabel _, tetapi lebih baik dibaca jika Anda menugaskannya ke huruf apa pun, yaitu s:s='s=%r;print s%%s';print s%s
Ehtesh Choudhury
5
Jika solusi ini bukan ciptaan Anda sendiri, Anda harus menjadikannya Wiki Komunitas. Juga, tautannya sudah mati.
mbomb007
1
Saya agak terlambat ke pesta, tetapi bisakah seseorang menjelaskan cara kerjanya?
MadTux
9
Ini membutuhkan linefeed tambahan agar valid. Karena itu, kode sumber tidak cocok dengan output.
Dennis
32

Vim, 17 , 14 penekanan tombol

Seseorang secara acak meng-upgrade ini, jadi saya ingat itu ada. Ketika saya membacanya kembali, saya berpikir "Hei, saya bisa melakukan yang lebih baik dari itu!", Jadi saya bermain golf dua byte. Ini masih bukan yang terpendek, tapi setidaknya ini perbaikan.

Untuk waktu yang lama, saya bertanya-tanya apakah vim quine dimungkinkan. Di satu sisi, itu harus dimungkinkan, karena vim sudah selesai. Tetapi setelah mencari vim quine untuk waktu yang sangat lama, saya tidak dapat menemukannya. saya memang menemukan tantangan PPCG ini , tetapi itu tertutup dan tidak persis tentang quina literal. Jadi saya memutuskan untuk membuatnya, karena saya tidak dapat menemukannya.

Saya sangat bangga dengan jawaban ini, karena dua pertama :

  1. Ini adalah quine pertama yang pernah saya buat, dan

  2. Sejauh yang saya tahu, ini adalah vim-quine pertama di dunia pernah diterbitkan! Saya bisa salah tentang ini, jadi jika Anda mengetahuinya, beri tahu saya.

Jadi, setelah perkenalan yang panjang itu, ini dia:

qqX"qpAq@q<esc>q@q

Cobalah online!

Perhatikan bahwa ketika Anda mengetik ini, itu akan menampilkan <esc>keystroke sebagai ^[. Ini masih akurat, karena ^[mewakili 0x1B, yang lolos di ASCII , dan cara vim secara internal mewakili <esc>kuncinya.

Perhatikan juga , bahwa pengujian ini mungkin gagal jika Anda memuat sesi vim yang ada. Saya menulis sebuah tip jawaban yang menjelaskan bahwa di sini , jika Anda menginginkan informasi lebih lanjut, tetapi pada dasarnya Anda perlu meluncurkan vim with

vim -u NONE -N -i NONE

atau ketik qqqsebelum menjalankan ini.

Penjelasan:

qq                  " Start recording into register 'q'
  X                 " Delete one character before the cursor (Once we play this back, it will delete the '@')
   "qp              " Paste register 'q'
      Aq@q<esc>     " Append 'q@q' to this line
               q    " Stop recording
                @q  " Playback register 'q'

Di samping catatan, jawaban ini mungkin merupakan rekor dunia untuk sebagian besar 'q's dalam jawaban PPCG, atau sesuatu.

DJMcMayhem
sumber
1
2i2i<esc>sangat dekat. Saya merasa harus ada sesuatu yang bisa saya lakukan untuk membuat ini bekerja.
Zwei
@ zwei aku tahu, sudah dekat rasanya sakit! Sebenarnya, <Esc>tersirat dalam V, sehingga berfungsi . Sayangnya itu juga menambahkan baris baru, itulah sebabnya saya belum mempostingnya.
DJMcMayhem
q"iq"qbP<Esc>qbPadalah 11. Setelah Anda menempatkan ini di reddit , saya menyelidiki pelanggaran di sini dan memutuskan untuk membuat akun. Ini adalah jawaban yang saya posting di sana.
udioica
2
@udioica Bisakah Anda mengeposkannya sebagai jawaban?
DJMcMayhem
28

Hilang , 120 116 98 96 76 70 66 byte

Edit: yay, di bawah 100

Sunting: Menyimpan banyak byte dengan beralih ke semua yang ada /di baris terbawah

:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////

Cobalah online! + verifikasi itu deterministik untuk semua kemungkinan keadaan

Lost adalah bahasa 2D di mana posisi awal dan arahnya sepenuhnya acak. Ini berarti harus ada banyak pengecekan kesalahan pada setiap tahap untuk memastikan Anda mendapat penunjuk instruksi yang benar, dan itu bukan salah satu yang baru saja berkeliaran secara acak.

Penjelasan:

Semua /s pada baris bawah ada untuk memastikan bahwa semua pointer yang bertelur dalam arah vertikal atau pada garis bawah disalurkan ke arah yang benar. Dari sana, mereka berakhir di beberapa tempat yang berbeda, tetapi semuanya berakhir tepat di

 ^%?>
 ////

Yang menghapus semua angka bukan nol dalam tumpukan. The ([setelah itu membersihkan apapun 0s ekstra juga.

Di tengah-tengah jelas, itu hits %, yang mematikan 'keselamatan', yang memungkinkan program untuk berakhir ketika hits @(tanpa ini, program bisa berakhir segera jika pointer dimulai di@ ).

Dari sana ia melakukan quine bahasa 2D yang cukup sederhana, dengan membungkus string literal ( ") di sekitar baris pertama, mendorong "karakter dengan menduplikasi spasi ( :2+) dan kemudian baris baru ( 52*). Untuk baris kedua, ia menciptakan /karakter ( 95*2+) dan menduplikatnya banyak ( >::1?:[:[[[[), sebelum akhirnya berakhir di @dan mencetak tumpukan secara implisit. The ?1adalah untuk menghentikan proses dari menciptakan terlalu banyak 0s jika pointer memasuki awal, menghemat harus membersihkan mereka nanti.

Saya menyimpan 20 byte di sini dengan membuat baris terakhir semua karakter yang sama, yang berarti saya bisa langsung dari proses duping ke akhir @.

Penjelasan tentang proses pembodohan:

[adalah karakter yang dikenal sebagai 'Pintu'. Jika pointer menyentuh sisi datar dari [atau ], itu mencerminkan, kalau tidak melewatinya. Setiap kali pointer berinteraksi dengan Pintu, itu beralih ke tipe yang berlawanan. Dengan menggunakan pengetahuan ini kita dapat membuat formula sederhana untuk berapa kali suatu instruksi akan dieksekusi dalam sebuah >:[blok.

Tambahkan jumlah instruksi awal. Untuk masing-masing [, tambahkan 2 kali jumlah instruksi di sebelah kiri itu. Sebagai contoh >::::[:[[[, kita mulai dengan 5 sebagai jumlah awal. Pintu pertama memiliki 4 instruksi dupe, jadi kami menambahkan 4 * 2 = 8 hingga 5 untuk mendapatkan 13. Tiga Pintu lainnya memiliki 5 dupes di sebelah kiri mereka, jadi kami menambahkan 3 * (5 * 2) = 30 hingga 13 untuk mendapatkan 43 instruksi dupe dieksekusi, dan ada 44 >s pada stack. Proses yang sama dapat diterapkan pada instruksi lain, seperti( mendorong sejumlah besar item dari stack ke cakupan, atau seperti yang digunakan di sini, untuk menghapus item dari stack.

Trik yang saya gunakan di sini untuk menghindari pembodohan terlalu banyak adalah 1?. Jika karakternya adalah 0, ?itu tidak melewatkan angka 1, yang berarti itu menduplikasi 1 untuk sisa dupe. Ini membuatnya lebih mudah untuk menghapus tumpukan nanti.

Jo King
sumber
25

Ini adalah dua quine Ruby terpendek dari SO :

_="_=%p;puts _%%_";puts _%_

dan

puts <<2*2,2
puts <<2*2,2
2

Jangan tanya saya bagaimana yang kedua bekerja ...

Nakilon
sumber
8
Yang kedua menggunakan heredoc, <<2memulai string pada baris berikutnya, dan *2mengulangi string
Ming-Tang
Mengapa Anda membutuhkan 2?
CalculatorFeline
1
@CalculatorFeline Ini adalah terminator dari string heredoc (yang harus muncul pada barisnya sendiri). Sebenarnya tidak harus berupa 2: tio.run/##KypNqvz/v6C0pFjBxsZAy0jHgAuFY8D1/z8A
Martin Ender
25

Fission , 6 byte

Tampaknya ini sekarang quine terpendek "tepat" di antara jawaban-jawaban ini. 

'!+OR"

Penjelasan

Aliran kendali dimulai Rdengan satu (1,0)atom yang benar. Ini menyentuh "mode cetak toggling dan kemudian membungkus garis, mencetak '!+ORsebelum memukul yang sama "lagi dan keluar dari mode cetak.

Itu meninggalkan "dirinya untuk dicetak. Cara terpendek adalah '"O(di mana '"mengatur massa atom ke kode karakter "dan Omencetak karakter dan menghancurkan atom), tetapi jika kita melakukan ini "akan mengganggu mode cetak. Jadi alih-alih, kami menetapkan nilai atom ke '!(satu kurang dari "), lalu menambahkan +dan kemudian mencetak hasilnya dengan O.

Alternatif

Berikut adalah beberapa alternatif, yang lebih panjang, tetapi mungkin teknik mereka menginspirasi seseorang untuk menemukan versi yang lebih pendek menggunakannya (atau mungkin mereka akan lebih berguna dalam quines umum tertentu).

8 byte menggunakan Jump

' |R@JO"

Sekali lagi, kode dimulai pada R. The @swap massa dan energi untuk memberikan (0,1). Oleh karena itu Jmembuat atom melompati Olurus ke atas ". Kemudian, seperti sebelumnya, semua kecuali "dicetak dalam mode string. Setelah itu, atom menyentuh |untuk membalikkan arahnya, dan kemudian melewati '"Opencetakan ". Ruang agak mengganggu, tetapi tampaknya perlu, karena kalau tidak, 'akan membuat atom memperlakukan |sebagai karakter, bukan cermin.

8 byte menggunakan dua atom

"'L;R@JO

Ini memiliki dua atom, mulai dari kiri ke Lkanan dan ke kanan dari R. Atom yang tertinggal akan mendapatkan nilainya '"yang kemudian dicetak dengan O(dan atomnya dihancurkan). Untuk atom yang tepat, kita menukar massa dan energi lagi, melompati Ountuk mencetak sisa kode dalam mode cetak. Setelah itu nilainya ditentukan oleh 'Ltetapi itu tidak masalah karena atom kemudian dibuang ;.

Martin Ender
sumber
Secara teknis tidak valid karena kurangnya kode / pemisahan data dalam sumber.
CalculatorFeline
4
@CalculatorFeline '!+mengkodekan ".
Martin Ender
Saya tidak terbiasa dengan Fission, tetapi apakah akan |R@JO"'berhasil, atau apakah Anda masih membutuhkan ruang setelah itu '?
MildlyMilquetoast
1
@MistahFiggins Saya rasa begitu, tetapi yang lebih penting Anda akan mencetak yang 'pertama.
Martin Ender
24

JavaScript lintas-browser (41 karakter)

Ini bekerja di 5 browser web teratas (IE> = 8, Mozilla Firefox, Google Chrome, Safari, Opera). Masukkan ke dalam konsol pengembang di salah satu di antaranya:

eval(I="'eval(I='+JSON.stringify(I)+')'")

Ini bukan "curang" - tidak seperti quine byte tunggal Chris Jester-Young, karena dapat dengan mudah dimodifikasi untuk menggunakan alert() fungsi (biaya 14 karakter):

alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))

Atau dikonversi ke bookmarklet (seharga 22 karakter):

javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
Tolong berdiri
sumber
24

C, 64 60 byte

main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}

Sejauh ini, ini adalah C Cine terpendek yang dikenal. Ada karunia yang diperluas jika Anda menemukan yang lebih pendek.

Ini berfungsi di GCC , Dentang , dan TCC dalam POSIX lingkungan . Ini memunculkan perilaku berlebihan yang tidak terdefinisi dengan mereka semua.

Hanya untuk bersenang-senang, inilah repo yang berisi semua pertanyaan C yang saya tahu. Silakan garpu / PR jika Anda menemukan atau menulis yang berbeda yang menambahkan sesuatu yang baru dan kreatif dari yang sudah ada.

Perhatikan bahwa ini hanya berfungsi di lingkungan ASCII . Ini berfungsi untuk EBCDIC , tetapi masih membutuhkan POSIX . Selamat mencoba menemukan lingkungan POSIX / EBCDIC: P

Bagaimana itu bekerja:

  1. main(s)mainargumen penyalahgunaan , mendeklarasikan variabel yang sebenarnya tidak diketik s. (Catatan yang ssebenarnya bukan yang tidak diketik, tetapi karena kompiler yang terdaftar secara otomatis meng-cast-nya seperlunya, mungkin juga *.)
  2. printf(s="..."set ske string yang disediakan dan meneruskan argumen pertama ke printf.
  3. sdiatur ke main(s){printf(s=%c%s%1$c,34,s);}.
  4. The %cdiatur ke ASCII 34, ". Ini memungkinkan quine. Sekarang sterlihat seperti ini:
    main(s){printf(s="%s%1$c,34,s);} .
  5. Ini %sdiatur ke sdirinya sendiri, yang dimungkinkan karena # 2. Sekarang sterlihat seperti ini:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}.
  6. Ini %1$cdiatur ke ASCII 34 ", printfargumen ** pertama. Sekarang sterlihat seperti ini:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
    ... yang kebetulan merupakan kode sumber asli.

* Contoh berkat @Pavel ** argumen pertama setelah penentu
format - dalam hal ini s,. Tidak mungkin untuk merujuk penspesifikasi format.

Saya pikir tidak mungkin ini akan menjadi lebih pendek dengan pendekatan yang sama. Jika printfspecifier format dapat diakses melalui $, ini akan bekerja selama 52 byte:

main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
MD XF
sumber
Meskipun tentu saja tidak boleh dianggap sebagai bersaing, pemenang "Penyalahgunaan aturan terburuk" dari Kontes Kode C 1994 International Obfuscated, 1994_smr.c , jelas lebih pendek.
Ray
@ Ray Ini tidak diizinkan. Ini bukan quine yang tepat menurut definisi apa pun. Aturan quien diubah karena program itu: P
MD XF
Saya setuju sepenuhnya, tetapi ini adalah retasan yang cukup menarik sehingga perlu disebutkan kapan saja seseorang menyebut quine terkecil yang diketahui, jika hanya karena alasan historis.
Ray
4
sbertipe int, bukan "variabel yang tidak diketik".
feersum
2
Semua kompiler ini tampaknya memungkinkan konversi implisit pointer ke int. s=3jelas tidak akan berfungsi karena Anda harus meneruskan string dua kali printf.
feersum
24

Java, 528 byte:

Solusi Java dengan pendekatan asli:

import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}

dalam bentuk yang mudah dibaca:

import java.math.*;
class a
{
    public static void main (String [] a)
    {
        BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36); 
        int i=0; 
        for (byte c:b.toByteArray ())
        {
            if (++i==92) 
                System.out.print (b.toString (36)); 
            System.out.print ((char) c);
        }
    }
}
Pengguna tidak diketahui
sumber
Bagaimana cara kerjanya?
Loovjo
1
@Loovjo: Mirip dengan solusi lain yang memotong kode menjadi dua bagian dan menyisipkan seluruh String yang merepresentasikan kode di dalamnya lagi, tetapi seluruh kode tidak hanya String tetapi dikodekan sebagai nomor panjang di base 36 (26 karakter alfabet + 10 digit).
pengguna tidak diketahui
1
Ini bisa dipersingkat jika Anda menempatkan if(++i==92),
tuskiomi
2
@tuskiomi: Terima kasih, disingkat menjadi dua karakter
pengguna tidak diketahui
1
@userunknown Sebenarnya, a*karena array tidak keluar di Jawa, itu C. Beberapa bagian lain untuk golf :, di import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("abc",36);int i=0;for(int c:b.toByteArray())System.out.printf("%s%c",++i==92?b.toString(36):"",c);}}manaabc akan menjadi String nomor ajaib yang baru dihitung. Di java 8+ juga dimungkinkan untuk berubah class a{public static void mainmenjadi interface a{static void main, dan di Java 10+ juga dimungkinkan untuk berubah import java.math.*;dan BigInteger b=new BigInteger(ke var b=new java.math.BigInteger(.
Kevin Cruijssen
23

Ayam , 7

chicken

Tidak, ini tidak langsung digaungkan :)

Timtech
sumber
Sialan, Anda mengalahkan saya untuk itu :)
Taconut
Itu tidak digaungkan, itu adalah string chicken!
Erik the Outgolfer
Tidak ada pemisahan kode / data, dan karenanya tidak valid.
CalculatorFeline
10
@CalculatorFeline Apakah Anda membaca peraturan?
Timtech
1
@JoKing Saya rasa ini tidak valid, karena aturan tantangannya hanya melarang panjang nol dan menyontek (membaca file sumber Anda sendiri). Satu-satunya hal yang melarang quines yang tidak patut adalah celah standar - kecuali celah standar umumnya tidak dianggap berlaku untuk jawaban yang ada sebelumnya.
pppery
23

Retina , 20 14 9 7 byte

Sebelum kita mulai, saya ingin menyebutkan solusi sepele dari file yang berisi satu 0. Dalam hal ini Retina akan mencoba menghitung 0s pada input kosong, yang hasilnya juga 0. Saya tidak akan menganggap itu quine yang tepat.

Jadi ini yang benar:

>\`
>\`

Cobalah online!

Atau, kita bisa menggunakan ; bukan >.

Penjelasan

Program ini terdiri dari penggantian tunggal yang kami cetak dua kali.

Di baris pertama, ` memisahkan konfigurasi dari regex, sehingga regex kosong. Oleh karena itu string kosong (yaitu input yang tidak ada) diganti dengan baris kedua, kata demi kata.

Untuk mencetak hasilnya dua kali, kami membungkusnya dalam dua tahap output. Yang dalam, \mencetak hasilnya dengan linefeed jejak, dan yang luar,> ,, mencetak tanpa satu.

Jika Anda agak terbiasa dengan Retina, Anda mungkin bertanya-tanya apa yang terjadi pada output implisit Retina. Keluaran implisit Retina bekerja dengan membungkus tahap akhir suatu program dalam tahap keluaran. Namun, Retina tidak melakukan ini, jika tahap akhir sudah merupakan tahap keluaran. Alasan untuk itu adalah bahwa dalam program normal lebih bermanfaat untuk dapat mengganti tahap keluaran implisit dengan yang khusus seperti \atau ;untuk satu byte (daripada harus menyingkirkan yang implisit dengan .bendera juga). Sayangnya, perilaku ini akhirnya menghabiskan biaya dua byte untuk quine.

Martin Ender
sumber
20

Javascript (36 karakter)

(function a(){alert("("+a+")()")})()

Ini, AFAICT, quine javascript terpendek yang diposting sejauh ini.

Peter Olson
sumber
1
Itu ... sangat mengesankan. Anda harus menjelaskan cara kerjanya untuk saya 8- |
TehShrike
3
Petunjuk @TehShrike: Anda dapat melihat konten suatu fungsi dengan memaksa ke string. Misalnya, jika Anda memiliki fungsi a, Anda dapat mengakses isinya dengan menelepon a.toString.
Peter Olson
7
Untuk menjadi bertele-tele, meskipun, ini hanya quine jika implementasi JavaScript Anda mengubah fungsi apersis sama seperti yang telah ditulis di atas. Namun, output dari kode ini cenderung menjadi quine pada implementasi JavaScript apa pun.
Ilmari Karonen
1
Berikut adalah Quine sama, 1 byte pendek: !function a(){alert("!"+a+"()")}().
Ismael Miguel
1
(a=()=>alert(($ {a})))()
Dennis C
19

GolfScript, 8 byte

Saya selalu berpikir quine GolfScript terpendek (benar) adalah 9 byte:

{'.~'}.~

Di mana trafeed linefeed diperlukan karena GolfScript mencetak linefeed trailing secara default.

Tapi saya baru saja menemukan quine 8-byte, yang bekerja persis di sekitar batasan linefeed:

":n`":n`

Cobalah online!

Jadi tangkapannya adalah bahwa GolfScript tidak mencetak linefeed baris, tetapi mencetak isi ndi akhir program. Hanya saja, nberisi linefeed untuk memulai. Jadi idenya adalah untuk menggantinya dengan string ":n`", dan kemudian menggantinya , sehingga salinan pada tumpukan dicetak dengan tanda kutip dan salinan disimpan dalam ncetakan tanpa.

Seperti yang ditunjukkan oleh Thomas Kwa, 7-byte CJam quine juga dapat disesuaikan dengan solusi 8-byte:

".p"
.p

Sekali lagi, kita perlu linefeed tambahan.

Martin Ender
sumber
6
Golfscript aneh.
CalculatorFeline
19

Labyrinth , 124 110 53 byte

Berkat Sp3000 untuk bermain golf 9 byte, yang memungkinkan saya untuk bermain golf 7 byte lainnya.

44660535853919556129637653276602333!
1
:_98
/8 %
@9_.

Cobalah online!

Penjelasan

Labirin 101:

  • Labyrinth adalah bahasa 2D berbasis stack. Tumpukan tidak berdasar dan diisi dengan nol, sehingga muncul dari tumpukan kosong bukanlah kesalahan.
  • Eksekusi dimulai dari karakter valid pertama (di sini kiri atas). Di setiap persimpangan, di mana ada dua atau lebih jalur yang mungkin untuk mengambil penunjuk instruksi (IP), bagian atas tumpukan diperiksa untuk menentukan ke mana harus pergi berikutnya. Negatif belok kiri, nol maju dan positif belok kanan.
  • Digit dalam kode sumber tidak mendorong nomor yang sesuai - sebaliknya, mereka mengeluarkan bagian atas tumpukan dan mendorong n*10 + <digit>. Ini memungkinkan penumpukan yang mudah dalam jumlah besar. Untuk memulai nomor baru, gunakan _, yang mendorong nol.
  • " adalah no-ops.

Pertama, saya akan menjelaskan versi yang sedikit lebih sederhana yaitu satu byte lebih lama, tetapi sedikit kurang magis:

395852936437949826992796242020587432!
"
:_96
/6 %
@9_.

Cobalah online!

Gagasan utamanya adalah untuk menyandikan isi utama sumber dalam satu angka, menggunakan basis yang besar. Angka itu kemudian dapat dengan mudah dicetak kembali sebelum diterjemahkan untuk mencetak sisa kode sumber. Penguraiannya hanyalah aplikasi berulang divmod base, di mana mencetak moddan terus bekerja dengan divsampai nol.

Dengan menghindari {}, kode karakter tertinggi yang kita perlukan adalah _(95) sehingga basis 96 cukup (dengan menjaga basis rendah, angka di awal lebih pendek). Jadi yang ingin kita enkode adalah ini:

!
"
:_96
/6 %
@9_.

Mengubah karakter-karakter tersebut menjadi poin-poin kode mereka dan memperlakukan hasilnya sebagai angka dasar-96 (dengan digit paling signifikan sesuai !dan yang paling signifikan ., karena itulah urutan di mana kita akan membongkar nomor itu), kita dapatkan

234785020242697299628949734639258593

Sekarang kode dimulai dengan trik yang cukup keren (jika boleh saya katakan demikian) yang memungkinkan kita untuk mencetak kembali encoding dan menyimpan salinan lain untuk decoding dengan overhead yang sangat sedikit: kita memasukkan nomor ke dalam kode secara terbalik. Saya menghitung hasilnya dengan skrip CJam ini. Jadi mari kita beralih ke kode aktual. Inilah awalnya:

395852936437949826992796242020587432!
"

IP dimulai di sudut kiri atas, menuju ke timur. Sementara itu berjalan di atas angka-angka itu, itu hanya membangun nomor itu di atas tumpukan. Angka itu sendiri sama sekali tidak berarti, karena itu kebalikan dari yang kita inginkan. Ketika IP menyentuh !, yang muncul nomor ini dari tumpukan dan mencetaknya. Itu semua yang ada untuk mereproduksi pengkodean dalam output.

Tetapi sekarang IP telah menemui jalan buntu. Itu berarti berbalik dan sekarang bergerak kembali ke barat (tanpa mengeksekusi !lagi). Kali ini, dengan mudah, IP membaca nomor dari belakang ke depan, sehingga sekarang nomor di atas tumpukan tidak menyandikan sisa sumber.

Ketika IP sekarang menyentuh sudut kiri atas lagi, ini bukan jalan buntu karena IP dapat berbelok ke kiri, jadi sekarang dan sekarang bergerak ke selatan. Ini "adalah no-op, yang kita butuhkan di sini untuk memisahkan nomor dari loop utama kode. Ngomong-ngomong soal:

...
"
:_96
/6 %
@9_.

Selama bagian atas tumpukan belum nol, IP akan berjalan melalui kode yang agak padat ini di loop berikut:

"
>>>v
^< v
 ^<<

Atau ditata secara linear:

:_96%._96/

Alasan mengapa diperlukan giliran itu adalah karena semantik aliran kontrol Labyrinth. Ketika setidaknya ada tiga tetangga ke sel saat ini, IP akan berbelok ke kiri pada nilai tumpukan negatif, teruskan pada nol dan belok kanan pada nilai tumpukan positif. Jika arah yang dipilih tidak mungkin karena ada dinding, IP akan mengambil arah yang berlawanan sebagai gantinya (itulah sebabnya ada dua belokan kiri dalam kode meskipun bagian atas tumpukan tidak pernah negatif).

Kode loop itu sendiri sebenarnya cukup mudah (mengompresnya dengan ketat ini bukan dan merupakan kontribusi utama Sp3000):

:    # Duplicate the remaining encoding number N.
_96  # Push 96, the base.
%.   # Take modulo and print as a character.
_96  # Push 96 again.
/    # Divide N by 96 to move to the next digit.

Setelah Nmencapai nol, kontrol perubahan aliran. Sekarang IP ingin bergerak lurus ke depan setelah /(yaitu barat), tetapi ada tembok di sana. Jadi alih-alih jika berbalik (timur), jalankan 6lagi. Itu membuat bagian atas tumpukan positif, sehingga IP berbelok ke kanan (selatan) dan menjalankan 9. Bagian atas tumpukan sekarang 69, tetapi yang kita pedulikan adalah positif. IP mengambil belok kanan lagi (barat) dan bergerak ke @yang mengakhiri kode.

Singkatnya, sebenarnya cukup sederhana.

Oke, sekarang bagaimana kita mencukur byte tambahan itu. Jelas, bahwa no-op tampaknya boros, tetapi kita membutuhkan baris tambahan: jika loop berdekatan dengan nomor tersebut, IP akan segera pindah ke sana alih-alih melintasi seluruh nomor. Jadi bisakah kita melakukan sesuatu yang bermanfaat dengan larangan itu.

Nah, pada prinsipnya kita bisa menggunakannya untuk menambahkan digit terakhir ke dalam encoding. Pengkodean tidak benar-benar perlu semua pada baris pertama ... !hanya memastikan bahwa apa pun yang ada juga akan dicetak di sana.

Namun ada masalah, kami tidak bisa melakukan ini:

95852936437949826992796242020587432!
3
:_96
/6 %
@9_.

Masalahnya adalah bahwa sekarang kita telah mengubah "ke 3, yang juga mengubah angka aktual yang kita inginkan. Dan tentu saja angka itu tidak berakhir 3. Karena angka tersebut sepenuhnya ditentukan oleh kode mulai dari !kita tidak dapat melakukan banyak hal tentang itu.

Tapi mungkin kita bisa memilih digit lain? Kami tidak benar-benar peduli apakah ada 3di tempat itu asalkan kita berakhir dengan angka yang mengkodekan sumber dengan benar. Sayangnya, tidak ada satu pun dari 10 digit yang menghasilkan pengkodean yang digit paling signifikannya cocok dengan digit yang dipilih. Untungnya, ada beberapa kelonggaran dalam sisa kode sehingga kita dapat mencoba beberapa pengkodean lagi tanpa menambah jumlah byte. Saya telah menemukan tiga opsi:

  1. Kita bisa berubah @menjadi /. Dalam hal ini kita dapat menggunakan angka apa saja dari 1357dan mendapatkan pengkodean yang cocok. Namun, ini berarti bahwa program kemudian diakhiri dengan kesalahan, yang diizinkan tetapi tampaknya tidak terlalu bersih.
  2. Spasi bukan satu-satunya karakter "dinding". Setiap karakter yang tidak digunakan, terutama semua huruf. Jika kita menggunakan huruf besar, maka kita bahkan tidak perlu menambah pangkalan untuk menampungnya (karena titik kode di bawah _). 26 pilihan memberi banyak kemungkinan. Misalnya untuk Asetiap digit angka ganjil. Ini sedikit lebih baik, tetapi masih tidak tampak elegan, karena Anda tidak akan pernah menggunakan huruf dalam kode nyata.
  3. Kita bisa menggunakan basis yang lebih besar. Selama kita tidak meningkatkan basis secara signifikan, jumlah digit desimal dalam pengkodean akan tetap sama (khususnya, setiap basis hingga 104 baik-baik saja, meskipun basis di atas 99 sebenarnya membutuhkan karakter tambahan dalam kode itu sendiri). Untungnya, basis 98 memberikan solusi pencocokan tunggal: ketika kita menggunakan digit 1, pengkodean juga berakhir 1. Ini adalah satu-satunya solusi di antara pangkalan 96, 97, 98, 99, jadi ini memang sangat beruntung. Dan begitulah akhirnya kita dengan kode di bagian atas jawaban ini.
Martin Ender
sumber
19

Hilang , 293 262 249 bytes

>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\

Cobalah online!

Penjelasan

Seluruh proyek ini telah naik turun. Saya terus berpikir itu tidak mungkin dan kemudian datang dengan ide gila yang mungkin berhasil.

Mengapa Quine yang Hilang begitu sulit?

Seperti yang Anda ketahui, Lost adalah bahasa pemrograman 2D di mana lokasi awal dan arahnya sepenuhnya acak. Hal ini membuat penulisan program yang hilang sama sulitnya dengan menulis kode pengerasan radiasi. Anda harus mempertimbangkan setiap lokasi dan arah yang memungkinkan.

Yang sedang berkata ada beberapa cara standar untuk melakukan sesuatu. Sebagai contoh di sini adalah cara standar untuk mencetak string.

>%?"Stringv"(@
^<<<<<<<<<<<<<

Ini memiliki aliran pengumpulan di bagian bawah yang meraih sebagian besar ips dan menariknya ke lokasi awal. Begitu mereka mencapai lokasi awal (kiri atas) kita membersihkannya dengan loop menyingkirkan semua nilai pada stack kemudian mengubah keamanan mendorong string dan keluar. (Keselamatan adalah konsep yang unik untuk Kehilangan setiap program harus mengenai %sebelum keluar, ini mencegah kemungkinan program berakhir pada awal). Sekarang ide saya adalah memperluas formulir ini menjadi quine yang lengkap.

Hal pertama yang harus dilakukan adalah mengerjakan ulang loop sedikit, loop yang ada khusus untuk format String.

>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<

Kita perlu menambahkan stream kedua untuk menghindari kemungkinan !melompati stream dan membuat loop.

Sekarang kami ingin mencampur ini dengan format Quine standar. Karena Lost didasarkan sangat banyak pada Klein, pada dasarnya aku mencuri meminjam Klien Quine untuk Martin Ender .

:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<

Ini cukup mudah mencetak baris pertama quine. Sekarang yang perlu kita lakukan adalah mengkodekan stream. Nah ini lebih mudah diucapkan daripada dilakukan. Saya mencoba kira-kira empat metode berbeda untuk melakukan ini. Saya hanya akan menjelaskan yang berhasil.

Idenya di sini adalah menggunakan pintu untuk mendapatkan jumlah panah yang diinginkan. A Door adalah jenis cermin khusus yang berubah setiap kali dipukul. [mencerminkan ips yang datang dari kiri dan ]dari kanan. Ketika mereka dihantam oleh ip dari salah satu sisi ini orientasi saklar. Kita dapat membuat garis pintu-pintu ini dan reflektor statis untuk berulang kali melakukan operasi.

>:[[[

Akan tampil :tiga kali. Dengan cara ini jika kita mendorong <ke stack sebelumnya, kita dapat membuat banyak dari mereka dengan byte lebih sedikit. Kami membuat 2 dari ini, satu untuk setiap baris, dan di antara mereka kami meletakkan baris baru, namun yang kedua hanya perlu berjalan sampai mencakup !kita menambahkannya untuk, apa pun dapat dibiarkan kosong menyelamatkan kita beberapa byte. Ok sekarang kita perlu menambahkan panah vertikal ke aliran kita. Di sinilah optimasi kunci masuk. Alih-alih mengarahkan semua ips ke "mulai" program secara langsung, kita akan mengarahkan mereka ke paling kiri, karena kita sudah tahu bahwa ips mulai di paling kiri harusbekerja (atau setidaknya akan bekerja di versi final) kami juga dapat mengarahkan ulang ips lainnya. Ini tidak hanya membuatnya lebih murah dalam byte, saya pikir optimasi ini adalah apa yang memungkinkan quine.

Namun masih ada beberapa masalah, yang paling penting adalah ips mulai setelah >didorong tetapi sebelum kita mulai membuat salinannya. Ips tersebut akan memasuki mesin fotokopi dan membuat banyak salinan dari 0. Ini buruk karena mekanisme pembersihan tumpukan kami menggunakan nol untuk menentukan bagian bawah tumpukan, meninggalkan sejumlah besar nol di bagian bawah. Kita perlu menambahkan metode sanitasi tumpukan yang lebih kuat. Karena tidak ada cara nyata untuk mengetahui apakah stack kosong, kita hanya perlu berusaha menghancurkan sebanyak mungkin item di stack. Di sini kita akan sekali lagi menggunakan metode pintu yang dijelaskan sebelumnya. Kami akan menambahkan ((((((((((([[[[[[[[[[[[[[ke akhir baris pertama tepat setelah sanitizor untuk menghilangkan nol.

Sekarang ada satu masalah lagi, karena kita mengalihkan aliran kita ke ips kiri atas mulai dari %dan bergerak ke bawah sudah mematikan keselamatan dan akan keluar sebelum waktunya. Jadi kita perlu mematikan keamanannya. Kami melakukan ini dengan menambahkan a #ke aliran, dengan cara itu ips yang mengalir melalui aliran akan dimatikan tetapi ips yang sudah disanitasi tidak akan. The #juga harus sulit kode ke baris pertama juga.

Itu saja, semoga Anda mengerti bagaimana ini bekerja sekarang.

Sriotchilism O'Zaic
sumber
: / begitu banyak kesalahan ketik dan tautan yang hilang
ASCII-saja
17

Yup , 1165 879 606 561 540 522 498 + 7 = 505 byte

Membutuhkan -cheatbendera untuk memungkinkan definisi alias.

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Cobalah online!

Penjelasan

Ada dua bagian untuk ini (seperti kebanyakan quines). Data:

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212

Dan dekoder:

=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Data hanyalah pengkodean biner dari decoder (atau lebih tepatnya kebalikannya). Setiap 0memulai karakter baru dan 1s dan 2s adalah 0- dan- 1bit, masing-masing.

Perhatikan bahwa itu 0adalah perintah Yup standar yang mendorong nol, sementara 1dan 2tidak didefinisikan pada titik ini. Namun, kami menetapkan seluruh bagian data ke perintah %sehingga 1dan 2dapat tetap tidak ditentukan hingga %benar-benar digunakan.

Selanjutnya, kami mendefinisikan beberapa perintah lagi:

0e-=<;
0<-=>;
:0~--=1;
1>=2;

<mengurangi bagian atas tumpukan, >menambahnya. 1(agak tidak sengaja) menggandakan bagian atas tumpukan. 2gandakan dan kemudian tambahkan. Berkat definisi ini, sesuatu seperti 0221111akan benar-benar meninggalkan 48 (110000 dalam biner) di stack.

32 byte yang tersisa melakukan decoding aktual dalam dua bagian. Pertama, kita perlu merekonstruksi string data.

0%                ` Push a zero and then the data.
{                 ` For each value...
  {               `   Until that value is zero...
    >0<~{~>~<<}>  `   divmod 2. The div is the input to the next iteration,
                  `   the mod gives us the next bit.
    >>]           `   Increment twice (gives 2 or 3) and put at the bottom
                  `   of the stack.
  }
  >]              ` Increment the 0 and put it at the bottom as well.
}
$                 ` Reverse the entire stack.
{<#}              ` Decrement and print each number.

Dan akhirnya, kami mendorong data lagi dan mencetak setiap nilai sebagai karakter:

%{@}

Untuk referensi di masa mendatang, berikut adalah skrip CJam untuk menyandikan data.

Martin Ender
sumber
17

Fueue , 423 byte

Fueue adalah esolang berbasis antrian di mana program yang berjalan adalah antrian.

)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Cobalah online!

Bagaimana itu bekerja

Penjelasan ini mungkin atau mungkin tidak ada jalan keluar. Di sisi lain saya tidak tahu bagaimana menjelaskannya dengan lebih singkat dengan cara yang saya harap orang bisa ikuti.

Lembar cheat Fueue

Lihat artikel wiki esolang untuk detailnya, termasuk beberapa fitur yang tidak digunakan dalam program ini.

  • Program awal adalah keadaan awal antrian, yang dapat berisi elemen-elemen berikut:

    • Bilangan bulat integer (hanya non-negatif dalam sumber, tetapi yang negatif dapat dihitung), mengeksekusi mereka mencetak karakter.
    • Blok bersarang dibatasi braket kotak, lembam (dipertahankan utuh kecuali beberapa fungsi menindakinya).
    • Fungsinya, argumen mereka adalah elemen yang mengikutinya segera dalam antrian:
      • +*/-%: bilangan bulat aritmatika ( -adalah unary, %negasi logis). Lemah jika tidak diberi nomor argumen.
      • ()<: letakkan elemen dalam tanda kurung, hapus tanda kurung dari blok, tambahkan elemen terakhir ke blok. Dua yang terakhir inert kecuali diikuti oleh blok.
      • ~:: swap, duplikat.
      • $: copy (mengambil nomor + elemen). Lambat sebelum non-angka.
      • H: menghentikan program.

    Perhatikan bahwa saat []bersarang, ()jangan - yang terakhir hanyalah fungsi yang terpisah.

Sintaks penelusuran jejak

Spasi adalah opsional dalam Fueue, kecuali antara angka. Dalam jejak eksekusi berikut ini akan digunakan untuk menyarankan struktur program, khususnya:

  • Ketika suatu fungsi dijalankan, ia dan argumennya akan dimatikan dari elemen sekitarnya dengan spasi. Jika beberapa argumen rumit, mungkin ada ruang di antara mereka juga.
  • Banyak jejak eksekusi dibagi menjadi "delay blob" di sebelah kiri, dipisahkan dari bagian di sebelah kanan yang melakukan manipulasi data yang substansial. Lihat bagian selanjutnya.

Kurung keriting {}(tidak digunakan dalam Fueue) digunakan dalam jejak untuk mewakili hasil integer dari ekspresi matematika. Ini termasuk angka negatif, karena Fueue hanya memiliki literal non-negatif - -adalah fungsi negasi.

Berbagai nama metavariabel dan ...digunakan untuk menunjukkan nilai dan singkatan.

Taktik penundaan

Secara intuitif, siklus eksekusi di sekitar antrian, sebagian memodifikasi apa yang dilewatinya. Hasil dari suatu fungsi tidak dapat dijalankan lagi sampai siklus berikutnya. Bagian-bagian berbeda dari program secara efektif berkembang secara paralel selama mereka tidak berinteraksi.

Akibatnya, banyak kode yang ditujukan untuk sinkronisasi, khususnya untuk menunda eksekusi bagian-bagian program hingga waktu yang tepat. Ada banyak opsi untuk bermain golf ini, yang cenderung mengubah bagian-bagian itu menjadi gumpalan yang tidak dapat dibaca yang hanya dapat dipahami dengan melacak siklus eksekusi mereka dengan siklus.

Taktik ini tidak akan selalu disebutkan secara individual di bawah ini:

  • )[A]keterlambatan Auntuk satu siklus. (Mungkin metode termudah dan paling mudah dibaca.)
  • ~ef menukar elemen e dan fyang juga menunda eksekusi. (Mungkin yang paling tidak mudah dibaca, tetapi sering kali paling pendek untuk penundaan kecil.)
  • $1e menunda satu elemen e .
  • -dan %berguna untuk menunda angka (yang terakhir untuk0 dan 1.)
  • Saat menunda beberapa elemen yang sama dalam satu baris, :atau $dapat digunakan untuk membuatnya dari satu elemen .
  • (nmembungkus ntanda kurung, yang nantinya dapat dihapus dengan nyaman. Ini sangat penting untuk perhitungan numerik, karena angka terlalu tidak stabil untuk disalin tanpa terlebih dahulu menempatkannya di blok.

Struktur keseluruhan

Sisa dari penjelasan ini dibagi menjadi tujuh bagian, masing-masing untuk bagian dari program yang sedang berjalan. Siklus yang lebih besar setelah sebagian besar dari mereka mengulangi sendiri akan disebut "iterasi" untuk membedakan mereka dari "siklus" melewati tunggal melalui seluruh antrian.

Berikut adalah bagaimana program awal dibagi di antara mereka:

A:  )$$4255%%1(~
B:  ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:  
D:  (H-
E:  
F:  
G:  ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Angka besar pada akhir program mengkodekan sisanya secara terbalik, dua digit per karakter, dengan 30 dikurangkan dari setiap nilai ASCII (jadi mis. 10Mengkode a (.)

Pada level yang lebih tinggi, Anda dapat menganggap data dalam program ini (dimulai dengan bignum) sebagai mengalir dari kanan ke kiri, tetapi kontrol mengalir dari kiri ke kanan. Namun, pada level yang lebih rendah, Fueue membuat perbedaan antara kode dan data setiap saat.

  • Bagian G menerjemahkan bignum menjadi angka ASCII (misalnya digit 0sebagai bilangan bulat 48), memisahkan angka yang paling tidak penting terlebih dahulu. Ini menghasilkan satu digit setiap 15 siklus.
  • Bagian F berisi nilai ASCII digit yang dihasilkan (masing-masing di dalam blok) sampai bagian E dapat mengkonsumsinya.
  • Bagian E menangani angka yang dihasilkan dua sekaligus, memasangkannya ke dalam blok formulir [x[y]] , juga mencetak karakter yang disandikan dari masing-masing pasangan.
  • Bagian D terdiri dari blok yang sangat bersarang yang secara bertahap dibangun dari [x[y]]blok sedemikian rupa sehingga setelah berisi semua digit, dapat dijalankan untuk mencetak semuanya, lalu menghentikan seluruh program.
  • Bagian C menangani konstruksi bagian D, dan juga membuat ulang bagian E.
  • Bagian B menciptakan kembali bagian C serta dirinya sendiri setiap 30 siklus.
  • Bagian A menghitung mundur siklus sampai iterasi terakhir dari bagian lain. Kemudian ia membatalkan bagian B dan menjalankan bagian D.

Bagian A

Bagian A menangani penjadwalan akhir program. Dibutuhkan 4258 siklus untuk mereduksi menjadi fungsi swap tunggal ~, yang kemudian membuat penyesuaian ke bagian B yang menghentikan loop utamanya dan mulai menjalankan bagian D sebagai gantinya.

)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
  • Suatu $fungsi menciptakan 4255 salinan berikut ini %sementara (membungkus ~tanda kurung.
  • Setiap siklus yang terakhir %digunakan untuk beralih nomor berikut antara 0dan 1.
  • Ketika semua %digunakan, $1salinan 1 dibuat [~](efektif NOP), dan pada siklus berikutnya )menghapus tanda kurung.

Bagian B

Bagian B menangani regenerasi sendiri serta pengulangan baru dari bagian C setiap 30 siklus.

) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]            [BkB]
)$ $24%     %0  :<  [~:)~)]    ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1   < < [~:)~)] [BkB]   [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0      < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1         [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                    (1)
~:) ~)[BkB]                 [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB]                 ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]      (2)
) [BkB] [BkB]               $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
  • Sebuah :duplikat mengikuti blok besar (satu salinan disingkat [BkB]), lalu) menghapus tanda kurung dari salinan pertama.
  • $$24%%0 membuat hitung mundur yang mirip dengan yang ada di bagian A.
  • Sementara ini menghitung mundur, :<berubah menjadi <<, dan ~menukar dua blok, menempatkan kode untuk bagian C baru terakhir.
  • Dua <fungsi mengemas dua blok terakhir ke yang pertama - ini berlebihan pada iterasi normal, tetapi akan memungkinkan ~dari bagian A untuk melakukan tugasnya di akhir.
  • (1) Ketika hitungan mundur selesai, )tanda kurung luar dihapus. Selanjutnya ~:)berubah menjadi ):dan ~)menukar )ke awal kode bagian C.
  • (2) Bagian B sekarang kembali pada siklus awalnya, sementara a )baru saja akan menghapus tanda kurung untuk mulai menjalankan iterasi baru dari bagian C.

Dalam iterasi akhir, ~dari bagian A muncul di titik (1) di atas:

~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                  (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]              )

The ~swap yang )di blok dan ke bagian C, mencegah bagian B dari yang dijalankan lagi.

Bagian C

Bagian C menangani penggabungan pasangan karakter digit baru ke dalam blok bagian D, dan juga membuat iterasi baru dari bagian E.

Di bawah ini menunjukkan iterasi khas dengan xdan ymewakili kode ASCII digit. Dalam iterasi pertama, elemen "D" dan "E" yang masuk adalah yang pertama [H]dan -sebagai gantinya, karena tidak ada bagian E sebelumnya yang dijalankan untuk menghasilkan pasangan karakter digit apa pun.

C                                               D             E
$11~ )  ~<[[+$4--498+*-:~-10)):])<~]  [)))~]  < [)))~[...]]   [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~]  < [)))~] [)))~[...][x[y]]]
~~~ ~~~     )  ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~       ~ )   [)))~[....]]                                  [[+$4--498+*-:~-10)):])<~]
                                              ~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
                                                [)))~[....]]  ~[+$4--498+*-:~-10)):])<~
  • Ini menggunakan metode sinkronisasi yang berbeda yang saya temukan untuk jawaban ini. Ketika Anda memiliki beberapa fungsi swap ~berturut-turut, baris tersebut akan menyusut menjadi sekitar 2/3 setiap siklus (karena satu ~swap dua berikut), tetapi kadang-kadang dengan sisa dari ~s yang mendatangkan malapetaka memanipulasi dengan hati-hati apa yang mengikuti.
  • $11~menghasilkan baris seperti itu. Selanjutnya ~swap a <di blok berikut. Lain <di akhir menambahkan blok pasangan digit baru (digit x dan y sebagai kode ASCII) ke dalam blok bagian D.
  • Siklus berikutnya, ~baris memiliki ~~sisa, yang bertukar ~atas yang berikut ini ). Yang lain <menambahkan bagian D ke a[)))~] blok.
  • Selanjutnya swap ~itu sendiri menukar blok berikut dengan kode E bagian baru di seluruh blok bagian D. Kemudian sisa baru ~menukar )seberang, dan akhirnya yang terakhir ~~di ~baris menukar salah satu dari mereka menyeberang ke bagian E sama seperti )telah menghapus tanda kurung.

Dalam iterasi akhir, bagian A ~telah bertukar )melintasi bagian B dan ke bagian C. Namun, bagian C berumur pendek sehingga sudah menghilang, dan )berakhir di awal bagian D.

Bagian D

Bagian D menangani pencetakan angka besar terakhir dan menghentikan program. Selama sebagian besar program dijalankan, itu adalah blok lembam yang bagian B – G bekerja sama dalam membangun.

    (H -
    [H]-
    ⋮
    [)))~[H-]]                  After one iteration of section C
    ⋮
    [)))~[)))~[H-][49[49]]]]    Second iteration, after E has also run
    ⋮
)   [)))~[...]]     [49[48]]    Final printing starts as ) is swapped in
    ))) ~[...][49[48]]
    )) )[49[48]] [...]
    )) 49 [48][...]             Print first 1
    ) )[48] [...]
    ) 48 [...]                  Print 0
    )[...]                      Recurse to inner block
    ...
    ⋮
    )[H-]                       Innermost block reached
    H -                         Program halts
  • Pada siklus pertama program, (membungkus fungsi penghentian Hdalam tanda kurung. SEBUAH- berikut, itu akan digunakan sebagai elemen dummy untuk iterasi pertama, bukan pasangan digit.
  • Pasangan digit nyata pertama yang digabungkan adalah [49[49]], sesuai dengan final 11dalam angka.
  • Pasangan digit terakhir [49[48]](sesuai dengan 10di awal numeral) sebenarnya tidak dimasukkan ke dalam blok, tetapi ini tidak membuat perbedaan sama )[A[B]]dan )[A][B]setara, keduanya berubah menjadi A[B].

Setelah iterasi terakhir, yang )ditukar ke kanan dari bagian B tiba dan bagian D blok diblokir. Di )))~awal setiap sub-blok memastikan bahwa semua bagian dieksekusi dalam urutan yang benar. Akhirnya blok terdalam berisi Hpenghentian program.

Bagian E

Bagian E menangani kombinasi pasangan digit ASCII yang diproduksi oleh bagian G, dan keduanya mencetak karakter yang dikodekan yang sesuai dan mengirimkan blok dengan pasangan gabungan ke kiri ke bagian C dan D.

Sekali lagi di bawah ini menunjukkan iterasi khas dengan xdan ymewakili kode ASCII digit.

E                                                   F
~ [+$4--498+*-:~-10)):] )              <  ~         [y] [x]
) [+$4--498+*-:~-10)):]                   < [x] [y]
+ $4-  - 498  +*- :~ -10 ) )              : [x[y]]
+---  -{-498} +*- ~~{-10} )       ) [x[y]]  [x[y]]
+--    - 498  +*   -{-10}       ~ ) x  [y]  [x[y]]
+-    -{-498} +               * 10 x  )[y]  [x[y]]
+      - 498                    + {10*x} y  [x[y]]
                         + {-498} {10*x+y}  [x[y]]
{10*x+y-498}  [x[y]]
[x[y]]
  • Blok digit yang masuk ditukar, kemudian blok y ditambahkan ke blok x, dan seluruh blok pasangan disalin. Satu salinan akan dibiarkan sampai akhir untuk bagian C dan D.
  • Salinan lainnya di-deblock lagi, lalu urutan fungsi aritmatika diterapkan untuk menghitung 10*x+y-498, nilai ASCII dari karakter yang dikodekan. 498 = 10*48+48-30, 48s membatalkan pengodean ASCII dari xdan ysementara 30menggeser pengodean dari 00–99ke30–129 , yang mencakup semua ASCII yang dapat dicetak.
  • Angka yang dihasilkan kemudian dibiarkan dieksekusi, yang mencetak karakternya.

Bagian F

Bagian F terdiri dari blok inert yang berisi kode digit ASCII. Untuk sebagian besar program yang dijalankan akan ada paling banyak dua di sini, karena bagian E mengkonsumsinya dengan kecepatan yang sama dengan yang dihasilkan G. Namun, pada tahap pencetakan akhir, beberapa 0angka berlebih akan dikumpulkan di sini.

[y] [x] ...

Bagian G

Bagian G menangani pemisahan angka besar di akhir program, angka paling tidak penting terlebih dahulu, dan mengirim blok dengan kode ASCII mereka ke kiri ke bagian lain.

Karena tidak ada cek penghentian, itu akan benar-benar terus menghasilkan 0angka ketika angka telah dipangkas menjadi 0, sampai bagian D menghentikan seluruh program dengan Hfungsi.

[BkG] menyingkat salinan blok kode awal yang besar, yang digunakan untuk replikasi diri untuk memulai iterasi baru.

Inisialisasi dalam siklus pertama:

) :~  : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
)  ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]     ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]       ~ : [10...11]  [BkG]

Iterasi tipikal, Nmenunjukkan nomor yang akan dipisah:

) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]        ~ : [N]  [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 )         : [N]  : [BkG]
)  ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]  +5 5     ) [N]  [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]               ~ 10 N  [N] [BkG] [BkG]
) ~:~  ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~]               / N 10  [N] [BkG] [BkG]
)  ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                 ( {N/10}  [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                    : [{N/10}]  [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 )           ~ ~ [{N/10}]  [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 )             ) [{N/10}]  ~ [{N/10}] [N]  [BkG] [BkG]
)  ~ * [):~[$1(+48]):~+]  -10            ~ ) {N/10}  [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+]               * {-10} {N/10}  ) [N]  [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~                 + {-10*(N/10)} N  [{N/10}] [BkG] [BkG]
)  ~ ~ [$1(+48]  )                 ~ ~ {N%10}  [{N/10}] [BkG] [BkG]
) [$1(+48]                 ~ ) {N%10}  ~ [{N/10}] [BkG]  [BkG]
$1(                     + 48 {N%10}    ) [BkG]  [{N/10}] [BkG]
                        ( {48+N%10}   BkG [{N/10}] [BkG]            New iteration starts
                        [{48+N%10}]   ....
  • Gumpalan penundaan di sini sangat berbulu. Namun, satu-satunya trik penundaan baru adalah menggunakan +:5alih-alih --10menunda 10dua siklus. Sayangnya hanya satu dari 10program yang dibantu oleh ini.
  • The [N]dan [BkG]blok digandakan, maka satu salinan Ndibagi oleh10 .
  • [{N/10}]digandakan, maka lebih banyak fungsi aritmatika digunakan untuk menghitung kode ASCII dari digit terakhir Nas 48+((-10)*(N/10)+N). Blokir dengan kode ASCII ini dibiarkan untuk bagian F.
  • Salinan lain [{N/10}]ditukar antara [BkG]blok untuk mengatur awal iterasi baru.

Bonus quine (540 bytes)

)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63

Cobalah online!

Karena saya tidak yakin metode mana yang akan terpendek, saya pertama kali mencoba menyandikan karakter sebagai angka dua digit yang dipisahkan oleh (s. Kode inti sedikit lebih pendek, tetapi representasi data 50% lebih besar menggantikannya. Tidak golf seperti yang lain, ketika saya berhenti ketika saya menyadari itu tidak akan mengalahkan itu. Ini memiliki satu keuntungan: Tidak memerlukan implementasi dengan dukungan bignum.

Struktur keseluruhannya agak mirip dengan yang utama. Bagian G tidak ada karena representasi data mengisi bagian F secara langsung. Namun, bagian E harus melakukan perhitungan divmod yang sama untuk merekonstruksi digit angka dua digit.

Ørjan Johansen
sumber
1
Anda harus memasukkan penjelasan XD
VFDan
1
)$n[)](adalah byte yang lebih pendek untuk penghitung penundaan.
jimmy23013
15

Jelly, 3 byte

”ṘṘ

Cobalah online!

Verifikasi

$ echo $LANG
en_US
$ xxd -g 1 quine.jelly
0000000: ff cc cc                                         ...
$ ./jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...

Bagaimana itu bekerja

”ṘṘ    Main link. No input.

”Ṙ     Set the return value to the character 'Ṙ'.
  Ṙ    Print a string representation of the return value.
       This prints: ”Ṙ
       (implicit) Print the return value.
       This prints: Ṙ
Dennis
sumber
Versi interpreter mana yang digunakan? Ketika saya mengujinya, itu output di UTF-8 meskipun input dalam codepage Jelly (dan perubahan dalam pengkodean akan membuatnya tidak-quine).
1
Pengkodean keluaran tergantung pada pengaturan terminal Anda: jika diatur ke UTF-x, ia menggunakan itu; jika diatur ke hal lain, itu menggunakan halaman kode Jelly. Di Linux, LANG=en_UShanya mencapai itu. tio.run/nexus/bash#@@/…
Dennis