Objektif:

Kode dua program di mana masing-masing program menghasilkan kedua kode sumber interlaced per karakter seperti ritsleting, Quine celah ganda. Output dari Double-slit Quine dimulai dengan karakter pertama dari kode sumber program pertama. Jika kode sumber dari salah satu program lebih pendek dari yang lain, maka sisa output harus diisi dengan sisa kode sumber yang lebih panjang.

Aturan:

1. Anda dapat menggunakan bahasa pemrograman apa pun untuk kedua program, tidak perlu bahasa pemrograman yang sama untuk keduanya.
2. Program Anda tidak boleh mengambil input apa pun dari file, nama file, jaringan, program lain, atau apa pun.

Kriteria wajib:

• Ada tangkapan, di suatu tempat di output kata QUINEdalam huruf kapital harus ada, tidak terputus.
• Anda harus menyatakan dua bahasa pemrograman apa yang Anda gunakan. Jika Anda menggunakan bahasa pemrograman yang sama untuk keduanya, maka Anda hanya perlu menyatakan satu bahasa pemrograman.
• Kedua program harus dapat dieksekusi, atau ditafsirkan, masing-masing independen dari program lain.

Contoh:

Memiliki contoh kode sumber program satu ini :

"QIE"

Memiliki contoh ini kode sumber program dua :

"UN"

Maka output Double-slit Quine yang valid dari kedua program harus:

""QUINE""

Ini adalah kode-golf, byte terkecil ketika menjumlahkan panjang kedua kode sumber, dan jelas juga panjang setiap output program, menang!

CJam, 49 47 byte

{`:_"__~~e#QUINE"}_~

dan

{`:_"__~~e#QUINE"}_~e#QUINE

keduanya cetak

{{``""__~~""++::__""ee##QQUUIINNEE""}}__~~e#QUINE

Cobalah online: program 1 , program 2 , bukti validitas

Bagaimana mereka bekerja

{                }   e# Push a code block.
                  _~ e# Execute a copy.
 `                   e# Convert the code block into a string.
  :_                 e# Duplicate each character of the resulting string.
    "__~~e#QUINE"    e# Push this string.

Program 1 selesai di sini dan memiliki representasi string dari seluruh kode sumbernya (yang masing-masing karakter diulang dua kali) serta string e # QUINE pada stack.

Program 2 juga mem-parsing e#QUINE, yang merupakan komentar.

Dalam kedua kasus, CJam mencetak dua string secara otomatis, menghasilkan output yang disebutkan di atas.

Serius, 46 56 42 byte

QUNX;RZtdXεj.ƒ£REIQ

Hex Dump:

51554e583b525a746458ee6a2e7f9f9c524549510a

Program kedua adalah program yang tepat ini terbalik. Itu memang mengandung karakter yang tidak terlihat, tetapi jumlah byte benar. Kedua program menghasilkan string palindromik ini:

QQUINEXR;£RƒZ⌂t.djXεεXjd.t⌂ZƒR£;RXENIUQQ

(Untuk beberapa alasan ini menampilkan karakter yang tidak terlihat ketika mengeluarkannya di terminal saya. Saya tidak benar-benar mengerti bahwa byte 7F.)

Bagaimana itu bekerja:

Q                     Push the source to the stack
 U                    Nop
  NX                  Push and pop lyrics to 99 bottles of beer
    ;R                Make a copy of the source reversed.
      Z               Zip them together.
       t              Completely flatten the list.
        dX            Delete the trailing newline
          εj          Join it into a string.
            .         Print it with a trailing newline.
             ⌂        (This is that 7F byte that won't show up. It halts.)

Sisa program tidak dieksekusi.

Lalu ke arah lain:

\n                   Nop
  Q                  Push the source code.
   IE                Nops
     R               Reverse source code to get source of first program
      £              Eval it into a function
       ƒ             Call it.

Pada titik ini, kami sekarang menjalankan program pertama di atas, jadi eksekusi berlanjut seperti yang dijelaskan di sana.

Saya sangat mengeksploitasi fakta bahwa beberapa perintah tidak melakukan apa pun untuk string atau tumpukan kosong di sini. Saya juga mengeksploitasi perilaku tak terduga tketika hanya ada satu item di stack. Jangan berharap program ini berfungsi dalam versi Serius di masa mendatang.

Karena versi online dari interpreter Serius terus rusak, Anda harus mengunduh penerjemah dan menjalankannya di mesin Anda sendiri untuk mengujinya.

GolfScript, 46 byte

{`{.}%"..~~QUINE"}.~

dan

{`{.}%"..~~QUINE"}.~QUINE

keduanya cetak

{{``{{..}}%%""....~~~~QQUUIINNEE""}}..~~QUINE

Cobalah online: program 1 , program 2 , bukti validitas

Bagaimana itu bekerja

{`{.}%"..~~QUINE"}.~

{                }    # Push a code block.
                  .~  # Execute a copy.
 `                    # Convert the code block into a string.
  {.}%                # Duplicate each character of the resulting string.
      "..~~QUINE"     # Push that string.

Kode sumber program 2 juga mem-parsing QUINE\n, yang merupakan dua token yang tidak ditentukan.

Perl, 61 + 60 = 121 byte

Program 1:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#QIE

Program 2:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#UN

Saya pikir saya akan mencobanya dalam bahasa non-golf. Ini pada dasarnya hanya konstruktor quine universal di Perl yang dimodifikasi untuk menggandakan setiap karakter sebelum mencetaknya, dan menambahkannya QUINEsampai akhir. Maka kita hanya perlu menempel komentar di akhir kode untuk mengkompensasi teks yang ditambahkan.

(Saya menulis ini tanpa benar-benar melihat jawaban yang lain. Ternyata akan mungkin untuk menghemat satu byte dengan meletakkan seluruh komentar dalam satu program, tetapi saya tidak yakin apakah saya hanya akan menyalin algoritma secara terang-terangan seperti itu.)