Quine 1-up - это программа, очень похожая на Quine. Единственное существенное отличие состоит в том, что вместо однократной печати, когда n копий программы объединяются, результат печатает исходную программу n + 1 раз.

пример

Если ваша программа Abc123:

Abc123  ->  Abc123Abc123
Abc123Abc123  ->  Abc123Abc123Abc123
Abc123Abc123Abc123  -> Abc123Abc123Abc123Abc123

Вызов

Ваша задача состоит в том, чтобы создать кратчайшую действующую 1-куану на любом языке. Применяются обычные правила Куайна, поэтому вы не можете:

• Отправьте пустую программу.
• Прямо или косвенно читайте ¹ исходный код.
• Используйте quining встроенные модули.

Это код-гольф, поэтому выигрывает самый короткий код в байтах.

^{1 Это не включает использование жестко запрограммированной строки или кодового блока как части вашей программы.}

GolfScript, 12 байт

{`'.~'+:n}.~

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

объяснение

Это объединяет идеи из стандартного quine GolfScript:

{'.~'}.~

И мой недавно обнаруженный квин :

":n`":n`

Основная идея снова заключается в использовании, nкоторое неявно печатается в конце программы, чтобы получить дополнительную копию квин. Поскольку присвоение переменной ничего не меняет при повторном выполнении в последующих копиях, это добавит только одну копию. Вот разбивка кода:

{        # Standard quine framework. This pushes the block, duplicates it and runs the
         # second copy, such that it can process the first copy to create a quine.
  `      # Convert the block to its string representation.
  '.~'+  # Append the string '.~' to make a complete quine. This is simply left on the
         # stack to be printed at the end.
  :n     # Store the string in n such that one more copy is printed at the end.
}.~

GolfScript, 12 байт

{: ".~"][}.~

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

Как работает исходный код

{: ".~"][}.~

{        }    Define and push a code block.
          .~  Push a copy and execute it.
 :            Save the code block in the space character.
              Every subsequent space will now execute the code block.
   ".~"       Push that string.
       ]      Wrap everything up to the last [ in an array.
        [     Set a new array marker.

Если приведенный выше исходный код выполняется один раз, стек в конечном итоге

["" {: ".~"]} ".~"]

где пустая строка в начале соответствует начальному состоянию стека (пустой ввод).

Две копии исходного кода оставили бы окончательное состояние

["" {: ".~"]} ".~"] [{: ".~"]} ".~"]

три копии окончательного состояния

["" {: ".~"]} ".~"] [{: ".~"]} ".~"] [{: ".~"]} ".~"]

и так далее.

Что произойдет дальше

После выполнения исходного кода интерпретатор делает следующее.

1. Он оборачивает весь стек в массив и помещает этот массив в стек.

   Для двух копий исходного кода стек теперь содержит

   ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [["" {: ".~"][} ".~"] [{: ".~"][} ".~"]]
   

2. Он выполняется putsс намерением распечатать упакованную стопку с последующей переводом строки.

   putsопределяется как {print n print}, поэтому он делает следующее.

   1. printпечатает свернутую копию стека без проверки его (т. е. без преобразования его в строковое представление). Это отправляет

      {: ".~"][}.~{: ".~"][}.~
      

      (исходный код) в STDOUT и выскакивает копию стека с вершины стека.

      Стек теперь содержит

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"]
      

   2. выполняет блок кода, который мы определили ранее.

      :начинается с сохранения [{: ".~"][} ".~"]в пространстве характер, затем ".~"толкает себя, ]обертывания ".~"в массиве, и [устанавливает новый маркер массива.

   3. n выдвигает строку, состоящую из одного перевода строки.

      Стек теперь содержит

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n"
      

   4. выполняется еще раз. Однако он был переопределен, когда мы вызывали его впервые, и теперь содержит массив, а не блок кода.

      На самом деле, это толкает [{: ".~"][} ".~"], оставляя стек как

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n" [{: ".~"][} ".~"]
      

   5. Наконец, printпечатает самый верхний элемент стека, не проверяя его, отправляя

      {: ".~"][}.~
      

      в STDOUT, 1 - повышение исходного кода.

Javascript ES6 (REPL), 55 байтов

var a=-~a;$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

Сохранено 2 байта благодаря @ user81655!

объяснение

Вот стандартная структура Quine:

$=_=>`$=${$};$()`;$()

Вы должны увидеть эту структуру внутри представления. Более подробное объяснение ниже.

var a=-~a;

Это счетчик, по умолчанию равный 1. В основном, он говорит нам, сколько нужно повторять квин и приращения в одно и то же время.

$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

Это часть Quine. По сути, мы повторяем строку quine счетчиком +1. Последующие вызовы функций отменят вывод.

CJam, 14 байтов

{"_~"]-2>_o}_~

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

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

{"_~"]-2>_o}_~

{          }    Define a code block and push it on the stack.
            _~  Push and execute a copy of it.
 "_~"           Push that string.
     ]          Wrap the entire stack in an array.
      -2>       Discard all but the last two elements (block and string).
         _o     Push and print a copy of that array.

После выполнения последней копии программы массив, содержащий блок и строку, все еще находится в стеке, поэтому он печатается неявно.

Groovy, 83 байта

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

Есть один встроенный и не завершающий перевод строки. Это печатает:

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

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

Рубин, 43 байта

1;s="1;s=%p;$><<s%%s*n=2-0";$><<s%s*n=2-0

Само по себе это печатает сам 2-0или 2раз. При объединении с другой копией самого себя конечный оператор печати выглядит следующим образом $><<s%s*n=2-01, то есть он выводит себя только один раз ( 01будучи восьмеричным 1). Таким образом, только последняя копия строки печатается дважды, остальные печатаются один раз.

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

NodeJS, 63 61 60 55 байт

это также будет работать в JavaScript (ES6), если вы считаете, что несколько сообщений консоли разделяются символами новой строки (REPL не требуется)

Сохранено 2 байта благодаря @ dev-null

(f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t()))()

обратите внимание, что в конце кода есть новая строка.

Это был интересный, безусловно, один из моих любимых на этом сайте.

Я вполне уверен, что это не может быть гораздо лучше. (возможно, printфункция SpiderMonkey ...)

объяснение

//FIRST ITERATION
            console.log(`(f=${f})()`)                   //logs to the console a quine of the source code using function f's toString()
                                     ||                 //causes the expression to evaluate to the second part, since console.log's return value is falsy
                                       (_=>t)           //a function that returns function t when called
       t=_=>                                            //defines function t to be the code above. When called, t will log a quine and then return a function that returns t.
      (                                      )(t())     //call t twice. (one call is done via the t() as an ignored parameter) This will print the quine twice.
 f=_=>                                                  //define f as the above code.
(                                                  )()  //call function f with no arguments. this results in a function returning t. (the result of calling t once)
                                                        //this newline is to compensate for console.log's behavior of adding a newline to its output
//SECOND ITERATION
(                                                  )    //call the function that returns t that was returned from the first iteration. This expression will result in whatever that function returns, which is t.
 f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t())     //this part evaluates to a function, which is passed as a parameter to the function that returns t, that ignores its parameter.
                                                    ()  //call whatever the last expression returned, which is the function t, with no parameters. This will print the quine once.
                                                        //this call will result in a function returning t, just like from the first iteration, so we can add on more iterations at will.

Рубин, 55 байт

n||=2;s="n||=2;s=%p;$><<(s%%s)*n;n=1;";$><<(s%s)*n;n=1;

Здесь нет ничего интересного, это просто обычный рубиновый квин с прилавком.

JavaScript (ES6), 164 байта

console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))
console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))

Работает на любой странице тестирования JS или консоли в Firefox, предполагая, что пробел между двумя сообщениями консоли считается переводом строки.

Perl 6 , 58 53 байта

Спасибо Джо Кингу за -5 байтов.

<say "<$_>~~.EVAL for 0..!.++;">~~.EVAL for 0..!.++;

По мотивам Джо Кинга .

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

Japt, 40 байт

Oo("+Q ²pT°?1:2 é4;POo("+Q ²pT°?1:2 é4;P

Проверьте это онлайн! Объяснение впереди.

Y

Неконкурентный, 6 байт

UCn*px

Y - головная пушка, которая у меня была некоторое время, и это вдохновило меня на ее написание. Это сделано для задач, в которых последовательность является ключевой, таких как эта. Код разделен на ссылки по символам «узла». В этом случае наш код помещается в две цепочки (изначально) с узлом C.

U  C  n* px
1  N    2

Uзаписывает трансцендентную строку, т. е. ту, которая охватывает ссылки. Он записывает, пока не встретит другого U. Если a Uне встречается в конце строки, он оборачивается. Также Uвключен в строку по умолчанию. После записи строки мы переходим к узлу C, который просто перемещает нас к следующей ссылке.

nтолкает количество цепей. Для нашего базового случая это 2. Для последовательности Kцепочек существуют K+2цепочки, так же как и Kузлы. *это повторение строки. pпечатает весь стек (в данном случае одну строку) и xзавершает программу

В тексте:

UCn*px
U..... record that string
 C     next link
  n*   repeat that string twice.
    px print and terminate

UCn*pxUCn*pxUCn*px
U.....U            record string
 C                 next link
  n*               repeat that string four times (three Cs)
    px             print and terminate

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

Брахилог , 20 байт

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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

Модифицировано из этого квайна.

⊥                       Fail,
 ∨                      or
                w       print
  "⊥∨~kgjw₃w₅"          "⊥∨~kgjw₃w₅"
                 ₃      formatted
              gj        with itself;
                 ₃w₅    print it again at the end of the program if this route succeeds.

Когда он соединяется с самим собой, каждый маршрут, кроме последнего, завершается неудачно, и программа переходит к следующему, выполняя каждый w₃и возвращаясь к предыдущему, w₅кроме самого последнего.

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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