У нас было много задач по квине , но многие форматы квин схожи, давайте создадим некоторую разницу в наших квинах.

Ваша задача - создать выборку программ на одном языке (не менее 2), каждая из которых выводит свой собственный исходный код, однако ни одна из этих программ не может использовать какие-либо символы.

Например, если вы создаете программу, используя:

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

Ваша следующая программа не может включать в себя:

%()+2finpqrstwx

и так далее.

правила

• Вы можете использовать символы Юникода, но вы все равно должны получать очки в байтах.
• Все программы должны соответствовать определению сообщества правильного квайн . Это означает, что пустая строка, среди прочего, не считается действительной квиной.
• Стандартные лазейки запрещены.
• Функции или полные программы разрешены, если они соответствуют приведенному выше определению.
• Символо-независимые языки (включая Lenguage и Headsecks) запрещены.
• Большинство программ побеждает, с самым коротким общим кодом в качестве разрыва связи.

V , 3 , 5 quines, 46 байтов

2A2A

Попробуйте онлайн!

HexDump:

00000000: 3241 3241                                2A2A

Объяснение:

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

5­­­a5­­­a

Попробуйте онлайн!

HexDump:

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

Объяснение:

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

1«I1«I

Попробуйте онлайн!

HexDump:

00000000: 31ab 4931 ab49                           1.I1.I

Объяснение:

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

Вот где они начинают становиться фанки ...

ñi34x@-qPÉÑ~ÿ

Попробуйте онлайн!

HexDump:

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

Объяснение:

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

Попробуйте онлайн!

HexDump:

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

Объяснение:

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

Этот ответ наполнен черной магией. Квины 1 и 4 не новы, но остальные 3 никогда не были найдены раньше, поэтому более половины из этих квинов были обнаружены сегодня.

Желе , _{2 3 4} 5 квинов, _{14 18 81 65 59 56 326 265 247 229} 216 байт

3 байта

”ṘṘ

Попробуйте онлайн!

Стандартный Quine. ”Ṙэто один символ буквальный для Ṙ.Ṙпечатает строковое представление этого, затем строка Ṙнеявно печатается.

4 байта

⁾⁾ḤḤ

Попробуйте онлайн!

⁾начинает двухбуквенный строковый литерал и Ḥудваивает его аргумент. При вводе строки Ḥполучает отображение на каждый символ. Таким образом, Ḥдействие на строку ⁾Ḥдает⁾⁾ḤḤ к исходному коду.

11 байт

ȮṾṖƊ}“ȮṾṖƊ}

Попробуйте онлайн!

На правой стороне, “ȮṾṖƊ}строковый литерал дляȮṾṖƊ} . Закрывающий символ автоматически добавляется в EOF.

Слева от строкового литерала Ɗоборачивается ȮṾṖв одну монаду и }превращает ее в диаду, использующую правильный аргумент - строковый литерал. Ȯпечатает string ( ȮṾṖƊ}), Ṿсоздает строковое представление string ( “ȮṾṖƊ}”) и Ṗудаляет ”символ. Строка “ȮṾṖƊ}остается после монады и неявно печатается.

38 49 36 байт

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

Попробуйте онлайн!

Впервые я когда-либо использовал пространство в геле для гольфа.

Список чисел в начале содержит ordостальные символы в коде. После того:

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 байта

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

Попробуйте онлайн!

Использует базовые 250 номеров и индексов в кодовой странице желе. Сохранено 72 байта путем изменения алгоритма. Использовал каждое число для индексации на кодовой странице Jelly, но теперь я преобразовываю целое число обратно в основание 250, а затем индексирую в кодовую страницу Jelly, в основном вдвое уменьшая количество литералов, которое мне нужно в первой строке. Это также уменьшает количество необходимых уникальных персонажей, но я не могу придумать, как сделать больше квинов.

Я использовал, ⁾“”которые создают строковые литералы Ọи ØJкоторые создают строки из чисел. Я не могу придумать какие-либо другие способы создания струн. У меня все еще есть цифра 9и она ‘’доступна, поэтому, если есть другой способ создания строк из чисел, можно создать еще одну квинну.

Haskell , 3 квина, 1119 байт

Quine 1, 51 байт

IOПечать анонимного действия напрямую на стандартный вывод.

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

Попробуйте онлайн!

Quine 2, 265 байт

Функция fпринимает фиктивный аргумент и возвращает строку.

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]

Попробуйте онлайн!

Quine 3, 803 байта

Все, что LANGUAGEидет после прагмы, является произвольной функцией, принимающей фиктивный аргумент и возвращающей строку.

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

Попробуйте онлайн!

Символы

Куайн 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

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

Как это работает

Куайн 1

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

Quine 1 - это модифицированная версия моего недавнего Golf с ответом quine (с улучшениями от H.PWiz):

• Так как полные программы не нужны, main=был удален.
• <>и $были заменены их почти синонимами mappendи id.

Это освобождает жизненно важных персонажей =<>и полезного оператора $для других квинов.

Куайн 2

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

В Quine 2 используются несколько аналогичные методы для программирования 2 в моем недавнем ответе « Взаимно исключающие квинусы» , но он приспособлен для непосредственного квинования себя и особенно для того, чтобы не использовать символьные литералы, которые необходимы для квин 3. Оба из них достигаются с помощью showфункции, который по счастливой случайности еще не использовал ни одного из своих персонажей.

В этой строке используются табуляции вместо пробелов, но я использовал пробелы ниже для удобства чтения.

• gэто данные Quine, как список целых чисел в конце кода. Каждое число представляет символ из остальной части кода.
  • Числа сдвинуты 9, так что вкладка есть 0. Это делает кодировку немного короче, позволяя строчным буквам для имен функций и переменных помещаться в 2 цифры.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] является функцией для преобразования числа в символ (фактически строка из одного символа)
  • [[show 9!!0,show 1!!0..]!!6..] диапазон символов, начинающийся с символа табуляции, который индексируется с помощью !!c .
  • Сам символ табуляции создается путем индексации в другом диапазоне [show 9!!0,show 1!!0..], начиная с цифр '9'и'1' и прыжков вниз с шагом 8.
  • Цифровые символы создаются путем индексации в showстроке соответствующей цифры.
• f c=[b=<<g]!!0++show g это основная функция. cэто фиктивный аргумент.
  • b=<<gиспользует =<<для преобразования каждого числа в gего символ. (Использование, =<<а не eg map, поэтому bнеобходимо обернуть его возвращенный символ в список.)
  • show gдает строковое представление gсписка России и ++объединяет строки.
  • Потому что =<<имеет более низкий приоритет, чем ++, некоторые скобки необходимы. Чтобы избежать использования ()(зарезервировано для Quine 3), [...]!!0индексирует в список с одним элементом.

Куайн 3

По замыслу других quines quine 3 по-прежнему имеет доступ к скобкам, лямбда-выражениям, символьным литералам и конструктору строки / списка :. Этого будет достаточно, чтобы построить функцию, которая предопределяет код на Куайна в строку.

К сожалению, все строчные гласные (кроме иногда y) были использованы, не оставляя полезных буквенно-цифровых встроенных функций. И []""ушли. Это не оставляет нормального способа создать пустую строку, чтобы начать притворяться, что код.

Тем не менее, почти все заглавные буквы все еще доступны, поэтому LANGUAGEпрагма для получения расширения языка возможна. Снова по счастливой случайности,CPP (включить препроцессор C) это единственное расширение языка, названное только заглавными буквами. И макросы CPP часто имеют заглавные имена.

Таким образом, чтобы получить необходимую пустую строку, квина включает CPP, использует __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&'{'&'-'&......

После языковой прагмы квайн состоит из лямбда-выражения, связывающего свои параметры с этими четырьмя аргументами (оставляя последний фиктивный параметр _для последующего применения):

• qпривязан к '\'', давая символ одинарной кавычки;
• _:_:_:_:_:_:_:_:zпривязан __TIME__, то есть, как строка "??:??:??", создавая zпустую строку;
• yпривязанный к (\(?)v k x->v$k?x)лямбда-комбинатору, используемому для преобразования данных о хине из левой ассоциированной ("foldl") в правую ассоциированную ("foldr") форму;
• Оператор (#)привязан к \(&)(%)v->v&'{'&'-'&...самим данным по квине.

Данные по квине приводятся в форме церковного кодирования, лямбда-выражения с параметрами (&)(%)v.

• Применяя выражение к конкретным значениям для создания экземпляров (&), (%)и vэта кодировка может использоваться либо для создания основного кода quine, либо для перестройки самого представления данных quine.
• По умолчанию правило фиксированности Хаскелла &и %левых ассоциативных операторов стало внутри лямбды. Таким образом, параметры персонажа объединяются с начальными vслева.
• Для большинства персонажей kесть соответствующий &'k'.
• Когда kесть 'или \, которое необходимо экранировать внутри символьных литералов, вместо этого используется кодировка %'\k'.

Поскольку кодирование данных остается ассоциативным, а строки построены ассоциативным образом, y = (\(?)v k x->v$k?x)вводится комбинатор для устранения несоответствия.

• y(...)предназначен для построения подходящих функций для использования в качестве данных (&)и (%)операторов quine
• vявляется функцией от строк к строкам (для vпримера приводятся данные по квине ).
• kявляется символом, xстрокой и ?оператором, который объединяет их в новую строку. (Для основного кода (?)=(:). Для фактического восстановления представления данных Quine это более сложно.)
• Таким образом, y(?)v k = \x->v$k?xесть еще одна функция из строк в строки.

• В качестве примера того, как это меняет ассоциативность, если (&)=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)

В более общем случае, когда (#)функция данных quine f1,f2является функциями, объединяющими символы со строками:

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

применяя функцию данных quine с помощью (&)=y(f1)и (%)=y(f2), и это использует предписанные f1и f2для объединения символов данных quine с x, а затем передает полученную строку в v.

Тело основного лямбда-выражения объединяет все это:

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

• '&':q:k:q:xдля символа, kпредшествующего &'k'строке x, в то время как '%':q:'\\':k:q:xprepends %'\k', которые являются их исходными формами данных Quine.
• Таким образом y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x, это правильные параметры для перестройки представления данных Quine, перед которым ставится финал z(пустая строка), а затем передается следующей функции.
• y(:)#y(:) являются правильными параметрами для добавления основного кода квина в строку без других модификаций.
• В конце концов, \x->xфункция ничего не делает с созданной формулой, которая возвращается.

Perl 6 , 3 квина, 274 байта

Quine 1, 52 байта

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

Попробуйте онлайн!

Quine 2, 102 байта

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

Попробуйте онлайн!

Quine 3, 120 байт

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

Попробуйте онлайн!

Проверка отдельных наборов байтов

Было много маневров, чтобы получить эту третью муку. Perl 6 имеет 4 методы вывода (что я знаю), say, put, printи printf. Оба sayи putвыводят новые строки, так как я не могу использовать оба. put, print, printfВсе они содержат pи t. Мы можем обойти это частично используя EVALверхний регистрPRINT . Оттуда, я не думаю, что можно получить 4 квина ... (хотя, возможно, что-то вроде shell "echo '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:

Это квинна в формате printf |(q[printf q[%s]]xx 2), то есть она форматирует копию строки в себя. Однако мы не можем использовать, sтак как это использовалось в предыдущей квине say. Таким образом, мы используем строку OR ( ~|) для @и !3, чтобы произвести %sдеталь, но мы не можем сделать это как для строки форматирования, так и для строки, которая будет вставлена, поэтому мы должны сделать это Z~с дополнительной строкой и пустой строкой, хотя мы тогда не можем использовать ,для разделения двух, поэтому мы делаем Xx qw[1 0]для умножения строки на 1 и 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:

Это EVAL quine, который старается изо всех сил делать все заглавными, чтобы избежать конфликта с другими quine. Это включает в себя много из EVALх, а также немало lcи ucконвертировать между случаями.

<...>.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 квинов, 193 535 байт

9 байт

ÿ'ÿ⌐_'ÿ⌐_

Попробуйте онлайн!

45 байт

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

Попробуйте онлайн!

49 байтов

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

Попробуйте онлайн!

99 байт

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

Попробуйте онлайн!

4488 байт

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

Попробуйте онлайн!

188 845 байт

Я не могу связать это, так что вот программа на Perl 6, которая генерирует фактический quine

Проверка отличимости

Я могу определенно выжать еще одну квиню из этого, хотя я думаю, что у меня не осталось способов протолкнуть строки прямо в стек, поэтому мне придется прибегнуть к более странным методам. Даже незнакомые методы поступают, как я пытаюсь за шестую квиню. В некоторых случаях квины могут быть короче, но я сокращаю количество используемых байтов при подготовке.

Хорошо, технически я мог бы сделать еще одну квинну, так как у меня все еще есть несколько нужных мне операторов (push-строка, инкрементная строка, дублирование, отображение, выталкивание), именно циклы сжимают нас. Это {}единственные операторы, которые могут указывать кодовый блок произвольной длины, и я действительно нуждаюсь в них в 6-й строке. Я мог бы использовать некоторые другие блоки кода, но они ограничены, и я сомневаюсь, что циклы зацикливания будут такими короткими, поскольку у нас заканчиваются простые операторы.

Хорошо, некоторые запоздалые объяснения:

Все квины имеют почти одинаковую структуру:

• Вставить строку, или список строк, или список символов в стек.
• Объедините все это в один список
• Дублируйте список
• Карта поверх копии, печать / нажатие символов, используемых для получения оригинальных символов
• Распечатать исходный список символов в виде строки

Куайн 1:

По сути, это то же самое, что я написал в обычном вопросе.

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

Куайн 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:

Причина этого Куайн так много больше , чем другие, что увеличивающиеся строк использует юникод представления, которые действительно отстой для некоторых из символов в коде, особенно , когда мы пытаемся создать символ ⌂в коде, который раздувает код более чем на 8000 символов, что приводит к значительному увеличению части представления.

⌂         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 был непротиворечивым относительно того, использовали ли строки нативную кодовую страницу или нет.

Python 2, 2 квина, 434 353 349 446 байт

Это было в основном просто посмотреть, смогу ли я сделать это на Python.

30 байтов (включая завершающий перевод строки):

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

и 416 байтов без завершающего символа новой строки:

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

(Гольф 81 байт благодаря Линн, но добавил нагрузку из-за заботы о новой строке.)

объяснение

Первый - это просто стандартная короткая Python-квина , но модифицированная, чтобы не использовать _. Поскольку это Python 2, он также не использует (или ).

Второй задумался. Длинная строка кодируется с использованием hexкодека (таким образом гарантируя, что он будет содержать только 0- 9и a- f) и декодируется как

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

Это использует хитрость quine для получения собственного исходного кода, затем кодирует его, используя hex_codec, а затем печатает его в окружении exec"".decode("hex"), используя, sys.stdout.writeчтобы избежать печати новой строки. Выполнение этого кода выводит вторую квинну, как я ее сгенерировал.

Я подозреваю, что более двух невозможно в Python, хотя я хотел бы увидеть это, если я ошибаюсь!

Если вы не против, Eval Quines

Эрджан Йохансен предложил следующее для предварительно закодированной второй квин

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

который получит 30 + 248 = 278 байт для следующего вывода:

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

Использование execэтого способа не обманывает в соответствии с PPCG надлежащими правилами но мне кажется несколько обманчивым (элегантным и умным, но все же обманчивым), потому что некоторые символы используются и как код, и как данные. (Хотя моя версия действительно использует exec, код и данные являются отдельными.) Таким образом, я буду держать мой счет на 446.

Japt , 2 3 квина, 106 172 байта

Первый - довольно подробный вариант моего ответа N char .

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

Попробуй это здесь .

Вторая квинна - это лучшая квинта ETHProduction , которая является хорошим стандартным квинтом для Джапта.

"iQ ²"iQ ²

Попробуй это здесь .

Третий использует ``и код XORing для хранения данных.

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

Попробуй это здесь .

Поскольку ()'они все еще доступны, возможно, удастся выжать еще одну квинну.

Gol> <> , ₂ 3 квина, _{17 28 27} 26 байт

6 байт

"r2ssH

Попробуйте онлайн!

_{11 10} 9 байт

'3d*Wo{|;

Попробуйте онлайн!

11 байт

Eh`#Ma0piS0

Попробуйте онлайн!

Gol> <> имеет три способа печати любого символа:

• o Получите одно значение и напечатайте как символ
• H Поп все, распечатать как символ, и остановить
• S"..." Вывести строковый литерал, не затрагивая стек

Но я не мог найти способ написать Quine, используя S"..." в качестве единственного метода вывода, поэтому я придумал два вышеупомянутых, используя два вида строковых литералов.

Третий (Джо Кинг) использует pкоманду для создания "in S"на лету, которая в свою очередь печатает все, кроме нуля в конце. Затем Ehпечатает ноль и выходит.

Теперь, когда мы использовали все выходные команды И pкоманду, я считаю, что невозможно создать еще одну квинну (если только кто-то не S"придумает квиню без нее p).

Рубин , 2 квина, 27 + 44 = 71 байт

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

Попробуйте онлайн!

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

Попробуйте онлайн!

Я в основном ограничен методами вывода, здесь. Есть немало способов манипулирования строками, но кроме$><< всех используемых методов вывода, кажется, что они слишком сильно пересекаются. Я думаю, что может быть выход, evalно сложно сложить несколько манипуляций со строками разных типов.

Javascript ES6, 2 квина, 43 + 22 = 65 байт

Куайн 1:

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

Quine 2:

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

> <> , 2 квина, 8 + 16 = 24 байта

8 байт

#o<}-1:"

Попробуйте онлайн!

Взято из этого ответа .

16 байт

'r3d*d8*7+e0p>>|

Попробуйте онлайн!

Это основано на 'r3d*>o<Куайном, за исключением того, oи <не может быть использована, так что я заменил <с |и динамически создаваемые o(111 = 8 * 13 + 7) и помещают его , где второй >есть.

2 квина это предел

К сожалению, мы ограничены количеством выходных команд. nбесполезен, потому что он выводит только числа, поэтому oдолжен быть выполнен в любой строке. Единственный способ динамически создавать oэто с p. Таким образом, один quine может использовать o, а другой может создать его сp , но не может быть третьего квина.

Может быть возможно, чтобы третий quine оставил исходный код в стеке, если это имеет значение.

Java 10, 2 квина, 1448 1248 байт

1350 1122 байта

\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

Попробуйте онлайн.

Эквивалентно:

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

Объяснение:

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 байт

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()вернется, nullкогда ничего не предоставлено, поэтому TIO возвращает a NullPointerExceptionв этом случае .

Чтобы доказать, что это рабочий метод, замените его System.console()на System.out: Попробуйте онлайн.

Объяснение:

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

Общее объяснение:

В Java quine обычно делается так:

• String sСодержит исходный код отформатирован.
• %sиспользуется для ввода этой строки в себя с помощью s.format(...).
• %c, %1$cИ 34используются для форматирования двойных кавычек.
• s.format(s,34,s) складывает все это вместе.

В этом случае кратчайшая лямбда-функция quine в Java 10 будет такой ( 82 байта ):

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

Попробуйте онлайн.

Поскольку единственный способ получить две квины в Java - использовать версию с юникодом \uHEXA, которая преобразуется в символы во время компиляции, я не могу использовать символы 0123456789ABCDEF\uв не-юникодной версии. Таким образом, меньшая версия не в Юникоде будет использовать System.console()вместо returnили System.out(оба содержат 'u'), и будет использовать '}'-'['и два раза %cвместо34 и %1$c.

Несколько замечаний по поводу версии Unicode:

• Я специально использую %04Xвместо%04x (для шестнадцатеричных прописных вместо строчных).
• Я использую 92, %cи%3$c для форматирования косой черты.
• Использование заглавных \Uбукв вместо строчных, \uпо-видимому, недопустимо, иначе я бы просто использовал returnболее короткую версию , не поддерживающую юникод.