Напишите программу (или функцию) (назовем ее P1), которая при запуске выводит другую программу P2 на том же языке и ровно на 1 байт длиннее P1.

Программа P2 при запуске должна вывести третью программу P3, которая на 1 байт длиннее P2. P3 должен выводить программу P4, которая на один байт длиннее P3 и т. Д. То же самое для P5, P6, ..., P∞.

Цепочка программ должна идти бесконечно или в такое место, где интерпретатор больше не может справиться (но должен оставаться теоретически верной программой на языке)

правила

• Стандартные лазейки запрещены
• Все программы в цепочке должны быть на одном языке
• Нет данных. Вывод идет в стандартный вывод или возвращаемое значение функции
• Программа должна завершиться через некоторое время. Программа, которая прекращает генерировать выходные данные после определенного промежутка времени, но никогда не завершает свою работу, не квалифицируется

Победит самая короткая программа P1 в байтах на каждом языке!

JavaScript (ES6), 14 12 байт

-2 байта благодаря @Shaggy

f=_=>"f=_"+f

Тестовый фрагмент

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

7 , 4 байта ASCII

1603

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

Я знаю, что 7 обычно не кодируется в ASCII, но на этот раз это более удобное кодирование, поэтому мы добавляем 1 байт при каждом запуске, а не 3 бита.

Я также не уверен, считается ли это обманом или нет. (Обычно неясно, обманывает ли 7 quine, так как он перекрывает границу несколькими способами.) Вы можете привести приличный аргумент, который 0кодирует 6, но в целом неясно, откуда берутся результирующие символы «в 7, потому что у него так много, довольно странных, неявных поведений.

Эта программа печатает себя с 1добавлением, и будет делать это, даже если вы добавите число 1s к нему. Вот откомментированный след отладки 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(В программе ничего не |осталось, поэтому eнемедленно выйдет из программы как побочный эффект, означающий, что финальные 7s никогда не запускаются).

Основная путаница в том, откуда берутся все символы, состоит в том, что большинство команд в 7 просто выдают данные при запуске, а затем 6пытаются восстановить последовательность команд, которая выдаст данный фрагмент данных; это часто заканчивается близко, но не идентично оригиналу. (В целях цитирования вы обычно пишете программу на 7 таким образом, что результат будет почти одинаковым, обычно различаясь в начальных или конечных 7s.) Так, например, 1данные в данных становятся 716, что является самым простым способом добавить 1к текущей строке данных. Мы изначально создали его с 16другой (но похожей) последовательностью символов, разрушительно удаляя один из|маркеры, с которых начинались данные. (Наверное, лучший аргумент в пользу того, что это не буквальная формула, состоит в том, что выходные данные отличаются от входных!)

Haskell , 74 66 байт

РЕДАКТИРОВАТЬ:

• -2 байта H.PWiz с помощью <>, затем -6 путем перемещения (10*)<$>.

Теперь используется новый свободный <>оператор (для Semigroupумножения требуется, чтобы GHC 8.4 работал без импорта.)

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Попробуйте онлайн! (Читы с импортом, поскольку TIO еще не имеет GHC 8.4.)

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

• main=putStr$ является шаблоном для вывода следующего строкового значения.

• fst<>showявляется функцией, которая принимает кортеж и возвращает строку, состоящую из первого элемента кортежа, объединенного со строковым представлением кортежа. Т.е.

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>умножает последний элемент следующего кортежа на 10, добавляя цифру 0к его строковому представлению.

C (gcc) , 134 132 байта

Незначительная переделка канонической буквы С. Ужасно долго.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

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

Деление 2 , 7 байт

'!+OR!"

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

Стандартный квин Fission , но с дополнительным, !который печатает дополнительные 0x01 в начале кода на каждой итерации.

Пари / ГП , 35 байт

(f=(x)->print1("(f="f")("1x")"))(1)

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

Python 2 , 38 байт

s="print's=%r;exec s'%(s+'#')";exec s

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

брейкфак , 420 байт

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

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

Это модификация «стандартной» сущности BrainFuck , с .концом в конце, которая добавляет дополнительную .каждую итерацию.

Сама квинна кодирует символы Brainfuck в виде набора шестнадцатеричных цифр: в частности, шестнадцатеричных цифр c-0x2b, которые обычно следующие:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

Кодировка охватывает два фрагмента кода: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++выдвигает кодировку самой кодировки, [[<++++++++++++++++>-]<+++++++++.<]обходит стек и печатает все.

Грязный , 9 байт

'"n[!]a!␛

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

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Если чтение исходного кода разрешено:

Грязный , 8 байт

Q[!]W33!

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

Разъяснение:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Может быть действительным:

Грязный , 4 байта

Q[‼]

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

Он печатает исходный код с завершающим переводом строки.
(И куча пробелов, из-за ошибки. Хотя без них все работает.)

Обратите внимание, что он работает только в собственном наборе символов, а не при использовании внешнего интерфейса UTF8 - поэтому, чтобы попробовать его на TIO, вам нужно заменить символ, который он выводит между символами []s ‼, что является эквивалентом UTF8 для печати ,

Java 8, 162 146 байт

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

Попробуйте онлайн.
Попробуйте первую программу вывода ; Попробуйте вторую программу вывода ; Попробуйте третью программу вывода .

Объяснение:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -part:

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

Задание часть:

• +1 добавляет 1 к неформатированной и отформатированной программе.
• .replaceAll("1+$","");}: Поскольку мы хотим увеличить количество байт программы только на единицу вместо двух, мы удаляем все завершающие 1 перед возвратом.

> <> , 9 байт

#o<:}-1:"

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

Вариация классической> <> формулы, которая просто добавляет еще одну команду dupe для копирования #вперед.

Perl 5 , 32 байта

$_=q{say"\$_=q{$_
};eval"};eval

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

GolfScript , 9 байт

{'.~1'}.~

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

CJam , 9 байт

{"_~1"}_~

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

Я публикую оба этих решения в одном и том же ответе, поскольку они представляют собой просто тривиальные вариации друг друга и работают абсолютно одинаково. Они оба основаны на общей квине GolfScript {'.~'}.~(или {"_~"}_~в CJam), которая описана более подробно, например, в моем предыдущем ответе.

Разница лишь в том, что этот вариант добавляет 1байт к концу своего вывода. Как это случается, любая строка 1s (или любой другой целочисленный литерал без начальных нулей) сама по себе является тривиальной формой как в GolfScript, так и в CJam, поэтому любые строки, уже присутствующие в конце кода выше, будут просто дословно скопированы в вывод. Поскольку GolfScript (и CJam) используют целые числа произвольной длины, это будет работать для произвольно длинных программ, по крайней мере, до тех пор, пока компьютер, на котором выполняется код, имеет достаточно памяти для его хранения.

Атташе , 76 72 61 байт

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

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

Стандартный quine, который добавляет пробел в конец xпосле каждой итерации.

Первые несколько итераций:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

и т.п.

Атташе, 72 байта

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

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

Это просто вариант стандартного формата quine с переменной, yкоторая устанавливается 10*yпосле каждой итерации

Первые несколько итераций:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

и т.п.

Swift 4 , 89 байт

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Включает завершающий перевод строки

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

Haskell , 88 байт

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Попробуйте онлайн! Увеличивается путем добавления #к строке данных.

Stax , 20 18 байт

"34s+cTZL"34s+cTZL

Запустите и отладьте его

Создает дополнительный пробел перед 2-й кавычкой при каждой итерации.

объяснение

Использует программу "34s+cTZL "34s+cTZLдля объяснения.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

JSTX , 4 байта

£↕♣:

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

Рунические чары , 6 байт

"'<S@>

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

Это было странно. Все, что мне нужно было сделать, это удалить ~из оригинальной лебеды, найденной Джо Кингом .

Каждый дополнительный прогон добавляет другой <в конец, например:

"'<S@><<<<<<<<<

Все из которых ничего не делают.

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

Желе , 11 байт

“⁾;⁶;ØV” ṘV

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

Чудо , 33 байта

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Интересный вариант нормальной квинны, который добавляет 1 после каждой итерации.

Прогрессирование:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

объяснение

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

Одна из интересных частей этой статьи - Wonder может работать с числами произвольной точности, поэтому прогрессия не будет прерываться после определенного количества единиц.

ColdFusion, 277 байт

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Это тривиальная модификация моей анкеты ColdFusion, которая добавляет новую строку каждый раз, когда она вызывается .

Протестировано локально на Lucee-Express-5.2.6.60

Пакет Windows, 38 36 байт

echo|set/p"=q">q&copy/b/y %0+q %0
::

Этот код создает файл с именем «q», содержащий букву «q», а затем добавляет его в исходный файл. Обратите внимание, что «::» - это псевдоним для «rem», который не требует дополнительного пробела.

Сохранено 2 байта благодаря пользователю 3493001.

Gol> <> , 7 байт

":r2ssH

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

Это простая вариация обычной Gol> <> квин, но она добавляется при Hкаждом запуске. Поскольку Hкоманда останавливает программу, дополнительные Hв конце не изменяют поведение.

T-SQL , 175 байт

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

Сначала я написал SQL-квиню, а затем изменил ее, добавив дополнительный пробел (несколько вдохновленный этим ответом ).

Befunge-98 (PyFunge) , 22 19 байт

r:#,_ #;'D2/'<,,@;"

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

Добавляет <перед последним "каждое поколение.

C # (интерактивный компилятор Visual C #) , 89 байт

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Вдохновленный ответом Кевина Круйссена.

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