Tìm lỗ 1 ở đây .

Tạo một câu hỏi mà khi chạy, sẽ xuất ra khối mã nguồn riêng của nó nhiều lần. Trong thực tế, nó phải xuất ra n lần, trong đó n trong số nguyên tố tiếp theo.

Tôi nghĩ rằng một ví dụ cho thấy nó tốt nhất.

[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]

Mỗi Chương trình sẽ xuất "khối" cơ sở của nó (vì vậy [MY QUINE]) số lần nguyên tố tiếp theo .

Các hàm được xây dựng để tính toán xem một số có phải là số nguyên tố hay không, (như hàm isPrime) hoặc để xác định số nguyên tố tiếp theo (như hàm nextPrime ()) không được phép.

• Điều này có nghĩa là các hàm liệt kê số lượng ước không được phép
• Các hàm trả về thừa số nguyên tố cũng không được phép

Đây phải là một câu hỏi thực sự (ngoại trừ một số thời gian, xem điểm tiếp theo), vì vậy bạn không nên đọc mã nguồn của riêng mình.

Vì các ngôn ngữ như Java và C # đã ở thế bất lợi, Bạn không cần phải xuất mã hoàn toàn. Nếu nó có thể được đặt trong một hàm (được gọi là) và xuất ra quine tiếp theo, bạn tốt.

Đây là mã golf, vì vậy mã ngắn nhất sẽ thắng!

CJam, 31 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Ý tưởng

Để kiểm tra tính nguyên thủy, chúng ta sẽ sử dụng định lý Wilson , trong đó nêu rõ rằng một số nguyên n> 1 là số nguyên tố khi và chỉ khi (n - 1)! ≡ -1 (mod n) , điều này đúng khi và chỉ khi (n - 1)! + 1% n == 0 .

Mã

{                           }_~ 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 byte

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

Điều này chắc chắn có thể được chơi golf hơn nữa.

Làm thế nào nó hoạt động:

{                               }_~   "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";

Cảm ơn Martin đã nhắc nhở tôi về ]W=mánh khóe :)

Dùng thử trực tuyến tại đây

Toán học, 248 222 byte

Chỉnh sửa: Đã sửa lỗi sử dụng hàm liên quan đến số nguyên tố, nhưng cũng cải thiện cách xử lý một chút.

Chỉnh sửa: Cảm ơn Dennis đã giới thiệu cho tôi định lý của Wilson.

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]

Điều này giả định rằng kernel được thoát giữa các lần chạy tiếp theo của quine (hoặc ít nhất nlà được đặt lại), bởi vì nó dựa vào nviệc không được xác định trước khi phiên bản đầu tiên [MyQuine]được chạy.

Điều này có thể được rút ngắn rất nhiều, nhưng tôi không có nhiều kinh nghiệm với các câu hỏi, đặc biệt là trong Mathicala.

Đây là một lời giải thích:

1;

Điều này không làm gì cả, nhưng nếu được nối vào phần cuối của câu hỏi trước, nó sẽ nhân kết quả của biểu thức cuối cùng bằng 1(không phải là op) và dấu chấm phẩy ngăn chặn đầu ra. Điều này đảm bảo rằng chỉ có bản sao cuối cùng của [MyQuine]bản in bất cứ điều gì.

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

Đây initialises nđến 1trong bản sao đầu tiên của [MyQuine]và sau đó tăng nó bằng cách 1trong mỗi bản sao hơn nữa - ví dụ này chỉ đếm bao nhiêu bản có trong n.

Bỏ qua trước đến cuối bây giờ:

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

Điều này tìm thấy số nguyên tố tiếp theo sử dụng định lý Wilson .

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

Đây là quine thực tế. Nó tạo ra các NextPrime@nbản sao của chính mã. Nó cũng hơi lạ. Có, tôi đang nhân hai chuỗi ở đó và không có chuỗi nào không có kết quả có ý nghĩa. QUINE_PREFIXchứa tất cả mã trước hai chuỗi và QUINE_SUFFIXchứa tất cả mã sau hai chuỗi. Bây giờ thông thường bạn sử dụng Apply(hoặc @@) để biến một danh sách thành một chuỗi các đối số. Nhưng bạn có thể thay thế bất kỳ Headbằng Apply- ví dụ: nhân. Vì vậy, mặc dù đây là một sản phẩm, tôi vẫn có thể biến nó thành hai đối số cho chức năng của mình. Chức năng đó có:

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

Đâu #là đối số thứ nhất (chuỗi tiền tố), #2là đối số thứ hai (chuỗi hậu tố), ##là một chuỗi của cả hai đối số. Tôi cần phải chuẩn bị trước 1để bảo toàn phép nhân - nếu không ##sẽ tách ra trong danh sách đối số ToString. Dù sao, ToString[1##,InputForm]&@@("abc"*"def")trả lại "abc"*"def"... chỉ là những gì tôi cần!

Tôi nghĩ rằng với tất cả những thứ tôi cần xung quanh quine, một evalquine dựa trên cơ sở sẽ phù hợp hơn ở đây. Tôi sẽ xem xét điều đó sau hoặc ngày mai.

J - 60 char

Sử dụng phương pháp nguyên tố tiếp theo như các câu trả lời khác. (Đó là 4 p:bit.)

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

Một mẹo nhỏ J dễ thương là f :ghành động như fkhi đưa ra một đối số và gkhi đưa ra hai đối số . Vì vậy, nếu bạn viết ra, hãy nói f :;'a'f :;'a'f :;'a'rằng hành động f'a';'a';'a'đó rất tuyệt vời bởi vì đó là một danh sách được đóng hộp có các mục 'a'và độ dài của nó là số lần xuất hiện.

Vì vậy, chúng ta có thể nâng điều đó thành một loại điều kỳ quặc. Các fchúng tôi sử dụng trông giống như (foo $~ bar), nơi fooxây dựng phần chuỗi mà chúng ta lặp lại nhiều lần, bartìm số nguyên tố tiếp theo và nhân lên nó bằng 60, chiều dài của chuỗi trong 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

Con trăn 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)
#