Mieliśmy wiele wyzwań quine , ale wiele formatów quine jest podobnych, pozwala stworzyć pewną wariancję w naszych quinesach.

Twoim zadaniem jest utworzenie wyboru programów w tym samym języku (co najmniej 2), z których wszystkie generują własny kod źródłowy, jednak żaden z tych programów nie może udostępniać żadnych znaków.

Na przykład, jeśli tworzysz program za pomocą:

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

Twój następny program nie może zawierać:

%()+2finpqrstwx

i tak dalej.

Zasady

• Możesz używać znaków Unicode, ale nadal musisz zapisywać wyniki w bajtach.
• Wszystkie programy muszą spełniać wspólnotową definicję właściwego quine . Oznacza to, że pusty ciąg znaków nie jest liczony między innymi jako poprawny quine.
• Standardowe luki są zabronione.
• Funkcje lub pełne programy są dozwolone, o ile spełniają powyższą definicję.
• Języki niezależne od symboli (w tym Lenguage i Headsecks) są niedozwolone.
• Większość programów wygrywa z najkrótszym łącznym kodem jako remis.

V , 3 , 5 quines, 46 bajtów

2A2A

Wypróbuj online!

Hexdump:

00000000: 3241 3241                                2A2A

Wyjaśnienie:

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

5­­­a5­­­a

Wypróbuj online!

Hexdump:

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

Wyjaśnienie:

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

1«I1«I

Wypróbuj online!

Hexdump:

00000000: 31ab 4931 ab49                           1.I1.I

Wyjaśnienie:

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

Tutaj zaczynają się funky ...

ñi34x@-qPÉÑ~ÿ

Wypróbuj online!

Hexdump:

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

Wyjaśnienie:

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

Wypróbuj online!

Hexdump:

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

Wyjaśnienie:

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

Ta odpowiedź jest wypełniona czarną magią. Quiny 1 i 4 nie są nowe, ale pozostałe 3 nie zostały nigdy wcześniej znalezione, więc ponad połowa z nich została właśnie odkryta.

Galaretka , _{2 3 4} 5 quines, _{14 18 81 65 59 56 326 265 247 229} 216 bajtów

3 bajty

”ṘṘ

Wypróbuj online!

Standardowy quine. ”Ṙjest dosłowny dla jednego znaku Ṙ. Ṙwypisuje reprezentację ciągu, a następnie ciąg Ṙzostaje domyślnie wydrukowany.

4 bajty

⁾⁾ḤḤ

Wypróbuj online!

⁾rozpoczyna literał ciąg dwóch znaków i Ḥpodwaja argument. Po wprowadzeniu ciągu Ḥjest mapowany na każdy znak. ḤDziałając w ten sposób na sznurku⁾Ḥ daje ⁾⁾ḤḤkod źródłowy.

11 bajtów

ȮṾṖƊ}“ȮṾṖƊ}

Wypróbuj online!

Po prawej stronie “ȮṾṖƊ}znajduje się literał ciąguȮṾṖƊ} . Znak zamykający ciąg jest automatycznie dodawany w EOF.

Po lewej stronie literału łańcuchowego Ɗzawija ȮṾṖsię w pojedynczą monadę i }zamienia ją w diadę, która używa właściwego argumentu, literału łańcuchowego. Ȯwypisuje string ( ȮṾṖƊ}), Ṿtworzy ciąg reprezentujący string ( “ȮṾṖƊ}”) i Ṗusuwa ”znak. Ciąg “ȮṾṖƊ}zostaje po monadzie i jest domyślnie drukowany.

38 49 36 bajtów

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

Wypróbuj online!

Po raz pierwszy użyłem przestrzeni w golfie Jelly.

Lista liczb na początku zawiera ordresztę znaków w kodzie. Po tym:

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 bajtów

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

Wypróbuj online!

Wykorzystuje podstawowe 250 liczb i indeksów do strony kodowej Jelly. Zaoszczędzono 72 bajty, zmieniając algorytm. Używałem każdej liczby do indeksowania na stronie kodowej Jelly, ale teraz przekształcam liczbę całkowitą z powrotem na bazę 250, a następnie indeksuję na stronę kodową Jelly, zasadniczo zmniejszając o połowę liczbę literałów, których potrzebuję w pierwszym wierszu. Zmniejsza to również liczbę potrzebnych unikatowych postaci, ale nie mogę wymyślić sposobu, aby zrobić więcej quines.

Zużyłem już, ⁾“”które tworzą literały łańcuchowe, Ọa ØJktóre tworzą ciągi liczbowe. Nie mogę wymyślić żadnych innych sposobów tworzenia łańcuchów. Nadal mam cyfrę 9i jestem ‘’dostępny, więc jeśli istnieje inny sposób tworzenia ciągów z liczb, może być możliwe wykonanie innego quine.

Haskell , 3 piny, 1119 bajtów

Quine 1, 51 bajtów

Anonimowa IOakcja drukowana bezpośrednio na standardowe wyjście.

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

Wypróbuj online!

Quine 2, 265 bajtów

Funkcja fprzyjmuje fikcyjny argument i zwraca ciąg znaków.

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]

Wypróbuj online!

Quine 3, 803 bajtów

Wszystko po LANGUAGEpragmie jest anymalną funkcją, przyjmującą fikcyjny argument i zwracającą ciąg znaków.

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

Wypróbuj online!

Postacie

Quine 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

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

Jak to działa

Quine 1

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

Quine 1 to zmodyfikowana wersja mojego ostatniego Golfa, odpowiedź quine (z ulepszeniami H.PWiz):

• Ponieważ pełne programy nie są potrzebne, main=został usunięty.
• <>i $zostały zastąpione ich prawie synonimami mappendi id.

Uwalnia to ważne postacie =<>i pomocnego operatora $dla innych quines.

Quine 2

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

Quine 2 używa nieco podobnych metod do programowania 2 moich ostatnich wzajemnie wykluczających się Quines , ale dostosowano ją do bezpośredniego quinowania się, a zwłaszcza w celu uniknięcia używania literałów znaków, które są potrzebne dla quine 3. Oba te sposoby są osiągane za pomocą showfunkcji, na szczęście nie wykorzystano jeszcze żadnej z jego postaci.

Quine używa tabulatorów zamiast spacji, ale dla czytelności użyłem spacji poniżej.

• gto dane quine, jako lista liczb całkowitych na końcu kodu. Każda liczba reprezentuje znak z reszty kodu.
  • Liczby są przesuwane 9, tak aby tabulator był 0. To sprawia, że ​​kodowanie jest nieco krótsze, ponieważ małe litery w nazwach funkcji i zmiennych mogą zmieścić się w 2 cyfrach.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] to funkcja służąca do konwersji liczby na znak (w rzeczywistości ciąg jednoznakowy).
  • [[show 9!!0,show 1!!0..]!!6..] to zakres znaków rozpoczynający się od znaku tabulacji, do którego indeksuje się !!c .
  • Znak tabulacji jest wytwarzany przez indeksowanie do innego zakresu [show 9!!0,show 1!!0..], zaczynając od cyfr '9'i'1' i skoki w krokach 8.
  • Znaki cyfr są tworzone przez indeksowanie w showciągu odpowiedniej cyfry.
• f c=[b=<<g]!!0++show gjest główną funkcją. cjest fałszywym argumentem.
  • b=<<gsłuży =<<do konwertowania każdej liczby gna jej znak. (Użycie =<<zamiast np mapDlatego bpotrzeby owinąć swój charakter zwrócony w liście).
  • show gdaje ciąg znaków reprezentujący glistę, oraz++ łączy ciągi znaków.
  • Ponieważ =<<ma niższy priorytet niż ++, potrzebne jest trochę braketingu. Aby uniknąć używania ()(zarezerwowane dla quine 3), [...]!!0indeksuje do listy z jednym elementem.

Quine 3

Zgodnie z projektem innych quinesów, quine 3 nadal ma dostęp do nawiasów, wyrażeń lambda, literałów znaków i konstruktora ciągów / list :. To wystarczy, aby skonstruować funkcję, która będzie kontynuowana Kodeksu Quine'a na sznurku.

Niestety, wszystkie samogłoski pisane małymi literami (z wyjątkiem czasami y) zostały użyte, nie pozostawiając żadnych przydatnych wbudowanych funkcji alfanumerycznych. Też []""już nie ma. Nie pozostawia to normalnego sposobu na zbudowanie pustego ciągu, aby rozpocząć udawanie kodu.

Jednak prawie wszystkie wielkie litery są nadal dostępne, więc istnieje LANGUAGEmożliwość uzyskania rozszerzenia języka. Ponownie, dzięki szczęściu, CPP(włącz preprocesor C) jest jedynym rozszerzeniem językowym o nazwie zawierającym tylko wielkie litery. Makra CPP często mają wielkie litery.

Aby uzyskać niezbędny pusty ciąg, quine włącza CPP, używa __TIME__makra, aby uzyskać stałą ciągu formy "??:??:??"(wygodnie jest mieć zawsze tę samą długość) i dopasować wzorzec na nim.

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

Po pragmie języka quine składa się z wyrażenia lambda wiążącego swoje parametry z tymi czterema argumentami (pozostawiając końcowy parametr pozorny _do zastosowania później):

• qzwiązany '\'', dając pojedynczy znak cudzysłowu;
• _:_:_:_:_:_:_:_:zzwiązany __TIME__, podobnie jak łańcuch "??:??:??", tworząc zpusty łańcuch;
• yzwiązany z (\(?)v k x->v$k?x)kombinatorem lambda używanym do konwersji danych quine z postaci powiązanej od lewej („foldl”) do postaci powiązanej z prawą („foldr”);
• Operator (#)zobowiązał się do \(&)(%)v->v&'{'&'-'&...samych danych quine.

Dane z quine są podane w formie kodowania Churcha, wyrażenia lambda z parametrami (&)(%)v.

• Przez zastosowanie wyrażenia do określonych wartości do utworzenia wystąpienia (&), (%)orazv to kodowanie może być użyte albo do zbudowania podstawowego kodu quine, albo do przebudowania samej reprezentacji danych quine.
• Domyślnie reguła stałości Haskell jest, &i %stać lewo operatorom asocjacyjnych wewnątrz lambda. W ten sposób parametry postaci łączą się z początkowym, vzaczynając od lewej.
• W przypadku większości znaków kistnieje odpowiednik &'k'.
• Gdy kjest 'lub \, które muszą być poprzedzone znakami literowymi, kodowanie odbywa się zamiast tego %'\k'.

Ponieważ kodowanie danych jest asocjacyjne, ale łańcuchy są budowane we właściwy sposób asocjatywny, wprowadzono kombinator w y = (\(?)v k x->v$k?x)celu wyeliminowania niedopasowania.

• y(...)ma na celu zbudowanie odpowiednich funkcji do wykorzystania jako danych (&)i (%)operatorów quine .
• vjest funkcją od ciągów do ciągów (dane quine vsą przykładami).
• kto znak, xciąg i ?operator, który łączy je w nowy ciąg. (W przypadku kodu podstawowego (?)=(:). Dla faktycznej rekonstrukcji reprezentacji danych quine jest to bardziej skomplikowane.)
• Zatem y(?)v k = \x->v$k?xjest inną funkcją od ciągów do ciągów.

• Jako przykład tego, jak to zmienia skojarzenie, jeśli (&)=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)

Mówiąc bardziej ogólnie, kiedy (#)jest to funkcja danych quine i f1,f2są to funkcje łączące znaki z łańcuchami:

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

zastosowanie funkcji danych quine za pomocą (&)=y(f1)i (%)=y(f2), i to wykorzystuje przepisane f1i f2do łączenia znaków danych quine z x, a następnie przekazuje wynikowy ciąg do v.

Ciało głównego wyrażenia lambda łączy to wszystko:

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

• '&':q:k:q:xponieważ znak kpoprzedza &'k'ciąg znaków x, podczas gdy '%':q:'\\':k:q:xpoprzedza %'\k', które są ich oryginalnymi formami danych quine.
• Zatem y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:xodpowiednie parametry do przebudowania reprezentacji danych quine, dołączone do finałuz (pusty ciąg), a następnie przekazane do następującej funkcji.
• y(:)#y(:) są właściwymi parametrami do dodania kodu podstawowego quine do łańcucha, bez innych modyfikacji.
• Wreszcie \x->xnie można nic zrobić ze skonstruowanym quine, który jest zwracany.

Perl 6 , 3 quiny, 274 bajty

Quine 1, 52 bajty

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

Wypróbuj online!

Quine 2, 102 bajty

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

Wypróbuj online!

Quine 3, 120 bajtów

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

Wypróbuj online!

Weryfikacja różnych zestawów bajtów

Zdobycie trzeciego quinu wymagało wiele manewrów. Perl 6 ma 4 sposoby wyjścia (to jestem świadomy), say, put, printi printf. Zarówno sayi putnowe wiersze wyjściowe, ponieważ nie mogę używać obu. put, print, printfWszystkie zawierają pa t. Możemy to obejść częściowo, używając EVALwielkich liter PRINT. Stamtąd nie wydaje mi się, aby można było uzyskać 4 quiny ... (choć może coś w tym rodzajushell "echo 'quine'" może działać)

Możemy wtedy obejść problemy z odstępami, używając różnego rodzaju białych znaków do oddzielania operatorów, spacji, tabulatorów i znaków nowej linii.

Objaśnienia:

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:

Jest to quine w formacie printf |(q[printf q[%s]]xx 2), tzn. Formatuje kopię łańcucha w siebie. Jednak nie możemy użyć, sponieważ jest to używane w poprzednim quinie say. Tak więc używamy operatora OR ciągu ( ~|) na @i !3, aby wytworzyć %sczęść, ale nie możemy tego zrobić zarówno z ciągiem formatu, jak i ciągiem do wstawienia, więc musimy zrobić Z~z dodatkowym ciągiem i pustym ciągiem, chociaż wtedy nie możemy użyć ,do rozdzielenia tych dwóch, więc wykonujemy Xx qw[1 0]mnożenie przez 1 i 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:

Jest to EVALNA quine, która stara się zrobić wszystko wielkimi literami, aby uniknąć konfliktu z innymi quinesami. Wiąże się to wiele od EVALs, a także sporo lci ucdo konwersji pomiędzy przypadkach.

<...>.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 bajtów

9 bajtów

ÿ'ÿ⌐_'ÿ⌐_

Wypróbuj online!

45 bajtów

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

Wypróbuj online!

49 bajtów

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

Wypróbuj online!

99 bajtów

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

Wypróbuj online!

4488 bajtów

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

Wypróbuj online!

188,845 bajtów

Naprawdę nie mogę połączyć się z tym, więc oto program w Perlu 6, który generuje właściwy quine

Weryfikacja odrębności

Z całą pewnością mogę wycisnąć z tego kolejną quinę, choć myślę, że zabrakło mi sposobów na pchanie ciągów prosto na stos, więc będę musiał uciekać się do dziwniejszych metod. Nadchodzą jeszcze dziwniejsze metody, gdy staram się o szóstą dziesiątkę. W niektórych przypadkach quines może być krótszy, ale redukuję używane bajty w przygotowaniu.

Ok, technicznie mogę być w stanie zrobić jeszcze jedną quine, ponieważ wciąż mam kilku operatorów, których potrzebuję (ciąg push, ciąg przyrostowy, duplikacja, mapowanie, popping), to pętla nas ogranicza. Są {}to jedyne operatory, które mogą wskazać blok kodu o dowolnej długości i naprawdę potrzebuję ich w szóstej piątce. Mógłbym użyć niektórych innych bloków kodu, ale są one ograniczone i wątpię, aby sekcje zapętlające były tak krótkie, ponieważ brakuje nam łatwych operatorów.

Okej, spóźnione wyjaśnienia:

Wszystkie quines mają prawie taką samą strukturę:

• Wepchnij ciąg lub listę ciągów lub listę znaków do stosu.
• Połącz to wszystko w jedną listę
• Powiel listę
• Mapuj kopię, drukując / popychając znaki użyte do uzyskania oryginalnych znaków
• Wydrukuj oryginalną listę znaków jako ciąg

Quine 1:

Jest to w zasadzie to samo, co zamieściłem w normalnym pytaniu quine.

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

Powodem, dla którego ten quine jest o wiele dłuższy niż inne, jest to, że inkrementowanie ciągów używa reprezentacji Unicode, co naprawdę jest do bani dla niektórych znaków w kodzie, szczególnie gdy próbujemy utworzyć znak ⌂w kodzie, co powoduje napompowanie kodu o ponad 8000 znaków, co następnie bardzo mocno napełnia część reprezentacyjną.

⌂         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

Ten ostatni quine zostałby znacznie zmniejszony, gdyby MathGolf był spójny, czy ciągi znaków używają natywnej strony kodowej, czy nie.

Python 2, 2 quines, 434 353 349 446 bajtów

To było głównie po to, aby sprawdzić, czy mogę to zrobić w Pythonie.

30 bajtów (w tym końcowy znak nowej linii):

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

i 416 bajtów, bez końcowego znaku nowej linii:

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

(Grał w golfa 81 bajtów dzięki Lynn, ale dodał obciążenie ze względu na dbanie o nową linię).

Wyjaśnienie

Pierwszy to tylko standardowa krótka quine Pythona , ale zmodyfikowana, by nie używać _. Ponieważ jest to Python 2, również nie używa (lub ).

Drugi zastanowił się. Długi łańcuch jest kodowany przy użyciu hexkodeka (co gwarantuje, że będzie zawierał tylko 0- 9i a- f) i dekoduje jako

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

Wykorzystuje quine trick, aby uzyskać własny kod źródłowy, a następnie koduje go za pomocą hex_codec, a następnie drukuje w otoczeniu exec"".decode("hex"), używającsys.stdout.write aby uniknąć drukowania nowego wiersza. Uruchomienie tego kodu powoduje wyświetlenie drugiego quine, czyli tego, jak go wygenerowałem.

Podejrzewam, że więcej niż dwa są niemożliwe w Pythonie, ale chciałbym to zobaczyć, jeśli się mylę!

Jeśli nie masz nic przeciwko eval quines

Ørjan Johansen zasugerował następujące kwestie dla wstępnie zakodowanej drugiej quiny

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

co dałoby wynik 30 + 248 = 278 bajtów dla następujących danych wyjściowych:

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

Używanie execw ten sposób nie jest oszustwem zgodnie z właściwymi regułami quine PPCG, ale wydaje mi się nieco oszukiwane (eleganckie i sprytne, ale wciąż oszukiwane), ponieważ niektóre znaki są używane zarówno jako kod, jak i dane. (Mimo że moja wersja używa exec, kod i dane są osobne.) Więc zachowam wynik na 446.

Japt , 2 3 quiny, 106 172 bajtów

Pierwsza z nich jest dość pełną wersją mojej odpowiedzi w postaci N char quine .

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

Wypróbuj tutaj .

Drugi quine to większy dobry quine ETHProduction , który jest dobrym standardowym quine dla Japt.

"iQ ²"iQ ²

Wypróbuj tutaj .

Trzeci używa `` XORing i kod znaków do przechowywania danych.

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

Wypróbuj tutaj .

Ponieważ ()'wciąż są dostępne, może być możliwe wyciśnięcie jeszcze jednego quine.

Gol> <> , ₂ 3 quiny, _{17 28 27} 26 bajtów

6 bajtów

"r2ssH

Wypróbuj online!

_{11 10} 9 bajtów

'3d*Wo{|;

Wypróbuj online!

11 bajtów

Eh`#Ma0piS0

Wypróbuj online!

Gol> <> ma trzy sposoby wydrukowania dowolnego znaku:

• o Podaj jedną wartość i wydrukuj jako char
• H Pop wszystko, drukuj jako char i zatrzymaj
• S"..." Drukuj dosłowny ciąg znaków bez wpływu na stos

Ale nie mogłem znaleźć sposobu na napisanie quinu za pomocą S"..." jako jedynej metody wyjściowej, więc wymyśliłem powyższe dwa, wykorzystując dwa rodzaje literałów łańcuchowych.

Trzeci (autorstwa Jo Kinga) używa ppolecenia, aby utworzyć „ "w S"locie”, co z kolei drukuje wszystko oprócz zera na końcu. NastępnieEh drukuje zero i wychodzi.

Teraz, kiedy pzużyliśmy wszystkie polecenia wyjściowe ORAZ polecenie, uważam, że niemożliwe jest utworzenie kolejnej quine (chyba że ktoś S"wymyśli quine bez p).

Rubin , 2 quiny, 27 + 44 = 71 bajtów

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

Wypróbuj online!

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

Wypróbuj online!

Ograniczają mnie głównie metody produkcji. Istnieje wiele sposobów manipulowania ciągami, ale poza $><<wszystkimi użytecznymi metodami wyjściowymi wydaje się, że przecinają się za bardzo. Myślę, że może istnieć wyjście, evalale trudne jest zagnieżdżanie wielu różnych operacji na łańcuchach.

JavaScript ES6, 2 quiny, 43 + 22 = 65 bajtów

Quine 1:

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

Quine 2:

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

> <> , 2 quinesy, 8 + 16 = 24 bajty

8 bajtów

#o<}-1:"

Wypróbuj online!

Zaczerpnięte z tej odpowiedzi .

16 bajtów

'r3d*d8*7+e0p>>|

Wypróbuj online!

Opiera się to na 'r3d*>o<quine, z wyjątkiem oi <nie można go używać, więc zastąpiłem <go |i utworzyłem dynamicznie o(111 = 8 * 13 + 7) i umieściłem go tam, gdzie >jest 2. miejsce .

2 quines to limit

Niestety jesteśmy ograniczeni liczbą poleceń wyjściowych. nnie jest użyteczny, ponieważ wypisuje tylko liczby, więc omusi być wykonywany w dowolnym quine. Jedynym sposobem na dynamiczne tworzenie ojest użycie p. Więc jeden quine może użyćo , a drugi może go tworzyćp , ale nie może być trzeciego quine.

Jeśli to się liczy, możliwe, że trzeci kod pozostawi kod źródłowy na stosie.

Java 10, 2 quiny, 1448 1248 bajtów

1350 1122 bajtów

\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

Wypróbuj online.

Równoważny:

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

Wyjaśnienie:

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 bajtów

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()zwróci, nullgdy nie zostanie podany żaden, więc TIO zwraca NullPointerExceptionw tym przypadku a .

Aby udowodnić, że to działa, zastąp System.console()go System.out: Wypróbuj online.

Wyjaśnienie:

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

Ogólne wyjaśnienie:

W Javie quine zwykle wykonuje się w następujący sposób:

• String sZawiera kod źródłowy niesformatowany.
• %ssłuży do wprowadzania tego ciągu do siebie za pomocą s.format(...).
• %c, %1$ci 34służą do formatowania podwójnych cudzysłowów.
• s.format(s,34,s) łączy to wszystko.

W takim przypadku najkrótszą funkcją quine lambda w Javie 10 byłoby ( 82 bajty ):

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

Wypróbuj online.

Ponieważ jedynym sposobem na posiadanie dwóch pinów w Javie jest użycie wersji Unicode \uHEXA, która jest konwertowana na znaki podczas kompilacji, nie mogę używać znaków 0123456789ABCDEF\uw wersji innej niż Unicode. Tak więc, mniejsza lub inna niż Unicode wersja będzie używać System.console()zamiast returnlub System.out(oba zawierają „u”) i będzie używać '}'-'['i dwa razy %czamiast34 i%1$c .

Kilka rzeczy do zapamiętania na temat wersji Unicode:

• Celowo używam %04Xzamiast%04x (dla dużych Hexadecimal zamiast małych).
• Używam 92, %ci%3$c do formatowania ukośniki.
• Używanie dużej \Ulitery zamiast małych liter \ujest najwyraźniej niedozwolone, inaczej użyłbym tylko returnkrótszej wersji bez kodu Unicode.