text:
Hast Thou Slain the Jabberwock?
Your task is to output the exact string
The Jabberwocky

without taking input.  Normal rules for input and output apply, so both functions and programs are allowed.
Of course there is a catch, it wouldn't be fun without a catch.  Your program, when stripped of non-alphabetic characters, must start the poem The Jabberwocky (case insensitive).  To start the poem it must be a continuous substring of the poem starting at the beginning.  The empty string is fine (although you probably won't score very well).
Here is the text for reference:
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyesofflamecamewhifflingthroughthetulgeywoodandburbledasitcameonetwoonetwoandthroughandthroughthevorpalbladewentsnickersnackheleftitdeadandwithitsheadhewentgalumphingbackandhastthouslainthejabberwockcometomyarmsmybeamishboyofrabjousdaycalloohcallayhechortledinhisjoytwasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabe

Here is a program you can use to test this property.
If you run out of poem to use you may not use any additional alphabetic characters.
Alphabetic characters are characters a-z and A-Z here is the complete list:
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Scoring
Your program will be scored in the number of non-alphabetic bytes used with fewer being better.
Here is a Haskell program that scores answers. (This assumes inputs are valid)
Example program
The following program would be valid:
twas&*brilliga77812nd Thesli thyt Oves didgy reand Gim bleinth ewab eal lmims ywe""""""""
ret h eb or o g o ve sa n dthemomerAthsoutgrabebewaretheJABBERWOCKmysonthe)(*)()((*98980908(()*(jawsthatbit

When stripped down to alphabetic characters it is:
twasbrilligandTheslithytOvesdidgyreandGimbleinthewabeallmimsyweretheb orogovesandthemomerAthsoutgrabebewaretheJABBERWOCKmysonthejawsthatbit

Which matches the first bit of the poem (case insensitive).
This program would score 59 because it contains these non-alphabetic characters:
&*77812           """"""""
          )(*)()((*98980908(()*(

What do you mean by "Start the poem"?

I think he means when stripped of all non-alphabetic characters, all the characters must be a subset of the jabberwocky, starting at the beginning

This is trivial to do in languages without letters.

@Pavel Sorry, I lost internet for a moment.  The program included specifies exactly what I mean.  tbfninja's interpretation is also exactly correct.

I get a score of 59 for your example program, including 22 bytes of whitespace (which are certainly not alphabetic).

@Nitrodon Yes, I made a mistake there.  Thanks.

In this case I strongly suggest that you add a score to the output of your validating Haskell snippet.

@WeijunZhou I've gone ahead and added it.

You can edit it into the question. Personally I prefer a single script rather than two.

The pedant in me feels obligated to remind you that the name of the poem is Jabberwocky (with no article), while the name of the beast is the Jabberwock (with no -y). Of course you can't change the required output now, but...

Thanks, @DLosc, I was about to mention the exact same thing.

Why so many votes to close as unclear? The "Here is a program you can use to test this property." part completely and unambiguously determines the valid criteria.

@user202729 I did not vtc as I don't think it is unclear, but it's worth noting that code in some language is only good to specify a problem for those who understand that language so cannot make a question here clear.

@JonathanAllan Their being unable to understand the question doesn't necessary mean that the question is unclear...

@user202729 well that's just unavoidable, but the language used here is English - if someone posts a question in Catalan I'm pretty sure it'll be closed as unclear even if it is perfectly written.

oOo CODE, score 0
Thanks to Dennis for golfing the Brainfuck code.
TwASbRIlLIgAnDthEsliTHyTOvEsdiDgyreaNdgImbleinthEwaBeaLlmimSywEreThEBoroGoveSAndTheMOmERaTHSoutGRabEbeWArEthEjaBbeRWockMYsONtHEJawsTHaTBiTEThecLawSthATcaTChBeWAReTHeJuBJuBBiRDAndsHUNtHeFRuMIoUSbANdERSnatchheTooKHisvORpaLswORdinhAndLonGtiMetHEmanXomEFoEHeSOUg

Try it online!
I've got bad news for this challenge... :(
oOo CODE is just a binary encoding of brainfuck which uses the case of a letter for each bit. So yeah, since the poem is long enough (or the output short enough) to cover a Brainfuck program that prints The Jabberwocky (without actually trying hard to golf it), this becomes a trivial optimal answer.

Golfed.

@JoKing Try it online! (generated with BF-Crunch)

"bad news" ... yes, that's bad. I predicted Unary will get 0 bytes, the rule changed, and there are still score 0 submissions.

I don't think it's bad news at all. This has zero implications on how fun it is to golf in other languages.

C, score  104   79  74
Thanks to @gastropner for lowering the score to 79 and thanks to @wizzwizz4 for lowering it further to 74!
*t,w;a(s,b,rilligand){*(t//he
=s++)="lithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewareThe Jabberwock\0mysonthejawsthat"[b++]?//i
:121;*t>12e1?*++t//hecl
=0:a//wsthatcatchbewarethejubjubbirdandshunthefrumiou
(s,b);}an;der(s,n){a(//tchhetookhi
s,88);}

Try it online!

Score 79

Wouldn't //abcdefgh\n be 1 fewer characters than /*abcdefgh*/?

@wizzwizz4 Yes, it would. Thanks!

Fission 2, score 3
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewaRe"The Jabberwock"mysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyesofflamecamewhifflingthroughthetulgeywoodandburbledasitcameonetwoonetwoandthroughandthroughthevorpalbladewentsnickersnackheleftitdeadandwithitsheadhewentgalumphingbackandhastthouslainthejabberwockcometomyarmsmybeamishboyO

Try it online!
Explanation
We can ignore most of the lowercase letters, they just set an atom's energy to their code point.
...Re"The Jabberwock"my...oyO

The uppercase R is the program's entry point, as it creates an atom going right. As I said, we can ignore the e. Then " toggles string mode, which just prints all characters it encounters to STDOUT, which gives us The Jabberwock. That only leaves the y. We could use the y that's coming up immediately in y, but then we'd have to waste at least one non-letter byte on printing it (!) and possibly another on terminating the program.
Instead, we patiently wait for y to show up immediately before o in the poem. Because that lets us use O which prints the character and destroys the atom, terminating the program. This way, the only non-letter characters we need are the space and the two quotes.

Very very impressive.

Alice, score 7
"T/was"bri@lligandtheslithytovesdidgyreandgimbleinthewabeallmimsywe
rethe borogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyesofflamecamewhifflingthroughthetulgeywoodandburbledasitcameonetwoonetwoandthroughandthroughthevorpalbl
adewentsn

Try it online!
The / makes the IP move diagonally and bounce off the edges, so the instructions actually executed are "The "ono@.  The n command (in ordinal mode) pushes the string "Jabberwocky" if the top of the stack is empty, and o outputs the top of the stack.

Very nice answer!

Right tool for the job.

Nice, I tried several things but didn't find any layout that scored nearly as well as this.

Jelly, score  6  4
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathSOUTGRABEBEWARE“The Jabberwock”m”y

A full program printing the result
(as a monadic link it prints The Jabberwock as a side-effect and returns the character y)
Inserts the characters “ ”” into a case-changed prefix of the poem.
This works because:

The last h before SOUTGRABEBEWARE“The Jabberwock”m”y is (at least at the time of writing!) an undefined atom, which makes that all become a new link which takes the default input of 0 and performs some monadic functions, SOUTGRABEBEWARE, which yield 1 (see below).
1“The Jabberwock”m then performs m, modulo slicing, on "The Jabberwock" with a slice size of 1, yielding "The Jabberwock".
The trailing ”y is a new leading constant chain so Jelly prints that list of characters and then yields the character y, and since it's now the end of the program this then gets printed.

 implicit input = 0
S sum             0
O cast to ordinal 0
U upend           [0]
T truthy indices  []
G group           []
R range           []
A absolute value  []
B to-binary       []
E all-equal?      1
B to-binary       [1]
E all-equal?      1
W wrap            [1]
A absolute value  [1]
R range           [[1]]
E all-equal?      1

Previous 6 byter:
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
“The Jabberwock”m1“y

Try it online!
The six non-poem characters are a newline plus “ ”1“.

Alternative 6s:
“T“wasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewaret“he Jabberwock”m2“y

twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewaret
“The Jabberwockmy”ṪṭṖ

Is the first program not valid without  m1“y? It still prints The Jabberwock and begins with a subset of the poem

No, the m1“y (or it could be m1”y) is needed because we must print The Jabberwocky, not The Jabberwock.

Charcoal, score 3
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware⎚The Jabberwock⌈my

Try it online!
Inserted the three characters: ⎚ ⌈
...it also works with the whole poem.
How?
twas ... ware⎚The Jabberwock⌈my - no input
twas ... ware                    - print this text     >  twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
             ⎚                  - clear the screen    >
               The Jabberwock    - print this text     > The Jabberwock
                             ⌈   - (print) maximum of:
                              my -   this text         > The Jabberwocky

Ruby (-p), Score 12
$_=#twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
'The Jabberwock'+#m
?y

Try it online!
Abuse all the comments!
With the -p flag, ruby will print whatever stored in $_. Requires a single line of any input.

I don't think you can use -p here, because of the required line of input. "Your task is to output the exact string The Jabberwocky without taking input."

@benj2240 -p is a command line flag, not an input.

@benj2240 Taking unused empty input when no input is required is allowed, by meta concencus. This takes an empty line.

@Pavel I see, thank you

Charcoal, score: 5 4
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware⎚The Jabberwock¿m¦y

Try it online! Edit: Saved 1 byte thanks to @ASCII-only. Explanation: Translates to the following verbose code:
Print("twas...beware");
Clear();
Print("The Jabberwock");
if ("m") Print("y");

whole poem :P

@JonathanAllan Fixed!

Foo, score 5
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware"The Jabberwock"m"y"

Try it online!

><>, Score: 13 12
\twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
\"The Jabberwockmy"$~\sonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyeso
fflamecamewhifflingth>ro<

Try it online!
Verification and scoring.
Immediately redirects to the second line, which pushes "The Jabberwockmy" in reverse to the stack. $~ pops the excess m and >ro< prints the whole stack, reversing it beforehand.

PowerShell, Score: 19 10
#twasbrilligandTheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethe
'The Jabberwock'+#m
'y'

Try it online!
Port of Pavel's Ruby answer. Thanks to Jo King for -9 points.
The strings are + concatenated together. Once the comments are removed and the code parsed, PowerShell sees this as 'The Jabberwock'+'y'. That string is left on the pipeline and output is implicit.

I was just about to post this exact answer :P

Can’t you combine The and Jabberwock into one string? Try it online!

@JoKing Indeed, thanks. Funny how you're getting by without the line continuation character. I wonder when that parsing rule changed...

Retina 0.8.2, score: 21 20 18 16 13 8 6
|twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
The Jabberwock0$*my

Try it online! Edit: Score reduced by 2 thanks to @MartinEnder.

You can score 6 like this: https://tio.run/##JYwxDgIxDAR7XkFBRcU7qPmATVaJhZ1IjiGKxN9D0LUzO@sIqbTWNwZ1dlGVTDVFQVeJMqN90JOkPB2bZzFWSN1@EINUTazPAcdG3Lzlf3A8WDM4RentHdn3nHfkOD0Kzndiho/2fN0uV5tr/QA and then 5 by switching to Retina 1.0 (and using * instead of $*).

C, score 23
twasbrilligandtheslithytovesdidgyreandgimble(int**h){//ewabeallmimsyweretheborogovesandthemomerat
*h//soutgrabebeware
="The Jabberwock"//m
"y";}

Try it online!

05AB1E, score 14
"twasbrilligand""The ""slithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethe"Š"Jabberwock"+"my"Š

Try it online!

Yabasic, 13
Thanks for @Pavel's Ruby answer!
#twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
?"The Jabberwock";//m
?"y"

Try it online!

I count a score of 20, I think you forgot to count newlines.

Yes, there are problems with scores of other answers as well.

Just a note: Yabasic is available for use at Try It Online, you should consider adding a link to your solution at TIO such as this one

@TaylorScott How can I fail to notice that! Fixed.

I think you have an extra "the" at the end of the first line.

@12Me21 Yes. Pasted the wrong version. Thank you for correcting me.

Java (OpenJDK 9), score 11
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware->"The Jabberwock"+//m
"y"

Try it online!
Credits

-2 score thanks to Kevin Cruijssen
-3 score thanks to Wheat Wizard

-2 score by changing () to t (unused Void null parameter), and removing the leading t from the comment.

@KevinCruijssen Thank you for the insights. :-) However, regarding the <s>16</s> 14 I prefer, as always on any StackExchange network to provide a final answer. The changes themselves are listed in the revision page, making it easy for everybody to see the actual changes, and how the answer evolved over time, rather than putting all past and current information in one big unreadable post.

Ah ok, fine by me. :) The edit was mainly meant to fix 'bytes' to 'score'.

@KevinCruijssen Indeed, I saw your change in the credits and they were welcome. In my previous comment, I only meant the title. I even created a meta-post on that topic. ;-)

Now that you have removed the comment on the first line you don't need the line break any longer.

VBA, score 5
Run in the Immediate Window:
?twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware"The Jabberwock"m"y

How it works:

? - This prints out output as a string

-

twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware - without Explicit declaration, this is treated as an empty string

-

"The Jabberwock" - String.  When you put 2 variables/strings next to each other, VBA will automatically concatenate them.  (2 non-variable strings would require a space so as not to add a double-quote)

-

m - Another implicit empty-string, automatically concatenated

-

"y - Another string.  Left open, the Immediate Window will automatically close this when it hits the end of the line - again, automatically concatenated

-
1 question-mark, 1 space and 3 double-quotes.  VBA sees this as ?"" & "The Jabberwock" & "" & "y" or ?"The Jabberwocky"

Haskell, score 12
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware="The Jabberwock"++{-m-}"y"

Try it online!
Defines a zero-argument function twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware :: String whose output is "The Jabberwocky".

Jelly, score: 8
“ĠȥṘ®ṖȤ»

Try it online!
Just compresses the string, and is an empty string when all non-alphabet characters are removed. Annoyingly, the shortest compressed form, “81Iȯd» has  alphabetical characters, neither of which are t or w

Stax, 11
£«≡¿«_→Ä:£◘

Run and debug online!
Just a compressed string literal that is in turn packed.

SOGL V0.12, score 9
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware”The” Jabberwock”:⁄m+ y+

Try it Here!

Canvas, score 5
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware∙The Jabberwockｐm∙yｐ

Try it here!

Pip, score 5
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestOOD|"The Jabberwock"witheyesofflamecamewhifflingthroughthetulge'y

Try it online!
Fortunately, lowercase letters in Pip are all variables, which are no-ops in expressions by themselves. The interesting part of the code:
OOD|"The Jabberwock"

The scanner breaks up OOD as O followed by OD. OD is an undefined variable, which evaluates as nil (falsey); we then logical-or this with "The Jabberwock", and O outputs it without a newline.
'y

Single-character string y. Since it is the last expression in the program, it is printed.

SmileBASIC, score 10
@twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware?"The Jabberwock";
@m?"y

This was pretty much taken directly from the Yabasic answer, and since SB is a better language, we can shorten it by using labels rather than comments, which eliminates the need for some of the line breaks
There is also this alternative solution, for the same size:
@twasbrillig ... ?"The Jabberwock"+@my[2]

A label inside an expression is treated as a string. (@my == "@my"), so taking character 2 gives "y".

C (gcc), score 58
The useful fact that // style comments + newlines are cheaper than old-style ones comes straight from @wizzwizz4's comment for @Steadybox's answer.
The -m32 flag is required.
Some might be brought to a frumious mood by the lengthy name of the function to call, whereas others might rightly find such objections mimsy; in the end, we must all of us heed the siren song of low scores.
twasbrilligan;d(t,h,e,slithytovesdidgyreandgimble)int*h,*e;//wabeallmimsywere
{t--?*h++=*e++,//borogovesan
d(t,h,e):0;}momerathsoutgrabebewar;*e="The Jabberwock\171";mysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoug(h,tsoreste){d(4,h,e);}

Try it online!

Perl 5, subroutine, score 11
{twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware;'The Jabberwock'.~'X'}

but with the character \x86 (v134) instead of the X.
(perlsub says "The signature is part of a subroutine's body. Normally the body of a subroutine is simply a braced block of code.")

Does this print the y?

@JoKing oops! Now it does; thanks.

Batch, score 15 11
:twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbiteth
@ec%lawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffisht%ho%ughthestood% The Jabberwock%withe%y

Basically just echo The Jabberwocky with unused variables and labels.
Old version (score 24):
:twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyesofflamecamewh
@if %1%fl%i==%ngthroughthetulgeywoodandburbledasitcameonetwoonetwoandthroughandthroughthevorpalbladewentsnickersnackheleftitdeadandwithitsheadhewentgalumphingbackandhastthousla%i n The Jabberwock%cometom%y
:armsmybeamishboyofrabjousdaycalloohcallayh
@echo %*

Requires code to be saved in a file named n.bat and run from the same directory.
Alternate version which can have any name (score 27):
:twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyesofflamecamewh
@if %1%fl%i==%ngthroughthetulgeywoodandburbledasitcameonetwoonetwoandthroughandthroughthevorpalbladewentsnickersnackheleftitdeadandwithitsheadhewentgalumphingbackandhastthousla%i %~n0 The Jabberwock%cometom%y
:armsmybeamishboyofrabjousdaycalloohcallayh
@echo %*

Explanation (with variables removed):
:twas...                         Label (No labels were used, no goto in the poem)
@if %1i==i %~n0 The Jabberwocky  If no command line arguments, run this batch file again
:arms...                          with the arguments 'The Jabberwocky'
@echo %*                         Echo all arguments

Ruby, 9 non letter bytes
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvor=p alswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestood="The Jabberwock"+withe=?y

Try it online!
Golfed version (for readability):
x=p z="The Jabberwock"+w=?y

Uses a few long and useless variables. In ruby, you can put whatever_you_want= before an expression, and it will still return that expression, just with the side effect of creating an oddly-named variable.

Self-modifying Brainfuck, score 16
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware␀The Jabberwock␀my<[<<]>[.>]>>.

Try it online!
Explanation
Initially the tape is set up like this:
$$
\begin{aligned}
  \dots\  \texttt{␀}\  \texttt{T}\  \texttt{h}\  \texttt{e}\  \texttt{␠}\  \texttt{J}\  \texttt{a}\  \texttt{b}\  \texttt{b}\  \texttt{e}\  \texttt{r}\  \texttt{w}\  \texttt{o}\  \texttt{c}\  \texttt{k}\  \texttt{␀}\  \texttt{m}\  \texttt{y}\  \texttt{<}\  \texttt{[}\  \texttt{<}\  \texttt{<}\  \texttt{]}\  \texttt{>}\  \texttt{[}\  \texttt{.}\  \texttt{>}\  \texttt{]}\  \texttt{>}\  \texttt{>}\  \texttt{.}\ & \texttt{␀}\  \texttt{␀}\  \dots \\
    & \uparrow
\end{aligned}
$$
Since we want to move to the beginning of the string we use <[<<] such that we jump over the first \$\texttt{␀}\$ character.
Now we can just move to the \$\texttt{T}\$ with > and print the whole string with [.>] and since we picked the substring where the next \$\texttt{y}\$ is not far, we can just jump to it directely and print it with >>..

BF, 143 bytes (score 143)
-[--->+<]>-.[---->+++++<]>-.---.--[--->+<]>-.+++++[->++<]>.--[--->++++<]>+.+..+++.+++++++++++++.+++++.--------.------------.++++++++.[--->+<]>.

Try it online!
No letters means no poem.
Alternate (BF, 861 bytes, score 143)
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewarethejabberwockmysonthejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvorpalswordinhandlongtimethemanxomefoehesoughtsorestedhebythetumtumtreeandstoodawhileinthoughtandasinuffishthoughthestoodthejabberwockwitheyesofflamecamewhifflingthroughthetulgeywoodandburbledasitcameonetwoonetwoandthroughandthroughthevorpalbladewentsnickersnackheleftitdeadandwithitsheadhewentgalumphingbackandhastthouslainthejabberwockcometomyarmsmybeamishboyofrabjousdaycalloohcallayhechortledinhisjoytwasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabe-[--->+<]>-.[---->+++++<]>-.---.--[--->+<]>-.+++++[->++<]>.--[--->++++<]>+.+..+++.+++++++++++++.+++++.--------.------------.++++++++.[--->+<]>.

Now with 100% more poem

@cairdcoinheringaahing I don't think the rules are clear enough in order to determine if this is valid or not.

@cairdcoinheringaahing it passes the test program (would you prefer I cut and paste the poem before the code? its just a no-op)

I've also downvoted this answer.  It is valid, as you pointed out but it chooses a language for which the challenge is as uninteresting as possible.  (also your second submission has the same score as the first one)

It's also an extremely lazy answer, as you've just pasted the required text into a brainfuck text generator

@WheatWizard Did you also downvote the 1k answers that are just a comment with the poem, a non-alphanumeric print function, "The Jabberwock" a comment with "m", and then printing "y"?

@NoOneIsHere I'm a little confused by the syntax of your question. I'm not sure what a 1k answer is, but I have downvoted a number of answers here.

@WheatWizard 1k means 1,000 (the number, not rep)

Please include score ty

Fission, score 6
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewaRe"The Jabberwock"m"y";

Try it online!

C# (Mono C# Shell), Score 12
//twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
"The Jabberwock"//m
+"y"

Try it online!
Mono comes with a program called, well, csharp, that lets you run C# programs as a script. It's essentially a wrapper for the REPL, and supports implicit printing.

APL (Dyalog), score 21 14
1⌽1↓¯2⌽106↓'twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebewareThe Jabberwockmy'

Try it online!

JavaScript (SpiderMonkey), score 12
twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware=>
"The Jabberwock"+//m
"y"

Try it online!
Credits
Shamelessly ripped from this answer for Java.
-2 points from Brian H.

get rid of the first comment and put it in the input variable name to save some chars. twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware=>"The Jabberwock"+//m "y". This saves two / and a newline.

APL (Dyalog Unicode), score 10
'twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware'⊢'The Jabberwock',⊢/'my'

Try it online!
'my' the character vector "my"
⊢/ rightmost element; "y"
'The Jabberwock', prepend the main part; "The Jabberwocky"
'twa…are'⊢ yield that and discard the beginning of the poem

dc, score 14 12
#twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
[The Jabberwock]#myso
n121#thejawsthatbitetheclawsthatcatchbewarethejubjubbirdandshunthefrumiousbandersnatchhetookhisvor
P

Try it online!
Rather uninteresting solution, but I'm not sure it can be optimized much more beyond uninteresting. Just comments everything out until the first part of the string, comments out until we hit an n to print, then inputs 121 as the ASCII value of 'y' and comments out until we hit a P to print.
-1 point thanks to Jo King (and no thanks to my inattention…)
-1 more point when I realized using the ASCII value for 'y' was ultimately shorter.

You don’t need the second half of the poem (and therefore one of the comments) if you’re not using it

@JoKing Thanks, in my mind there was a scoring penalty for missing bits of poem — not sure where that came from.

PHP, score 12
<?=#twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware
"The Jabberwock".#m
y;

Try it online!
It's interesting that in the poem, it says "he chortled" which contains the word echo (ignoring the white space). I tried to use this to my advantage instead of having the <?=, but always came out with a higher score that way.

Befunge-93, 33 17 score
^twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesan
<dthemomerathsoutgrabebeware>:#,_@#:"The Jabberwock"m#"y"

Try it online!
Golfed 16 score thanks to the suggestion by W W

16 if you delete the trailing bits of the poem

CJam, score 8
"twasbrilligandtheslithytovesdidgyreandgimbleinthewabeallmimsyweretheborogovesandthemomerathsoutgrabebeware";"The Jabberwock"'m;'y

'tis a shame this was so simple, I was enjoying using the c to convert numbers to characters and then rearrange them at great expense.
Try it online
Verify online
Explanation:
"tw...re";          Discard the first part of the poem
"The Jabberwock"    Push a jabberwock
'm;                 Discard a spare m
'y                  Take the last y


text:
Creating a function over multiple lines
I'm attempting to create a function over multiple lines.
Parameters of the challenge:

Function returns 'barbarian'
Only 2 characters per line
40 lines maximum.
I keep trying to use a fat arrow to declare my function, but fat arrows don't seem to work if you don't have them connected.

Source of Challenge: https://www.codewars.com/kata/multi-line-task-plus-plus-hello-world
My current work:
f=
(
)=>

'\
b\
a\
r\
b\
a\
r\
i\
a\
n\
s\
'

This works, but the ')=>' is 3 characters long. I really just want to know how it is possible to even stretch out the creation of a function. I can't find any info on it anywhere as it's obviously not very practical.

Related?

Welcome to PPCG! Unfortunately, this challenge does not have an objective winning criterion, and I am voting to close this challenge until rectified. In the future, please use the sandbox to receive feedback on your question before it is posted.

Also Stack Overflow would be a better place for this, if worded differently

@tfbninja Thanks for the heads up. I think I just will have to restructure the question. StackOverflow sent me here in the first place.

I think this is fine as a question asking for tips to solve a particular code challenge and have voted to reopen.

I agree with Laikoni that this is definitely asking for advice on dealing with a code layout constraint (i.e., restricted source) rather than asking a programming question like at SO.

Here is a 38 line solution:
f=
[]
[
'\
m\
a\
p'
][
'\
c\
o\
n\
s\
t\
r\
u\
c\
t\
o\
r'
]`
r\
e\
t\
u\
r\
n\
'\
b\
a\
r\
b\
a\
r\
i\
a\
n\
'`

It creates a function using the Function constructor, which it accesses from [].map.constructor using subscript notation ([]['map']['constructor']). This is the method JSFuck uses to create functions.

Are you not accessing []['map']['constructor'] instead of []['sum']['constructor']?

Unless I'm reading this wrong, it returns 'barbarians' plural?

@cole The question's attempt -- contrary to the question's problem statement -- also seems to output the plural.

_< sorry typos

This is great! Is there any way to shave it down to even fewer lines? Just curious at this point as this is the first I have heard of constructors.

35 Lines
f=
0[
c=
'\
c\
o\
n\
s\
t\
r\
u\
c\
t\
o\
r'
][
c]
`
r\
e\
t\
u\
r\
n\
'\
b\
a\
r\
b\
a\
r\
i\
a\
n'
`

Try it online!
Uses the fact that 0 is a number, the constructor of 0 is Number, and the constructor of Number is Function.
32 Lines
0[
c=
'\
c\
o\
n\
s\
t\
r\
u\
c\
t\
o\
r'
][
c]
`
f=
_\
=>
'\
b\
a\
r\
b\
a\
r\
i\
a\
n'
`(
)

Try it online!
This essentially runs
Function(`
f=
_=>
'barbarian'`)()

which uses the IIFE structure. Added bonus is that we can line-break some parts in the function body to reduce the line count.
24 Lines
f=
''
[
'\
t\
r\
i\
m'
][
'\
b\
i\
n\
d'
]`
b\
a\
r\
b\
a\
r\
i\
a\
n`

Try it online!
Inline version:
f=''['trim']['bind']`
barbarian`

Since all we want is to return a string, we can get away with a string method bound to a string. By using trim, we can also safely leave a beginning newline.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Abstract Rewriting Challenge (Cops)
This is a somewhat proof-golf-like cops-and-robbers challenge. This is the cops' thread; the robbers' thread is here.
Cops
Your task is to define an abstract rewriting system in which the reachability of one word from another is difficult to determine. You will prepare the following things:

A set of symbols, called the alphabet. (You may use any Unicode characters for these, but please don't use whitespace, or symbols that are hard to distinguish from each other.)
A source string composed of symbols from your alphabet.
A target string composed of symbols from your alphabet.
A set of rewrite rules using characters from your alphabet. (See below for the definition of a rewrite rule.)
A proof showing whether your source string can be converted into your target string by successive application of your rewrite rules. This proof might consist of an actual sequence of rewrite steps, or a mathematical proof that such a sequence must exist, or a mathematical proof that such a sequence does not exist.

You will post the first four of these, keeping the proof secret; the robbers will try to crack your answer by providing their own proof that your target string can or can not be reached from your source string. If your submission is not cracked within two weeks, you may mark it as safe and edit in your proof.
Submissions will be scored according to the number of characters in their rewrite rules and their source and target strings, as detailed below. The winner will be the uncracked submission with the lowest score.
What is a rewrite rule?
A rewrite rule is simply a pair of strings in your alphabet. (Either of these strings may be empty.) An application of a rewrite rule consists of finding a substring that is equal to the first string in the pair, and replacing it with the second.
An example should make this clear:
Suppose alphabet is A, B and C; the source string is "A"; the target string is "C" and the rewrite rules are
A:B
B:BB
B:A
AA:C

then the target string is reachable in the following way:
A
B   (using rule 1)
BB  (using rule 2)
AB  (using rule 3)
AA  (using rule 3)
C   (using rule 4)

Scoring
Your score will be

the length of your source string,
plus the length of your target string,
plus the length of all the strings included in your rewrite rules,
plus one extra point for each rewrite rule.

If you write your rewrite rules with a colon separator as above, this is just the total length of all the rewrite rules (including the separator), plus the lengths of the source and target strings. A lower score is better. The number of distinct characters in your alphabet will be used to break ties, with fewer being better.
Bounty
I'd like to see answers that really go for low scores. I will award 200 rep to the first answer that scores less than 100 points in this challenge and doesn't get cracked.

Bah, not expressive enough for the MU puzzle.

@Neil technically they're as expressive as Turing machines - you could make a version of the MU puzzle, but you'd need a bunch of extra symbols and transition rules to implement the Mx -> Mxx rule, so it would end up much more complicated than Hofstadter's original.

326 points - Cracked by jimmy23013
The level is Picokosmos #13 by Aymeric du Peloux (with a trivial modification). I tried to find a tasteful level that could be implemented with "boxes" and "walls" being the same character. For this level it was possible by making the central choke point two columns wide rather than one.
The rules/initial/target strings could be golfed a bit more, but this is just for fun.
Initial string:
___##___####_____##_#_#_##_#_!####______##_#####__####_#_######__###__

Target string:
___##___####_____##_#_#_##_#_#####____!__#_#####__####_#_######__###__

Rules:
_wW:!
_<:<_
Vv_:!
V_:_V
R:>>>>>>>>>>>>>
V#:#V
#w<:w#
>v_:_v
_wX:#
_!:!_
!:wLW_
L:<<<<<<<<<<<<<
#W:W#
!#_:_!#
_w<:w_
#<:<#
!:_VRv
>v#:#v
Uv_:#
_W:W_
_X:X_
>#:#>
#X:X#
U_:_U
Vv#:!URv
#wW:wLX!
>_:_>
!_:_!
_#!:#!_
U#:#U

Cracked.

171 points, cracked by HyperNeutrino
Source: YAAAT
Target: VW626206555675126212043640270477001760465526277571600601
Rules:
T:AAAAAT
T:BBU
U:BU
U:ZW
AB:BCA
CB:BC
AZ:Z
CZ:ZC
YB:Y
YZ:V
V:VD
DCC:CD
DCW:W+
DW:W_
___:0
__+:1
_+_:2
_++:3
+__:4
+_+:5
++_:6
+++:7

Just something obvious to do. The actual sequence of rewrite steps probably won't fit in an SE answer.

I must have faltered somewhere because I can only get to VWx where x is formed from any binary string of _ (0) and + (1) which evaluate to 10*n+6 (including leading _; n = non-negative integer) yet the x given (626...601) is formed from binary which evaluates to 10*n+3 (for a large n).

Things like this are solvable by pure logic?

Cracked - thanks for the challenge!

@HyperNeutrino Drat, I was hoping your crack would've exposed where I'd stumbled.

33 points, cracked by user71546
A simple one to start off.
Source: xnor
Target: xor
Rewrite rules:
x:xn
no:oon
nr:r
ooooooooooo:

The last rule takes 11 o's to the empty string.

Cracked

Yay! I have taken a picture of that empty string!

139 points (safe-ish)
I intended this answer to be cracked, and user202729 basically solved it in the comments, but nobody posted an answer in the robbers' thread, so I'm marking it "safe-ish" and including my proof below.
(These things are evidently much easier to make than they are to crack. Nobody has tried to go for a really low score yet though, and there might be more fun to be had at that end of things, if this challenge ever takes off.)

Here's a self answer. It's potentially very hard, but should be easy if you work out where it came from.
alphabet: ABCDEⒶⒷⒸⒹⒺⒻ⬛⚪←→
source: ←A→
target: ←→
Rules: (whitespace is not significant)
← : ←⬛
→ : ⬛→
A⬛ : ⚪B
A⚪ : ⚪Ⓑ
⬛Ⓐ : E⚪
⚪Ⓐ : Ⓔ⚪
B⬛ : ⚪C
B⚪ : ⚪Ⓒ
Ⓑ⬛ :
Ⓑ⚪ : ⚪Ⓕ
⬛C : D⚪
⚪C : Ⓓ⚪
Ⓒ⬛ : ⬛B
Ⓒ⚪ : ⬛Ⓑ
D⬛ : ⚪E
D⚪ : ⚪Ⓔ
⬛Ⓓ : C⬛
⚪Ⓓ : Ⓒ⬛
⬛E : A⚪
⚪E : Ⓐ⚪
Ⓔ⬛ : ⬛D
Ⓔ⚪ : ⬛Ⓓ
Ⓕ⬛ : ⚪C
Ⓕ⚪ : ⚪Ⓒ
⬛ :
⚪ :
⬛ :
⚪ :

Here is an ASCII version, in case that unicode doesn't display well for everyone.

Proof
This is equivalent to the current best contender for a six state busy beaver. A busy beaver is a Turing machine that halts after a really long time. Because of this, the source string ←A→ can indeed be transformed into the target string ←→, but only after more than 7*10^36534 steps, which would take vastly longer than the age of the universe for any physical implementation.
The Turing machine's tape is represented by the symbols ⬛ (0) and ⚪ (1). The rules
← : ←⬛
→ : ⬛→

mean that the ends of the tape can always be extended with more zeros. If the head of the Turing machine ever gets near one end of the tape we can just apply one of these rules, which allows us to pretend that the tape is infinite, and starts out filled with all zeros. (The symbols → and ← are never created or destroyed, so they're always at the ends of the tape.)
The Turing machine's head is represented with the symbols ABCDEⒶⒷⒸⒹⒺⒻ and . A means the head is in state A and the symbol under the head is a ⬛ (0), whereas Ⓐ means it's in state A and the symbol under it is a ⚪ (1). This is continued for the other states, with the circled letter representing a 1 underneath the head and the uncircled version representing a 0. (There is no symbol F because it happens that the head never ends up in state F with a 1 underneath it.)
The state  is the halting state. It has the special rules
⬛ :
⚪ :
⬛ :
⚪ :

If the halting state is ever reached we can repeatedly apply these rules to "suck in" all of the tape (including any extra zeros that arose from extending the tape more than necessary), leaving us in the state ←→. Therefore the reachability problem boils down to whether the state  will ever be reached.
The remaining rules are the transition rules for the Turing machine. For example, the rules
A⬛ : ⚪B
A⚪ : ⚪Ⓑ

can be read as "if the machine is in state A and there is a zero under the head, then write a 1, change to state B and move right." Moving right takes two rules, because the tape cell to the right might contain a ⬛, in which case the machine should go into state B, or the cell might contain a ⚪, in which case it should go into state Ⓑ, since there is a ⚪ underneath it.
Similarly,
⬛Ⓓ : C⬛
⚪Ⓓ : Ⓒ⬛

means "if the machine is in state D and there is a 1 under the head, then write a 0, change to state C and move left."
The Turing machine used was discovered by Pavel Kropitz in 2010. Although it's often mentioned in the context of busy beavers, its actual transition table is a little tricky to track down, but it can be found for example here. It can be written as
    0   1

A   1RB 1LE
B   1RC 1RF
C   1LD 0RB
D   1RE 0LC
E   1LA 0RD
F   1RH 1RC

which can be read as "if the machine is in state A and there is a zero under the head, then write a 1, change to state B and move right," and so on. It should be straightforward, if laborious, to check that each entry of this table corresponds to a pair of rules as described above.
The only exception is the rule 1RH that occurs when the machine is in state F over a 0, because it seemed fairly pointless to make the machine write a 1 and move to the right when it could just halt immediately as soon as it ever enters state F over a 0. So I changed the rule that would have been
Ⓑ⬛ : ⚪F

into
Ⓑ⬛ :

This is why there is no symbol F in the alphabet. (There are some other 'golfs' I could have made, but I didn't want to obscure it too much.)
That's basically it. The target string is reachable from the source string, but only after a ridiculous number of steps.
One more fun fact: if I had used
←A⚪⚪→
as the starting point instead, then it would take not 7*10^36534 steps to halt, but 10^10^10^10^18705352 steps, which is a very big number indeed.

This looks like an implementation of a turing machine

I think this is the  "current 6-state, 2-symbol best contender" Turing Machine listed here. Now someone just need to prove they're equivalent.

Inefficient interpreter.

@user202729 Why not post as an answer?

287 points, safe
Source: YAAT
Target:
VW644507203420630255035757474755142053542246325217734264734527745236024300376212053464720055350477167345032015327021403167165534313137253235506613164473217702550435776242713

Rules:
T:AAAAAT
T:BBU
U:BU
U:ZW
AB:BCA
CB:BC
AZ:Z
CZ:ZC
YB:Y
YZ:V
V:VD
DCC:CD
DCW:W+
DW:W_
___:0
__+:1
_+_:2
_++:3
+__:4
+_+:5
++_:6
+++:7

I found that openssl is much easier to use than gpg for this purpose.

See HyperNeutrino's crack to the weaker version. In this case, The number of Cs is:
22030661124527021657244569669713986649562044939414344827127551659400215941242670121250289039666163853124410625741840610262419007778597078437731811349579211

And the prime factors are:
220040395270643587721928041668579651570457474080109642875632513424514300377757
100120985046540745657156603717368093083538096517411033964934953688222272684423

The first number mod 5 = 2, so it is possible to get the final string.

Factorization on TIO failed. Related, related.

Assuming this is random 512 bit semiprime, current PCs will take weeks to months to factor this

It's safe now .

48 points, cracked by bb94
Alphabet: abc
Source: cbaabaabc
Target: cbacbcabc
Rewrite rules:
ab:ba
bc:cb
ca:ac
ab:cc
bc:aa
ca:bb

Cracked

402 points
Alphabet: abcdefghijklmnopqrstu
Source: abcdoi
Target: ioabcdnnnnnnnnnnnnnnnnnn
Rewrite rules:
ab:ba
ba:ab
ac:ca
ca:ac
ad:da
da:ad
bc:cb
cb:bc
bd:db
db:bd
cd:dc
dc:cd
na:an
nb:bn
nc:cn
nd:dn
nm:mn
nj:jn
aoi:eag
boi:ebg
coi:ecg
doi:edg
ae:ha
be:hb
ce:hc
de:hd
ioa:kam
iob:kbm
ioc:kcm
iod:kdm
ma:aj
mb:bj
mc:cj
md:dj
dg:rdnnnnnnnnnn
cg:qcnnnnn
bg:pbnn
ag:fan
cr:fc
br:fb
ar:fa
bq:fb
aq:fa
ap:fa
er:io
eq:io
ep:io
ef:io
hf:io
kd:dunnnnnnnnnn
kc:ctnnnnn
kb:bsnn
ka:aln
uc:cl
ub:bl
ua:al
tb:bl
ta:al
sa:al
um:oi
tm:oi
sm:oi
lm:oi
lj:oi
:n
The last rule allows you to create as many ns as you need.
Ugly as it seems, it's actually quite nice, one way or another...

*In aoi:eog is eog supposed to be eag?

@Cowsquack yes, thanks for picking that up

1337 Points
Definitely not competitive, and took way too long to create (I hope I made no mistake).
Hint:

 try to understand the source string before looking at the rules

Alphabet: ABEILRSTabcdefijlr
Source:
SIbbbbbbbdbffacebbfadbdbeecddfaeebddcefaddbdbeeecddaaaaadfaeeebdddcefbbfadbdbdbeeecdddfaeeebdddcefaddbdbeeecddaaaadfaeeebdddcefbfadbdbdbeeecdddfaeeebdddcbdbffacebfadbdbeecddfaeebddceeefadddbdbeeeecddddfaeeeebddddceefaddbdbeeecdddfaeeebdddceefadadbefadfacdbeecddfaeebddcefaeeefaddbdbeeecdddfaeeebdddcceecdfaeeaddceecefaeadcbefadfacecdfaebdceeeeefadddddbdbeeeeeecddddddfaeeeeeebddddddceeefaddaeecdddbdbffacebfadbdbeecddfaeebddceeefadddbdbeeeecddddfaeeeebddddceefaddbdbeeecdddfaeeebdddceefadadbefadfacdbeecddfaeebddcefaeeefaddbdbeeecdddfaeeebdddcceecdfaeeaddceecefaeadcbefadfacecdfaebdcefaefaeeebdddcdcefaceeaaaceefacdffacebdceeeeefadddddbdbeeeeeecddddddfaeeeeeebddddddceeefaddaeecdddbdbffacebfadbdbeecddfaeebddceeefadddbdbeeeecddddfaeeeebddddceefaddbdbeeecdddfaeeebdddceefadadbefadfacdbeecddfaeebddcefaeeefaddbdbeeecdddfaeeebdddcceecdfaeeaddceecefaeadcbefadfacecdfaebdcefaefaeeebdddcdcefaceeaaaaceefacdffacebdcecefacE
Target: SE
Rewrite rules:

Ab:bA
bA:Ab
Aa:aA
aA:Aa
Ad:dA
dA:Ad
Ae:eA
eA:Ae
Af:fA
fA:Af
Ac:cA
cA:Ac
IA:AI
AI:IA
Bb:bB
bB:Bb
Ba:aB
aB:Ba
Bd:dB
eB:Be
Be:eB
dB:Bd
Bf:fB
fB:Bf
Bc:cB
cB:Bc
E:BE
S:SB
Ib:AbI
AIa:aI
IdB:dBI
BIe:eIB
AIf:AfI
BIfB:BfiLB
Lb:bL
La:aL
Le:eL
Ld:dL
Lf:fL
Lc:cL
ib:bi
ia:ai
ie:ei
id:di
if:fil
lb:bl
la:al
le:el
ld:dl
lf:fl
lc:cl
icl:ci
icL:cI
Ic:jRc
bj:jb
aj:ja
dj:jd
ej:je
br:rb
ar:ra
dr:rd
er:re
fr:rf
cr:rc
bR:Rb
aR:Ra
dR:Rd
eR:Re
fR:Rf
cR:Rc
cj:jrc
fjr:jf
fjR:If
I:T
TB:T
BT:T
bT:T
aT:T
dT:T
eT:T
fT:T
cT:T
T:

Note that I made some mistakes initially, so the score was changed. Nevertheless, the idea is the same. I hope there are no more mistakes now.

154 Points
Alphabet: P.!xABC[{mD<
Source: [x!P.P...P..P.P....P..P.P.....P.P....P......P.P..P...P.P...Pm (61 characters)
Target: {CCCCC< (there are 5 Cs, so 7 characters)
Rules:
P.  →  .PP
!.  →  !
x   →  AxB
x   →
AB  →  BAC
CB  →  BC
CA  →  AC
[B  →  [
[A  →  {
{A  →  {
!   →  !m
mP  →  PmD
Dm  →  mD
DP  →  PD
!P  →  ?
?P  →  ?
!m  →  <
<m  →  <
C<D →  <

There are 19 rules, total number of characters = 67.

106 points - cracked by HyperNeutrino
Alphabet: ABCDEFGHIJ
Source: FIABCJAGJDEHHID
Target: F
Rewrite Rules:
B:DCIE
A:IFBA
D:EEFJ
C:GFIC
E:HBJG
F:FEBG
G:HFCJ
H:DIGB
I:FCAH
J:BHEA

EJGI:FF
FFF:J
FF:E
EE:D
DDEA:FI
I:F

Okay, HyperNeutrino has proved that this is unsolvable. However, there is another solution to this.

Take:
I E C D H G J A F B
1 2 3 4 5 6 7 8 9 10

The value of the source is even. The value of the target is odd. If we take each side, total the value, and take the value to mod 2, the values stay the same. Therefore, this cannot be achieved.

cracked

You're welcome to edit in your intended solution, if you want to.

@Nathaniel , okay sure

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Abstract Rewriting Challenge (Robbers)
This is a somewhat proof-golf-like cops-and-robbers challenge. This is the robbers' thread; the cops' thread is here.
Robbers
The cops will post abstract rewriting systems. Your task is to crack their submissions by proving that the target string either can or can not be reached from the source string by applying their rewrite rules. (You can do this either by posting a sequence of rewrite rules that starts with the source string and ends with the target, or by proving mathematically that this does, or does not, exist.)
See the cops' thread for details and definitions.

Do'h! I put a bounty on the wrong question, this was meant to be on the cops' challenge. So somebody will get a random bounty.

No worries, I have refunded the bounty.

@DJMcMayhem: Huh... so that's why the SE API is listing this question as featured, but with no bounty amount or closing date. :o Oh well, time to add some input validation to my user script.

jimmy23013
Let's work backwards for this one. We first turn the digits into their binary representations. We go from VW626206555675126212043640270477001760465526277571600601 to VW++__+_++__+____++_+_++_++_+++_++++_+__+_+_++__+___+_+____+___++++_+______+_+++___+__++++++________++++++____+__++_+_++_+_+_++__+_+++++++_++++__+++_______++______+. Next, we keep applying the inverse of DCW:W+ and DW:W_ until we clear all symbols. Our result is now VDCDCDDDCDDCDCDDDCDDDDDCDCDDCDDCDCDDCDCDDCDCDCDDCDCDCDCDDCDDDCDDCDDCDCDDDCDDDDCDDCDDDDDCDDDDCDCDCDCDDCDDDDDDDCDDCDCDCDDDDCDDDCDCDCDCDCDCDDDDDDDDDCDCDCDCDCDCDDDDDCDDDCDCDDCDDCDCDDCDDCDDCDCDDDCDDCDCDCDCDCDCDCDDCDCDCDCDDDCDCDCDDDDDDDDCDCDDDDDDDCW. We now want to make this string match VD+C+W; that is, we want to move all of the Ds to the left of all of the Cs. This can be done by reversing DCC:CD. We do this by repeating the following algorithm:

Find the first D that is to the right of a block of Cs.
Move the D to the left of that block.
Double the number of Cs.

Through some math, we can determine that we will end up with 123 Ds and 4638704741628490670592103344196019722536654143873 Cs (you were right about this not fitting in an SE answer... I doubt this would fit if stored as states of all of the atoms in the Earth combined :P).
If we keep applying the reverse of V:VD, we can get rid of all of the Ds now, so we get VCCC.......CCCW. We convert the V back into YZ. Now we have YZCCC.......CCCW.
We want to be able to get rid of all of the Cs and have it in the form YAAA...AAABBB...BBBZW. Fortunately, this can be done by the following method. Firstly, we inverse-apply YB:Y 587912508217580921743211 times to get YBBB.......BBBZCCC.......CCCW. Then, we repeat the following sequence of steps (where [?*] means any number of ?, not necessarily greater than zero):

Inverse-apply CZ:ZC 587912508217580921743211 times to get Y[A*]BBB.......BBBCCC.......CCCZCCC.......CCCW
Inverse-apply CB:BC many times to get Y[A*]BCBCBC.......BCBCBCZCCC.......CCCW
Inverse-apply AZ:Z and AB:BCA many times to get Y[A*]ABBB.......BBBZCCC.......CCCW

Through induction, we see that we can move the BZ combination all the way to the end (except before the W) and then the number of As is 1/587912508217580921743211 of the number of Cs, leaving us with 7890127658096618386747843 As. We now have YAAA.......AAABBB.......BBBZW. Convert the ZW back to a U, then inverse-apply U:BU many times to keep only 2 Bs and then convert the BBU to a T, and you now have YAAA.......AAAT. Then, you can inverse-apply T:AAAAAT many times to get YAAAT because the number of As was 3 larger than a multiple of 5.
Thanks for the challenge!

Is it stated anywhere or is it by default that inverse apply is allowed?

@WeijunZhou I mean, if applying A:B to ABC gives BBC, it's obvious that applying the inverse of A:B to BBC can give ABC. It's not specifically stated that it's allowed, but I can easily just reverse my steps and have a "conventional" solution, it's just that it's easier to go backwards IMO.

I mean ,for example, if there is only one rule A:B and it is not stated that inverse apply is allowed then I don't think you can go from BBC to ABC. This specific case may be different and there are some way to go in the other direction. I will check it later.

@WeijunZhou he's not going from BBC to ABC, he's saying that if the current string is BBC then a possible previous string is ABC.

@WeijunZhou I'm not applying the inverse as a forward step, I'm entirely working backwards. If I reverse everything (all steps and make inverse-apply into a forward application) it will look more like a conventional solution.

@Nathaniel I see. Thank you for your clarification.

@HyperNeutrino ^^

Which program did you use to factorize this and how long did it take?

@user202729 wolfram alpha :D

feersum
This is a sokoban puzzle. The starting position is:
          ___#
#___####_____#
#_#_#_##_#_!##
##______##_###
##__####_#_###
###__###__

The ending position is:
          ___#
#___####_____#
#_#_#_##_#_###
##____!__#_###
##__####_#_###
###__###__

It can be solved using the following key sequence:

←←→↓↓←↑←←←←←←↓↓→↑←↑↑↑←←↓→↑→↓↓→→→→→→↓→↑↑↓↓←↓←↑→↑←←←←↑←←↓→→→→→↓→→↑↑→↑↑←↓←←↓↓→↑←↑→→↑→→↓←↓←←↓↓→↑←←←←←←←↑↑←←↓→→↓→↓↓←↑←↑→↑↑←←↓→↑→↓↓←↓→↑→→→→→→↓↓←↑→↑←←←←←←→→→→→→↑↑←↓→↓←↑↑→→↑→→↓←↓←→↑↑←↓←↓↑→→↓←↑←←↓↓↓→→↑↑↓↓←←↑↑→↓↑↑→↑→→↓←↓←↓←←↑↑→→↑→↓←↓↓←←←←←↑←←↓→→→→→←←←←←↑↑←←↓→→↓↓←↑→→→→

Here is a bash program that converts the key sequence to sed commands and applies them. The sed commands contains only replacing commands using the rewrite rules defined in the cop's answer, and labelling and branching commands that doesn't modify the string. It confirms that you can get the target string using only the rewrite rules.
s="___##___####_____##_#_#_##_#_!####______##_#####__####_#_######__###__"
input=

while
    printf '\n%80s\n' "$s"|fold -w14
    read -n 1
    [ "$REPLY" = $'\e' ]
do
    read -n 2
    case "$REPLY" in
    [A)
        s="$(sed '
s:!:wLW_:
        :a
s:L:<<<<<<<<<<<<<:
s:#w<:w#:
s:_w<:w_:
s:_<:<_:
s:#<:<#:
s:#wW:wLX!:
s:_W:W_:
s:#W:W#:
s:_wW:!:
s:_X:X_:
s:#X:X#:
s:_wX:#:
        ta' <<<"$s")";;
    [B)
        s="$(sed '
s:!:_VRv:
        :a
s:R:>>>>>>>>>>>>>:
s:>v#:#v:
s:>v_:_v:
s:>_:_>:
s:>#:#>:
s:Vv#:!URv:
s:U_:_U:
s:U#:#U:
s:Uv_:#:
s:V_:_V:
s:V#:#V:
s:Vv_:!:
        ta' <<<"$s")";;
    [C)
        s="$(sed '
s:!#_:_!#:
        te
s:!_:_!:
        :e' <<<"$s")";;
    [D)
        s="$(sed '
s:_#!:#!_:
        te
s:_!:!_:
        :e' <<<"$s")";;
    esac
    input="$input${REPLY:1}"
done

echo "$input"

Try it online!
Try it online (with escape code removed)!
For up and down, !:wLW_ or !:_VRv is applied for once correspondingly, and the relevant rules are applied repeatedly until the ! appeared again. For right, one of !#_:_!# and !_:_! is applied. For left, one of _#!:#!_ and _!:!_ is applied.
See the output in the links for the position after each move.

boboquack
For a given string, take all the letters (a = 0, b = 1, c = 2), sum them up and take the modulo 3. Then none of the rewrite rules change that value. The source string has a value of 1, and the target has a value of 2. Therefore, no combination of rules will transform the source string to the target string.

xnor

Rule 1 x:xn
Rule 2 no:oon
Rule 3 nr:r
Rule 4 ooooooooooo:

We use [X,Y] to indicate a run of Y Xs

Starting from xn[o,A]r,

Applying Rule 2 once we have x[o,2]n[o,A-1]r.
Applying Rule 2 once more we have x[o,4]n[o,A-2]r
Applying until the os between n and r becomes 0, we have x[o,2*A]nr.
Applying Rule 3 once we have x[o,2*A]r.
Applying Rule 1 once we have xn[o,2*A]r.

So, we have an algorithm to generate from xn[o,A]r to xn[o,2*A]r.

Starting from xnor = xn[o,1]r, repeating 10 times the algorithm -- except in the 10th loop we stop at Step 4, having x[o,1024]r.
Applying Rule 4, this clears 1023 = 11 * 93 os, leaving xor.

VortexYT
There is no way of eliminating Fs without creating/using other characters; thus, we must use I:F as the last step to get to the target. No rule gives a single I without other unwanted characters thus you can't get to the target string.
Equivalently, if you try to map backwards from the source, you can only get from F to I before you have no more options.

Ooch, that hurts. There is another solution though...

@VortexYT oh really, there is? hm, did not know. but yeah the target can't map back more than one step which probably made this a ton easier than you intended :P

2x easier to be exact

The Empty String Photographer
The target string cannot be reached because there is no right-to-left override in the rules. That's even easier than the effort I put into formatting the original answer. Very unfunny. :p

@TheEmptyStringPhotographer how is it wrong?

still not seeing it

@TheEmptyStringPhotographer > please don't use whitespace, or symbols that are hard to distinguish from each other

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
The greedy cutter
iBug recently got a long bar made of composite, yet valuable materials. The bar is so long that iBug can't easily sell it for credits, so he wants to cut it. The bar is made of such fragile and magic materials that, if a part is broken, all parts of the bar made of the same material will break, too, making it hard to cut arbitrarily.
iBug wants to cut the bar into as many pieces as possible. He also loves very short programs and code-golfing, so he made an abstract analysis of his problem.
iBug's magic bar is represented as a string (or an array or a sequence of characters if you prefer), like this:
aaabbccccccbbbaaacccccaabbbaaaaa

Each letter in the string represents one magic material. The bar always matches the RegEx ^\w*$, so there may be up to 63 materials in the bar. A "part" is a consecutive sequence of any characters that are not separated by spaces.
iBug wants you to write a program that calculates the maximum parts that he could get, if zero or more character sets are fully removed (replaced by spaces), and tell iBug that number.

Example 1:
In:  aaabbccccccbbbaaacccccaabbbaaaaa
Out: 4

Description: If b is fully removed from the bar, iBug could get 4 parts. He can also get 4 parts by removing b and c, as is shown below
aaabbccccccbbbaaacccccaabbbaaaaa  # Original string
aaa  cccccc   aaacccccaa   aaaaa  # Remove 'b'
aaa           aaa     aa   aaaaa  # Remove 'b' and 'c'

And that's the maximum number of parts iBug can get from this bar
Example 2:
In:     111aa___9999____aaa99111__11_a_aa999
Result: 111aa   9999    aaa99111  11 a aa999
Out:    6

Description: By removing only the underscore, iBug can get 6 parts from the bar and that's the maximum.
Example 3:
In:  __________
Out: 1

Description: What? You wanna cut this? It's only possible to get 1 part if you don't cut it at all.
Example 4:
In:
Out: 0

Description: There's nothing to cut, so zero.

There's also some rules that iBug want the programs to obey:

iBug dislikes standard loopholes and they are forbidden.
As long as it works, it need not be a full program. A function that takes input from a parameter and gives output via return value is also accepted.
Flexible input and output are allowed. Your program or function can take a string, or an array of characters, or whatever you find easiest to deal with. You can give the output by printing the number or returning it.

Sample test cases (but not limited to these)
aaabbbaaa           = 2
123456789           = 5
AaAaAaAa            = 4
aaabcccdedaaabefda  = 6
________            = 1
(empty)             = 0

Since this is a code-golf, the shortest program (in bytes) in each language wins!

Extra
iBug highly appreciates if you can provide an explanation for your program, even though it does not affect your scoring (it's still length in bytes).

How does 123456789 yield 5? And how does aaabcccdedaaabefda yield 6? I get 2 and 4 respectively for these two test cases.

@Mr.Xcoder for the first one, remove 2468, for the second, remove bd.

@MartinEnder Oh so any subsequence can be removed? if any of the characters are fully removed suggested otherwise.

@Mr.Xcoder, if I've understood the challenge correctly, you remove 2,4,6,8 from the first and b,d,f from the second.

@Mr.Xcoder it means removing all copies of any set of characters. I think the worked example shows it quite well.

Nice challenge. But may I suggest dropping the restriction that full programs must exit without errors next time. In general programs that crash or write to STDERR or return values through the exit code are accepted on this site.

@TonHospel Great, suggestion accepted. Thanks.

Do we need to handle the empty string? I have a submission that doesn't due to a quirk of the way the language splits strings, and adding a special case would be a bit annoying.

@MagicOctopusurn According to this page, \w is equivalent to [A-Za-z0-9_]

Haskell, 73 71 70 bytes
x#z|z==x=' '|1<2=z
f x=maximum$length(words x):[f$(c#)<$>x|c<-x,c>' ']

Thanks to Laikoni for saving 1 byte!
Try it online!

maximum$(length$words x): can be shortened to maximum$length(words x):.

JavaScript (ES6), 109 90 bytes

f=s=>Math.max((s.match(/\s+/g)||[]).length,...[...s].map(c=>c>` `&&f(s.split(c).join` `)))
<input oninput=o.textContent=/\s/.test(this.value)?``:f(this.value)>
0

Somewhat slow on the 123456789 test case. Previous 109-byte answer wasn't limited to !/\s/:

f=
s=>(g=a=>Math.max(a.filter(s=>s).length,...[...a.join``].map(c=>g([].concat(...a.map(s=>s.split(c)))))))([s])
<input oninput=o.textContent=f(this.value)>
0

shorter (103 bytes) and faster (port of my ruby answer :)

@AsoneTuhid Oh, I didn't see the restriction on the character set; my code works for any string at all.

The only character it doesn't have to work for is space isn't it?

@AsoneTuhid Your port only works for exactly those characters that it needs to work for; your original seems to work for anything except spaces.

What characters does your original answer work for that the new one doesn't?

@AsoneTuhid Like your port, my new one only works for the characters that it needs to work for.

What does that mean? What characters did it work for before that it didn't have to?

@AsoneTuhid The old version works for any characters, including spaces and symbols.

I see, I don't know about your new version but I'm pretty sure my port works for everything except spaces. In any case, nice golfing, have a +1.

@AsoneTuhid No, you use \w, which limits you to the required input.

You're right, for some reason I thought \w matched everything. You could sacrifice 2 bytes by replacing \w with [^ ] so it would work for everything except spaces.

I assume javascript also has \S

@TonHospel Thanks, that covers most characters.

Actually it still doesn't work for unprintable ASCII below 31 but it's not as if you can easily input it in the snippet.

Python 2, 111 93 72 bytes
-21 bytes thanks Kirill L.
f=lambda s:max([len(s.split())]+[f(s.replace(c,' '))for c in s if'/'<c])

Try it online!

It looks like the approach currently used by JS and Ruby works quite well for Python too: 73 bytes

@KirillL. thanks for the recommendation

Ruby, 98 89 75 64 61 bytes
f=->s{[s.split.size,*s.scan(/\w/).map{|c|f[s.tr c,' ']}].max}

Try it online!
smaller and slower than before!
Basically a port of @Neil's Javascript answer
Ungolfed and annotated
def f(input_string)
    # splits by / +/ by default
    size0 = input_string.split.size
    # an array of all non-space characters in input_string
    characters = input_string.scan(/\w/)
    size1 = characters.map {|i|
        # all letters and digits and _ are "bigger" than /, space isn't
        if i > '/'
            # tr replaces every occurrence of i in input_string with space
            next_string = input_string.tr(i, ' ')
            f(next_string) # recursive call
        else
            0
        end
    }
    # max value between size0 and any element in size1
    return [size0, *size1].max
end

Try it online!

Jelly,  13  11 bytes
Too many 2-byte instructions
-2 thanks to Zgarb (use the outer product quick þ >.<)
eþŒPŒr¬S€ṀḢ

A monadic link accepting a list of characters and returning a non-negative integer.
Try it online!
How?
For each subsequence of the input (the sets we may remove, plus redundant equivalents) gets an existence list to identify which are removed then effectively finds how many runs of zeros remain and yields the maximum. The last part works in a slightly odd way since I found it golfier than more naive alternatives - it finds the runs as [element, count] pairs, negates to identify zeros as ones, sums finds the maximum then takes the head (the sum of elements rather than of counts).
eþŒPŒr¬S€ṀḢ - Link: list of characters        e.g. "aabcde"
  ŒP        - power-set - gets all subsequences    ["","a","a","b",...,"bd",...,"aabcde"]
 þ          - outer-product with:
e           -   exists in?                         [[0,0,0,0,0,0],[1,1,0,0,0,0],[1,1,0,0,0,0],[0,0,1,0,0,0],..,[0,0,1,0,1,0]...,[1,1,1,1,1,1]]
    Œr      - run-length encode                    [[[0,6]],[[1,2],[0,4]],[[1,2],[0,4]],[[0,2],[1,1],[0,3]],...,[[0,2],[1,1],[0,1],[1,1],[0,1]],...,[[1,6]]]
      ¬     - NOT                                  [[[1,0]],[[0,0],[1,0]],[[0,0],[1,0]],[[1,0],[0,0],[1,0]],...,[[1,0],[0,0],[1,0],[0,0],[1,0]],...,[[0,0]]]
        €   - for €ach:
       S    -   sum                                [[1,0],[1,0],[1,0],[2,0],...,[3,0],...,[0,0]]
         Ṁ  - maximum                              [3,0]
          Ḣ - head                                 3

I think €Đ€ can be þ.

Perl 5, (older versions), -p -I., 52 49 43 bytes
Old style counting: +3 for -p: 46 bytes (because it must be in a program, it can't be run using -e)
barsplit.pl:
#!/usr/bin/perl -pI.
$G[split]+=s%\S%do$0for s/$&/ /rg%eg;$_=$#G

Run with the string on STDIN:
echo aaabcccdedaaabefda | ./barsplit.pl; echo

Try it online!
The -I. option is there to make this also work on recent perls where by default . is no more in @INC. In older versions of perl that option is not needed. I tested that on an older machine that still had perl 5.20, so the score is based on that (otherwise I should also count the . argument to -I)
Fast version (49 bytes):
#!/usr/bin/perl -pI.
$G[split]+=s%.%$$_++||do$0for s/$&/ /rg%eg;$_=$#G

Husk, 12 11 bytes
▲mȯ#€0gM€¹Ṗ

Try it online!
This works by brute force and is quite slow.
Add u to the right end to make it run faster, without changing the semantics.
Explanation
▲mȯ#€0gM€¹Ṗ  Implicit input, say S = "abddccbdcaab"
          Ṗ  Powerset of S: P = ["","a","b","ab","d","ad"...,"abddccbdcaab"]
 m           Map this function over P:
              Argument is a subsequence, say R = "acc"
       M ¹    Map over S
        €     index of first occurrence in R: [1,0,0,0,2,2,0,0,2,1,1,0]
      g       Group equal elements: [[1],[0,0,0],[2,2],[0,0],[2],[1,1],[0]]
  ȯ#          Count the number of groups
    €0        that contain 0: 3
▲            Take maximum of the results: 4

Wolfram Language (Mathematica), 77 bytes
Max@Table[Tr[1^StringSplit[#,(##|##)..&@@s]],{s,Subsets@Union@Characters@#}]&

Try it online!


text:
Rebuild a rectangular array from a corner
I once had a beautiful rectangular array. It was very symmetrical, but unfortunately it has fallen apart and now I only have the top left corner. Your task will be to rebuild the original array.
Your program will receive a 2 dimensional array of integers. For ease of parsing, you may assume they are all between 1 and 9. Your task is to reverse the array's columns, its rows, and both, stitch together the resulting corners, and return the resulting array.
You can assume the array dimensions will be at least 1x1.
Test cases:
Input:
1 2 3
4 5 6

Output:
1 2 3 3 2 1
4 5 6 6 5 4
4 5 6 6 5 4
1 2 3 3 2 1

Input:
1

Output:
1 1
1 1

Input:
9
9
9

Output:
9 9
9 9
9 9
9 9
9 9
9 9

This is code-golf, fewest bytes wins!

I'll bet charcoal can do this in under 10

@tbfninja https://chat.stackexchange.com/transcript/message/43184083#43184083 but could maybe be shorter with a different input format.

@MagicOctopusUrn yes

@tfbninja ＷＳ⟦ι⟧‖Ｍ→↓ perhaps? 5 bytes to read the input and 4 to reflect it.

@Neil nice

@Neil yeah, except that I don't see an answer yet :P also is that valid?

I'm 99% sure that there is a lang that do this with ╬ (or some similar character) just can't remember which one  :c

@Rod Close enough?

@Rod called it :P.

Canvas, 1 byte
╬

Try it here!
Outputs as a multiline string

Nice, @Rod called that one hah! Is this your language too Dzaima?

Damn... I should've remembered...

@MagicOctopusUrn Yeah, IIRC it's meant to basically be S.O.G.L. II: Electric Boogaloo?

Haskell, 25 24 bytes
r=(++)<*>reverse
r.map r

Try it online!

Python 3, 38 bytes
lambda a:[b+b[::-1]for b in a+a[::-1]]

Try it online!
Takes a list of lists and returns a list of lists.
Explanation:
lambda a:                              # anonymous lambda function
                   for b in a+a[::-1]  # for each row in the array and the upside-down array
          b+b[::-1]                    # the row with its reverse appended
         [                           ] # return in a list

Husk,  7  6 bytes
Coincidentally, Erik had posted the exact same code in the Husk chatroom about a minute before I posted this.
‼oTS+↔

Try it online!
Pervious version, 7 bytes:
mS+↔S+↔

05AB1E, 2 bytes
∞∊

Try it online!

   # Input:Array of String | ['12','34']
---#-----------------------+------------------------------------------
∞  # Mirror horizontally.  | [12,34]       -> [1221,3443]
 ∊ # Mirror vertically.    | [1221,3443]   -> [1221\n3443\n3443\n1221]

Credit for Mr. Xcoder pointing out that arrays of string may count as 2D arrays and Pavel for confirming it.

... 2 bytes

For ease of parsing, you may assume they are all between 1 and 9 – So I think this is valid. Awaiting Pavel's confirmation, I guess

@Mr.Xcoder that was what I had initially, then the TIO 2D arrays as input was weird... so had to come up with that header stuff.

A string is an array of characters, so a list of strings is still a 2d array. @Mr.Xcoder's solution is valid.

Coolio, works for me.

Retina, 13 bytes
\%`$
$^$`
Vs`

Try it online!
Explanation
\%`$
$^$`

On each line (%), match the end of the line ($), and insert the reverse ($^) of the entire line ($`) and print the result with a trailing linefeed (\). This does the reflection along the vertical axis and prints the first half of the output.
Vs`

This just reverses the entire string, which is equivalent to a 180° degree rotation, or in our case (due to the horizontal symmetry) a reflection along the horizontal axis. This way this works is that V's (reverse) default regex is (?m:^.*$), which normally matches each line of the string. However, we activate the singleline option s, which makes . match linefeeds as well and therefore this default regex actually matches the entire string.
The result of this is printed automatically at the end of the program, giving us the second half of the output.

This doesn't look like any regex flavor I know of :P

@Pavel Because Retina isn't just regex. :)

@Pavel the only part of that code that is an actual regex is the $ on the first line. ;) I'll add an explanation later.

JavaScript (Node.js), 62 55 49 46 bytes
A=>(j=x=>[...x,...[...x].reverse()])(A).map(j)

Try it online!
Because Array.prototype.reverse() reverses the array in place, I have to make a shallow copy somewhere first. A=>(j=x=>[...x,...x.reverse()])(A).map(j) does not work.

J, 12 bytes
(,|.)@,.|."1

Try it online!
Explanation
         |."1 - reverse each row
       ,.     - and stitch them to the input
 (   )@       - and
  ,|.         - append the rows in reversed order

Jelly, 5 bytes
m€0m0

Try it online!

Also 5 bytes: m0Z$⁺ (by Hyper Neutrino).

MATL, 5 bytes
,tPv!

Try it online!
Explanation:
(implicit input)
,               # do twice:
 t              # dup top of stack
 P              # flip vertically
 v              # vertically concatenate
 !              # transpose
(implicit output)

Octave,  33  29 bytes
Thanks to @Giuseppe for golfing four bytes!
@(A)[B=[A;flip(A)] fliplr(B)]

Try it online!

29 bytes

Ruby, 35 bytes
->a{r=->b{b+b.reverse}
r[a].map &r}

Try it online!
A lambda accepting a 2D array and returning a 2D array. It's straightforward, but here's the ungolfed version anyway:
->a{
  r=->b{ b+b.reverse } # r is a lambda that returns the argument and its reverse
  r[a].map &r          # Add the array's reverse, then add each row's reverse
}

awk, 88 bytes
{s="";for(i=NF;i>0;i--)s=" "$i s" "$i;a[FNR]=s;print s}END{for(i=NR;i>0;i--)print a[i]}

Welcome to PPCG! Nice first answer :)

Java 8, 140 131 bytes
m->{String r="";for(int a=m.length,b=m[0].length,i=a+a,j;i-->0;r+="\n")for(j=b+b;j-->0;)r+=m[i<a?i:a+a+~i][j<b?j:b+b+~j];return r;}

Explanation:
Try it online.
m->{                      // Method with integer-matrix parameter and String return-type
  String r="";            //  Result-String, starting empty
  for(int a=m.length,     //  Amount of rows of the input-matrix
          b=m[0].length,  //  Amount of columns of the input-matrix
          i=a+a,j;        //  Index integers
      i-->0;              //  Loop over double the rows
      r+="\n")            //    After every iteration: append a new-line to the result
     for(j=b+b;j-->0;)    //   Inner loop over double the columns
       r+=                //    Append the result with:
          m[i<a?          //     If `i` is smaller than the amount of rows
             i            //      Use `i` as index in the input-matrix
            :             //     Else:
             a+a+~i]      //      Use `a+a+i-1` as index instead
           [j<b?          //     If `j` is smaller than the amount of columns
             j            //      Use `j` as index in the input-matrix
            :             //     Else:
             b+b+~j];     //      Use `b+b+j-1` as index instead
  return r;}              //  Return the result-String

J, 11 bytes
Anonymous tacit prefix function.
|:@(,|.)^:2

Try it online!
|: transpose
@(…) the result of:
 , the argument followed by
 |. its reverse
^:2 and all this done twice

Triangularity, 31 bytes
...)...
..IEM..
.DRs+}.
DRs+...

Try it online!
Explanation
Removing the characters that make up for the padding, here is what the program does:
)IEMDRs+}DRs+ – Full program. Takes a matrix as a 2D list from STDIN.
)             – Push a 0 onto the stack.
 I            – Take the input at that index.
  E           – Evaluate it.
   M    }     – For each row...
    DR        – Duplicate and replace the second copy by its reverse.
      s+      – Swap and append.
         DR   – Duplicate the result and replace the second copy by its reverse.
           s+ – Swap and append.

R, 57 bytes
function(m)rbind(N<-cbind(m,m[,ncol(m):1]),N[nrow(N):1,])

Try it online!

APL+WIN, 11 bytes
Prompts for a 2d array of integers.
m⍪⊖m←m,⌽m←⎕

Stax, 5 bytes
:mm:m

Run and debug it online
:m means mirror, which is input.concat(reverse(input)).  m, in this context means output each line after applying...
So, mirror the array of rows, and then mirror each row and output.

SNOBOL4 (CSNOBOL4), 119 113 bytes
	T =TABLE()
I	X =X + 1
	I =INPUT	:F(D)
	OUTPUT =T<X> =I REVERSE(I)	:(I)
D	X =X - 1
	OUTPUT =GT(X) T<X>	:S(D)
END

Try it online!
Takes input as strings on STDIN, without spaces. This only works because the digits are 1-9 and would fail otherwise.

I can see why people don't use this language anymore. This is so weird.

@Pavel SNOBOL is truly a terrible language to work with. this is a more modern C implementation of it which has additional builtin functions like REVERSE; the original only supported integer arithmetic as well, as far as I can tell.

Add++, 30 bytes
D,f,@,bU€{r}B]{r}
D,r,@,dbR+

Try it online!
The footer simply transforms the nested array into the format in the question. Defines a function f, which expects a matrix (nested array) as an argument.

Japt, 6 bytes
mê1 ê1

Try it here

Explanation
           :Implicit input of 2D array
m          :Map
 ê1        :  Mirror sub array
    ê1     :Mirror main array

Charcoal, 5 bytes
θ‖Ｃ→↓

Try it online!
Thanks to ASCII-only for a better input format.

I wonder if this input format is valid, since I'm afraid Charcoal can't handle input otherwise. If it isn't, I'll happily delete this answer.

This is valid I/o.

@Pavel I just wondered because you had said that "Your program will receive a 2 dimensional array of integers", while a string is 1-dimensional (and no, the outer [] don't exactly make it 2D).

@ASCII-only Charcoal really needs a better I/O method...

@Neil He didn't get pinged here, but I pinged him over TNB. :)

Well, this works? Not sure if it counts as super hacky or not

@ASCII-only That's no improvement at all lol.

@EriktheOutgolfer Well, it's basically the same as standard Python input method

@EriktheOutgolfer fixed.

Mathematica, 29 bytes
(g=#~Join~Reverse@#&)@*Map[g]

Try it online!

SOGL V0.12, 2 bytes
-1 byte thanks to dzaima.
╬ø

Try it here!

APL (Dyalog Classic), 7 bytes
⍪∘⊖⍨⊢,⌽

Try it online!

C (gcc), 114 111 bytes

Saved three bytes thanks to Kevin Cruijssen; inverting the loops.

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)printf("%d,",A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]);}

Try it online!
C (gcc), 109 bytes (abusing ease of parsing)

Thanks to Kevin Cruijssen for suggesting to only allow one-digit input integers; saved two bytes.

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)putchar(A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]+48);}

Try it online!

You can save 3 bytes by inverting the loops. for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)

Does not fulfill spec; prints the array, rather than returning it.

"For ease of parsing, you may assume they are all between 1 and 9.", so you can remove the comma in the printf("%d" for an additional -1 byte.

@Rogem I would say printing the array falls under accepted i/o.

@KevinCruijssen Thanks a lot; using the ease of parsing I managed to shave off another byte.

Uiua, 9 bytes
⍥(⍉⊂∶⇌.)2

Try it!
⍥(⍉⊂∶⇌.)2
⍥(     )2  # run a function twice
      .    # duplicate
     ⇌     # reverse
   ⊂∶      # prepend
  ⍉        # transpose

Python 3, 49 bytes
def f(a):o=[i+i[::-1]for i in a];return o+o[::-1]

Where a is the input array. This function will return a 2D array.

Julia 0.6, 55 49 bytes
~i=i:-1:1
!x=[x x[:,~end];x[~end,:] x[~end,~end]]

Try it online!
~(i) is a function to create slice from i down to 1.
So ~end gives the slice end:-1:1
!(x) is the function to do the rebuilding of the array.

V, 12 bytes
yGæGPÎy$æ_|P

Try it online!
Explanation:
yG              " Yank every line
  æG            " Reverse the order of the lines
    P           " Paste what we yanked
     Î          " On every line:
      y$        "   Yank the whole line
        æ_      "   Reverse the whole line
          |     "   Move to the beginning of the line
           P    "   Paste what we yanked

Clojure, 56 bytes
(fn[i](map #(concat %(reverse %))(concat i(reverse i))))

Creates an anonymous function which takes the two dimensional list and returns
the fixed rectangle as two dimensional list.
Try it online!

Perl 5 -lp -Mfeature=say, 36 bytes
unshift@l,$_.=reverse;END{say for@l}

Deparsed:
BEGIN { $/ = "\n"; $\ = "\n"; }
use feature 'say';
LINE: while (defined($_ = readline ARGV)) {
    chomp $_;
    unshift @l, $_ .= reverse;
    sub END {
        say $_ foreach (@l);
    }
}
continue {
    die "-p destination: $!\n" unless print $_;
}

Try it online!

Proton, 29 bytes
a=>[b+b[by-1]for b:a+a[by-1]]

Try it online!
There are a few other interesting approaches though:
Proton, 29 bytes
a=>map(g,(g=x=>x+x[by-1])(a))

Try it online!
You can define the mirror sub-function g in-line, because Proton. It's not shorter though.
Proton, 36 bytes
(a=>[x[0]for x:zip(*(a+a[by-1]))])*2

Try it online!
This should be (a=>zip(*(a+a[by-1])))*2 which is 24 bytes, but the zip function is completely broken. Basically, you mirror it and zip, and then do that twice (you can multiply a function by a positive integer to apply the function multiple times).


text:
Find relevant digit groupings
Recently, my reputation was 25,121. I noticed that each digit grouping (i.e. the numbers separated by commas) was a perfect square.
Your challenge is, given a non-negative integer N and a unary boolean Black Box Function f : Z* → B , yield a truthy value if each value of f applied to the digit groupings of N is truthy, and falsey otherwise.
One can find the digit groupings by splitting the number into groups of 3, starting from the right side. The leftmost group may have 1, 2, or 3 digits. Some examples:
12398123  -> 12,398,123    (3 digit groupings)
10        -> 10            (1 digit grouping)
23045     -> 23,045        (2 digit groupings)
100000001 -> 100,000,001   (3 digit groupings)
1337      -> 1,337         (2 digit groupings)
0         -> 0             (1 digit grouping)

Additional rules

This function can map to either booleans (e.g. true and false), 1s and 0s, or any truthy/falsey value. Please specify which format(s) are supported by your answer.
You may take an integer as input, or an integer string (i.e. a string composed of digits).
You may write a program or a function.
When passing the digital groups to the function f, you should trim all unnecessary leading zeroes. E.g., f, when applied to N = 123,000 should be executed as f(123) and f(0).

Test cases
Function notation is n -> f(n), e.g., n -> n == 0. All operators assume integer arithmetic. (E.g., sqrt(3) == 1)
function f
integer N
boolean result

n -> n == n
1230192
true

n -> n != n
42
false

n -> n > 400
420000
false

n -> n > 0
0
false

n -> n -> 0
1
true

n -> sqrt(n) ** 2 == n
25121
true

n -> sqrt(n) ** 2 == n
4101
false

n -> mod(n, 2) == 0
2902414
true

n -> n % 10 > max(digits(n / 10))
10239120
false

n -> n % 10 > max(digits(n / 10))
123456789
true

If we are unable to take functions as arguments, are we allowed to assume that the function is defined as a variable and we reference that in our program?

@cairdcoinheringaahing Please read the reference for Black box functions, specifically the references at the end of that post. To summarize, yes, you can, even if your language is capable of taking functions as arguments (afaict)

Can the input be negative? Zero? You talk about integers, but all the examples are positive. I'd also suggest including test cases where a grouping of 000 needs to be handled.

@xnor Good point, I'll do that

Can the input number be just 0?

@AsoneTuhid Yes, as you are "given a non-negative integer N", which includes 0.

@ConorO'Brien In that case you should add (n -> n > 0 applied to 0) to the test cases because most answers fail on it.

Are the digit groups of 0 [0] or []?

@EriktheOutgolfer They are [0].

Jelly, 5 bytes
bȷÇ€Ạ

Try it online!
The command-line argument is the number. The line above the line this function resides in is the main line of the rest of the program, that is, the code that gets called for each of the groups. Be careful not to refer to the line bȷÇ€Ạ is in! The example used here is the 5th test case.

I'm pretty sure that this is a failure when applying n -> n != 0 to 0

@AsoneTuhid It's not; The number is 0, and its digit group list is [0], so then Ṇ gets mapped to each element (the single 0 here), turning the list into [1] and, since all of the elements of this list are truthy, 1 is returned. Note that if I had the digit group list be [] instead the result wouldn't change, as all of the elements of [] are truthy (vacuous truth). However, the result can be different for different programs, and the rules aren't exactly clear on this (asked OP).

Sorry then, I barely understand Jelly. Nice solution.

Brachylog, 8 bytes
ḃ₁₀₀₀↰₁ᵐ

Try it online!
The blackbox function goes on the second line (or the "Footer" on TIO) and the integer is read from STDIN. Prints true. or false. accordingly.
ḃ₁₀₀₀      Compute the base-1000 digits of the input.
     ↰₁ᵐ   Map the blackbox predicate over each digit. We don't care about the
           result of the map, but the predicate must succeed for each digit,
           otherwise the entire map fails.

APL (Dyalog), 16 13 bytes
3 bytes saved thanks to @Adám
∧/⎕¨1e3⊥⍣¯1⊢⎕

Try it online!
How?
1e3⊥⍣¯1⊢⎕ - input the number and encode in base 1000
⎕¨ - input the function and apply on each
∧/ - reduce with logical and

Save 3 bytes by going explicit: Try it online!

@Adám thanks! I liked the alpha-alpha though...

correct me if i'm wrong but i think this is a failure

Python 2, 46 bytes
g=lambda f,n,k=1000:f(n%k)and(n<k or g(f,n/k))

Try it online!

44 bytes by using * in place of and.

Haskell, 42 40 38 bytes
f#n=f(mod n 1000)&&(n<1||f#div n 1000)

The blackbox function must return True or False.
Try it online!
Edit: -2 -4 bytes thanks to @ovs.

2 bytes more using && instead of and

C (gcc), 66 58 48 bytes
-10 bytes thanks to @Neil!
t=1000;g(f,i)int f();{i=f(i%t)&(i<t||g(f,i/t));}

Try it online!

45 bytes? g(f,i)int f();{i=!i||f(i%1000)&&g(f,i/1000);}

fails when applying f(n){return n > n;} to 0

Best fix I could do cost 3 bytes: Try it online!

Wolfram Language (Mathematica), 30 bytes
And@@#/@#2~IntegerDigits~1000&

Try it online!

JavaScript (ES6), 40 36 bytes
f=>g=i=>f(i%1e3)&(i<1e3||g(i/1e3|0))

Takes the function and value by currying and returns 0 or 1. Edit: Saved 4 bytes thanks to @Shaggy.

1000 -> 1e3 to save a couple of bytes. And could you replace && with & for another byte?

@Shaggy Yes, I think that's safe enough. Same goes for betseg's answer?

fails for function_name(n=>n>0)(0) (returns true)

@AsoneTuhid Thanks, fixed.

Java (OpenJDK 9), 94 bytes
f->n->{int r=0,l=n.length();for(;l>0;l-=3)r+=f.test(n.substring(l<4?0:l-3,l))?0:1;return r<1;}

Try it online!

fails when applying n -> n > 0 to 0

@AsoneTuhid fixed at great cost of bytes.

Pyth, 9 bytes
.AyMjQ^T3

Try it online! (uses the third test case)
Assumes the black-box function is named y. You can declare such a function using L (argument: b), as shown on TIO. I will implement all the test cases later, if I have time.

Stax, 8 bytes
Vk|Eym|A

Stax programs do not have function calls or arguments, so we store a block in the Y register that consumes and produces a single value.  This can be done before the program code.
{...}Yd     store a block in the Y register that executes ...
Vk|E        get "digits" of input using base 1000
    ym      map "digits" to array using y as mapping function
      |A    all elements are truthy?

Here's an example using the perfect square function.

Clean, 54 bytes
import StdEnv
$n=if(n<1)True($(n/1000))&&f(n rem 1000)

Try it online!
Defines the function $ :: Int -> Bool, expecting a function f :: Int -> Bool to be defined elsewhere.

fails when applying n -> n > 0 to 0

@AsoneTuhid Fixed.

Common Lisp, 73 72 bytes
(defun g(x f)(and(funcall f(mod x 1000))(or(< x 1e3)(g(floor x 1e3)f))))

Try it online!

This is my first Lisp answer, so it's probably terrible.

05AB1E, 8 bytes
₄вεI.V}P

Try it online!
Explanation
₄в         # convert first input to base-1000
  ε   }    # apply to each element
   I.V     # execute second input as code
       P   # product of the resulting list

Takes the number as the first line of input and the function as the second.
Outputs 1 for truthy and 0 for falsy.

This doesn't execute the code on each element, but on the whole list.

@EriktheOutgolfer: With 05AB1E's automatic vectorization it will in most cases. I just realized that it won't work for Qand Ê though. I'll revert back to the 8-byte version.

Still, it's not .V that vectorizes, it doesn't even take the list as an argument itself to begin with.

@EriktheOutgolfer: I've never said that .V vectorizes. In the example in my link it's È.

Actually Q and Ê would work with vectorization unlike I previously stated, but using automatic vectorization would make these commands map on the whole list which feels outside the spirit of the challenge so we need ε.

Excel VBA, 79 bytes
An anonymous VBE immediate window function that takes input, n as type integer from range [A1], and the name of a publically defined VBA function from range [B1].
t=1:n=[A1]:While n:t=t*-Application.Run(""&[B1],n Mod 1E3):n=Int(n/1E3):Wend:?t

Usage example
In a public module, the input function, in this case f() is defined.
Public Function f(ByVal n As Integer) As Boolean
    Let f = (n Mod 2 = 0)
End Function

The input variables are set.
[A1]=2902414    ''  Input Integer
[B1]="f"        ''  input function

The immediate window function is then called.
t=1:n=[A1]:While n:t=t*-Application.Run(""&[B1],n Mod 1E3):n=Int(n/1E3):Wend:?t
 1              ''  Function output (truthy)

Ruby, 37 bytes
g=->f,n{f[n%x=1000]&&(n<x||g[f,n/x])}

Try it online!
A recursive lambda, taking function and integer and returning boolean.
36 bytes (only positive n)
g=->f,n{n>0?f[n%k=1000]&&g[f,n/k]:1}

This version returns 1 for truthy, false for falsey. Unfortunately it can fail when n = 0
Try it online!

I think you have to count g= if it's recursive

@AsoneTuhid Oh, that makes sense. I'll add it in.

Also, try this (-1 byte), it returns 1 as the truthy value

That wrinkled my brain a little... I had to tinker around a bit to convince myself it worked in all cases. Thanks!

I was wrong, this version doesn't work for g[->n{n>0},0] (returns true). It only fails if the input is 0 but the question says "non-negative" so you should go back to 37. sorry

Appleseed, 51 bytes
(lambda(n f)(all(map f(or(to-base 1000 n)(q(0))))))

Anonymous lambda function that takes a number and a function and returns a boolean value.
Try it online!
(lambda (n f)         ; Function with parameters n and f
 (all                 ; Return true if all elements of this list are truthy:
  (map f              ; Map the function f to each element of
   (or                ; This list if it is nonempty:
    (to-base 1000 n)  ; Convert n to a list of "digits" in base 1000
    (q (0))           ; Or if that list is empty (when n=0), then use the list (0) instead
   ))))

Add++, 15 bytes
L,1000$bbbUª{f}

Try it online!
Requires a function f to be declared in the TIO header.
How it works
D,f,@,0.5^i2^A=	; Declares a function 'f' to check if a perfect square
		; E.g. 25 -> 1; 26 -> 0

L,		; Declare the main lambda function
		; Example argument: 		[25121]
	1000$bb	; Convert to base 1000	STACK = [[25 121]]
	bUª{f}	; Is 'f' true for all?	STACK = [1]

Husk, 7 bytes
`ΛmrC_3

Try it online! Takes N as a string and f as a function object. Given a number, f can return any truthy or falsy value.

Japt, 9 bytes
Had to sacrifice 3 bytes and take input as a string in order to handle the n=>n>0 test case when n=0. I could get them back if it was permitted to pass the groupings to the function as strings and convert them to integers within the function, when necessary
ò3n)mn eV

Try it
The function, as allowed by consensus, is preassigned to variable V on the second line of the header - the empty first line is essential.
Here are all the test case functions rewritten for Japt.
n -> n == n                           X{X==X}
n -> n != n                           X{X!=X}
n -> n > 400                          X{X>400}
n -> n > 0                            X{X>0}
n -> n -> 0                           X{X{0}}
n -> sqrt(n) ** 2 == n                X{Xq v1}
n -> mod(n, 2) == 0                   X{X%2==0}
n -> n % 10 > max(digits(n / 10))     X{X%10>Xz10 ì rw}