Найдите отверстие 1 здесь .

Создайте квин, который при запуске выдает свой собственный блок исходного кода несколько раз. Фактически, он должен вывести его n раз, где n в следующем простом числе.

Я думаю, что пример показывает это лучше всего.

[MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]

Каждая программа будет выводить свой базовый «блок» (так [МОЙ КУИН]) следующее простое число раз.

Встроенные функции для вычисления того, является ли число простым числом (например, функция isPrime) или для определения следующего простого числа (например, функция nextPrime ()), не допускаются.

• Это означает, что функции для перечисления количества делителей не допускаются
• Функции, которые возвращают простую факторизацию, также запрещены

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

Поскольку такие языки, как Java и C #, уже находятся в невыгодном положении, вам не нужно выводить полностью рабочий код. Если это можно было бы поместить в функцию (которая вызывается) и вывести следующую строку, то у вас все хорошо.

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

CJam, 31 байт

{'_'~]-3>U):U{)__,1>:*)\%}g*}_~

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

идея

Чтобы проверить простоту, мы будем использовать теорему Вильсона , которая утверждает, что целое число n> 1 является простым тогда и только тогда, когда (n - 1)! -1 (mod n) , что верно тогда и только тогда, когда (n - 1)! + 1% n == 0 .

Код

{                           }_~ e# Define a block and execute a copy.
                                e# The original block will be on top of the stack.
 '_'~]                          e# Push those characters and wrap the stack in an array.
      -3>                       e# Keep only the last three elements (QUINE).
         U):U                   e# Increment U (initially 0).
             {           }g     e# Do-while loop:
              )__               e# Increment the integer I on the stack (initially U).
                 ,1>            e#   Push [1 ... I-1].
                    :*          e#   Multiply all to push factorial(I-1).
                      )\%       e#   Push factorial(I-1) + 1 % I.
                                e# While the result is non-zero, repeat.
                                e# This pushes the next prime after U.
                           *    e# Repeat QUINE that many times.

CJam, 36 35 байт

{]W="_~"]U):U{)_,{)1$\%!},,2>}g*}_~

Это, безусловно, может быть дальше.

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

{                               }_~   "Copy this code block and execute the copy";
 ]W=                                  "Take just the last element from the stack";
                                      "The other thing on stack is the block from above";
    "_~"]                             "Put "_~" on stack and wrap the 2 things in an array";
                                      "At this point, the string representation of stack"
                                      "elements is identical to the source code";
         U):U                         "Increment U and update U's value. This  variable"
                                      "actually counts the number of [Quine] blocks";
             {)_,{)1$\%!},,2>}g       "Find the next prime number"
                               *      "Repeat the array that many times, thus repeat the"
                                      "[Quine] block, the next prime times";

Спасибо Мартину за напоминание мне об ]W=уловке :)

Попробуйте онлайн здесь

Mathematica, 248 222 байта

Редактировать: Исправлено использование функции, связанной с простыми числами, но также немного улучшено квинирование.

Изменить: Спасибо Деннис за то, что познакомил меня с теоремой Уилсона.

1;n=If[ValueQ@n,n+1,1];StringJoin@Array[#<>ToString[1##,InputForm]<>#2&@@\("1;n=If[ValueQ@n,n+1,1];StringJoin@Array[#<>ToString[1##,InputForm]<>#\2&@@("*"&,For[i=n,Mod[++i!/i+1,i]>0,0];i]")&,For[i=n,Mod[++i!/i+1,i]>0,0];i]

Это предполагает, что ядро ​​завершается между последующими запусками quine (или, по крайней мере n, сбрасывается), потому что оно полагается на nнеопределенность до [MyQuine]запуска первого экземпляра .

Это, вероятно, может быть значительно сокращено, но у меня нет большого опыта работы с куинами, особенно в Mathematica.

Вот объяснение:

1;

Это ничего не делает, но если оно объединено в конце предыдущей квине, оно умножает результат последнего выражения на 1(что не является опцией), а точка с запятой подавляет вывод. Это гарантирует, что только последняя копия [MyQuine]печатает что-либо.

n=If[ValueQ@n,n+1,1];

Это инициализирует nк 1в первой копии , [MyQuine]а затем увеличивает его на 1каждой последующей копии - то есть это только подсчитывает , сколько копий есть в n.

Перейдите к концу сейчас:

For[i=n,Mod[++i!/i+1,i]>0,0];i

Это находит следующее простое число, используя теорему Вильсона .

StringJoin@Array[#<>ToString[1##,InputForm]<>#2&@@\("QUINE_PREFIX"*"QUINE_SUFFIX")&,NEXTPRIME[n]]

Это фактическая Куайн. Он создает NextPrime@nкопии самого кода. Это также немного странно. Да, я умножаю две строки там, и нет, это не имеет значимого результата. QUINE_PREFIXсодержит весь код до двух строк и QUINE_SUFFIXсодержит весь код после двух строк. Теперь обычно вы используете Apply(или @@), чтобы превратить список в серию аргументов. Но вы можете заменить любого Headс Apply- например , умножением. Таким образом, несмотря на то, что это продукт, я все равно могу превратить его в два аргумента своей функции. Эта функция делает:

#<>ToString[1##,InputForm]<>#2

Где #первый аргумент (строка префикса), #2второй аргумент (строка суффикса), ##это последовательность обоих аргументов. Мне нужно подготовить, чтобы 1сохранить умножение - иначе ##бы всплыл список аргументов для ToString. В любом случае, ToString[1##,InputForm]&@@("abc"*"def")возвращается "abc"*"def"... как раз то, что мне нужно!

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

J - 60 символов

Использует следующий простой метод, как и другие ответы. (Это 4 p:немного.)

((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''

Милый маленький J трюк в том, что он f :gдействует, fкогда ему дают один аргумент, а gкогда дают два. Итак, если вы выписываете, говорите, f :;'a'f :;'a'f :;'a'что это действует как f'a';'a';'a', что здорово, потому что это коробочный список, элементы 'a'которого и длина которого являются числом вхождений.

Таким образом, мы можем поднять это до мелочей. fМы используем как выглядят (foo $~ bar), где fooстроит часть строки , которые мы повторить снова и снова, barнаходит следующее простое число и умножает его на 60, длину строки в foo.

   ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
   # ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
180
   ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
   # ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
300

Python 2.7, 214

from sys import*;R,s=range,chr(35)
def N(n):
 if n<3:return n+1
 for p in R(n+1,n+n):
    for i in R(2, p):
     if p%i==0:break
     else:return p
P=file(argv[0]).read();print(P.split(s)[0]+s)*N(P.count(chr(37)));exit(0)
#