# Print X without X (robber's thread)

This is the robber's thread of a challenge. You can view the cop's thread here

A pretty common beginner style question is to print some string, but, there's a catch!, you need to do it without using any of the characters in the string itself!

For this challenge we will find out who is the best at printing X without X. There are two threads to this, a cop's thread and a robber's thread.

In the cop's thread users will choose a language (which we will call Y) and a string (which we will call X) and write a program in language Y which takes no input and outputs X without using any of the characters in X. The cop will then post both X and Y without revealing the program they have written.

Robbers will be select cop answers and write programs in language Y which take no input and output X. They will post these "cracks" as answers in this thread. A crack need only work not be the intended solution.

Once a cop's answer is one week old, so long as it has not been cracked, the cop may reveal their program and mark it as "safe". Safe answers can no longer be cracked

Robbers will be scored by the total number of successful cracks with more cracks being better.

• Congrats on an excellent challenge with high 'replay value'. I've had a lot of fun participating on both sides, digging into a couple of languages for the first time along the way. Aug 20, 2020 at 3:22

# Vyxal O, 548783 bytes, cracks EmanresuA's fourth answer

Sample:

\o\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"fLkZ:\o\o"\o"fL%"¯∑\o\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"\o"fL%Ė


Full program

Add any more characters, and we'll pass 1 million bytes probably.

# Vyxal O, 774094 bytes, cracks EmanresuA's fifth answer

Sample:

\o‛ooLẋ‛ooLẋ‛ooLẋ‛ooLẋ‛ooLẋ‛ooLẋ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤Ȧ\oL¤ȦLkA‛ooL¤ȦkAFĖ


Full program

My poor computer is becoming unable to handle uploading/dealing with the program lengths.

# Vyxal, 1318498 bytes, cracks lyxal's answer

Sample:

uuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεkP'bfBuuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuε=)kP'bfBuuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuε=)Wf‛  jĖ‛  j‛  o


Try it Online!

Generator:

,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»\;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏRq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵O¢ṙṗṖ¦†AVG↲↳⋏⋎Ṅ⁋×λ√⌈⌊:ḊD # This is the full string to print ḣ$C›‛uε*\upkP'bfBu120‛uε*+‛=)++              # The first character needs to be handled differently
$ƛC›‛uε*\ipkP'bfBu75‛uε*+‛=)++;∑+ # Here's the rest of the characters kP'bfBu68‛uε*+‛=)++ # Change the numbers to characters at the end Wf+\‛+ jĖ+\‛+ j+\‛+ o+ # Join everything by spaces and execute, then pretty-print  Try it Online! • This is currently invalid as semicolons are banned. You can trivially replace them with }, ], or ), because Vyxal. Sep 27, 2021 at 18:42 • @emanresuA Oh yeah, I meant to do that and then forgot. Thanks, I'll update it. Sep 27, 2021 at 19:27 # Vyxal, 2513525 bytes, cracks lyxal's answer Samplez: ðḃðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZðḃZf∑k^ṘðḃðḃZðḃZf∑kv‛ouoṘkv‛ouoð¶rðḃZðḃZfṘZf∑ṘĖZf∑ðḃoZf∑ĖĖ  ez Generator: ḟṙIcKġ₴…‹›+*/-d↵Ǎ½ƒɖø∆₈₇∞₆₄JiẎȯht42069ḢṪḣṫ¡Þ₀₁C!¬⇧İNeVERgȮṄnaGḭ⟇ėyOU⊍p⇩Ż÷«»⌐m≬\ṡ∷‡⁽⟨|⟩‟„$∇_Ǐq꘍₍₌Π⁺βτʀʁɾɽ¨żẏ?¹⁰²ǔǓǒǑǐǎꜝ₂₃₅&ẇŀl↑↓∴∵¢\;¥£¾F¼⅛%→←"ẋ¤Ḋε€ṗṖ¦†A↲↳⋏⋎⁋×λ√⌈⌊:Dbjwxz,BHMQSTXY)}]([{<>ḂĊḞĿṀṠẆẊ℅@°•ß↔æƈ§≈µ¯±≠⁼≥≤=∩s∪ĠṁȦ'ċḋṅ13578ȧ
ƛ‛ðḃ$C‹ðḃZ*+f∑k^ṘðḃðḃZðḃZf∑kv‛ouoṘkv‛ouoð¶rðḃZðḃZfṘZf∑ṘĖZf∑ðḃoZf∑ĖĖ+;∑‛W∑+  # Vyxal, 29261004498694420 bytes, cracks'd lYXAL;s anser This solution has two main parts to it: Generating arbitrary numbers, and converting those numbers into characters. ## Arbitrary numbers: uAuAuuArv∨v∧∑  Explanation:  uA # Push 1 u r # Cast to range [-1..n) uAuA v∨v∧ # Change all numbers in range to 1 ∑ # Sum  Continue wrapping with uAuAu rv∨v∧∑ to increment. Example: Try it Online! ## Numbers to characters: k^k^kAPP‛A.‛..PokfPĖ  Explanation:  k^ # Push hex digits kAP # Strip ABCDEF to get 0123456789 k^ P # Strip 0123456789 to get ABCDEF ‛A.‛..P # Remove . from A. o # Strip A to get BCDEF kfP # Strip Fizz to get BCDE Ė # Execute BCDE  B # Convert from binary C # Convert to char D # Triplicate E # Execute as Python (Does nothing)  Example: Try it Online! ### Extra This program takes a character and returns the number of bytes required to print it: Try it Online! # Vyxal, 239993933 bytes, lyxal get cracked on The backbone of this solution is the generation of arbitrary negative numbers, allowing for indexing to get all the commands we need. ## How negative numbers? u # Push -1 koo # Remove 01234567 Does nothing except convert to string Ė # Execute  We can decrement to any number by stringing many of these snippets together into a series. Essentially, this executes subtract, then pushes 1. The 1 is used for the next subtraction in the series. This means we need to get rid of the first subtraction in a series and the last 1 in a series. ### Subtraction no To remove the first subtraction: uu  This just pushes a couple of -1s, so the first subtraction is just -1 - -1. ### 1 no To remove the last 1: uPĖ  This uses -1 to turn 1 into an empty string, which is then executed to remove it. Try it Online! ## Why negative numbers tho? How do arbitrary negative numbers help us? Vyxal uses the same indexing as Python, so we can use negative numbers to index into stuff. However, to index into something, we need i. We don't have that command available to us, but it is in the builtin aeiou, which we can make use of: kv # Push aeiou uuukooĖukooĖukooĖukooĖ # Push -3 and 1 kv # Push aeiou ‛ouo # Remove ou to get aei Ė # Execute  Now that we have i and any negative number, we can index into our builtins to get useful stuff. For example, we can index into 01234567 to get 1, and we can index into printable ASCII to get + and C. We can use the 1+ over and over to increment a number, then use C to convert it to a character. (Yes, I know I could just push -1 and use - instead of +, which would be a lot shorter, but that's not as fun.) Once we have the pieces, namely arbitrary negative numbers and indexing, creating a solution becomes trivial. Here's an example for printing !: apparently the link was too long so here's a gist of the program that you can copy into the interpreter wait hold on didn't we already do all of this for the last cop # Vyxal, 102953210 bytes, makes lyxal very sad Y'all'dn't've given me those deltas. kl¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯s¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯℅  Try it Online! So it turns out that using deltas on a string or a list of characters will just remove the last character if all the characters are different. Removing a bunch of stuff, sorting, then removing a bunch of stuff will allow us to get any uppercase letter we want from kl. That gives us C, so we just need to figure out how to increment. My first thought was using urL, but the delta trick only lets us get uppercase letters. Then I realized that we could use s to get a range, then join stuff to it and get the length to get any number we want. Join and Length are both uppercase letters, so that's perfect. s # Sort; casts the number to a range kl # Push UPPERCASElowercase reversed alphabet J # Join L # Length  Doing this over and over will increment the number over and over, and we can push a 7 to start using k℅L, since we just need the starting number to be less than 10 (\n). From here, it's just a straightforward increment to target, convert to char, and we've got our crack! Here's an example printing !: wow even this comparatively short program is too long to include here as a link # Vyxal, 5228096860937807017 bytes, beats lyxal ...Who says I need inf to win? klkl₃₃kl₃₃kWsĖ  Try it Online! This ended up being really complicated, until I realized I was an idiot. At first, I had a really big thing to get the last letter of a string, then I realized that that was stupid and I was stupid and Vyxal is stupid and I'm stupid, and I could remove a part of it completely, which would allow me to remove another part of it, golfing the solution by 8.5 exabytes. So it turns out all I needed to do was get the last letter of kl, then use / and some things to remove it from kl, then get the last letter of that and remove it from that, etc. to get any letter command I wanted. Getting the last letter turned out to be simple: kl₃₃ # Push 1 kl₃₃ # Push 1 kW # Push https:// s # Sort Ė # Execute  ^ (This is the part that I overcomplicated. If you're curious, I talked a bit about it in chat.) Being able to get the last letter of a string allowed me to get az/t from the builtins. As it turns out, / would end up being very handy. I was able to get the last letter of a builtin, e.g. a from kl, and then split the builtin on that letter, which would give me a list of that builin minus the letter, and an empty string. Then I could sort the list and get the last element, which would be the builtin without the removed letter. klklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖklklkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖkl₃₃kl₃₃kWsĖkWkl₃₃kl₃₃kWsĖĖskl₃₃kl₃₃kWsĖ  Try it Online! This allowed me to create an exponentially growing program to get any letter from the builtin, which allowed me to increment using the same methods I've used before. It also allowed me to get C to convert the numbers to characters. The entire program is pretty much just a bunch of kl₃₃kl₃₃kWsĖ repeated over and over, with some other stuff sprinkled in. Here's an example printing !: wow this program is just absolutely too long there's no way im going to be able to even put it in a gist but here you go # 67 bytes, cracks emanresu A's answer with(_=>1)constructor("conso\x6ce\x2e\x6cog('\x5b\x2e\x6c\x46')")()  • If you're really going for golfing this, \56 Apr 9 at 0:33 # JavaScript, cracks allxy's answer {at:{constructor:c}}='';cconso\x6ce\x2e\x6cog('\x5b\x2e\x6c\x46')$$$$  # Scala, cracks @user's answer println{"" + {40 toChar} + {46 toChar}}  Try it online! • Cool! Never thought about braces. I defined a function taking a single argument and used infix notation – user Jul 25, 2020 at 17:38 • Yeah, my immediate thought when I saw (. was postfix notation -- spent a while trying to figure out why println 3 wasn't working when I stumbled upon the braces trick. Jul 25, 2020 at 17:44 • By the way, you needn't mark it as (repl). Just wrap an object Main extends App {} around it (it's what I did). – user Jul 25, 2020 at 17:56 • Ah, thanks, I'll update the TIO link. Jul 25, 2020 at 17:58 # 05AB1E, cracks @SomoKRoceS's answer 46ç  Try it online! Pushes 46, then converts to a character, with implicit output. # Keg, Lyxal's answer f;;p;f;r⑨m⑨ 7+u;Z⑨⑨:a;  Try it online! # Befunge-98 (PyFunge), 37 bytes, cracks pppery's answer This code is terrible. "NRTS"4(0"<"1+D0"r"1+D0"o"1+D0"+"1+D@  Try it online! # Keg, 264 bytes, cracks Lyxal's answer Uses the -oc flag. ‡32‡32‡10‡32‡45‡32‡43‡32‡46‡32‡56‡32‡7‡32‡33‡32‡95‡32‡126‡32‡9320‡32‡92‡32‡59‡10‡32‡32‡10‡32‡45‡32‡43‡32‡46‡32‡56‡32‡7‡32‡33‡32‡95‡32‡126‡32‡9320‡32‡92‡32‡59‡10  Try it online! • Doesn't seem to replicate the 0x07s and trailing newline in the original question (see the TIO link there), but I would imagine that's easily fixable. If it's not, I have a different solution I can post. Jul 26, 2020 at 14:00 • Indeed, it doesn't; I'm not sure how that happened (probably an issue when copying a nonprintable); fixed. Jul 26, 2020 at 14:18 • I never used flags in the original, hence this is an invalid crack. Aug 13, 2020 at 4:58 • @Lyxal it doesn't matter if it's not intended Aug 13, 2020 at 6:11 • It does. I just got told a crack was invalid for using flags when the original program didn't use them. Aug 13, 2020 at 6:23 # Javascript, cracks PkmnQ's answer Target: (\SuC) In browser (tested on Chrome): atob['constr'+${!0}[2]+'ctor']$${'console.log'+atobKA==+atobIihcXFN1QykiKQ==} In Node: U={!0}[2];global['F'+U+'nction']$${global['B'+U+'ffer'].from99${''}111${''}110${''}115${''}111${''}108${''}101${''}46${''}108${''}111${''}103${''}40${''}39${''}40${''}92${''}92${''}83${''}117${''}67${''}41${''}39${''}41}$


Try it online!

OP already revealed an important trick (running arbitrary code in JSF$ck), so it was just a matter of creating the required chars from something else. Browser version uses base64 decoding function atob, and Node version uses Buffer.from, which luckily takes an array of numeric strings as an array of bytes. • Honestly, I didn't think of using atob. I used (again) unescape. Jul 28, 2020 at 10:33 T-SQL DECLARE @String VARCHAR SELECT @String = 0x28 SELECT @String  Outputs ( but doesn't contain ( by using implicit type coercion. • Nice. I did the same but just in a more complex way Jul 28, 2020 at 20:31 # Ruby, cracks @Dingus' answer, 77 bytes I imagine this is almost certainly not the crack in mind, but this was the other solution I found before posting the crack for @Histocrat's second cop. printecho -n \x27\x2e\x27\\\x27\x27\x22\x3f\x25\x28\x29\x5b\x5d\x3a\x3c\x27  Try it online! • This requires Ruby+bash, not just Ruby-on-Unix. But the same principle works with Ruby-on-Unix: use printf \\047... instead of echo \x27…. Jul 30, 2020 at 22:57 • I've posted a fortified version so will hold off on revealing my solution. Jul 31, 2020 at 4:47 # PicoLisp, cracks @Wezl's answer 5 bytes Marking this community wiki as @Dingus Googled the error and found a solution and I applied the previous crack's style and removed bits. [[0]]  Try it online! • Unless there's a version of PicoLisp that does something bizarre, this doesn't work. [[0]] causes picolisp to segfault, and it does not print anything to stdout and stderr. If you see a message like segmentation fault when you run it, that message comes from your shell. Jul 30, 2020 at 22:45 # Dirty, 2 bytes, cracks @HighlyRadioactive's answer 0Ḃ  Try it online! Seems to work with any digit(s) preceding Ḃ, which is described in the docs as the 'bytes to UTF8' operator. • The intended solution is: 1 (Yay!) – null Aug 1, 2020 at 6:04 ## Ruby, cracks Dingus's fourth answer RUBY_VERSION =~ /\D/ DOT =$&
RUBY_VERSION =~ //
EMPTY_STRING = $&$_ = $LOADED_FEATURES * EMPTY_STRING$_ =~ /C/i; LC_C = $&$_ =~ /H/i; LC_H = $&$_ =~ /R/i; LC_R = $& H_DOT_CHR = LC_H + DOT + LC_C + LC_H + LC_R emit = EMPTY_STRING h = 112; emit += eval H_DOT_CHR h = 117; emit += eval H_DOT_CHR h = 116; emit += eval H_DOT_CHR h = 99; emit += eval H_DOT_CHR h = 32; emit += eval H_DOT_CHR h = 104; emit += eval H_DOT_CHR h = 99; eval emit h = 100; eval emit h = 111; eval emit h = 112; eval emit h = 114; eval emit h = 46; eval emit h = 96; eval emit h = 39; eval emit h = 34; eval emit h = 63; eval emit h = 37; eval emit h = 40; eval emit h = 91; eval emit h = 123; eval emit h = 58; eval emit h = 60; eval emit  Try it online! Since we can use eval, the problem is to bootstrap a string that contains some interesting Ruby code. Since we have concatenation, this reduces to looking for individual characters. I went for h.chr, which will then let us construct arbitrary characters with h = NNN; s = eval "h.chr". (h could be any character that is permitted and that we manage to stuff into the string.) Once we have that, we build the string "putc h", and use that to print any character given by its numeric code. Like before, I tried to extract characters from strings with regular expression matching. And like before, this divides into two subproblems: how to match an individual character, and finding or constructing a string that contains the desired character. Once that's done, we can copy the character from $&. Reviewing regexp features,

Some backslash escapes that match a character in a class are permitted. For example /\D/ matches the first character in a string that isn't a digit. Conveniently, in RUBY_VERSION, that's a ..

Since i is permitted, we can do case-insensitive matching. Since all uppercase letters are permitted, we can obtain a one-character string containing a lowercase letter by matching the corresponding uppercase letter against a string that contains the desired lowercase letter. We do this for c, h and r, all of which are present in $LOADED_FEATURES. That's an array of strings, which we convert to a string by using the join method which is conveniently available as the * operator. This part has me slightly uneasy because it verges on the specifics of an installation rather than on a language feature. However, the necessary characters are found in complex and thread and as far as I understand, these module names have to be present in $LOADED_FEATURES regardless of installation details.

• Hats off to you for thwarting me at every attempt. This has been fun. I've posted my code in the cops thread. Aug 1, 2020 at 14:12

This was kinda hard, but kinda easy and really fun!

object Main; def main(using Array[String]) = print("" + 58.toChar + 92.toChar + 123.toChar);


You can try this on: https://scastie.scala-lang.org/Sthw2Vr7QG26mbMHQuirkg

As of today, it produces the expected output:

## DISCLAIMER!!!!

This answer is HEAVILY based on https://codegolf.stackexchange.com/a/207833/!

As based on this comment - Print X without X (cop's thread)

@LuisMendo To start as of now full programs are required so return is not possible regardless. I will say that you must indicate if your intended output is to STDERR, although for most languages errors should be somewhat distinct from legitimate output. – Ad Hoc Garf Hunter

The answer was required to be a full program, but the presented answer isn't.

Also, the answer I've taken inspiration from has a mistake on it.

The O.P. of the answer hasn't said their personal opinion since 31st, regarding the validity of the answer.

I believe this answer is different enough to be posted by itself.

• Nice job with “using”! Didn’t think of it (I used @main). Also, you don’t need object Main
– user
Aug 4, 2020 at 0:19
• @user Thank you! I believe that that information should be also part of the cop's answer, where you post your intended solution. This way, more people can learn more and, in case comments are deleted, the information isn't lost. And everybody else is doing the same (I did it too). The using was totally found by chance when reading this: github.com/lampepfl/dotty/commit/… Aug 4, 2020 at 0:20
• Yep, I’ll do that tomorrow when I’m on my PC. Again, nice job. Still, did you have to crack it today, when I was almost safe? :/
– user
Aug 4, 2020 at 0:50
• @user I mean, it sounded like an interesting challenge. I didn't wanted to pass on it. Specially since part of the answer was already made. (Admitedly, the hardest part for me, honestly.) Aug 4, 2020 at 1:01
• @user I know you meat it as a joke, don't worry. Dotty seems to be interesting and has some cool concepts. Sorry for stealing your almost-safe submission :( Aug 4, 2020 at 7:56

aa*b+01pv
+b*aa<;


Try it online!

How can you output a character without using the o command?

With the letter p is how!

• See new challenge!
– null
Aug 12, 2020 at 6:41

llllllllllrnnnnnnnnnn'':::,+:::,+:::,+:::,+:::,+:::,+::l+:::,:pv
> <                                                         ~r~$<  Exits with an error, but when using the right interpreter (e.g. this), it's not actually output. • OK, you win. The new challenge is even more inconvenient... – null Aug 12, 2020 at 7:51 # ><>, cracks HighlyRadioactive's third answer '.':,:&:-&:&&:&:+:&:&+:&:&+:&:&+:&:&+:&:&+:&:&+:&:&+rnnnnnnnnnn''&:&+:&:&+:&:&+:&:&+:&:&+:&:&+'k'&:&+'n'&:&+'k'&:&+'n'&:&+&:pv > < r<  Exits with an error, but when using the right interpreter (e.g. this), it's not actually output. I knew the register because I stole the feature for Keg. • Not the intended solution... a fourth one – null Aug 12, 2020 at 8:07 • @HighlyRadioactive okay then. Aug 12, 2020 at 8:08 • My intended solutions are much terser than yours... That is, no whitespaces, no repeating code, well golfed. – null Aug 12, 2020 at 8:10 • We're not here for golf though. We're here to crack answers. Aug 12, 2020 at 8:18 • Just sayin'. (f chars) – null Aug 12, 2020 at 8:19 # ><>, cracks HighlyRadioactive's fifth answer 'u':-'u':,:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+rnnnnnnnnnn'''u':,+:'u':,+:'u':,+:'u':,+:'u':,+:'u':,+'%''u':,+'k''u':,+'n''u':,+'h''u':,+'n''u':,+'u':,:pv > < r<  Exits with an error, but when using the right interpreter (e.g. this), it's not actually output. • Right, that's the intended answer. Round 6. (It lasted a whole 7 minutes!) – null Aug 12, 2020 at 8:34 • @HighlyRadioactive round 6 will be my last for today. I'll do more tomorrow after that. Aug 12, 2020 at 8:35 • I will probably be out of solutions after round 6... This one was the intended solution for round 2 by the way. I was going to use l for round 3... – null Aug 12, 2020 at 8:36 # ><>, cracks HighlyRadioactive's eigth answer :n::+n:::++n::::+++n:::::++++n::::::+++++n:::::::++++++n::::::::+++++++n:::::::::++++++++n:+:+:+:+:+::++::,+:::,+:::,+:::,+:::,+:::,+:::,+::,:+:+:+:+:+::,:::::++++++::,::::++++::,:+*:*::,:::::::++++++++:::,::+++:::,:::::+++++-::,:+:+:+:+:+::,::,::,::,::,::,::,+++++++::,:+:+:+:+:+::,::,++::,:+:+:+:+:+::,:+:+:++:::,+:::,:+:+:+:+::,:+:+++::,:+:+:+::,+::,+::,:+:+:+::,:++:::,:::::+++++*::,:++::-:p::,:+:+::,+::,:+*::*+::,+::,::-p::,::,::,::,::,++++:+::,::,::,::,::,::,+++++*::,:+::-pr>  Try it online! Requires this interpreter, or, this one like so: • For ease of use I ask that you assume there are no command line flags in cases where command line flags are not mentioned. -- OP – null Aug 13, 2020 at 4:45 • @HighlyRadioactive asking doesn't equate to solid rules. Aug 13, 2020 at 4:46 • Command line flags count as different languages -- also OP Aug 13, 2020 at 4:47 • @Dingus which indicates this answer is not written in ><> and is thus invalid – null Aug 13, 2020 at 4:48 • Then that one's not acceptable too – null Aug 13, 2020 at 4:57 # Keg, cracks Lyxal's answer aA%,aA%,KA%,aA%,nA%,aA%,lA%,aA%,oA%,aA%,yA%,aA%,7,aA%,bA%,aA%,Àa%,aA%,673**,aA%,é85**,aA%,¾b%,aA%,fA%,KA%,aA%,aA%,KA%,aA%,nA%,aA%,lA%,aA%,oA%,aA%,yA%,aA%,7,aA%,bA%,aA%,Àa%,aA%,673**,aA%,é85**,aA%,¾b%,aA%,fA%,KA%,  Ungolfed to avoid what appears to be a bug in Keg. I can't remember if this is exactly what I had in mind a month ago as I can't find the file and never bothered to generate a TIO link in my history, but I reckon it's pretty close. Try it online Explanation: While taking away + and - will make it a little harder to generate numbers, % is still a powerful tool. Unsurprisingly, it's a modulo operator, and by moduloing, say, 65 and 97 (characters A and a, respectively), we can get 32, corresponding to space. It's just subtraction with more steps! We mostly just abuse this to get the characters we need, occasionally switching our base to something like a. This won't work for characters greater than 125 (I mean, it could, but I don't want to look up UTF-8 codes), however, and we need two of these: ~ and ⑨. For ~ we just multiply 6, 7, and 3 to get 126. ⑨ has a prime factorization of 2^3 * 5 * 233, so we use é (char code 233), 8, and 5 and multiply through. # AlphaBeta, 228 bytes, cracks @PkmnQ's answer wEFrErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErErLErLErLErLErLErLErLErLErLErLErLErL  Try it online! w # set Register 3 value to 1 (Register 1 to the power of Register 2; both initially 0) EF # copy Register 3 value to Registers 1 and 2 r # set Register 3 value to 2 (sum of values of Registers 1 and 2) Er × 94 # 94 times, increment Registers 1 and 3 ErL × 12 # 12 times, increment Registers 1 and 3 and print Register 3 as char  • nEFrErEFrEFrEFrEFrEFrEynFrLErLErLErLErLErLErLErLErLErLErLErL is shorter, but this isn't code golf Nov 6, 2020 at 10:11 # Lua, 2433 bytes, cracks @LuaNoob's second answer io.write(_G[([[string]])][string.lower([[CHAR]])](string.len([[................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[..................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[....................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.....................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[......................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.......................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[........................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.........................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[..................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[....................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[......................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.......................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[..........................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...........................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.............................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[...............................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[............................................................................................]])).._G[([[string]])][string.lower([[CHAR]])](string.len([[.................................................................................................]])))  Try it online! Untested in 5.1 (TIO has 5.3.5), but I don't believe there's any code here that depends on the minor version. Pretty similar to the first crack. This time we don't have a or #, which we work around by calling string.char as _G[([[string]])][string.lower([[CHAR]])] and # as string.len. I used this Ruby code to generate the Lua: X = %q(0123456789 "#$&'*+-/\\a)
`