Kami memiliki banyak tantangan quine , tetapi banyak format quine serupa, mari kita buat beberapa varian di quine kami.

Tugas Anda adalah membuat pilihan program dalam bahasa yang sama (setidaknya 2), yang semuanya menghasilkan kode sumber mereka sendiri, namun, tidak satu pun dari program ini dapat membagikan karakter apa pun.

Misalnya, jika Anda membuat program menggunakan:

printf+qw(printf+qw(%s)x2)x2

Program Anda berikutnya tidak dapat mencakup:

%()+2finpqrstwx

dan seterusnya.

Aturan

• Anda dapat menggunakan karakter unicode, tetapi Anda masih harus mencetak dalam byte.
• Semua program harus memenuhi definisi komunitas tentang quine yang tepat . Ini berarti bahwa string kosong tidak dihitung sebagai quine yang valid, antara lain.
• Celah standar dilarang.
• Fungsi atau program lengkap diizinkan selama memenuhi definisi di atas.
• Simbol bahasa independen (termasuk Bahasa dan Kepal) dilarang.
• Sebagian besar program menang, dengan kode total terpendek sebagai tie breaker.

V , 3 , 5 quines, 46 byte

2A2A

Cobalah online!

Hexdump:

00000000: 3241 3241                                2A2A

Penjelasan:

2     " 2 times...
 A    " (A)ppend the following text...
  2A  "   '2A'

5­­­a5­­­a

Cobalah online!

Hexdump:

00000000: 35ad adad 6135 adad ad61                 5...a5...a

Penjelasan:

5---        " 5 - 3 times...
    a       " (a)ppend the following text...
     5---a  "   '5---a'

1«I1«I

Cobalah online!

Hexdump:

00000000: 31ab 4931 ab49                           1.I1.I

Penjelasan:

1«      " 1 + 1 times...
  I     " (I)nsert the following text...
   1«I  "   '1«I'

Di sinilah mereka mulai menjadi funky ...

ñi34x@-qPÉÑ~ÿ

Cobalah online!

Hexdump:

00000000: f169 1633 341b 7840 2d71 50c9 d17e ff    .i.34.x@-qP..~.

Penjelasan:

ñ                       " Wrap all the following in macro '"q':
 i<C-v>34               "   Insert character code 34 `"`
         <esc>          "   Return to normal mode
              x         "   Delete the character we just inserted. Now, running `@-` will be equal to running `"`
                  P     "   Paste...
               @-       "   From Register...
                 q      "   "q
                   ÉÑ   "   Insert 'Ñ' at the beginning of this line
                     ~  "   Toggle the case of the character we just inserted
                      ÿ "   Black magic

:norm é:":p

Cobalah online!

Hexdump:

00000000: 3a6e 6f72 6d20 e93a 223a 70              :norm .:":p

Penjelasan:

:norm       " Run the following commands as if typed:
      é:    "   insert ':'. Somehow also does black magic and resets the value of '":`
        ":p "   Paste the last ex command to be run ('norm é:":p')

Jawaban ini dipenuhi dengan ilmu hitam. Quines 1 dan 4 bukanlah hal baru, tetapi 3 lainnya semuanya belum pernah ditemukan sebelumnya, jadi lebih dari setengah quine ini baru ditemukan hari ini.

Jelly , _{2 3 4} 5 quines, _{14 18 81 65 59 56 326 265 247 229} 216 byte

3 byte

”ṘṘ

Cobalah online!

Quine standar. ”Ṙadalah karakter satu karakter untuk Ṙ. Ṙmencetak representasi string ini kemudian string tersebut Ṙsecara implisit dicetak.

4 byte

⁾⁾ḤḤ

Cobalah online!

⁾memulai dua karakter string literal dan Ḥmenggandakan argumennya. Dengan input string, Ḥdipetakan ke setiap karakter. Jadi Ḥbertindak pada ⁾Ḥhasil string ⁾⁾ḤḤ, kode sumber.

11 byte

ȮṾṖƊ}“ȮṾṖƊ}

Cobalah online!

Di sisi kanan, “ȮṾṖƊ}adalah string literal untuk ȮṾṖƊ}. Karakter penutup string secara diam-diam ditambahkan di EOF.

Di sebelah kiri string literal, Ɗmembungkus ȮṾṖmenjadi monad tunggal dan }mengubahnya menjadi angka dua yang menggunakan argumen yang benar itu, string literal. Ȯmencetak string ( ȮṾṖƊ}), Ṿmembuat representasi string dari string ( “ȮṾṖƊ}”) dan Ṗmenghapus ”karakter. String “ȮṾṖƊ}dibiarkan setelah monad dan dicetak secara implisit.

38 49 36 byte

32,52,52,7884,106,64,44,7884 44Ọj@,Ọ

Cobalah online!

Pertama kali saya pernah menggunakan spasi di Jelly golf.

Daftar angka di awal menyimpan ordsisa karakter dalam kode. Setelah itu:

jṛ44Ọ$,Ọ
j           Join this list with...
 ṛ          right argument. Avoiding using ¤ so I can use it in the next program.
  44Ọ       chr(44)==',': [106, ',', ...]
     $      Causes Ọ to act on 44 before j acts on it.
      ,     Pair this list with...
       Ọ    chr of each number in the list. Yields jṛ44Ọ$,Ọ

270 198 180 162 byte

⁽¢_;⁽⁽¤;⁽¡_;⁽⁽¡;⁽¡¤;⁽$+;⁽⁽y;⁽Ẹ$;⁽⁺$;⁽AƑ;⁽?€;⁽b⁽;⁽¢¡;⁽_⁽;⁽¡¡;⁽¤ị;⁽ØJ;⁽µṭ;⁽€⁽;⁽¡S;⁽;⁽;⁽¡ʠ;⁽¤ị;⁽ØJ;⁽¤F;⁽ḊṄ;⁽ȧF
¢_⁽¤¡_⁽¡¡¤$+⁽yẸ$⁺$AƑ?€b⁽¢¡_⁽¡¡¤ịØJµṭ€⁽¡S;⁽¡ʠ¤ịØJ¤FḊṄȧF

Cobalah online!

Menggunakan angka dasar 250 dan indeks ke halaman kode Jelly. Disimpan 72 byte dengan mengubah algoritma. Sudah menggunakan setiap nomor untuk mengindeks ke halaman kode Jelly tetapi saya sekarang mengkonversi integer kembali ke basis 250 kemudian mengindeks ke halaman kode Jelly, pada dasarnya mengurangi separuh jumlah liter yang saya butuhkan di baris pertama. Ini juga mengurangi jumlah karakter unik yang diperlukan, tetapi saya tidak bisa memikirkan cara untuk membuat quines lagi.

Saya telah menggunakan ⁾“”yang membuat string literal dan Ọdan ØJyang membuat string dari angka. Saya tidak bisa memikirkan cara lain untuk membuat string. Saya masih memiliki digit 9dan ‘’tersedia, jadi jika ada cara lain untuk membuat string dari angka, dimungkinkan untuk membuat quine lain.

Haskell , 3 quines, 1119 bytes

Quine 1, 51 byte

IOPencetakan anonim langsung ke stdout.

putStr`mappend`print`id`"putStr`mappend`print`id`"

Cobalah online!

Quine 2, 265 byte

Fungsi ini fmengambil argumen dummy dan mengembalikan string.

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,90,52,82,89,52,51,51,94,84,24,24,39,34,34,106,95,102,110,0,94,50,89,0,90,52,82,82,82,106,95,102,110,0,48,24,24,39,35,106,95,102,110,0,40,24,24,39,37,37,84,24,24,45,37,37,84,24,24,90,84,50,94,52]

Cobalah online!

Quine 3, 803 bytes

Segala sesuatu setelah LANGUAGEpragma adalah fungsi anymous mengambil argumen dummy dan mengembalikan string.

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&'#'&'L'&'A'&'N'&'G'&'U'&'A'&'G'&'E'&' '&'C'&'P'&'P'&'#'&'-'&'}'&'('%'\\'&'q'&'('&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'z'&')'&'y'&'('&'#'&')'&'_'&'-'&'>'&'('&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'&'%'\''&':'&'q'&':'&'k'&':'&'q'&':'&'x'&')'&'#'&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'%'%'\''&':'&'q'&':'%'\''%'\\'%'\\'%'\''&':'&'k'&':'&'q'&':'&'x'&')'&'$'&'y'&'('&':'&')'&'#'&'y'&'('&':'&')'&'$'&' '%'\\'&'x'&'-'&'>'&'x'&')'&'z'&')'%'\''%'\\'%'\''%'\''&'_'&'_'&'T'&'I'&'M'&'E'&'_'&'_'&'('%'\\'&'('&'?'&')'&'v'&' '&'k'&' '&'x'&'-'&'>'&'v'&'$'&'k'&'?'&'x'&')'&'$'&' '%'\\'&'('&'&'&')'&'('&'%'&')'&'v'&'-'&'>'&'v'

Cobalah online!

Karakter

Quine 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

 #$%&'()-:>?ACEGILMNPTU\_kqvxyz{}

Bagaimana itu bekerja

Quine 1

putStr`mappend`print`id`"putStr`mappend`print`id`"

Quine 1 adalah versi modifikasi dari Golf terbaru saya , Anda jawaban quine (dengan perbaikan oleh H.PWiz):

• Karena program penuh tidak diperlukan, main=telah dihapus.
• <>dan $telah digantikan oleh sinonim mappenddan dekat mereka id.

Ini membebaskan karakter vital =<>dan operator yang membantu $untuk quines lainnya.

Quine 2

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,......]

Quine 2 menggunakan metode yang agak mirip untuk memprogram 2 jawaban Mutual Exclusive Quines saya yang baru-baru ini , tetapi diadaptasi untuk quine sendiri secara langsung dan terutama untuk menghindari penggunaan literal karakter, yang diperlukan untuk quine 3. Kedua hal ini dicapai dengan bantuan showfungsi, yang oleh keberuntungan semata belum memiliki karakter yang digunakan.

Quine ini menggunakan tab bukan spasi, tapi saya telah menggunakan spasi di bawah ini untuk keterbacaan.

• gadalah data quine, sebagai daftar bilangan bulat di akhir kode. Setiap angka mewakili karakter dari sisa kode.
  • Angka-angka digeser oleh 9, sehingga tab itu 0. Ini membuat pengodean sedikit lebih pendek dengan memungkinkan huruf kecil untuk fungsi dan nama variabel agar sesuai dalam 2 digit.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] adalah fungsi untuk mengubah angka menjadi karakter (sebenarnya string satu karakter).
  • [[show 9!!0,show 1!!0..]!!6..]adalah rentang karakter yang dimulai dengan karakter tab, yang diindeks menjadi !!c.
  • Karakter tab itu sendiri diproduksi oleh pengindeksan ke rentang lain [show 9!!0,show 1!!0..], dimulai dengan karakter digit '9'dan '1'dan melompat turun dalam langkah 8.
  • Karakter digit diproduksi dengan mengindeks ke dalam showstring digit yang sesuai.
• f c=[b=<<g]!!0++show gadalah fungsi utama. cadalah argumen bodoh.
  • b=<<ggunakan =<<untuk mengonversi setiap angka gmenjadi karakternya. (Penggunaan =<<bukannya misalnya mapadalah mengapa bperlu membungkus karakter yang dikembalikan dalam daftar.)
  • show gmemberikan representasi string dari gdaftar, dan ++menyatukan string.
  • Karena =<<lebih diutamakan daripada ++, beberapa bracketing diperlukan. Untuk menghindari penggunaan ()(dicadangkan untuk quine 3), [...]!!0indeks ke dalam daftar dengan satu elemen.

Quine 3

Dengan desain quine lain, quine 3 masih memiliki akses ke tanda kurung, ekspresi lambda, literal karakter, dan konstruktor string / daftar :. Ini akan cukup untuk membangun fungsi yang menambahkan kode quine ke string.

Sayangnya, semua huruf kecil (kecuali kadang-kadang y) telah digunakan, tanpa meninggalkan fungsi alfanumerik bawaan yang berguna. Juga []""sudah pergi. Ini tidak meninggalkan cara normal untuk membangun string kosong untuk mulai berpura-pura kode.

Namun, hampir semua huruf besar masih tersedia, jadi LANGUAGEpragma untuk mendapatkan ekstensi bahasa dimungkinkan. Sekali lagi oleh keberuntungan belaka, CPP(memungkinkan C preprocessor) adalah satu-satunya ekstensi bahasa bernama hanya dengan huruf besar. Dan makro CPP sering memiliki nama huruf besar.

Jadi untuk mendapatkan string kosong yang esensial, quine memungkinkan CPP, menggunakan __TIME__makro untuk mendapatkan string konstan dari bentuk "??:??:??"(mudah dijamin selalu memiliki panjang yang sama), dan kecocokan pola di atasnya.

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&......

Setelah pragma bahasa, quine terdiri dari ekspresi lambda yang mengikat parameternya ke empat argumen ini (meninggalkan parameter dummy akhir _untuk diterapkan kemudian):

• qterikat '\'', memberikan karakter kutipan tunggal;
• _:_:_:_:_:_:_:_:zterikat __TIME__, alias string seperti "??:??:??", sehingga membuat zstring kosong;
• yterikat pada (\(?)v k x->v$k?x), kombinator lambda yang digunakan untuk membantu mengubah data quine dari kiri terkait ("foldl") ke kanan terkait ("foldr") formulir;
• Operator (#)terikat \(&)(%)v->v&'{'&'-'&..., data quine itu sendiri.

Data quine diberikan dalam bentuk pengkodean Gereja, ekspresi lambda dengan parameter (&)(%)v.

• Dengan menerapkan ekspresi pada nilai-nilai tertentu untuk instantiate (&), (%)dan v, pengkodean ini dapat digunakan baik untuk membangun kode inti quine atau untuk membangun kembali representasi data quine itu sendiri.
• Dengan aturan fixity default Haskell, &dan %menjadi operator asosiatif kiri di dalam lambda. Dengan demikian parameter karakter digabungkan dengan awal yang vdimulai dari kiri.
• Untuk sebagian besar karakter k, ada yang sesuai &'k'.
• Ketika kadalah 'atau \, yang perlu melarikan diri dalam karakter literal, pengkodean adalah bukan %'\k'.

Karena pengkodean data adalah asosiatif kiri, tetapi string dibangun dengan cara asosiatif yang tepat, kombinator y = (\(?)v k x->v$k?x)diperkenalkan untuk menjembatani ketidakcocokan.

• y(...)dimaksudkan untuk membangun fungsi yang sesuai untuk digunakan sebagai data quine (&)dan (%)operator.
• vadalah fungsi dari string ke string (data quine dimaksudkan vmenjadi contoh).
• kadalah karakter, xstring, dan ?operator yang menggabungkannya menjadi string baru. (Untuk kode inti (?)=(:),. Untuk benar-benar merekonstruksi representasi data quine, ini lebih rumit.)
• Dengan demikian y(?)v k = \x->v$k?xadalah fungsi lain dari string ke string.

• Sebagai contoh bagaimana ini mengubah asosiatif, jika (&)=y(:):

  (v&k1&k2&k3) x
  = (((v&k1)&k2)&k3) x
  = y(:)(y(:)(y(:)v k1)k2)k3 x
  = y(:)(y(:)v k1)k2 (k3:x)
  = y(:)v k1 (k2:(k3:x))
  = v (k1:(k2:(k3:x)))
  = v (k1:k2:k3:x)

Lebih umum, kapan (#)fungsi data quine dan f1,f2adalah fungsi menggabungkan karakter dengan string:

(y(f1)#y(f2)$v) x
= (...(y(f1)(y(f1)v '{') '-')...) x
= v(f1 '{' (f1 '-' (... x)))

menerapkan fungsi data quine dengan (&)=y(f1)dan (%)=y(f2), dan ini menggunakan yang ditentukan f1dan f2untuk menggabungkan karakter data quine dengan x, dan kemudian meneruskan string yang dihasilkan ke v.

Tubuh ekspresi lambda utama menyatukan semua ini:

(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z

• '&':q:k:q:xuntuk karakter kprepends &'k'ke string x, sedangkan '%':q:'\\':k:q:xprepends %'\k', yang merupakan bentuk Quine data asli mereka.
• Dengan demikian y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:xadalah parameter yang tepat untuk membangun kembali representasi data quine, diawali dengan final z(string kosong), dan kemudian diteruskan ke fungsi berikut.
• y(:)#y(:) adalah parameter yang tepat untuk menambahkan kode inti quine ke string, tanpa modifikasi lainnya.
• Akhirnya \x->xtidak dapat melakukan apa-apa dengan quine yang dibangun, yang dikembalikan.

Perl 6 , 3 quines, 274 bytes

Quine 1, 52 bytes

my&d={S{\d}=$_};say
d
Q{my&d={S{\d}=$_};say
d
Q{4}}

Cobalah online!

Quine 2, 102 byte

printf	|(q[printf	|(q[@]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))

Cobalah online!

Quine 3, 120 byte

<'.EVAL'.UC,' GIVEN ',｢｢PRINT "<'.EVAL'.UC,' GIVEN ',｢｢".UC,.UC,"｣｣>.LC",".EVAL.EVAL".UC｣｣>.lc.EVAL.EVAL

Cobalah online!

Verifikasi set byte yang berbeda

Ada banyak manuver untuk mendapatkan quine ketiga. Perl 6 memiliki 4 metode output (bahwa aku sadar), say, put, printdan printf. Keduanya saydan putmenampilkan baris baru, karena saya tidak dapat menggunakan keduanya. put, print, printfSemuanya mengandung pdan t. Kita dapat menyiasati ini sebagian dengan menggunakan EVALuntuk menggunakan huruf besar PRINT. Dari sana, saya tidak berpikir mungkin untuk mendapatkan 4 quines ... (walaupun mungkin sesuatu seperti shell "echo 'quine'"mungkin bekerja)

Kami kemudian dapat mengatasi masalah spasi dengan menggunakan berbagai jenis spasi putih untuk memisahkan operator, spasi, tab, dan baris baru.

Penjelasan:

Quine 1:

my&d={        };         # Declare a function d which 
      S{\d}=$_           # Which substitutes a digit with the string again
                say      # Print with a newline
d                        # The function
Q{my&d={S{\d}=$_};say    # Applied to the string with the program
d
Q{4}}                    # With a digit where the it should be inserted again

Quine 2:

Ini adalah quine dalam format printf |(q[printf q[%s]]xx 2), yaitu memformat salinan string ke dalam dirinya sendiri. Namun kami tidak dapat menggunakan skarena itu digunakan dalam quine sebelumnya say. Jadi kami menggunakan string ATAU operator ( ~|) pada @dan !3, untuk menghasilkan %sbagian, tetapi kami tidak bisa melakukan itu baik untuk format string dan string yang akan dimasukkan, jadi kami harus melakukan Z~dengan string tambahan dan string kosong, meskipun kita kemudian tidak dapat menggunakan ,untuk memisahkan keduanya, jadi kita kemudian lakukan Xx qw[1 0]untuk mengalikan string dengan 1 dan 0.

printf |(                                  )      # Print with formatting
         q[...]       # The string of the program
               xx 2   # Duplicated
                    Z~| (                 )     # String or'd with
                         q[...]                 # A copy to insert the %s
                                Xx              # String multiplied to
                                   qw[1 0]      # itself and an empty string

Quine 3:

Ini adalah kueri EVAL yang mencoba yang terbaik untuk membuat semuanya huruf besar untuk menghindari konflik dengan quine lainnya. Ini melibatkan banyak dari EVALs serta beberapa lcdan ucuntuk mengkonversi antara kasus.

<...>.lc.EVAL        # Evaluate the lowercase version of the string which results in
.EVAL  given  ｢print "<'.eval'.uc,' given ',｢｢".uc,.uc,"｣｣>.lc",".eval.eval".uc｣
             .EVAL   # Evaluate again 

.EVAL  given  ｢...｣   # Set the string to $_ and pass it to .EVAL
print "<'.eval'.uc,' given ',｢｢".uc       # Print the first half of the quine uppercased
                                   ,.uc   # Print the string uppercased
                                       ,"｣｣>.lc"  # Print the .lc part lowercased
                                                ,".eval.eval".uc # Print the EVAL part uppercased

MathGolf , 4 5 6 quines, 193.535 byte

9 byte

ÿ'ÿ⌐_'ÿ⌐_

Cobalah online!

45 byte

û]∙ûxôû¬ûûûûû╡¬ûô╡û╡xûxxû¬ô]∙xô¬ûûû╡¬ô╡╡xxx¬ô

Cobalah online!

49 byte

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ

Cobalah online!

99 byte

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~

Cobalah online!

4488 byte

♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((DÄß─·ö♠,♦M-$*DÄß─ö7($$$qq$Äq╘

Cobalah online!

188.845 byte

Saya tidak dapat benar-benar terhubung ke yang ini, jadi inilah program Perl 6 yang menghasilkan quine yang sebenarnya

Verifikasi perbedaan

Saya paling jelas bisa memeras quine lain dari ini, meskipun saya pikir saya sudah kehabisan cara untuk mendorong string langsung ke stack, jadi saya harus menggunakan metode asing. Metode yang lebih aneh pun masuk saat saya mencoba quine keenam. Dalam beberapa kasus quines bisa lebih pendek, tapi saya mengurangi byte yang digunakan sebagai persiapan.

Oke, saya mungkin secara teknis dapat melakukan satu quine lagi, karena saya masih memiliki beberapa operator yang saya butuhkan (string push, string kenaikan, duplikasi, pemetaan, popping), itu adalah perulangan yang membatasi kita. Ini {}adalah satu-satunya operator yang dapat menunjukkan blok kode dengan panjang sewenang-wenang, dan saya benar-benar membutuhkannya di quine ke-6. Saya bisa menggunakan beberapa blok kode lain, tetapi terbatas, dan saya ragu bagian perulangan akan sesingkat itu, karena kita kehabisan operator yang mudah.

Oke, beberapa penjelasan yang terlambat:

Semua quines memiliki struktur yang hampir sama:

• Dorong string, atau daftar string, atau daftar karakter ke tumpukan.
• Gabungkan semuanya menjadi satu daftar
• Gandakan daftarnya
• Peta di atas salinan, mencetak / mendorong karakter yang digunakan untuk mendapatkan karakter asli
• Cetak daftar karakter asli sebagai string

Quine 1:

Ini pada dasarnya sama dengan yang saya posting di pertanyaan quine normal.

ÿ'ÿ⌐_'ÿ⌐_
ÿ            Push the next 4 bytes as a string
 'ÿ⌐_        Stack ["'ÿ⌐_"]
     'ÿ      Push the byte ÿ (I realise I could have used this in a later quine)
       ⌐     Rotate the ÿ to the bottom of the stack : ["ÿ", "'ÿ⌐_"]
        _    Duplicate top of stack: ["ÿ", "'ÿ⌐_", "'ÿ⌐_"]
             Implicitly print stack joined together : ÿ'ÿ⌐_'ÿ⌐_

Quine 2

û                Push the next 2 bytes as a string
 ]∙              Stack: ["]∙û"]
   û  û...      Repeat this for the rest of the code
           ]              Wrap the stack in an array : [["]∙","xô"...]]
            ∙             Triplicate                 : [[..],[..],[..]]
             x            Reverse the top array
              ô           Loop over the array, executing the next 6 instructions
                          Stack: [[..],[..],str]
               ¬          Rotate the stack : [str,[..],[..]]
                ûûû╡      Push the string "ûû" and discard the left character
                    ¬     Rotate the "û" to the bottom : ["û",str,[..],[..]]
                          This produces the initialisation part
                     ô    Loop over the array with the next 6 characters again
                      ╡╡xxx¬      Basically discard the string
                            ô     Flatten the last copy of the array onto the stack
                                  Implicitly output the code

Quine 3:

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ
ù...          Push the next 3 bytes as a string
              You know how this goes
    a         Wrap the top element in an array
     6æ       Repeat the next 4 instructions 6 times
       \      Swap the two top items
        a     Wrap the top item in an array
         \    Swap back
          +   Combine the two arrays
              This puts all the strings into a single array
           6            Push a 6
            ┼           Push the element two items down (the array)
             \          Swap with the 6 (this basically duplicates the array)
              ùùùù      Push "ùùù"
                  \§    Swap and get the 6th character (wrapping)
                    \   Swap with array : ["ù", [..]]
                     +  Prepend to array (implicitly mapping)
                      Σ\Σ     Join both the lists to strings and output

Quine 4:

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~
""             Push the empty string
  "..."        Push some code : ['','...']
       `       Copy the top two elements of the stack : ['','...','','...']
        ~      Evaluate the top element as code : ['','...','']
▐              Prepend the empty string to the code
  ⌠            Push a space and increment by 2 to get a quote
   ▌           Prepend to the array
     ⌠▌ ⌠▌ ⌠   Repeat three more times, leaving the last on top : ['', '""...','"']
              ⌠⌠...       Push a space and increment until it reaches a '`'
                    ⌠⌠... Repeat for the '~' : ['','"""...','"','`','~']
                          Implicitly output

Quine 5:

♠              Push 256
 ((...         Decrement until it reaches the correct byte representing the code
               Repeat for each character of the code
      DÄ       Repeat the next instruction 14 times
        ß      Wrap the top 4 elements in an array
         ─     Flatten the resulting monstrosity
          ·    Triplicate the array
           ö   Map the next 7 instructions over the array
                      Stack : [[..],[..],num]
            ♠         Push 128
             ,        Reverse subtraction : [[..],[..],128-num
              ♦M-$    Push the ( character
                  *   Repeat it 128-num times
                   DÄß─         Gather that up in an array and flatten again
                       ö        Map the next 6 instructions
                        7($$$qq
                    7($$$q    Print a ♠, without newline
                              q   Print the brackets without newline
                                  Stack : [[..],[..]]
                               $     Map the number to their values in the code page
                                Äq   Map print over each element
                                  ╘  Discard the last element of the stack

Quine 6:

Alasan Quine ini begitu jauh lebih lama dari yang lain adalah bahwa incrementing string menggunakan representasi unicode, yang benar-benar menyebalkan untuk beberapa karakter dalam kode, terutama ketika kita mencoba untuk membuat karakter ⌂dalam kode, yang mengembang kode oleh lebih dari 8000 karakter, yang kemudian mengembang bagian representasi dengan jumlah yang sangat besar.

⌂         Push an * character
 ))...    Increment until we reach the right character + 8
      ♫{ }            Repeat 10000 times
        α             Wrap the top two elements in an array
          ♫{     }    Then repeat 10000 times
            m{{}}     Shallowly flatten the array
                  h∞<     Double the array
                     m{          Map the doubled array to
                       ïí½<¿{    If it is the first half of the array
                             ⌂⌂  Push two asterisks
                               )))...    Increment into a '⌂' (there are something like 8000 )s here, with a couple of ! to help
                                     @   Rotate the top three elements
                                         Stack : ["⌂",char,"*"]
                                      0{     α4<{}=}←  Repeat while the asterisk is not the char
                                        ⌂⌡)   Push a )
                                           @  Rotate it under the char
                                            ) Increment the asterisk
                                                     ;;   Pop the extra copies of the character
                                                       }{  Else
                                                         ⌡⌡⌡⌡}   Subtract 8 from the character
                                                              }{}  End map and flatten array
                                                                   Print implicitly

Quine terakhir ini akan berkurang secara signifikan jika MathGolf konsisten pada apakah string menggunakan halaman kode asli atau tidak.

Python 2, 2 quines, 434 353 349 446 byte

Ini sebagian besar hanya untuk melihat apakah saya bisa melakukannya dengan Python.

30 byte (termasuk baris tambahan):

z='z=%r;print z%%z';print z%z

dan 416 byte, tanpa baris baru:

exec"696d706f7274207379730a793d222222696d706f7274207379730a793d7b7d0a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222220a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f6465282268657822292729".decode("hex")

(Golf 81 byte berkat Lynn tetapi menambahkan beban karena peduli tentang baris baru.)

Penjelasan

Yang pertama hanya standar pendek Python , tetapi dimodifikasi untuk tidak digunakan _. Karena ini adalah Python 2 juga tidak menggunakan (atau ).

Yang kedua mengambil beberapa pemikiran. String panjang dikodekan menggunakan hexcodec (sehingga menjamin bahwa itu hanya akan berisi 0- 9dan a- f) dan diterjemahkan sebagai

import sys
y="""import sys
y={}
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')"""
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')

Ini menggunakan tipuan quine untuk mendapatkan kode sumbernya sendiri, kemudian menyandikannya menggunakan hex_codec, dan kemudian mencetaknya dikelilingi exec"".decode("hex"), menggunakan sys.stdout.writeuntuk menghindari mencetak baris baru. Menjalankan kode ini menghasilkan quine kedua, yang merupakan cara saya membuatnya.

Saya menduga bahwa lebih dari dua tidak mungkin dalam Python, meskipun saya ingin melihatnya jika saya salah!

Jika Anda tidak keberatan eval quines

Ørjan Johansen menyarankan yang berikut ini untuk quine kedua yang sudah disandikan

y="""import sys
sys.stdout.write('exec"'+('y='+'"'*3+y+'"'*3+';exec y').encode("hex")+'".decode("hex")')""";exec y

yang akan mencetak 30 + 248 = 278 byte untuk output berikut:

exec"793d222222696d706f7274207379730a7379732e7374646f75742e777269746528276578656322272b2827793d272b2722272a332b792b2722272a332b273b65786563207927292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222223b657865632079".decode("hex")

Penggunaan execdengan cara ini tidak curang menurut aturan quine yang tepat PPCG tapi rasanya agak menipu saya (elegan dan pintar, tapi masih curang), karena beberapa karakter digunakan sebagai kode dan data. (Meskipun versi saya digunakan exec, kode dan datanya terpisah.) Jadi saya akan mempertahankan skor saya di 446.

Japt , 2 3 quines, 106 172 bytes

Yang pertama adalah versi verbose yang cukup dari jawaban quine char N saya .

[91,57,49,100,185,44,85,44,186,57,51,100,185,44,186,49,48,100,185,44,186,85,109,100,185,172,93,172]
[91d¹,U,º93d¹,º10d¹,ºUmd¹¬]¬

Coba di sini .

Quine kedua adalah quine bagus ETHProduction yang lebih besar , yang merupakan quine standar yang baik untuk Japt.

"iQ ²"iQ ²

Coba di sini .

Yang ketiga menggunakan ``dan char-code XORing untuk menyimpan data.

T=`f=fR;Zff-R-ReX%`;`T=\``+T+Tc^#

Coba di sini .

Sejak ()'masih tersedia, itu mungkin mungkin untuk memeras satu Quine lagi.

Gol> <> , ₂ 3 quines, _{17 28 27} 26 byte

6 byte

"r2ssH

Cobalah online!

_{11 10} 9 byte

'3d*Wo{|;

Cobalah online!

11 byte

Eh`#Ma0piS0

Cobalah online!

Gol> <> memiliki tiga cara untuk mencetak arang:

• o Pop satu nilai dan cetak sebagai char
• H Pop segalanya, cetak sebagai char, dan berhenti
• S"..." Cetak string literal tanpa memengaruhi tumpukan sama sekali

Tetapi saya tidak dapat menemukan cara untuk menulis quine menggunakan S"..."sebagai satu-satunya metode output, jadi saya datang dengan dua di atas, menggunakan dua jenis string literal.

Yang ketiga (oleh Jo King) menggunakan pperintah untuk membuat "in S"on the fly, yang pada gilirannya mencetak semuanya kecuali nol di akhir. Kemudian Ehcetak angka nol dan keluar.

Sekarang kita telah menggunakan semua perintah output DAN pperintah, saya percaya tidak mungkin untuk membuat quine lain (kecuali seseorang datang dengan S"quine tanpa p).

Ruby , 2 quines, 27 + 44 = 71 byte

$><<<<2*2<<2
$><<<<2*2<<2
2

Cobalah online!

s=%q{s=%q{S};s[?S]=s;puts s};s[?S]=s;puts s

Cobalah online!

Saya terutama dibatasi oleh metode output, di sini. Ada beberapa cara memanipulasi string, tetapi terlepas dari $><<semua metode output yang dapat digunakan tampaknya terlalu banyak bersinggungan. Saya pikir mungkin ada jalan keluar dengan evaltetapi sulit harus bersarang manipulasi string dari berbagai jenis.

Javascript ES6, 2 quines, 43 + 22 = 65 byte

Quine 1:

(function f(){return[,f,'))'].join('(')}())

Quine 2:

g=z=>"g="+g+";g``";g``

> <> , 2 quines, 8 + 16 = 24 byte

8 byte

#o<}-1:"

Cobalah online!

Diambil dari jawaban ini .

16 byte

'r3d*d8*7+e0p>>|

Cobalah online!

Ini didasarkan pada 'r3d*>o<quine, kecuali odan <tidak dapat digunakan, jadi saya diganti <dengan |dan dibuat secara dinamis o(111 = 8 * 13 + 7) dan menempatkannya di tempat ke-2 >.

2 quines adalah batasnya

Sayangnya, kami dibatasi oleh jumlah perintah keluaran. ntidak berguna karena hanya menampilkan angka, jadi oharus dieksekusi di quine apa pun. Satu-satunya cara untuk membuat secara dinamis oadalah dengan p. Jadi satu quine dapat digunakan o, dan yang lainnya dapat membuatnya p, tetapi tidak ada quine ke-3.

Dimungkinkan untuk memiliki quine ketiga meninggalkan kode sumber di stack jika itu diperhitungkan.

Java 10, 2 quines, 1448 1248 bytes

1350 1122 byte

\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0022\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0025\u0063\u0025\u0073\u0025\u0031\u0024\u0063\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0025\u0031\u0024\u0063\u0025\u0063\u0025\u0033\u0024\u0063\u0075\u0025\u0025\u0030\u0034\u0058\u0025\u0031\u0024\u0063\u002C\u0063\u0029\u0029\u003B\u007D\u0022\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0022\u005C\u005C\u0075\u0025\u0030\u0034\u0058\u0022\u002C\u0063\u0029\u0029\u003B\u007D

Cobalah online.

Setara dengan:

v->{var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";r.format(r,34,r,92).chars().forEach(c->System.out.printf("\\u%04X",c));}

Penjelasan:

v->{                   // Method with empty unused parameter and no return-type
  var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";
                       //  Unformatted source code
  r.format(r,34,r,92)  //  Formatted quine
   .chars()            //  Loop over the characters as integers
   .forEach(c->System.out.printf("\\u%04X",c));}
                       //   Print "\u" with hexadecimal value of these characters

126 byte

v->{int i='}'-'[';var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";System.console().printf(s,i,s,i);}

System.console()akan kembali nullketika tidak ada yang disediakan, jadi TIO mengembalikan a NullPointerExceptiondalam hal ini .

Untuk membuktikannya sebagai quine yang berfungsi, gantilah System.console()dengan System.out: Coba online.

Penjelasan:

v->{              // Method with empty unused parameter and no return-type
  int i='}'-'[';  //  Integer `i` = 34 (unicode value for double-quote)
  var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";
                  //  Unformatted source code
  System.console().printf(s,i,s,i);}
                  //  Print formatted quine

Penjelasan umum:

Di Jawa quine biasanya dilakukan seperti ini:

• Ini String sberisi kode sumber yang tidak diformat.
• %sdigunakan untuk memasukkan String ini ke dalam dirinya sendiri dengan s.format(...).
• %c, %1$cdan 34digunakan untuk memformat tanda kutip ganda.
• s.format(s,34,s) menempatkan semuanya bersama-sama.

Dalam hal ini fungsi lambda quine terpendek di Java 10 adalah ini ( 82 byte ):

v->{var s="v->{var s=%c%s%1$c;return s.format(s,34,s);}";return s.format(s,34,s);}

Cobalah online.

Karena satu-satunya cara untuk memiliki dua quine di Java menggunakan versi unicode \uHEXA, yang dikonversi ke karakter selama kompilasi, saya tidak dapat menggunakan karakter 0123456789ABCDEF\udalam versi non-unicode. Jadi, versi non-unicode yang lebih kecil akan menggunakan System.console()alih-alih returnatau System.out(keduanya berisi 'u'), dan akan menggunakan '}'-'['dan dua kali %calih-alih 34dan %1$c.

Beberapa hal yang perlu diperhatikan tentang versi unicode:

• Saya sengaja menggunakan %04Xbukannya %04x(untuk huruf heksadesimal bukan huruf kecil).
• Saya menggunakan 92, %cdan %3$cuntuk memformat garis miring.
• Menggunakan huruf kapital \Ualih-alih huruf kecil \utidak diperbolehkan, jika tidak, saya hanya akan menggunakan returnversi non-unicode yang lebih pendek.