Este desafío es bastante simple. Como entrada, tomas una expresión regular.

Luego, muestra una verdad / falsedad de si su código fuente coincide o no con la expresión regular. ¡Es así de simple! Solo dos cosas más:

• Sin quinas incorporadas; Sin embargo, puede acceder al código fuente del código por archivo IO, etc.
• Este es el código de golf , por lo que gana el código más corto en bytes .

Ejemplo

Si su código fuente fuera decir, abcuna entrada de a\wcdevolvería verdadero y una entrada de a\dcdevolvería falso.

Shell Z, 12 bytes

grep "$@"<$0

Los condicionales Zsh entienden solo los códigos de salida, y las secuencias de comandos salen con 0 o 1 en consecuencia.

Además, esto imprime una cadena no vacía (el código fuente) para una coincidencia y una vacía para una falta de coincidencia, que podría ser como valores verdadero / falso en combinación con test/ [.

El programa lee su propio archivo, pero de acuerdo con este comentario del OP, esto está permitido.

JavaScript (ES6), 39

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

Python 3, 119 bytes

Esto se ve mejor , IMO (y no lee el archivo).

(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())))

Agregado después de leer este comentario .

Julia, 64 54 bytes

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

Las expresiones regulares de Julia usan PCRE. Si bien leer el código fuente del archivo es una laguna estándar para quines, en este caso se ha permitido explícitamente. Toma datos sin nueva línea final.

Japt, 22 bytes

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

Marco estándar de quine con algunos bytes agregados para adaptarse a este desafío. Verdad = coincidencia (es), falso = nulo. Pruébalo en línea!

         // 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]] & 

Tenga en cuenta el espacio final. Utiliza el mecanismo estándar de Mma quine y prueba si coincide con la expresión regular.

Perl, 21 bytes

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

17 bytes más 4 bytes para -pl0. Corre así:

echo open | perl -pl0 quinean

El archivo fuente debe contener solo el código anterior (sin shebang, sin línea nueva). Emite 1si la expresión regular coincide y la cadena vacía si no (la cadena vacía es falsey en Perl).

Se pueden guardar cuatro bytes si se garantiza que la entrada no termine en una nueva línea:

open 0;say<0>=~<>

Corre así:

echo -n open | perl -M5.010 quinean

sayrequiere Perl 5.10+ y debe habilitarse con -M5.010. Según Meta , "el-M5.010 , cuando es necesario, es gratis", dando una puntuación de 17 bytes.

Cómo funciona

Esta es una variación simple del estándar "trampa" quine:

open 0;print<0>

Esto abre el archivo nombrado $0y lee el contenido con <0>.

$_=<0>=~$_lee una línea del archivo fuente, hace una coincidencia de expresiones regulares con los contenidos de $_(que fueron leídos por el -pindicador) y asigna el resultado a $_. -pimprime $_automáticamente al final.

Jolf, 18 15 bytes

Admite el sabor JS de RegEx, espero que esté bien. Pruébalo aquí! .

 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 (no competitivo)

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

Try it here (Firefox only).

Usar una versión con corrección de errores escrita después del desafío.

Explicación

⟮‼(ⒸⅩ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: Los bloques de copia NO son operadores de quine. Están destinados a ser alternativas más versátiles a las declaraciones variables.