Quine Suite yaz


30

Pek çok zorlu karşı karşıya kaldık , fakat pek çok terzi formatı benzer, sıralarımızda biraz değişkenlik yaratabiliyor.

Göreviniz, hepsi kendi kaynak kodlarını çıkaran aynı dilde (en az 2) bir program seçimi oluşturmak, ancak bu programların hiçbiri herhangi bir karakteri paylaşamıyor.

Örneğin, aşağıdakileri kullanarak bir program oluşturursanız:

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

Bir sonraki programınız hiçbirini içeremez:

%()+2finpqrstwx

ve bunun gibi.

kurallar

  • Unicode karakterler kullanabilirsiniz, ancak yine de bayt cinsinden puan vermelisiniz.
  • Tüm programlar topluluğun uygun bir quine tanımına uygun olmalıdır . Bu, boş dizginin, diğer şeylerin yanı sıra geçerli bir dizge olarak sayılmadığı anlamına gelir.
  • Standart boşluklar yasaktır.
  • İşlevlere veya tam programlara, yukarıdaki tanımı karşıladıkları sürece izin verilir.
  • Sembolden bağımsız dillere (Lenguage ve Headsecks dahil) izin verilmez.
  • Çoğu program, en kısa toplam kodla beraberlik kırıcı olarak kazanır.

Yakın oylar olduğu için, tartışma için sanal alan gönderisinin sırasını kaldıracağım
Dom Hastings

Sanal alan yorumlarının, işlev gönderimlerine izin verildiğinden bahsettiğini fark ettim, ancak meydan okuma bununla ilgili hiçbir şey söylemedi - bunun tersini, quines için varsayılan olarak varsayıyordum.
Ørjan Johansen

2
İlgili (Sohbetin zorluğunun türü - sınavlarınızın kendileri yerine birbirlerini çıkarmaları gerekir)
Nathaniel

1
Peki ya takip eden yeni hatlar? Kuyruklarımdan biri birini basarsa, diğeri bunu yapmaktan kaçınmak zorunda mı? (Çoğu cevabın bunu yapmadığından şüpheleniyorum.)
Nathaniel,

2
@DomHastings Meta bir soru bulamadım, ben de sordum .
Nathaniel

Yanıtlar:


27

V , 3 , 5 kuyruk, 46 bayt

2A2A

Çevrimiçi deneyin!

HexDump:

00000000: 3241 3241                                2A2A

Açıklama:

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

5­­­a5­­­a

Çevrimiçi deneyin!

HexDump:

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

Açıklama:

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

1«I1«I

Çevrimiçi deneyin!

HexDump:

00000000: 31ab 4931 ab49                           1.I1.I

Açıklama:

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

İşte korkak olmaya başladıkları yer ...

ñi34x@-qPÉÑ~ÿ

Çevrimiçi deneyin!

HexDump:

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

Açıklama:

ñ                       " 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

Çevrimiçi deneyin!

HexDump:

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

Açıklama:

: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')

Bu cevap kara büyü ile doludur. Birinci ve 4. sıralar yeni değildir, ancak diğer 3 tanesi daha önce bulunamamıştır, bu nedenle bu sıraların yarısından fazlası bugün keşfedilmiştir.


8
Üçüncü program trolling. "Siz bir normie :p"
mbomb007

4
@ mbomb007 ZorunluREEEEEE--
Magic Octopus Urn

17

Jelly , 2 3 4 5 quines, 14 18 81 65 59 56 326 265 247 229 216 bayt

3 bayt

”ṘṘ

Çevrimiçi deneyin!

Standart quine. ”Ṙkelimenin tam anlamıyla tek karakterdir . Bunun dize gösterimini sonra dizgeyi yazdırır örtülü olarak yazdırılır.

4 bayt

⁾⁾ḤḤ

Çevrimiçi deneyin!

iki karakterli bir dizgeyi başlatır ve bunun argümanını iki katına çıkarır. Bir dize girişi ile, her karakterin üzerine eşlenir. Böylece ipte etkili⁾Ḥ verimi⁾⁾ḤḤ , kaynak kodu.

11 bayt

ȮṾṖƊ}“ȮṾṖƊ}

Çevrimiçi deneyin!

Sağ tarafta “ȮṾṖƊ}, dize değişmezȮṾṖƊ} . Dize kapatma karakteri EOF'de tam olarak eklenir.

Dizgi değişmezinin solunda, tek bir monad içine Ɗsarılır ȮṾṖve }onu doğru değişkeni, dize değişmezini kullanan bir dyad'a dönüştürür. Ȯdizeyi ( ȮṾṖƊ}) yazdırır, dizenin ( ) dizesini temsil eder “ȮṾṖƊ}”ve karakteri kaldırır . Dize “ȮṾṖƊ}monaddan sonra bırakılır ve örtük olarak basılır.

38 49 36 bayt

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

Çevrimiçi deneyin!

Jelly golfünde ilk kez bir yer kullandım.

Baştaki sayıların listesi ordkoddaki karakterlerin geri kalanını tutar . Daha sonra:

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 bayt

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

Çevrimiçi deneyin!

Temel 250 sayı ve dizinleri Jelly kodu sayfasına kullanır. Algoritmayı değiştirerek 72 bayt kaydedildi. Her numarayı Jelly kod sayfasına indekslemek için kullanıyordum, ancak şimdi tamsayı tekrar 250 tabanına dönüştürüyorum, sonra ilk satırda ihtiyacım olan değişmezlerin sayısını yarıya indirerek Jelly kod sayfasına indeksliyorum. Bu ayrıca ihtiyaç duyulan benzersiz karakter sayısını da azaltır, ancak daha fazla sorgu yapmanın bir yolunu düşünemiyorum.

Ben kullandım ⁾“”dize hazır oluşturmak ve hangi ve ØJnumaralardan dizeleri oluşturmak hangi. Başka ipler yapmanın başka yollarını düşünemiyorum. Hala rakam var 9ve ‘’bir başka Quine yapmak mümkün olabilir numaralardan dizeleri yapma başka yolu yoktur eğer öyleyse, mevcut.


13

Haskell , 3 quines, 1119 bayt

Quine 1, 51 bayt

IODoğrudan stdout'a yazdıran anonim bir işlem.

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

Çevrimiçi deneyin!

Quine 2, 265 bayt

İşlev fkukla bir argüman alır ve bir dize döndürür.

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]

Çevrimiçi deneyin!

Quine 3, 803 bayt

LANGUAGEPragma'dan sonraki her şey , sahte bir argüman alan ve bir ip döndüren muazzam bir fonksiyondur.

{-#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'

Çevrimiçi deneyin!

Karakterler

Quine 1:


"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

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

Nasıl çalışır

Quine 1

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

Quine 1 Benim son değiştirilmiş bir versiyonu Golf sana quine (H.PWiz tarafından geliştirmelerle) cevap:

  • Tam programlar gerekli olmadığından, main=kaldırılmıştır.
  • <>ve $onların yakın eş anlamlıları mappendile değiştirilmiştir id.

Bu , diğer karakterlerde hayati karakterleri =<>ve yardımcı operatörü serbest bırakır $.

Quine 2

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

Quine 2, son Mutual Exclusive Exclusive Quines cevabımın 2 programını programlamak için biraz benzer yöntemler kullanıyor , ancak doğrudan kendi için quine ve özellikle de quin 3 için gerekli olan karakter değişmezlerini kullanmaktan kaçınmak için uyarlandı.show fonksiyonun Şans eseri, henüz kullandığı hiçbir karaktere sahip değildi.

Bu quine boşluk yerine sekmeleri kullanıyor, ancak okunabilirlik için aşağıdaki boşlukları kullandım.

  • gKodun sonundaki tamsayıların listesi olarak quine verileridir. Her sayı, kodun geri kalanından bir karakter gösterir.
    • Sayılar, 9o sekme olacak şekilde kaydırılır 0. Bu, fonksiyon için küçük harflerin ve değişken adlarının 2 basamağa sığmasına izin vererek kodlamayı biraz kısaltır.
  • b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] sayıyı karaktere dönüştürmek için kullanılan bir işlevdir (aslında bir karakterlik bir dize).
    • [[show 9!!0,show 1!!0..]!!6..]ile dizine eklenmiş bir sekme karakteriyle başlayan bir karakter aralığıdır !!c.
    • Sekme karakterinin kendisi başka bir dizine indeksleyerek [show 9!!0,show 1!!0..], rakam karakterleriyle başlayan '9've '1'8 adımda aşağı atlayarak üretilir .
    • Rakam karakterleri show, karşılık gelen rakamın dizgisine indekslenerek üretilir .
  • f c=[b=<<g]!!0++show gana işlevidir. ckukla bir argümandır.
    • b=<<gkullandığı =<<her sayı dönüştürmek için gonun karakterine. ( =<<Örneğin yerine map, neden bdöndürülen karakterini bir listeye sarması gerektiğinin nedenidir .)
    • show gg'in listesinin string gösterimini verir ve ++dizeleri birleştirir.
    • Çünkü =<<daha düşük önceliğe sahip ++, biraz parantez gerekli. Kullanmamak için ()(3. [...]!!0sıraya ayrılmıştır), bir element içeren bir listeye endekslenir.

Quine 3

Diğer kuyrukların tasarımına göre, 3. sıra hala parantez, lambda ifadeleri, karakter değişmezleri ve string / list yapıcısına erişebiliyor :. Bu , quine kodunu bir dizeye hazırlayan bir fonksiyon oluşturmak için yeterli olacaktır .

Ne yazık ki, tüm küçük harfli ünlüler (bazen hariç y) kullanılmış ve faydalı alfanümerik yerleşik işlevler bırakılmamış. Ayrıca []""gitti. Bu , kodu gibi davranmaya başlamak için boş bir dize oluşturmak için normal bir yol bırakmaz.

Bununla birlikte, neredeyse tüm büyük harfler hala mevcuttur, bu nedenle LANGUAGEdil uzatması için bir pragma mümkündür. Yine tam şans, CPP(C önişlemcisini etkinleştir) yalnızca büyük harflerle adlandırılan tek dil uzantısıdır. CPP makroları genellikle büyük harf adlarına sahiptir.

Böylece, temel boş dizgiyi elde etmek için, quine , formun bir dizgisi sabiti elde etmek için makroyu CPPkullanır (her zaman aynı uzunlukta olması uygun şekilde garanti edilir) ve desen üzerinde eşleşir.__TIME__"??:??:??"

{-#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&'{'&'-'&......

Dil pragmasından sonra, quine, parametrelerini bu dört argümana bağlayan bir lambda ifadesinden oluşur ( _daha sonra uygulanacak son bir boş parametre bırakarak ):

  • qbağlı '\'', tek bir alıntı karakteri vererek;
  • _:_:_:_:_:_:_:_:zbağlı __TIME__gibi bir dize aka "??:??:??"böylece yapım zboş bir dize;
  • ybağlı olarak (\(?)v k x->v$k?x), quine verilerinin sol ilişkili ("katlama") 'dan sağ ilişkili ("katlama") forma dönüştürülmesine yardımcı olmak için kullanılan bir lambda birleştiricisi;
  • Operatör (#)bağlı \(&)(%)v->v&'{'&'-'&...quine verilerinin kendisi,.

Kesit verileri, kilitli kodlama şeklinde, parametreli bir lambda ifadesi şeklinde verilir (&)(%)v.

  • Örneğini oluşturmak için belirli değerlere ifade uygulayarak (&), (%)vev bu kodlama Quine'ın çekirdek kodu oluşturmak için ya da quine veri temsilini kendisini yeniden halinde kullanılabilir.
  • Haskell'in varsayılan sabitlik kuralı &ve %lambda içinde solda ortak operatörler haline gelir. Böylece karakter parametreleri vsoldan başlayarak başlangıçta birleştirilir .
  • Çoğu karakter kiçin bir karşılık vardır &'k'.
  • Karakter değişmezleri içinde kaçması gereken veya olduğunda k, bunun yerine kodlama yapılır .'\%'\k'

Veri kodlaması birleştirici bırakıldığından, ancak dizeler doğru ilişkilendirici bir şekilde oluşturulduğundan, birleştirici y = (\(?)v k x->v$k?x)uyumsuzluğu köprülemek için tanıtılır.

  • y(...)quine verileri (&)ve (%)operatörleri olarak kullanmak için uygun fonksiyonlar oluşturmak amaçlanmıştır .
  • vdizgilerden dizgilere bir işlevdir (quine verilerinin amaçlanan vörnekleridir).
  • kkarakter, xbir dize ve ?bunları yeni bir dizgede birleştiren bir işlecidir. (Çekirdek kod (?)=(:)için,...... .Quine veri temsilini yeniden yapılandırmak için, daha karmaşıktır.
  • Bu nedenle y(?)v k = \x->v$k?x, dizgilerden dizgelere başka bir işlevdir.
  • Bunun ilişkililiği nasıl değiştirdiğinin bir örneği olarak, eğer (&)=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)

Daha genel olarak, (#)ince veri işlevi ne zaman ve f1,f2karakterleri karakter dizileriyle birleştiren işlevlerdir:

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

quine veri işlevini (&)=y(f1)ve ile uygulamak (%)=y(f2)ve bu, öngörülen f1ve f2quine verilerinin karakterlerini birleştirmek için kullanır xve sonra elde edilen dizgiyi iletir v.

Ana lambda ifadesinin gövdesi bunu bir araya getirir:

(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z
  • '&':q:k:q:xBir karakter için kbaşa ekler &'k'dize xise, '%':q:'\\':k:q:xprepends %'\k'orijinal quine veri formları,.
  • Bu nedenle y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x, son veriye z(boş dize) hazırlanmış ve ardından aşağıdaki işleve geçirilen ince veri gösterimini yeniden oluşturmak için doğru parametrelerdir .
  • y(:)#y(:) Quine'in çekirdek kodunu başka bir değişiklik yapmadan bir dizgeye hazırlamak için doğru parametrelerdir.
  • Sonunda \x->x, döndürülen yapılı quine ile hiçbir şey yapmaz.

9

Perl 6 , 3 sorgu, 274 bayt

Quine 1, 52 bayt

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

Çevrimiçi deneyin!

Quine 2, 102 bayt

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]))

Çevrimiçi deneyin!

Quine 3, 120 bayt

<'.EVAL'.UC,' GIVEN ',「「PRINT "<'.EVAL'.UC,' GIVEN ',「「".UC,.UC,"」」>.LC",".EVAL.EVAL".UC」」>.lc.EVAL.EVAL

Çevrimiçi deneyin!

Farklı bayt gruplarının doğrulanması

Üçüncü sırayı almak için çok fazla manevra oldu. Perl 6 (Bildiğim kadarıyla o) çıkışının 4 yöntemleri vardır, say, put, printve printf. Hem sayve putçıkış yeni satırlar, ben de kullanamıyorum olarak. put, print, printfTüm içerirler pve t. EVALBüyük harf kullanarak , kısmen bu sorunu çözebiliriz PRINT. Oradan 4 kuyruk almak mümkün olduğunu sanmıyorum ... (belki de shell "echo 'quine'"işe yarayabilir)

Operatörleri, boşlukları, sekmeleri ve yeni satırları ayırmak için farklı boşluk türlerini kullanarak boşluklarla ilgili sorunları çözebiliriz.

açıklamalar:

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:

Bu, printf |(q[printf q[%s]]xx 2)formattaki bir yazıdır, yani dizenin bir kopyasını kendi içine formatlar. Ancak sönceki quine'da kullanıldığı için kullanamayız say. Biz dize VEYA operatörünü kullanmak (Yani ~|) üzerine @ve !3üretme %sparçasını, ama yapmamız gereken bu yüzden, eklenecek biçim dizesi ve dize hem bunu yapamaz Z~ekstra dize ve boş bir dize ile, o zaman ,ikisini ayırmak için kullanamayız , o zaman Xx qw[1 0]1 ile 0 ile çarpmak için yapıyoruz .

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:

Bu, diğer kuyruklarla çatışmayı önlemek için her şeyi büyük harf yapmak için elinden gelenin en iyisini yapan EVAL bir quine'dir. Bu kapsar çok ait EVALepeyce yanı sıra s lcve ucdurumlar arasında dönüştürmek için.

<...>.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

9

MathGolf , 4 5 6 quines, 193,535 bayt

9 bayt

ÿ'ÿ⌐_'ÿ⌐_

Çevrimiçi deneyin!

45 bayt

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

Çevrimiçi deneyin!

49 bayt

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

Çevrimiçi deneyin!

99 bayt

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

Çevrimiçi deneyin!

4488 bayt

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

Çevrimiçi deneyin!

188,845 bayt

Bununla gerçekten bağlantı kuramıyorum, işte asıl sırayı oluşturan Perl 6 programı

Farklılığın doğrulanması

Kesinlikle kesinlikle bundan başka bir ip sıkıştırabilirim, ancak ipleri doğrudan yığına itme yollarım bittiğine inanıyorum, bu yüzden yabancı yöntemlere başvurmak zorunda kalacağım. Altıncı bir quine için çalışırken bile yabancı yöntemler geliyor. Bazı durumlarda, kuyruklar daha kısa olabilir, ancak hazırlık aşamasında kullanılan baytları düşürüyorum.

Tamam, teknik olarak bir tane daha quine yapabilirim, çünkü hala ihtiyacım olan birkaç operatöre sahibim (push string, artım string, çoğaltma, mapping, haşhaş), bizi daraltan döngü. {}İstenilen uzunlukta bir kod bloğu gösterebilir tek operatörleri ve gerçekten 6 Quine'ın bunları gerekir. Diğer kod bloklarından bazılarını kullanabilirim, ancak sınırlıdırlar ve kolay operatörlerden kaçtığımız için döngü bölümlerinin bu kadar kısa olacağından şüpheliyim.

Tamam, bazı gecikmeli açıklamalar:

Bütün quines neredeyse aynı yapıya sahiptir:

  • Bir dizeye veya dizelerin listesini veya yığına karakterlerin listesini itin.
  • Hepsini bir listede birleştirin
  • Listeyi çoğalt
  • Orijinal karakterleri elde etmek için kullanılan karakterleri yazdırarak / iterek kopyanın üzerinde eşleyin
  • Orijinal karakter listesini dize olarak yazdırma

Quine 1:

Bu temelde normal quine sorusuna gönderdiğimle aynı.

ÿ'ÿ⌐_'ÿ⌐_
ÿ            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:

Bu kıskacın diğerlerinden çok daha uzun olmasının nedeni , artan dizgelerin koddaki karakterlerin bazıları için gerçekten berbat olan unicode gösterimleri kullanmasıdır, özellikle de kodu kodunu şişiren kodda karakter yaratmaya çalıştığımızda 8000'den fazla karakter, bu da gösterim bölümünü çok büyük miktarda şişirir.

⌂         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

MathGolf, dizelerin yerel kod sayfasını kullanıp kullanmama konusunda tutarlı olsaydı, bu son sorgu önemli ölçüde azalırdı.


Yaratıcılığınıza hayran kaldım, bunlarla nasıl başa çıkabildiğinize dair bazı açıklamaları çok isterim. İlki, orijinal quine mücadelesinden tanıdığım, ancak geri kalanı sonsuza dek sürdükleri gibi görünüyor.
mart

@ maxb Altıncı bir quine üzerinde çalışıyorum ve ya bunu gönderdikten sonra ya da bıraktıktan sonra açıklama göndereceğim. btw, chr / ord ve artan karakter komutları tutarsız görünüyor. Birincisi kod sayfasını kullanır, ikincisi tipik unicode kullanır (ki bu 6. sırayı uzun süredir yapıyor)
Jo King

Uyguladıktan bir süre sonra sadece chr/ordbir tanesini kullandım, ikisini de kod sayfasını kullanmam gerektiğini düşündüm.
mart

6

Python 2,2 quines, 434 353 349 446 bayt

Bu çoğunlukla Python'da yapıp yapamayacağımı görmek içindi.

30 bayt (takip eden bir yeni satır dahil):

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

ve 416 bayt, sonunda yeni satır yok:

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

(Lynn sayesinde 81 byte golf attı, ancak yeni satırı dikkate alması nedeniyle bir yük ekledi.)

açıklama

İlki, sadece standart kısa Python quine'dir , fakat kullanılmaması için değiştirildi _. Bu Python 2 olduğundan, (ya da kullanmaz ).

İkincisi bazı düşünceler aldı. Uzun dize, hexcodec kullanılarak kodlanır (bu nedenle yalnızca 0- 9ve a- içereceğini garanti eder f) ve

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")')

Bu, kendi kaynak kodunu elde etmek için ince numaralar kullanır, sonra onu kullanarak kodlar hex_codecve sonra yeni bir satır yazdırmaktan kaçınmak için etrafını exec"".decode("hex")kullanarak sys.stdout.writeyazdırır. Bu kodun çalıştırılması, ikinci diziyi çıkarır;

Python'da ikiden fazla imkansız olduğundan şüpheleniyorum, yanılıyorsam görmek isterim!

Sakıncası yoksa eval quines

Ørjan Johansen önceden kodlanmış ikinci quine için şunu önerdi

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

aşağıdaki çıktı için 30 + 248 = 278 bayt olur:

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

Kullanımı execbu şekilde PPCG göre hile değildir uygun quine kurallarına ama bazı karakterler kodun hem de veri olarak kullanılmaktadır, çünkü benim (hala zarif ve zeki ama cheaty) için biraz cheaty hisseder. (Sürümüm kullanmasına rağmen execkod ve veriler ayrı.) Bu yüzden puanımı 446'da tutacağım.


1
"hex"yerine, "hex_codec"bir kaç bayt kurtarması gereken çalışır !
Lynn

1
Sondaki yeni satırlar önemliyse neden ilk sıranın sonuna boş bir satır eklemiyorsunuz?
mbomb007

1
Gibi bu . Bunun exec / eval olan dillerde oldukça standart bir aldatmaca olduğunu biliyorum.
Ørjan Johansen

1
Neden ilk quine ile aynı formatı kullanmıyorsunuz? Bunun gibi mi?
Jo King

2
print '<tab>',sonunda bir boşluk eklemez. Bu 85 açabilir Jo King'in öneri kapalı bayt: tio.run/...
ovs

5

Japt , 2 3 sıra, 106 172 bayt

İlki, N karakter quine cevabımın oldukça ayrıntılı bir versiyonudur .

[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¹¬]¬

Burada dene .

İkinci quine ETHProduction'ın Japt için iyi bir standart quine olan daha iyi quine'sidir.

"iQ ²"iQ ²

Burada dene .

Üçüncüsü ``, verileri depolamak için XORing'i kullanır ve karakter kodunu kullanır .

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

Burada dene .

Yana ()'hala kullanılabilir durumda olduğunu belki bir daha Quine dışarı sıkmak mümkün.


1
Gerçekten, gerçekten birincisini golfe atmaya çalışmak istiyorum, ama biliyorum ki, birkaç bira içtiğimde, tek bir karakteri değiştirmeye çalışır kalmaz beynim patlayacak! Lanet olası quines!
Shaggy

@Shaggy Alt çizgiyi almak ve içinden geçmek "'[+U+']+R+(Umd)¬"q mcsize hızlı güncellemeler için ilk satırı veriyor, eğer yardımcı olursa.
Nit

Ayrıca, daha fazla çekirdek sembolü olması için ilk çözümü yeniden değiştirdim, şimdi bir tane daha ekleyebilmek pratikte mümkün olabilir.
Nit

Bekle, şimdi puanın yüksek!
Shaggy

@Shaggy Kasıtlı olarak, başka bir sine yer açmaya çalışıyorum, kısaltmaya çalışmıyorum.
Nit

4

Gol> <> , 2 3 quines, 17 28 27 26 bayt

6 bayt

"r2ssH

Çevrimiçi deneyin!

11 10 9 bayt

'3d*Wo{|;

Çevrimiçi deneyin!

11 bayt

Eh`#Ma0piS0

Çevrimiçi deneyin!

Gol> <> herhangi bir char yazdırmak için üç yol vardır:

  • o Bir değeri aç ve char olarak yazdır
  • H Her şeyi patlat, karakter olarak yazdır ve durdur
  • S"..." Yığını etkilemeden dizenin değişmezini yazdır

Ancak kullanarak bir yazı yazmak için bir yol bulamadım S"..." as the only output method, so I came up with the above two, utilizing the two kinds of string literals.

(Jo King tarafından) üçüncüsü kullanır poluşturmak için komut "içinde S"sırayla sonunda sıfıra dışında her şeyi yazdıran anında. Sonra Ehsıfırı yazdırır ve çıkar.

Artık tüm çıkış komutlarını VE pkomutunu kullandığımızda, başka bir quine oluşturmanın imkansız olduğuna inanıyorum (birisi S"olmadan quine gelmezse p).


Bunun için nasıl S"..."?
Jo King,

3

Yakut , 2 sorgu, 27 + 44 = 71 bayt

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

I'm mainly limited by methods of output, here. There are quite a few ways of manipulating strings, but aside from $><< all the usable output methods seem to intersect too much. I think there might be a way out with eval but it's tricky having to nest multiple string manipulations of different kinds.


3

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

Quine 1:

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

Quine 2:

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

You could save a few bytes by not invoking the functions and then by using a template literal in the second one.
Shaggy

2
So JavaScript outgolfs japt
dylnan

@dylnan Not until it adds a third quine.
Nit

@Shaggy hey, thanks for your input, but I'm confused - shouldn't a quine be a full program? If it can be a function, must it print only itself? So would g=z=>"g="+g be a valid JS quine?
Pedro A

1
@Nit I'll see what I can do :P when dylnan commented, japt had only 2 quines as well
Pedro A

3

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

8 bytes

#o<}-1:"

Try it online!

Taken from this answer.


16 bytes

'r3d*d8*7+e0p>>|

Try it online!

This is based on the 'r3d*>o< quine, except o and < cannot be used, so I replaced < with | and dynamically created o (111 = 8*13 + 7) and placed it where the 2nd > is.


2 quines is the limit

Unfortunately, we're limited by the number of output commands. n is not useful because it only outputs numbers, so o must be executed in any quine. The only way to dynamically create o is with p. So one quine can use o, and another can create it with p, but there can be no 3rd quine.

It might be possible to have a third quine leave the source code on the stack if that counts.


2

Java 10, 2 quines, 1448 1248 bytes

1350 1122 bytes

\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

Try it online.

Equivalent to:

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));}

Explanation:

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 bytes

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() will return null when none is provided, so TIO returns a NullPointerException in this case.

To prove it's a working quine, replace System.console() with System.out: Try it online.

Explanation:

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

General explanation:

In Java a is usually done like this:

  • The String s contains the unformatted source code.
  • %s is used to input this String into itself with the s.format(...).
  • %c, %1$c and the 34 are used to format the double-quotes.
  • s.format(s,34,s) puts it all together.

In which case the shortest quine lambda-function in Java 10 would be this (82 bytes):

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

Try it online.

Since the only way to have two quines in Java is using the unicode version with \uHEXA, which is converted to characters during compilation, I'm unable to use the characters 0123456789ABCDEF\u in the non-unicode version. So, the smaller non-unicode version will use System.console() instead of return or System.out (both containing a 'u'), and will use '}'-'[' and two times %c instead of 34 and %1$c.

Some things to note about the unicode version:

  • I'm on purpose using %04X instead of %04x (for uppercase Hexadecimal instead of lowercase).
  • I'm using 92, %c and %3$c to format the slashes.
  • Using a capital \U instead of lowercase \u isn't allowed apparently, otherwise I would have just used return in the shorter non-unicode version.
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.