Ce défi est assez simple. En entrée, vous prenez une expression régulière.

Ensuite, vous affichez une vérité / falsey indiquant si votre code source correspond ou non à l'expression régulière. C'est si simple! Encore deux choses:

• Aucun quine builtins; vous pouvez cependant accéder au code source du code par fichier IO, etc.
• C'est du code-golf , donc le code le plus court en octets gagne!

Exemple

Si votre code source était dit, abcune entrée de a\wcretournerait vrai et une entrée de a\dcretournerait faux.

Coque Z, 12 octets

grep "$@"<$0

Les conditions Zsh ne comprennent que les codes de sortie et les scripts se terminent par 0 ou 1 en conséquence.

De plus, cela imprime une chaîne non vide (le code source) pour une correspondance et une chaîne vide pour une non-concordance, qui pourrait être des valeurs véridiques / fausses en combinaison avec test/ [.

Le programme lit son propre fichier, mais selon ce commentaire de l'OP, cela est autorisé.

JavaScript (ES6), 39

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

Python 3, 119 octets

Cela a l' air plus cool, IMO (et il ne lit pas le fichier).

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

Python 3, 67 octets

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

Ajouté après avoir lu ce commentaire .

Julia, 64 54 octets

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

Les expressions régulières de Julia utilisent PCRE. Bien que la lecture du code source du fichier soit une faille standard pour les quines, dans ce cas, il a été explicitement autorisé. Prend des entrées sans retour à la ligne.

Japt, 22 octets

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

Cadre de quine standard avec quelques octets ajoutés pour répondre à ce défi. Truthy = correspondance (s), falsy = null. Essayez-le en ligne!

         // 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 octets

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

Notez l'espace de fin. Utilise le mécanisme de quine Mma standard et teste s'il correspond à l'expression régulière.

Perl, 21 octets

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

17 octets plus 4 octets pour -pl0. Courez comme ceci:

echo open | perl -pl0 quinean

Le fichier source ne doit contenir que le code ci-dessus (pas de shebang, pas de retour à la ligne). Affiche 1si l'expression régulière correspond et la chaîne vide si ce n'est pas le cas (la chaîne vide est falsey en Perl).

Quatre octets peuvent être enregistrés si l'entrée est garantie de ne pas se terminer par une nouvelle ligne:

open 0;say<0>=~<>

Courez comme ceci:

echo -n open | perl -M5.010 quinean

saynécessite Perl 5.10+ et doit être activé avec -M5.010. Selon Meta , "le -M5.010, si nécessaire, est gratuit", ce qui donne un score de 17 octets.

Comment ça fonctionne

Il s'agit d'une variante simple du quine standard de "triche":

open 0;print<0>

Cela ouvre le fichier nommé $0et lit le contenu avec <0>.

$_=<0>=~$_lit une ligne du fichier source, fait une correspondance regex avec le contenu de $_(qui a été lu par l' -pindicateur) et affecte le résultat à $_. -ps'imprime $_automatiquement à la fin.

Jolf, 18 15 octets

Prend en charge la saveur JS de RegEx, j'espère que ça va. Essayez-le ici! .

 h$code.value#i

Commenté:

  $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 caractères / 26 octets (non concurrentiel)

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

Try it here (Firefox only).

Utiliser une version avec des corrections de bugs écrites après le challenge.

Explication

⟮‼(ⒸⅩ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

REMARQUE: les blocs de copie ne sont PAS des opérateurs de quine. Ils sont censés être des alternatives plus polyvalentes aux déclarations de variables.