Questa sfida è piuttosto semplice. Come input, prendi un'espressione regolare.

Quindi, viene emesso un valore di verità / falsità sul fatto che il codice sorgente corrisponda o meno all'espressione regolare. È così semplice! Solo altre due cose:

• No quine builtins; tuttavia, è possibile accedere al codice sorgente del codice tramite il file IO, ecc.
• Questo è code-golf , quindi vince il codice più breve in byte !

Esempio

Se il tuo codice sorgente fosse detto, abcun input di a\wcrestituire true e un input di a\dcrestituire false.

Z shell, 12 byte

grep "$@"<$0

I condizionali Zsh comprendono solo i codici di uscita e gli script escono con 0 o 1 di conseguenza.

Inoltre, questo stampa una stringa non vuota (il codice sorgente) per una corrispondenza e una vuota per una mancata corrispondenza, che potrebbe essere un valore di verità / falsa in combinazione con test/ [.

Il programma legge il proprio file, ma secondo questo commento dell'OP, questo è permesso.

JavaScript (ES6), 39

(f=_=>!!`(f=${f})()`.match(prompt()))()

Python 3, 119 byte

Questo sembra più bello, IMO (e non legge il file).

(lambda i:print(bool(__import__('re').search(input(),i))))("(lambda i:print(bool(__import__('re').search(input(),i))))")

Python 3, 67 byte

print(bool(__import__('re').search(input(),open(__file__).read())))

Aggiunto dopo aver letto questo commento .

Julia, 64 54 byte

r=readline;show(ismatch(Regex(r()),open(r,@__FILE__)))

Le espressioni regolari di Julia usano PCRE. Mentre la lettura del codice sorgente del file è una scappatoia standard per i quines, in questo caso è stato esplicitamente consentito. Accetta input senza newline finali.

Japt, 22 byte

"+Q ³sAJ fU"+Q ³sAJ fU

Framework quine standard con pochi byte aggiunti per rispondere a questa sfida. Verità = match (es), falsy = null. Provalo online!

         // Implicit: U = input string, A = 10, J = -1, Q = quotation mark
"..."+Q  // Take this string and concatenate a quotation mark.
³        // Repeat three times.
sAJ      // Slice off the first 10 and last 1 chars.
fU       // Match U to the result.

Mathematica, 63 byte

StringMatchQ[ToString[#0, InputForm], RegularExpression[#1]] & 

Nota lo spazio finale. Utilizza il meccanismo Mma Quine standard e verifica se corrisponde al regex.

Perl, 21 byte

open 0;$_=<0>=~$_

17 byte più 4 byte per -pl0. Esegui in questo modo:

echo open | perl -pl0 quinean

Il file di origine deve contenere solo il codice sopra (no shebang, no newline finale). Emette 1se il regex corrisponde e la stringa vuota se non lo fa (la stringa vuota è falsa in Perl).

È possibile salvare quattro byte se si garantisce che l'ingresso non termini in una nuova riga:

open 0;say<0>=~<>

Esegui in questo modo:

echo -n open | perl -M5.010 quinean

sayrichiede Perl 5.10+ e deve essere abilitato con -M5.010. Secondo Meta , "il -M5.010, quando necessario, è gratuito", dando un punteggio di 17 byte.

Come funziona

Questa è una semplice variazione del quine standard "barare":

open 0;print<0>

Questo apre il file indicato $0e legge il contenuto con <0>.

$_=<0>=~$_legge una riga dal file sorgente, fa una corrispondenza regex con il contenuto di $_(che sono stati letti dal -pflag) e assegna il risultato a $_. -pstampa $_automaticamente alla fine.

Jolf, 18 anni 15 byte

Supporta il sapore JS di RegEx, spero che vada bene. Provalo qui! .

 h$code.value#i

ha commentato:

  $code.value#      the document's element "code" (the program container)
_h            i     and output if it has (matches) the input string (i.e. regex)

𝔼𝕊𝕄𝕚𝕟, 14 caratteri / 26 byte (non competitivo)

⟮‼(ⒸⅩ222+ᶈ0)đï

Try it here (Firefox only).

Utilizzo di una versione con correzioni di bug scritte dopo la sfida.

Spiegazione

⟮‼(ⒸⅩ222+ᶈ0)đï // implicit: ï=input
⟮               // copy block: copy following code for later use
 (ⒸⅩ222+ᶈ0)   // take convert 10222 to char, add stuff inside copy block
‼           đï // check if input matches resulting string
               // implicit output

NOTA: i blocchi di copia NON sono operatori di quine. Sono pensati per essere alternative più versatili alle dichiarazioni variabili.