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:
If your source code was say, abc, an input of a\wc would return true and an input of a\dc would return false.
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.
-v. Or...
\$\endgroup\$
(f=_=>!!`(f=${f})()`.match(prompt()))()
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))))")
print(bool(__import__('re').search(input(),open(__file__).read())))
Added after reading this comment.
int is shorter than bool.
\$\endgroup\$
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.
"+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.
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.
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.
StringMatchQ[ToString[#0, InputForm], RegularExpression[#1]] &
Note the trailing space. Uses the standard Mma quine mechanism, and tests if it matches the regex.
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)
x.step is not a function.
\$\endgroup\$
math.
\$\endgroup\$
⟮‼(ⒸⅩ222+ᶈ0)đï
Using a version with bug fixes written after the challenge.
⟮‼(ⒸⅩ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.
Ⅹ to 10.
\$\endgroup\$
\dis not special in BRE; it matches the characterd. 3. Choosing a specific regex flavor restricts your challenge to languages that support it, and few languages support BRE. Is that intentional? \$\endgroup\$