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]

각 프로그램은 다음 소수 횟수로 기본 "블록"(따라서 [MY QUINE])을 출력 합니다 .

숫자가 소수인지 (isPrime 함수와 같은) 계산하거나 다음 소수 (NextPrime () 함수와 같은)를 판별하는 함수는 허용되지 않습니다.

• 이것은 제수를 나열하는 기능이 허용되지 않음을 의미합니다
• 소인수 분해를 반환하는 함수도 마찬가지로 허용되지 않습니다

이것은 진정한 quine이어야합니다.

Java 및 C #과 같은 언어는 이미 불리하므로 완전히 작동하는 코드를 출력 할 필요는 없습니다. 함수 (호출)에 넣고 다음 quine을 출력 할 수 있다면 좋습니다.

이것은 코드 골프이므로 가장 짧은 코드가 승리합니다!

CJam, 31 바이트

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

CJam 통역사 에서 온라인으로 사용해보십시오 .

생각

우선 순위를 확인하기 위해 Wilson의 정리를 사용합니다. 이 정리 에서는 (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=트릭 을 상기시켜 준 Martin에게 감사합니다 :)

여기에서 온라인으로 사용해보십시오

매스 매 티카, 248222 바이트

편집 : 프라임 관련 기능의 사용을 수정했지만 quining이 약간 개선되었습니다.

편집 : Wilson의 정리를 소개해 준 Dennis에게 감사합니다.

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]

이것은 커널이 첫 번째 인스턴스 가 실행 되기 전에 undefined에 n의존하기 때문에 quine의 후속 실행 사이에 종료된다고 가정 합니다.n[MyQuine]

이것은 아마도 많이 단축 될 수 있지만 특히 Mathematica에서 quine에 대한 경험이 많지 않습니다.

여기에 설명이 있습니다 :

1;

이것은 아무것도하지 않지만 이전 quine의 끝에 연결되면 마지막 표현식의 결과에 1(no-op)를 곱하고 세미콜론은 출력을 억제합니다. 이렇게하면 마지막 사본 만 [MyQuine]인쇄됩니다.

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

이 처음 상태 n로 1의 첫 번째 사본에 [MyQuine]다음하여 증가 1각 추가 사본 - 즉,이 단지 카운트에서 얼마나 많은 사본 n.

이제 끝으로 넘어가십시오.

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

이것은 Wilson의 정리를 사용하여 다음 소수를 찾습니다 .

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"... 내가 필요한 것!

나는 quine 주위에 필요한 모든 것을 가지고 eval여기에 기반 quine이 더 적합 할 것이라고 생각합니다. 나중에 또는 내일 살펴 보겠습니다.

J-60 자

다른 답변과 마찬가지로 다음 프라임 방법을 사용합니다. ( 4 p:비트입니다.)

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

귀여운 작은 J 트릭은 하나의 인수 가 주어 졌을 때 와 두 개의 인수가 주어 졌을 때 f :g처럼 작동 합니다. 따라서, 만약 당신이 글을 쓰면 , 그것은 다음과 같이 작동합니다 . 이것은 항목이 있고 길이가 발생 횟수 인 박스 목록이기 때문에 훌륭 합니다.fgf :;'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

파이썬 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)
#