Quine incrementale


23

Il tuo compito è quello di scrivere un programma o una funzione che emetta il primo carattere del suo codice sorgente, quindi il secondo, quindi il terzo ... ogni volta che viene eseguito.

Ad esempio, se il tuo programma era foonella lingua barnel file baz.bar, dovresti ottenere un output simile a questo:

λ bar baz.bar
f
λ bar baz.bar
o
λ bar baz.bar
o

Il tuo programma può fare qualsiasi cosa una volta che ha finito di stampare il suo codice sorgente in questo modo. È possibile modificare il codice sorgente per il file, ma ricordare che il codice sorgente da stampare è il codice sorgente originale .

Questo è un codice-golf, quindi vince il programma più breve in byte.


1
Se possiamo modificare il codice sorgente del file, significa che possiamo leggerlo anche noi?
FlipTack il

1
@ Flp.Tkc Buona domanda. Onestamente non ne ho idea. Non voglio che tu costruisca il quine leggendo la fonte, ma sto bene se leggi la fonte solo per la modifica del file.
Conor O'Brien,

Risposte:


6

Gelatina , 12 byte

“;⁾vṾ®ȯ©Ḣ”vṾ

Questo è un collegamento niladico. Provalo online! (Include il codice per chiamare il collegamento dodici volte.)

Come funziona

“;⁾vṾ®ȯ©Ḣ”vṾ  Niladic link.

“;⁾vṾ®ȯ©Ḣ”    Set the left argument and the return value to s =: ';⁾vṾ®ȯ©Ḣ'.
           Ṿ  Uneval; yield r =: '“;⁾vṾ®ȯ©Ḣ”', a string representation of s.
          v   Eval; execute s as a Jelly program with argument r.

 ⁾vV          Yield 'vṾ'.
;             Concatenate r and 'vṾ', yielding q =: '“;⁾vṾ®ȯ©Ḣ”vṾ'.
    ®ȯ        Take the flat logical OR of the register (initially 0) and q.
              This replaces 0 with q in the first run, but it will yield the
              content of the register in subsequent runs.
      ©       Copy the result to the register.
       Ḣ      Head; pop and yield the first character of the register.
              This modifies the string in the register, so it holds one fewer
              character after each call.

Come bonus aggiuntivo, poiché il registro conterrà una stringa vuota dopo la dodicesima chiamata, è di nuovo falsa e il collegamento è pronto per ricominciare. Chiamare il collegamento 24 volte produrrà il codice sorgente due volte, chiamandolo 36 volte tre volte, ecc.


Non conosco Jelly, quindi cosa fa esattamente il piè di pagina? Perché ^ 17?
Conor O'Brien,

Chiama il link sopra ( ¢), funzione di identità ( ¹, non proprio necessaria dopo la prima chiamata), imposta il valore di ritorno su avanzamento riga ( , stampa implicitamente il valore di ritorno precedente), ripeti. ¹e sono entrambi apice, ma non sono correlati. Li ho sostituiti con quelli meno confusi ¢;¢;¢;¢;¢;¢;¢;¢;¢;¢;¢;¢(chiama, concatena, ripeti).
Dennis,

12

Javascript - 26 byte

Definisce f()che restituisce il codice sorgente carattere per carattere.

n=0;f=x=>("n=0;f="+f)[n++]

Restituisce indefinito dopo aver esaurito i caratteri.

n=0;f=x=>("n=0;f="+f)[n++]
for(i=0;i<30;i++){console.log(f())} //test harness


Se non sbaglio, devi includere la chiamata di funzione come parte del codice.
Mama Fun Roll,

Link @MamaFunRoll al meta post pertinente?
Downgoat,

Non ne conosco nessuno: P Tuttavia, ho sempre pensato che la funzione stessa fosse parte del quine; forse c'è qualcosa che mi manca?
Mama Fun Roll,

@MamaFunRoll Le specifiche consentono in modo specifico le funzioni, quindi non dovrebbe essere necessaria una chiamata. Comunque non avrebbe molto senso per questa sfida particolare.
Dennis,

Va bene, sto solo assicurando.
Mama Fun Roll,

2

impilato , non competitivo, 34 byte

[tostr ':!' + execCounter # out]:!

Una variazione sul quine standard. Questo è un programma completo. Questo utilizza execCounterper ottenere quante volte questo programma è stato eseguito specificamente. Errori dopo aver emesso tutto.

Provalo qui!


2

Pip , 31 byte

{Y"{Y (yRsRPy++v)}"(yRsRPy++v)}

Una funzione anonima. Provalo su TIO!

Spiegazione

Inizia con questo Pip Quine standard:

Y"Y yRsRPy"yRsRPy
Y"Y yRsRPy"        Yank that string into y
           yRsRPy  In y, replace the space with repr(y)

Avvolgi questo tra parentesi graffe per renderlo una funzione. Ora, invece di restituire l'intera fonte, dobbiamo indicizzarla. L'uso di una variabile globale per l'indice e l'incremento ogni volta soddisfa il requisito "carattere successivo ogni volta che viene chiamato". vè il miglior candidato perché è preinizializzato -1. Incrementarlo la prima volta fornisce un indice di 0, la prossima volta 1, ecc.

Pip ha un indice ciclico, quindi una volta che la funzione stampa il suo ultimo carattere, ricomincia da capo.


1

Python, 90 byte

Un'estensione sullo standard Python quine (suggerimenti per il golf benvenuti):

def f(n=0,s='def f(n=0,s=%r):\n while 1:yield(s%%s)[n];n+=1'):
 while 1:yield(s%s)[n];n+=1

Questa è una funzione del generatore python , il che significa che si esegue l'iterazione su di essa e ogni iterazione fornisce il carattere successivo nel codice sorgente. Quando tutti i personaggi sono stati restituiti, questo si blocca IndexError.

Per i test, aggiungi semplicemente questo script alla fine del programma:

source = ''
try:
    # Call generator, add characters to the string
    for char in f():
        source += char
except IndexError:
    # Generator has reached end of source code
    pass

print(source)

Oppure provalo online!


1

*> <> , 13 21 byte

" r:2+a1Fi1+:1F1+[ro;

Crea un file denominato \nper tenere traccia dell'indice.

Potrebbe essere possibile giocare a golf di più, ma nulla mi salta immediatamente fuori ...

Produzione

$ starfish incrementalquine.sf 
"$ starfish incrementalquine.sf 
 $ starfish incrementalquine.sf 
r$ starfish incrementalquine.sf 
:$ starfish incrementalquine.sf 
2$ starfish incrementalquine.sf 
+$ starfish incrementalquine.sf 
a$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
F$ starfish incrementalquine.sf 
i$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
+$ starfish incrementalquine.sf 
:$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
F$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
+$ starfish incrementalquine.sf 
[$ starfish incrementalquine.sf 
r$ starfish incrementalquine.sf 
o$ starfish incrementalquine.sf 
;$ starfish incrementalquine.sf

Spiegazione

" r:2+                 build the quine
      a1F              open file named "\n"
         i1+:          read input, increment by 1, duplicate
             1F        save incremented input to file
               1+[     increment input, copy that many values to a new stack
                  ro   output the character at the beginning of the new stack
                    ;  end

Chine Incremental Cheating

a1Fi1+:0go1F;

Spiegazione

a1F            open file named "\n"
   i1+         read input and add 1 to it
      :0g      push the value at (input,0) to the stack
         o     output the value
          1F   save the incremented input to the file
            ;  exit

ahah, non avevo idea che potessi nominare un file "\ n". Anche se questo tecnicamente legge il codice sorgente, dalle gistruzioni.
Conor O'Brien,

@ ConorO'Brien, ah abbastanza giusto. hmm ...
redstarcoder il

*> <> Ha una sorta di indicizzazione dello stack? O la ripetizione del comando? Quindi, è possibile utilizzare il framework quine standard "your code goes here;per> <>, quindi accedere all'ennesimo membro in pila
Conor O'Brien,

@ ConorO'Brien yeah Teal Pelican mi ha mostrato questa variante di quine sulla mia altra risposta di chine quine :).
redstarcoder

1
@redstarcoder Ho lavorato di più sui quines (YAY!) e ho trovato un bel trucco, se sostituisci r con # puoi: 1- il # like; #; oppure [+ 1F1: + 1iF1a-1: "Al momento non posso provarlo, ma credo che tagli 1 byte dal tuo codice.> <> quines può essere fatto come #o <-1:" ecc: D
Alzavola pellicano il

1

Mathematica, 91 byte

Commenti molto graditi; Sto ancora imparando le corde su ciò che le quine sono quine appropriate.

(If[!NumberQ[q], q = 0]; StringTake[ToString[#0]<>FromCharacterCode[{91, 93}], {++q}]) & []

Definisce una funzione chiamata ripetutamente senza argomenti. Dopo la 91a chiamata, genera un grosso errore e restituisce un valore non valutato.

C'erano due problemi da superare: in primo luogo, volevo solo usare StringTake[ToString[#0]<>"[]"], ma ToString[]sembra cancellare le virgolette; così ho dovuto sostituire "[]"con FromCharacterCode[{91, 93}]. In secondo luogo, le variabili Mathematica iniziano non inizializzate, quindi non posso chiamare ++qprima che qsia definito; ecco perché If[!NumberQ[q], q = 0]è necessaria l'iniziale .

Coda irrilevante: guardando in alto NumberQ, ho imparato che Mathematica ha una funzione chiamata TrueQ... che, sì, restituisce Truese l'argomento è Truee Falsese l'argomento è False! (L'utilità è che ritorna anche Falsesu tutti gli altri argomenti.)


1

Microscript II, 40 33 byte

Un blocco di codice letterale, l'equivalente più vicino alla lingua di una funzione:

{ss1K+>K>s#<v{o}sl*v!(123v)lKp<o}

Dopo l'esecuzione, si reinserisce xper rendere più facile richiamare nuovamente.


0

Bash (e zsh, ksh), 39 byte

a=`<$0`;pwd>>0;echo ${a:`wc -l<0`-1:1}

Non stampa nulla dopo che il programma è stato stampato.

Assicurarsi 0che non esista nella directory corrente ed eseguire:

bash iquine.bash

Benvenuti in PPCG! Hai un'idea intelligente per incrementare l'indice. Sfortunatamente, sembra che questa risposta funzioni leggendo il proprio codice sorgente, il che significa che non è una quina valida per i nostri standard . Se lo modifichi per utilizzare quine tecniche diverse dalla lettura della propria fonte, sarà una buona risposta.
DLosc il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.