Quinean Regex Tester

Question

This challenge is pretty simple. As input, you take in a regular expression.

Then, you output a truthy/falsey of whether or not your source code matches the regular expression. It's that simple! Just two more things:

• No quine builtins; you may, however, access the code's source code by file IO, etc.
• This is code-golf, so shortest code in bytes wins!

Example

If your source code was say, abc, an input of a\wc would return true and an input of a\dc would return false.

Answer 1

Z shell, 12 bytes

grep "$@"<$0

Zsh conditionals understand only exit codes, and the scripts exits with 0 or 1 accordingly.

In addition, this prints a non-empty string (the source code) for a match and an empty one for a mismatch, which could be as truthy/falsy values in combination with test/[.

The program reads its own file, but according to this comment by the OP, this is allowed.

Answer 2

JavaScript (ES6), 39

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

Answer 3

Python 3, 119 bytes

This just looks cooler, IMO (and it doesn't read the file).

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

Added after reading this comment.

Answer 4

Julia, 64 54 bytes

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

Julia regular expressions use PCRE. While reading the source code of the file is a standard loophole for quines, in this case it has been explicitly allowed. Takes input with no trailing newline.

Answer 5

Japt, 22 bytes

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

Standard quine framework with a few bytes added to fit this challenge. Truthy = match(es), falsy = null. Try it 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.

Answer 6

Jolf, 18 15 bytes

Supports the JS flavour of RegEx, I hope that's okay. Try it here!.

 h$code.value#i

Commented:

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

Answer 7

Mathematica, 63 bytes

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

Note the trailing space. Uses the standard Mma quine mechanism, and tests if it matches the regex.

Answer 8

Perl, 21 bytes

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

17 bytes plus 4 bytes for -pl0. Run like this:

echo open | perl -pl0 quinean

The source file must contain only the code above (no shebang, no trailing newline). Outputs 1 if the regex matches and the empty string if it doesn't (the empty string is falsey in Perl).

---

Four bytes can be saved if the input is guaranteed not to end in a newline:

open 0;say<0>=~<>

Run like this:

echo -n open | perl -M5.010 quinean

say requires Perl 5.10+ and must be enabled with -M5.010. According to Meta, "the -M5.010, when needed, is free," giving a score of 17 bytes.

How it works

This is a simple variation on the standard "cheating" quine:

open 0;print<0>

This opens the file named in $0 and reads the contents with <0>.

$_=<0>=~$_ reads one line from the source file, does a regex match against the contents of $_ (which were read by the -p flag), and assigns the result to $_. -p prints $_ automatically at the end.

Answer 9

, 14 chars / 26 bytes (non-competitive)

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

Try it here (Firefox only).

Using a version with bug fixes written after the challenge.

Explanation

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

NOTE: Copy blocks are NOT quine operators. They are meant to be more versatile alternatives to variable declarations.