Esse desafio é bem simples. Como entrada, você recebe uma expressão regular.

Em seguida, você gera uma verdade / falsa sobre se seu código-fonte corresponde ou não à expressão regular. É simples assim! Apenas mais duas coisas:

• Não há quine builtins; você pode, no entanto, acessar o código-fonte do código pelo arquivo IO etc.
• Isso é código-golfe , então o código mais curto em bytes vence!

Exemplo

Se seu código-fonte fosse,, abcuma entrada de a\wcretornaria true e uma entrada de a\dcretornaria false.

Shell Z, 12 bytes

grep "$@"<$0

Os condicionais Zsh entendem apenas os códigos de saída e os scripts são encerrados com 0 ou 1 de acordo.

Além disso, isso imprime uma string não vazia (o código-fonte) para uma correspondência e uma vazia para uma incompatibilidade, que pode ser como valores de verdade / falsidade em combinação com test/ [.

O programa lê seu próprio arquivo, mas de acordo com este comentário do OP, isso é permitido.

JavaScript (ES6), 39

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

Python 3, 119 bytes

Isso parece mais legal, IMO (e não lê o arquivo).

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

Python 3, 67 bytes

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

Adicionado após a leitura deste comentário .

Julia, 64 54 bytes

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

As expressões regulares de Julia usam PCRE. Enquanto a leitura do código fonte do arquivo é uma brecha padrão para quines, nesse caso, foi explicitamente permitido. Recebe entrada sem nova linha à direita.

Japonês, 22 bytes

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

Estrutura padrão de quine com alguns bytes adicionados para atender a esse desafio. Verdade = correspondência (s), falso = nulo. Experimente 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 bytes

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

Observe o espaço à direita. Usa o mecanismo quine padrão do Mma e testa se ele corresponde ao regex.

Perl, 21 bytes

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

17 bytes mais 4 bytes para -pl0. Execute assim:

echo open | perl -pl0 quinean

O arquivo de origem deve conter apenas o código acima (sem shebang, sem nova linha à direita). Produz 1se o regex corresponde e a sequência vazia, se não (a sequência vazia é falsey no Perl).

Podem ser salvos quatro bytes se for garantido que a entrada não termina em uma nova linha:

open 0;say<0>=~<>

Execute assim:

echo -n open | perl -M5.010 quinean

sayrequer Perl 5.10+ e deve ser ativado com -M5.010. De acordo com Meta , "o -M5.010, quando necessário, é gratuito", dando uma pontuação de 17 bytes.

Como funciona

Esta é uma variação simples do quine padrão de "trapaça":

open 0;print<0>

Isso abre o arquivo nomeado $0e lê o conteúdo com <0>.

$_=<0>=~$_lê uma linha do arquivo de origem, faz uma correspondência regular com o conteúdo de $_(que foram lidos pelo -psinalizador) e atribui o resultado a $_. -pimprime $_automaticamente no final.

Jolf, 18 15 bytes

Suporta o sabor JS do RegEx, espero que esteja tudo bem. Experimente aqui! .

 h$code.value#i

Comentado:

  $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 caracteres / 26 bytes (não competitivo)

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

Try it here (Firefox only).

Usando uma versão com correções de erros escritas após o desafio.

Explicação

⟮‼(ⒸⅩ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: Os blocos de cópia NÃO são operadores de quine. Eles devem ser alternativas mais versáteis para declarações de variáveis.