Print X without X (robber's thread)

Question

This is the robber's thread of a cops-and-robbers 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.

Answer 1

Vyxal O, 182321 bytes, cracks EmanresuA's third answer

Sample:

`oooooooooooooooooooooooooooooooooooooooooooo`LkA'\D<;∑`lol`L%Ė`oooooooooooo...

Full code here

Answer 2

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.

Answer 3

Vyxal O, 2051108 bytes, cracks EmanresuA's tenth answer

Sample:

?ꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rLꜝ?rL?↵↵LkAτĖ

You read that right. The answer really is 2 million bytes. Github doesn't like the file, so here's the generator:

`,₴…‹›⟇+*/-d↵EǍ½ƒɖ1234567890ø∆e₈₇∞₆₄JpiẎȯhtḢṪḣṫ¡Þ₀₁C!¬⇧İN⇩Ż÷«»\`;¥£¾¼⅛%→←"ẋ¤ȦFȧ⌐m⊍g≬\ṡ∷‡⁽⟨|⟩‟„$∇_yǏṘRq꘍₍₌Π⁺ʀ↑↓G↲↳⋏⋎Ṅ⁋ð×λ√²⌈⌊:ḊD` \λ \‛ VC ƛ`?``ꜝ?rL`n*+`?↵↵LkAτĖ`+;

Why the \λ \‛ V? Because ‛ doesn't play nice inside strings.

Answer 4

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ε*\up`kP'bfBu`120‛uε*+‛=)++              # The first character needs to be handled differently
$ƛC›‛uε*\ip`kP'bfBu`75‛uε*+‛=)++;∑+            # Here's the rest of the characters
`kP'bfBu`68‛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!

Answer 5

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∑+

Answer 6

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!

Answer 7

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

Answer 8

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

Answer 9

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

Answer 10

67 bytes, cracks emanresu A's answer

with(_=>1)constructor("conso\x6ce\x2e\x6cog('\x5b\x2e\x6c\x46')")()

Answer 11

JavaScript, cracks allxy's answer

{at:{constructor:c}}='';c`conso\x6ce\x2e\x6cog('\x5b\x2e\x6c\x46')```

Answer 12

54 45 bytes, cracks @Ausername's answer

with(conso\u006ce)\u006cog('\x5b\56\x6c\x46')

Edit: Saved 9 bytes thanks to @Ausername.

Answer 13

Scala, cracks @user's answer

println{"" + {40 toChar} + {46 toChar}}

Try it online!

Answer 14

05AB1E, cracks @SomoKRoceS's answer

46ç

Try it online!

Pushes 46, then converts to a character, with implicit output.

Answer 15

Keg, Lyxal's answer

f;;p;f;r⑨m⑨ 7+u;Z⑨⑨:a;

Try it online!

Answer 16

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!

Answer 17

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!

Answer 18

Javascript, cracks PkmnQ's answer

Target: (\SuC)

In browser (tested on Chrome):

atob['constr'+`${!0}`[2]+'ctor']`$${'console.log'+atob`KA==`+atob`IihcXFN1QykiKQ==`}$```

In Node:

U=`${!0}`[2];global['F'+U+'nction']`$${global['B'+U+'ffer'].from`99${''}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.

Answer 19

T-SQL

DECLARE @String VARCHAR
SELECT @String = 0x28
SELECT @String

Outputs ( but doesn't contain ( by using implicit type coercion.

Answer 20

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.

print`echo -n \x27\x2e\x27\\\x27\x27\x22\x3f\x25\x28\x29\x5b\x5d\x3a\x3c\x27`

Try it online!

Answer 21

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!

Answer 22

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.

Answer 23

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.

Answer 24

Dotty, cracks @user's answer

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.

Answer 25

><>, cracks HighlyRadioactive's answer

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!

Answer 26

><>, cracks HighlyRadioactive's second answer

llllllllllrnnnnnnnnnn'`':::,+:::,+:::,+:::,+:::,+:::,+::l+:::,:pv
> <                                                         ~r~$< 

Exits with an error, but when using the right interpreter (e.g. this), it's not actually output.

Answer 27

><>, 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.

Answer 28

><>, 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.

Answer 29

><>, cracks HighlyRadioactive's seventh answer (yes, seventh)

00=n00=00=+n00=00=00=++n00=00=00=00=+++n00=00=00=00=00=++++n00=00=00=00=00=00=+++++n00=00=00=00=00=00=00=++++++n00=00=00=00=00=00=00=00=+++++++n00=00=00=00=00=00=00=00=00=++++++++n00=:+:+:+:+:+::++::,+:00=+:00=+:00=+:00=+:00=+00=:+:+:+:+:+00=:+:++00=:++00=00=00=00=00=++++00=00=+*:*00=:+:+:++:00=00=00=+++:00=00=00=++00=00=+*-00=:+:+:+:+:+00=+00=+00=+00=+00=+00=+00=+00=:+:+:+:+:+00=00=++00=:+:+:+:+:+::++00=00=+::**+00=00=00=00=00=00=00=+++++++00=00=pv
> <                                                                                                                                                                                                                                                                                                                                                                                                                                                                r<

Try it online!

Way easier than last time.

Answer 30

><>, 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: