ค้นหาหลุม 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]) จำนวนเฉพาะครั้งถัดไป

ฟังก์ชันที่มีอยู่แล้วภายในเพื่อคำนวณว่าตัวเลขนั้นเป็นจำนวนเฉพาะหรือไม่

• ซึ่งหมายความว่าไม่อนุญาตให้ใช้ฟังก์ชั่นเพื่อแสดงจำนวนตัวหาร
• ฟังก์ชั่นที่คืนค่าการแยกตัวประกอบเฉพาะนั้นไม่ได้รับอนุญาตเช่นกัน

นี่ควรเป็นควินจริง (ยกเว้นบางครั้งต้องรอดูอีกจุดหนึ่ง) ดังนั้นคุณไม่ควรอ่านซอร์สโค้ดของคุณเอง

เนื่องจากภาษาเช่น Java และ C # มีข้อเสียอยู่แล้วคุณไม่จำเป็นต้องส่งออกโค้ดที่ใช้งานได้ทั้งหมด ถ้ามันสามารถใส่ในฟังก์ชั่น (ที่เรียกว่า) และส่งออกควินถัดไปคุณจะดี

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดชนะ!

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";

ขอบคุณ Martin ที่เตือน]W=เคล็ดลับให้ฉัน:)

ลองออนไลน์ได้ที่นี่

Mathematica, 248 222 ไบต์

แก้ไข:แก้ไขการใช้งานของฟังก์ชั่นที่เกี่ยวข้องกับนายก แต่ยังปรับปรุง quining บิต

แก้ไข:ขอบคุณ Dennis ที่แนะนำให้ฉันรู้จักกับทฤษฎีบทของ 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]

สิ่งนี้จะถือว่าเคอร์เนลถูกปิดระหว่างการเรียกใช้ quine ในภายหลัง (หรืออย่างน้อยnจะถูกรีเซ็ต) เนื่องจากอาศัยnการไม่ได้กำหนดก่อนที่อินสแตนซ์แรกของการ[MyQuine]รัน

สิ่งนี้อาจสั้นลงได้มาก แต่ฉันไม่ได้มีประสบการณ์มากมายกับควินส์โดยเฉพาะอย่างยิ่งใน Mathematica

นี่คือคำอธิบาย:

1;

สิ่งนี้ไม่ได้ทำอะไรเลย แต่ถ้าต่อกันกับจุดสิ้นสุดของควินินก่อนหน้ามันจะทวีคูณผลลัพธ์ของการแสดงออกครั้งสุดท้ายโดย1(ซึ่งไม่ใช่ -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

นี้พบนายกถัดไปโดยใช้ทฤษฎีบทของวิลสัน

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:#) :;'''

เคล็ดลับเล็ก ๆ น้อย ๆ ที่น่ารักก็คือมัน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)
#