Напишіть сюїту Quine


30

У нас було багато проблем з , але багато форматів quine схожі, дозволяють створити певну дисперсію в наших лайках.

Ваше завдання - створити добірку програм однією і тією ж мовою (щонайменше 2), які виводять власний вихідний код, проте жодна з цих програм не може ділитися жодними символами.

Наприклад, якщо ви створюєте програму, використовуючи:

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

Ваша наступна програма не може містити жодного з:

%()+2finpqrstwx

і так далі.

Правила

  • Ви можете використовувати символи Unicode, але ви все одно повинні байти в байтах.
  • Усі програми повинні відповідати визначенню спільноти належної лайки . Це означає, що порожня рядок, крім усього іншого, не вважається дійсною квітами.
  • Стандартні лазівки заборонені.
  • Функції або повні програми дозволяються до тих пір, поки вони відповідають наведеному вище визначенню.
  • Мови незалежної від символів (включаючи мовні та навушники) заборонені.
  • Більшість програм виграє, з найкоротшим загальним кодом в якості вимикача.

Оскільки є близькі голоси, я скасую
Dom Hastings

Я зауважую, що в коментарях пісочниці йдеться про те, що подання функцій дозволено, але виклик нічого не говорить про це - я вважав протилежне як за замовчуванням для quines.
Ørjan Johansen

2
Споріднене (Вигляд зворотного виклику - ваші королеви повинні виводити один одного замість себе)
Натаніел

1
А що з новими лініями? Якщо одна з моїх цариць роздруковує одну, чи має інша уникати цього? (Я підозрюю, що більшість відповідей цього не робить.)
Натаніел

2
@DomHastings Мені не вдалося знайти мета питання, тому я його задав .
Натаніел

Відповіді:


27

V , 3 , 5 квінок, 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 ніколи раніше не було знайдено, тому більше половини цих лайків були лише виявлені сьогодні.


8
Третя програма - тролінг. "You a normie :p"
mbomb007

4
@ mbomb007 Обов’язковоREEEEEE--
Чарівний восьминога

17

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

3 байти

”ṘṘ

Спробуйте в Інтернеті!

Стандартна квілка. ”Ṙє одним буквальним символом для . друкує рядкове представлення цього, після чого рядок неявно друкується.

4 байти

⁾⁾ḤḤ

Спробуйте в Інтернеті!

починається буквальний рядок з двома символами і подвоюється його аргументом. За допомогою рядкового вводу відображається на кожному символі. Таким чином , чинне на строкових ⁾Ḥврожайності ⁾⁾ḤḤ, вихідний код.

11 байт

ȮṾṖƊ}“ȮṾṖƊ}

Спробуйте в Інтернеті!

Праворуч “ȮṾṖƊ}- це буквальний рядок для ȮṾṖƊ}. Символ закриття рядка мовчазно додається на EOF.

Зліва від літерального рядка, Ɗзагортається ȮṾṖв єдину монаду і }перетворює її в діаду, яка використовує правильний аргумент, рядковий літерал. Ȯдрукує рядок ( ȮṾṖƊ}), створює подання рядка рядка ( “ȮṾṖƊ}”) та видаляє символ. Рядок “ȮṾṖƊ}залишається після монади і неявно друкується.

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 чисел та індексів на кодовій сторінці Jelly. Збережено 72 байти, змінивши алгоритм. Використовував кожне число для індексації на кодовій сторінці Jelly, але зараз перетворюю ціле число назад в базу 250, потім індексує в кодову сторінку Jelly, в основному вдвічі зменшуючи кількість літералів, які мені потрібні в першому рядку. Це також зменшує кількість необхідних унікальних символів, але я не можу придумати спосіб зробити ще більше лайків.

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


13

Haskell , 3 quines, 1119 байт

Quine 1, 51 байт

Анонімний IOдрук дій безпосередньо до stdout.

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

Квінт 2:

	!+,.0123456789;<=[]bcfghosw

Квінт 3:

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

Як це працює

Квінка 1

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

Quine 1 - це модифікована версія мого недавнього Гольфу, вам відповідь (з удосконаленнями 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 моєї останньої взаємовиключної відповіді Quines , але пристосовану для прямого квіта , а особливо для уникнення використання літеральних символів, необхідних для quine 3. Обидва ці функції досягаються за допомогою showфункції, котрий за великою долею ще не використовував жодного свого персонажа.

Цей квінт використовує вкладки замість пробілів, але я використовував пробіли нижче для читання.

  • g- це дані quine, як список цілих чисел в кінці коду. Кожне число представляє символ із решти коду.
    • Цифри зміщуються на 9, так що ця вкладка є 0. Це робить кодування трохи коротшим, дозволяючи маленьким літерам для функцій та імен змінних розміщуватися у двох цифрах.
  • 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його символ. (Використання, =<<а не напр. map, Тому bпотрібно загорнути його повернутий символ у список.)
    • show gдає рядкове представлення gсписку 's і ++об'єднує рядки.
    • Оскільки =<<має нижчий пріоритет, ніж ++потрібне деяке дужки. Щоб уникнути використання ()(зарезервовано для quine 3), [...]!!0індексується до списку з одним елементом.

Квінт 3

Конструюючи інші лайки, quine 3 все ще має доступ до круглих дужок, лямбда-виразів, буквених символів та конструктора рядків / списку :. Цього буде достатньо для побудови функції, яка передує код quine до рядка.

На жаль, всі голосні голосні yбукви (крім інколи ) були використані, не залишаючи корисних буквено-цифрових вбудованих функцій. Також []""пішли. Це не залишає нормального способу побудувати порожній рядок, щоб почати робити вигляд на код.

Однак майже всі великі літери все ще доступні, тому можлива LANGUAGEпрагма отримати розширення мови. Знову ж таки з великою долею CPP(увімкніть препроцесор C) - це єдине розширення мови, назване лише великими літерами. А CPP макроси часто мають великі імена.

Таким чином, щоб отримати істотну порожню рядок, quine enable 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&'{'&'-'&......

Після мовної прагми quine складається з лямбда-виразу, що зв'язує свої параметри з цими чотирма аргументами (залишаючи остаточний параметр манекена, _який слід застосувати пізніше):

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

Дані quine подаються у вигляді кодування Церкви, лямбда-виразу з параметрами (&)(%)v.

  • Застосовуючи вираз до конкретних значень для екземпляра (&), (%)і vце кодування можна використовувати або для побудови основного коду quine, або для відновлення самого представлення даних quine.
  • За правилом виправлення Haskell за замовчуванням, &і %стають лівими асоціативними операторами всередині лямбда. Таким чином, параметри символів поєднуються з початковим vпочатком зліва.
  • Для більшості персонажів kє відповідне &'k'.
  • Коли kє 'або \, які потрібно уникнути всередині літературних символів, замість цього відбувається кодування %'\k'.

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

  • y(...)призначений для побудови відповідних функцій для використання в якості даних quine (&)та (%)операторів.
  • v- це функція від рядків до рядків ( vприклади даних, призначених для quine, є прикладами).
  • 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:xвперед %'\k'- на їх початкові форми даних quine .
  • Таким чином y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x, правильні параметри для відновлення подання даних quine, попередньо висунуті до остаточного z(порожня рядок), а потім передані наступній функції.
  • y(:)#y(:) - це правильні параметри для додавання основного коду quine до рядка без інших змін.
  • Нарешті, \x->xзмушений нічого не робити з побудованою quine, яка повертається.

9

Perl 6 , 3 quines, 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

Квінт 2:

Це quine у ​​форматі printf |(q[printf q[%s]]xx 2), тобто він форматує копію рядка в себе. Однак ми не можемо використовувати, sоскільки це було використано в попередніх квитах say. Отже, ми використовуємо оператор рядок АБО ( ~|) для @та !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

Квінт 3:

Це EVAL лайка, яка намагається зробити все можливим, щоб уникнути конфлікту з іншими лайками. Це включає в себе багато з 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

9

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 string, приріст рядка, дублювання, відображення, вискакування), це петля нас обмежує. {}Єдині оператори , які можуть можуть вказати кодовий блок довільної довжини, і мені дійсно потрібно їх в 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

Квінт 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

Квінт 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

Квінт 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

Квінт 6:

Причина, що ця квітка настільки довша, ніж інші, полягає в тому, що збільшити рядки використовують представлення unicode, що справді є достатнім для деяких символів у коді, особливо коли ми намагаємося створити символ у коді, який надуває код понад 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 відповідав тому, чи використовували рядки кодової сторінки чи ні.


Я вражений вашою винахідливістю, я хотів би пояснити, як вам вдалося придумати це. Перший я визнаю з оригінального виступу для quine, а решта виглядають так, як вони вічно придумали.
maxb

@maxb Я працюю над шостою квітами, і я опублікую пояснення, як тільки я напишу це або відмовлюся від нього. btw, команди chr / ord та приріст символів здаються непослідовними. Перший використовує кодову сторінку, де другий використовує типовий унікод (саме це робить 6-ту королеву такою довгою)
Джо Кінг,

Я зрозумів, що через деякий час після його впровадження я просто використав chr/ordдля одного з них, і я повинен змусити обох використовувати сторінку коду, замість цього я думаю.
maxb

6

Python 2, 2 quines, 434 353 349 446 байт

Це було здебільшого просто для того, щоб побачити, чи можу я це зробити на Python.

30 байтів (включаючи зворотний новий рядок):

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

і 416 байт, без зворотного нового рядка:

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

(81-байтовий Golfed завдяки Лінні, але додав навантаження через турботу про новий рядок.)

Пояснення

Перший - це лише стандартна коротка Python quine , але модифікована для використання _. Оскільки це 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")')

Для цього використовується хитрість хитрості, щоб отримати власний вихідний код, потім кодувати його за допомогою hex_codec, а потім друкує його в оточенні exec"".decode("hex"), використовуючи, sys.stdout.writeщоб уникнути друку нового рядка. Запуск цього коду виводить друге quine, саме так я його генерував.

Я підозрюю, що більше ніж два неможливо на Python, хоча я хотів би бачити це, якщо я помиляюся!

Якщо ви не заперечуєте проти овалів quval

Ørjan Johansen запропонував наступне для попередньо закодованої другої квінти

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.


1
"hex"працює замість цього "hex_codec", що має заощадити кілька байтів!
Лінн

1
Чому б вам просто не додати порожній рядок в кінці першого квита, якщо провідні рядки мають значення ...?
mbomb007

1
Як це . Я розумію, що це досить стандартний хитрощний трюк у мовах з exec / eval.
Ørjan Johansen

1
Чому б не використати повторно той самий формат, що і перший quine? Як це?
Джо Кінг

2
print '<tab>',не додає проміжку в кінці. Використовуючи це, ви можете на 85 байт від пропозиції Джо Кінга: tio.run/…
ов

5

Japt , 2 3 quines, 106 172 байт

Перший - це досить багатослівна версія моєї відповіді на 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¹¬]¬

Спробуйте тут .

Друга квітина - це більша хороша квітка ETHProduction , яка є хорошим стандартним лайном для Japt.

"iQ ²"iQ ²

Спробуйте тут .

Третій використовує ``та char-код XORing для зберігання даних.

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

Спробуйте тут .

Оскільки ()'вони все ще доступні, можливо, можна видавити ще одну лайку.


1
Я дуже, дуже хочу спробувати покатати перше, але я знаю, що з кількома пивами на борту, як тільки я спробую змінити одного персонажа, мій мозок вибухне! Прокляті лайки!
Кудлатий

@Shaggy Якщо взяти підсумковий рядок і запустити його, "'[+U+']+R+(Umd)¬"q mcви отримаєте перший рядок для швидкого оновлення, якщо це допоможе.
Ніт

Я також відремонтував перше рішення, щоб було доступно більше основних символів, можливо, зараз можна практично ще додати ще одну лайку.
Ніт

Зачекайте, тепер ваш результат вищий!
Кудлатий

@Shaggy Навмисно так, я намагаюся звільнити місце для іншої лайки, а не зробити її коротшою.
Ніт

4

Gol> <> , 2 3 quines, 17 28 27 26 байт

6 байт

"r2ssH

Спробуйте в Інтернеті!

11 10 9 байт

'3d*Wo{|;

Спробуйте в Інтернеті!

11 байт

Eh`#Ma0piS0

Спробуйте в Інтернеті!

Gol> <> має три способи друку будь-яких символів:

  • o Поставте одне значення та друкуйте як char
  • H Попс усе, друкувати як char, і зупиняти
  • S"..." Роздрукувати рядковий літерал, не впливаючи на стек

Але я не зміг знайти спосіб написати quine, використовуючи S"..."як єдиний вихідний метод, тому я придумав вищевказані два, використовуючи два види рядкових літералів.

Третій один (Джо Кінг) використовує pкоманду , щоб створити "в S"на льоту, що , в свою чергу , друкує все , крім нуля в кінці. Потім Ehвиводить нуль і виходить.

Тепер, коли ми використовували всі вихідні команди І pкоманду, я вважаю, що неможливо створити іншу quine (якщо хтось не придумає S"quine без p).


Як щодо цього для S"..."?
Джо Кінг

3

Рубі , 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але складним є гніздування декількох струнних маніпуляцій різного типу.


3

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

Квінка 1:

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

Квінт 2:

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

Ви можете зберегти кілька байтів, не викликаючи функції, а потім, використовуючи буквений буквал у другому.
Кудлатий

2
Тож JavaScript outgolfs japt
dylnan

@dylnan Тільки до того часу, поки не буде додано третю квинку.
Ніт

@Shaggy Ей, дякую за ваш внесок, але я розгублений - чи не слід королеви бути повноцінною програмою? Якщо це може бути функцією, чи повинен він друкувати лише сам? То чи було g=z=>"g="+gб дійсною кішкою JS?
Педро А

1
@Nit Я побачу, що я можу зробити: P коли Dylnan прокоментував, у japt було також лише 2 лайки
Педро A

3

> <> , 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. Таким чином, одна квітка може використовувати o, а інша може створювати її p, але 3-ї квінка не може бути.

Можливо, можливо, щоб третя квітка залишила вихідний код у стеці, якщо це враховується.


2

Java 10, 2 quines, 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 зазвичай робиться так:

  • String sМістить вихідний код відформатований.
  • %sвикористовується для введення цього рядка в себе за допомогою s.format(...).
  • %c, %1$cі 34використовуються для форматування подвійних лапок.
  • s.format(s,34,s) зводить це все разом.

У такому випадку найкоротша лаймда-функція у 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 є використання версії unicode з \uHEXA, яка перетворюється на символи під час компіляції, я не в змозі використовувати символи 0123456789ABCDEF\uу не-кодовій версії. Отже, менша версія unicode буде використовувати System.console()замість returnабо System.out(обидва містять 'u'), а використовуватиме '}'-'['і два рази %cзамість 34і %1$c.

Деякі речі, які слід зазначити про версію Unicode:

  • Я спеціально використовую %04Xзамість %04x(для великого шістнадцяткового замість малого).
  • Я використовую 92, %cі %3$cдля форматування косою риси.
  • Використання великої літери \Uзамість малих ліній, \uмабуть, не дозволено, інакше я б просто використовував returnу коротшій версії unicode.
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.