Burada Delik 1'i bulun .

Çalıştırıldığında, kendi kaynak kodu bloğunu birden çok kez veren bir sorgulama yapın. Aslında, bir sonraki asal sayının n olduğu n kez çıktı almalıdır.

Bence bir örnek bunu en iyi gösteriyor.

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

Her Program bir sonraki asal sayı kez temel "bloğunu" (yani [QUINE]) gönderir .

Bir sayının asal olup olmadığını (isPrime işlevi gibi) hesaplamak veya sonraki asal değerini (nextPrime () işlevi gibi) belirlemek için yerleşik işlevlere izin verilmez.

• Bu, bölen sayısını listeleyen işlevlere izin verilmediği anlamına gelir
• Asal çarpanlara ayırmayı döndüren işlevlere benzer şekilde izin verilmez

Bu gerçek bir quine olmalıdır (bazı boşluklar hariç, bir sonraki noktaya bakın), bu yüzden kendi kaynak kodunuzu okumamalısınız.

Java ve C # gibi diller zaten dezavantajlı olduğu için, tamamen çalışan bir kod çıkarmanıza gerek yoktur. Eğer bir fonksiyona (denir) konabilir ve bir sonraki alıntıyı çıkarırsanız, iyisinizdir.

Bu kod golf, bu yüzden en kısa kod kazanır!

CJam, 31 bayt

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

CJam yorumlayıcısında çevrimiçi deneyin .

Fikir

Önceliği kontrol etmek için, n> 1 tamsayısının yalnızca (n - 1) ise birincil olduğunu belirten Wilson teoremini kullanacağız ! ≡ -1 (mod n) , eğer ve sadece (n - 1) ise doğrudur ! +% 1 n == 0 .

kod

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

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

Bu kesinlikle daha da golf edilebilir.

Nasıl çalışır:

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

Bana ]W=numarayı hatırlattığı için Martin'e teşekkürler :)

Buradan çevrimiçi deneyin

Mathematica, 248222 bayt

Düzenleme: Asal ilişkili bir işlevin kullanımı düzeltildi, aynı zamanda biraz sorgulama geliştirildi.

Edit: Dennis'e beni Wilson teoremiyle tanıştırdığı için teşekkürler.

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]

Bu, çekirdeğin sonraki ayın çalıştırmaları arasında bırakıldığını (veya en azından nsıfırlandığını) varsayar , çünkü nilk örneği [MyQuine]çalıştırılmadan önce tanımsız olmaya dayanır .

Bu muhtemelen çok kısaltılabilir, ancak özellikle Mathematica'da, quines ile ilgili çok fazla deneyimim yok.

İşte bir açıklama:

1;

Bu hiçbir şey yapmaz, ancak bir önceki satırın sonuna birleştirilirse, son ifadenin sonucunu ( 1op olmayan) ve noktalı virgül çıktıyı bastırır. Bu, yalnızca son kopyasının bir [MyQuine]şey yazdırmasını sağlar.

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

Bu başlatır niçin 1ilk kopyasında [MyQuine]ve sonra satın alma işlemini artırır 1her ileri kopyasında - yani bu sadece sayıları içinde kaç tane kopya n.

Şimdi sonuna kadar atla:

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

Bu, Wilson teoremini kullanarak bir sonraki başbakanı bulur .

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

Asıl soru bu. NextPrime@nKodun kendisinin kopyalarını oluşturur . Ayrıca biraz garip. Evet, orada iki dizeyi çarpıyorum ve hayır bunun anlamlı bir sonucu yok. QUINE_PREFIXiki dizeden önceki QUINE_SUFFIXtüm kodu ve iki dizeden sonraki tüm kodu içerir. Şimdi genellikle Apply(veya @@) bir listeyi bir dizi argümana dönüştürmek için kullanırsınız. Ancak herhangi birini - örneğin çarpma Headile değiştirebilirsiniz Apply. Dolayısıyla bu bir ürün olmasına rağmen yine de onu işlevim için iki tartışmaya dönüştürebilirim. Bu işlev şunları yapar:

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

#İlk bağımsız değişken nerede (önek dizesi), #2ikinci bağımsız değişken (sonek dizesi), ##her iki bağımsız değişkenin bir sırasıdır. Ben 1çarpma korumak için prepend gerekir - aksi takdirde ##argüman listesine uyar ToString. Her neyse, ToString[1##,InputForm]&@@("abc"*"def")geri dönüyor "abc"*"def"... tam ihtiyacım olan şey!

Ayın etrafında ihtiyacım olan her şeyle birlikte, bu evaltemelli bir ayının daha uygun olacağını düşünüyorum. Bunu daha sonra ya da yarın ele alacağım.

J - 60 karakter

Diğer cevaplar gibi bir sonraki prime yöntemini kullanır. (Bu 4 p:biraz.)

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

Sevimli küçük bir hile, bir argüman verildiğinde ve iki kez verildiğinde olduğu f :ggibi davranır . Yani, yazarsanız, bunun gibi davrantığını söyleyin , bu harika çünkü öğeleri olan ve uzunluğu olay sayısı olan kutulu bir liste .fgf :;'a'f :;'a'f :;'a'f'a';'a';'a''a'

Böylece bunu daha hızlı bir şekilde kaldırabiliriz. Kullandığımız fgibi görünüyor (foo $~ bar), burada footekrarladığımız dize kısmını tekrar tekrar oluşturuyoruz bar, bir sonraki asal sayıyı buluyor ve dizenin uzunluğu olan 60 ile çarpıyor 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)
#