36
\$\begingroup\$

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.

\$\endgroup\$
1
  • 4
    \$\begingroup\$ 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. \$\endgroup\$
    – Dingus
    Aug 20 '20 at 3:22

114 Answers 114

1 2 3
4
1
\$\begingroup\$

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.

\$\endgroup\$
1
  • \$\begingroup\$ Hats off to you for thwarting me at every attempt. This has been fun. I've posted my code in the cops thread. \$\endgroup\$
    – Dingus
    Aug 1 '20 at 14:12
1
\$\begingroup\$

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: https://scastie.scala-lang.org/Sthw2Vr7QG26mbMHQuirkg


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.

\$\endgroup\$
6
  • \$\begingroup\$ Nice job with “using”! Didn’t think of it (I used @main). Also, you don’t need object Main \$\endgroup\$
    – user
    Aug 4 '20 at 0:19
  • 1
    \$\begingroup\$ @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/… \$\endgroup\$ Aug 4 '20 at 0:20
  • 2
    \$\begingroup\$ 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? :/ \$\endgroup\$
    – user
    Aug 4 '20 at 0:50
  • \$\begingroup\$ @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.) \$\endgroup\$ Aug 4 '20 at 1:01
  • 1
    \$\begingroup\$ @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 :( \$\endgroup\$ Aug 4 '20 at 7:56
1
\$\begingroup\$

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

\$\endgroup\$
1
  • \$\begingroup\$ See new challenge! \$\endgroup\$
    – null
    Aug 12 '20 at 6:41
1
\$\begingroup\$

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

\$\endgroup\$
1
  • 1
    \$\begingroup\$ OK, you win. The new challenge is even more inconvenient... \$\endgroup\$
    – null
    Aug 12 '20 at 7:51
1
\$\begingroup\$

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

\$\endgroup\$
5
  • 1
    \$\begingroup\$ Not the intended solution... a fourth one \$\endgroup\$
    – null
    Aug 12 '20 at 8:07
  • \$\begingroup\$ @HighlyRadioactive okay then. \$\endgroup\$
    – lyxal
    Aug 12 '20 at 8:08
  • \$\begingroup\$ My intended solutions are much terser than yours... That is, no whitespaces, no repeating code, well golfed. \$\endgroup\$
    – null
    Aug 12 '20 at 8:10
  • 2
    \$\begingroup\$ We're not here for golf though. We're here to crack answers. \$\endgroup\$
    – lyxal
    Aug 12 '20 at 8:18
  • \$\begingroup\$ Just sayin'. (f chars) \$\endgroup\$
    – null
    Aug 12 '20 at 8:19
1
\$\begingroup\$

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

\$\endgroup\$
3
  • \$\begingroup\$ Right, that's the intended answer. Round 6. (It lasted a whole 7 minutes!) \$\endgroup\$
    – null
    Aug 12 '20 at 8:34
  • \$\begingroup\$ @HighlyRadioactive round 6 will be my last for today. I'll do more tomorrow after that. \$\endgroup\$
    – lyxal
    Aug 12 '20 at 8:35
  • \$\begingroup\$ 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... \$\endgroup\$
    – null
    Aug 12 '20 at 8:36
1
\$\begingroup\$

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

enter image description here

\$\endgroup\$
13
  • 2
    \$\begingroup\$ 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 \$\endgroup\$
    – null
    Aug 13 '20 at 4:45
  • \$\begingroup\$ @HighlyRadioactive asking doesn't equate to solid rules. \$\endgroup\$
    – lyxal
    Aug 13 '20 at 4:46
  • \$\begingroup\$ Command line flags count as different languages -- also OP \$\endgroup\$
    – Dingus
    Aug 13 '20 at 4:47
  • 1
    \$\begingroup\$ @Dingus which indicates this answer is not written in ><> and is thus invalid \$\endgroup\$
    – null
    Aug 13 '20 at 4:48
  • 3
    \$\begingroup\$ Then that one's not acceptable too \$\endgroup\$
    – null
    Aug 13 '20 at 4:57
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
1
  • \$\begingroup\$ nEFrErEFrEFrEFrEFrEFrEynFrLErLErLErLErLErLErLErLErLErLErLErL is shorter, but this isn't code golf \$\endgroup\$
    – PkmnQ
    Nov 6 '20 at 10:11
1
\$\begingroup\$

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)
luaify = ->(s) { s.bytes.map{|b|"_G[([[string]])][string.lower([[CHAR]])](string.len([[#{'.'*b}]]))"}*'..' }
print "io.write(#{luaify[X]})"

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ let me fix that ASAP :D \$\endgroup\$
    – LuaNoob
    Feb 7 at 17:09
1
\$\begingroup\$

Forth (gforth), 13 bytes, cracks binarycat's challenge

.\"0x0B\x20\t\n"

Try it online!

This also happens to be my first Forth program. 😃

Explanation

It is really simple. I use .\" which allows me to use C-style escapes, and then I use a vertical tab (0x0B) to delimit the tokens, as Gforth uses the same whitespace rules as isspace(). The rest is just writing everything in C escapes.

\$\endgroup\$
1
\$\begingroup\$

Rattle, 48 bytes, cracks @DanielH.'s answer

+4*4*7,%=+4*7+7+7+++,+7+7,%=+7+7++b*7b**7b*b*7bB

Try it online!

Pretty straightforward: push a bunch of values to the stack, then either print them as characters (,) or concatenate them to the print buffer (b) as floats. I use %= (modulo with top of stack) to reset the stack.

\$\endgroup\$
2
  • \$\begingroup\$ This is awesome - this is the first answer (that I know of) by a user other than myself in Rattle! By the way, the default argument for the = command is 0, so you can actually remove the % \$\endgroup\$
    – Daniel H.
    Feb 11 at 5:13
  • 1
    \$\begingroup\$ @DanielH. I found it pretty easy to get up and running (albeit only doing really basic stuff). Looks like an interesting language. \$\endgroup\$
    – Dingus
    Feb 11 at 6:24
1
\$\begingroup\$

Dis, 47 bytes, cracks @tailsparkrabbitear's answer

*|||_________________________________________>!

Try it online! Link compiles and runs a copy of Ben Olmstead's interpreter in C.

Explanation

We make use of self-modifying code to execute the banned print instruction.

*|||                                         >  # set the accumulator to 123; also store 123 in cell 45
    _________________________________________   # no-ops
                                             >  # execute cell 45 (modified to codepoint 123), i.e. print accumulator as ASCII character
                                              ! # terminate
\$\endgroup\$
1
  • \$\begingroup\$ Great that it's shorter than my original answer! \$\endgroup\$ Jul 23 at 3:45
1
\$\begingroup\$

Javastack, cracks AUsername's sixth answer

((alphabet length not not) * 1234567890) (add * 1234567889) quote add alphabet alphabet length not not double index add alphabet (alphabet length not not * 17) (add * 16) index add alphabet (alphabet length not not * 18) (add * 17) index add 

Yeah this was way easier than last year's round 6. All I had to do was just change the answer to round 5. ;P

\$\endgroup\$
1
\$\begingroup\$

Javastack, cracks Enamresu A's twelfth answer

"abcegiln" "a" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop swap pop swap pop swap pop swap pop replace "b" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop pop pop pop replace "c" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop pop swap pop swap pop replace "e" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop swap pop swap pop swap pop swap pop swap pop replace "g" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop swap pop swap pop swap pop swap pop swap pop swap pop replace "i" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop swap pop swap pop swap pop replace "l" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate swap pop swap pop swap pop swap pop swap pop swap pop swap pop replace "n" ascii "0" "" replace "1" "" replace "2" "" replace "3" "" replace "4" "" replace "5" "" replace "6" "" replace "7" "" replace "8" "" replace "9" "" replace "a" "" replace "b" "" replace "c" "" replace "e" "" replace "g" "" replace "i" "" replace "l" "" replace "n" "" replace "o" "" replace "p" "" replace "q" "" replace "r" "" replace "s" "" replace "t" "" replace "w" "" replace "x" "" replace "y" "" replace "z" "" replace "A" "" replace "B" "" replace "C" "" replace "D" "" replace "E" "" replace "F" "" replace "G" "" replace "H" "" replace "I" "" replace "J" "" replace "K" "" replace "L" "" replace "M" "" replace "N" "" replace "O" "" replace "P" "" replace "Q" "" replace "R" "" replace "S" "" replace "T" "" replace "U" "" replace "V" "" replace "W" "" replace "X" "" replace "Y" "" replace "Z" "" replace "!" "" replace "~" "" replace " " "" replace "#" "" replace "&" "" replace "%" "" replace "'" "" replace "/" "" replace ":" "" replace "@" "" replace iterate pop pop pop pair pair pair pair pair pair pair swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop swap pop iterate iterate iterate iterate iterate iterate iterate pop pop pop pop pop pop swap pop replace

... 10526 bytes. This one was suffering.

\$\endgroup\$
1
\$\begingroup\$

Javastack, cracks Enamresu A eighth answer

zpake zpake equal "" add "" ceil index  
zpake zpake equal "" add (1) index add
(111) zpake zpake equal "" add (1) index "cha" add eval add
(115) zpake zpake equal "" add (1) index "cha" add eval add
(98) zpake zpake equal "" add (1) index "cha" add eval add
(103) zpake zpake equal "" add (1) index "cha" add eval add
(1234567890) add

For clarity:

zpake ceil zpake ceil equal = 1
(zpake ceil zpake ceil equal * n)(add * n - 1) = n

JavaScript abuse ftw

\$\endgroup\$
1
  • \$\begingroup\$ This is exactly what I had, pretty much. Nice job, this is beautiful. \$\endgroup\$
    – emanresu A
    Aug 8 at 4:08
1
\$\begingroup\$

Javastack, cracks Enamresu A's seventh (yes, seventh) answer

((alphabet length alphabet length divide) * 1234567890) (add * 1234567889)
alphabet (4) index alphabet (19) index add alphabet (14) index add alphabet (20) index add alphabet (16) index add eval add
alphabet (2) index add
alphabet (position of r in the alphabet) index add
alphabet (position of s in the alphabet) index add
alphabet (position of y in the alphabet) index add
alphabet (position of o in the alphabet) index add

Replace numbers in brackets ((n)) with (alphabet length alphabet length divide) * n (add * n - 1)

Do you see how I put seventh in italics? That's an ode to the fact that this isn't my first time reaching round 7 of a match.

\$\endgroup\$
1
\$\begingroup\$

Javastack, cracks Enamresu A's fifth answer

((maybe length not) * 1234567890) (add * 1234567889) quote add alphabet maybe length not double index add alphabet (maybe length not * 17) (add * 16) index add alphabet (maybe length not * 18) (add * 17) index add 

Traditionally, the next round is the one where I actually have to think for a while. Here's hoping I don't.

\$\endgroup\$
1
\$\begingroup\$

Javastack, cracks Enamresu A's fourth answer

not times context (increment * 1234567890) context (increment * 34) char context (increment * ascii value of "q") pair context (increment * ascii value of "d") join context (increment * ascii value of "l") pair context (increment * ascii value of "w") join pair sum

Vyxal features ftw.

That's enough for today.

\$\endgroup\$
1
\$\begingroup\$

Javastack, cracks Enamresu A's third answer

not increment * 1234567889 flatprint not increment * (ascii value of " - 1) char flatprint not increment * (ascii value of d - 1) flatprint not increment * (ascii value of w - 1) flatprint not increment * (ascii value of q - 1) flatprint

H...hey actually give me time to actually write a post please!

\$\endgroup\$
1
\$\begingroup\$

Javastack, cracks AUsername's thirteenth answer

107 char 100 char 115 char 109 char 117 char 106 char 118 char 102 char 98 char wrap 1 repeat "," "" replace

Sussy baka

\$\endgroup\$
0
\$\begingroup\$

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

\$\endgroup\$
1
  • \$\begingroup\$ Yep. Let's move on. \$\endgroup\$
    – null
    Aug 13 '20 at 3:52
0
\$\begingroup\$

APL (Dyalog Unicode), 81 bytes, cracks Ada's answer

∆←⍎'⎕A',22⊃⎕A
⎕←(25↑66↓∆),(26↑17↓∆),(97⊃∆),⍕2+1

Try it online!

This was pretty easy. ⎕A is our escape hatch - it's the list of all 26 capital letters in the English alplhabet. We want ⎕AV, a string containing all the letters Unicode APL uses. 22⊃⎕A gets the 22nd element of ⎕A ("V"), and we append that to the string '⎕A' and execute it to get the value of ⎕AV. That is assigned to a variable .

\$\endgroup\$
0
\$\begingroup\$

x86-16 machine code (DOS) - 9 bytes

B0 3C    MOV     AL, 3CH
D1 E0    SHL     AX, 1
34 20    XOR     AL, 20H
CD 29    INT     29H
C3       RET
\$\endgroup\$
1
  • 2
    \$\begingroup\$ What answer does this crack? \$\endgroup\$
    – Wheat Wizard
    Sep 8 at 15:56
1 2 3
4

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.