Trova Hole 1 qui .

Crea un quine che, quando eseguito, genera più volte il proprio blocco di codice sorgente. In effetti, deve essere emesso n volte, dove n nel prossimo numero primo.

Penso che un esempio lo mostri meglio.

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

Ogni programma emetterà il suo "blocco" di base (quindi [MY QUINE]) il numero primo successivo successivo .

Le funzioni integrate per calcolare se un numero è primo (come una funzione isPrime) o per determinare il primo primo (come una funzione nextPrime ()) non sono consentite.

• Ciò significa che le funzioni per elencare il numero di divisori non sono consentite
• Le funzioni che restituiscono la scomposizione in fattori primi sono ugualmente vietate

Questo dovrebbe essere un vero quine (ad eccezione di qualche margine di manovra, vedi punto successivo), quindi non dovresti leggere il tuo codice sorgente.

Dato che linguaggi come Java e C # sono già svantaggiati, non è necessario generare un codice totalmente funzionante. Se potesse essere messo in una funzione (che si chiama) e produrre il prossimo quine, sei a posto.

Questo è code-golf, quindi vince il codice più corto!

CJam, 31 byte

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

Provalo online nell'interprete CJam .

Idea

Per verificare la primalità, useremo il teorema di Wilson , che afferma che un numero intero n> 1 è primo se e solo se (n - 1)! ≡ -1 (mod n) , che è vero se e solo se (n - 1)! + 1% n == 0 .

Codice

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

Questo può sicuramente essere ulteriormente giocato a golf.

Come funziona:

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

Grazie a Martin per avermi ricordato il ]W=trucco :)

Provalo online qui

Mathematica, 248 222 byte

Modifica: risolto l'utilizzo di una funzione relativa a prime, ma migliorava anche un po 'il quining.

Modifica: Grazie a Dennis per avermi fatto conoscere il teorema di 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]

Ciò presuppone che il kernel sia chiuso tra le successive esecuzioni della quine (o almeno nsia resettato), perché si basa sul nfatto di non essere definito prima dell'esecuzione della prima istanza di [MyQuine].

Questo probabilmente può essere abbreviato molto, ma non ho molta esperienza con i quines, specialmente con Mathematica.

Ecco una spiegazione:

1;

Questo non fa nulla, ma se concatenato alla fine del precedente quine, moltiplica il risultato dell'ultima espressione per 1(che è un no-op) e il punto e virgola sopprime l'output. Questo assicura che solo l'ultima copia di [MyQuine]stampa qualsiasi cosa.

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

Questo inizializza nper 1la prima copia di [MyQuine]e poi lo incrementa di 1in ogni ulteriore copia - vale a dire questo a soli conta quante copie sono in n.

Passa subito alla fine ora:

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

Questo trova il prossimo numero primo usando il teorema di Wilson .

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

Questa è la vera quine. Crea NextPrime@ncopie del codice stesso. È anche un po 'strano. Sì, sto moltiplicando due stringhe lì, e no che non ha un risultato significativo. QUINE_PREFIXcontiene tutto il codice prima delle due stringhe e QUINE_SUFFIXcontiene tutto il codice dopo le due stringhe. Ora di solito usi Apply(o @@) per trasformare un elenco in una serie di argomenti. Ma puoi sostituirlo Headcon qualsiasi Apply- ad esempio moltiplicazione. Quindi, nonostante sia un prodotto, posso ancora trasformarlo in due argomenti per la mia funzione. Quella funzione fa:

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

Dov'è #il primo argomento (la stringa del prefisso), #2è il secondo argomento (la stringa del suffisso), ##è una sequenza di entrambi gli argomenti. Devo anteporre 1per preservare la moltiplicazione, altrimenti ##andrei a finire nella lista degli argomenti ToString. Comunque, ToString[1##,InputForm]&@@("abc"*"def")ritorna "abc"*"def"... proprio quello di cui ho bisogno!

Penso che con tutte le cose di cui ho bisogno intorno al quine, un evalquine basato su questo sarebbe più appropriato qui. Lo esaminerò più tardi o domani.

J - 60 caratteri

Utilizza il metodo next-prime come le altre risposte. (Questo è un 4 p:po '.)

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

Un piccolo trucco carino è che si f :gcomporta come fquando viene dato un argomento e gquando viene dato due. Quindi, se scrivi, dì f :;'a'f :;'a'f :;'a'che si comporta come f'a';'a';'a', il che è fantastico perché è un elenco in scatola i cui elementi sono 'a'e la cui lunghezza è il numero di occorrenze.

Quindi possiamo sollevarlo in una sorta di cosa delicata. fL'usiamo assomiglia (foo $~ bar), dove foocostruisce la parte stringa che si ripete più e più volte, bartrova il numero primo successivo e lo moltiplica per 60, la lunghezza della stringa in 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)
#