39
\$\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
  • 5
    \$\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

137 Answers 137

1 2 3 4
5
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\$
1
\$\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
  • 3
    \$\begingroup\$ What answer does this crack? \$\endgroup\$
    – Grain Ghost
    Sep 8 at 15:56
1
\$\begingroup\$

Vyxal O, 707126 bytes, cracks EmanresuA's seventh (yes, seventh) 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⟩LkA≬\D<ṡ∷∷Ė

Full code

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

Vyxal O, 299195 bytes, cracks EmanresuA's eigth answer

Sample:

×ǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏǏLkA√y$_y_y_y_Ė

Full code

...

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

Vyxal O, 801294 bytes, cracks EmanresuA's ninth answer

Sample:

¶ḃʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLʀLkA‛ABo↓ǐĖ

Full code (ignore the file name it's a very unfunny joke)

Yes.

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

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.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Bruh you could get around -1000000 bytes by using instead of ꜝ?rL. get golf'd baka \$\endgroup\$ Sep 27 at 19:34
  • \$\begingroup\$ @AaronMiller the whole point is that I answer these in the most inefficient and convoluted way possible \$\endgroup\$
    – lyxal
    Sep 27 at 23:25
1
\$\begingroup\$

Vyxal, 1606416 bytes, cracks lyxal's answer

Sample:

εuεuεuεuuεuεuεuεuε\‛§εḭĖ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εuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuεuuεuεuεuεuε\‛§εḭĖĖuuε

Full code

Generator program

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

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!

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

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

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

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

\$\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\$
1 2 3 4
5

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.