25
\$\begingroup\$

Given the output of the cop's program (o), the byte-count (n) and the number of unique bytes (c) used, come up with a corresponding piece of code that is n bytes long with c unique bytes which matches the cop's output o.

This is the cops thread. Post solutions that are to-be-cracked here.

The robbers thread is located here.

Cops should post solutions like this:

#[Language], `n` Bytes, `c` Unique Bytes (c*n points) [Cracked](Link-To-Crack)

    [Output]

---
    
(Optional spoiler)

Rules

  • You may not take any input for your program.
  • The program must use at least 1 byte, but cannot exceed 255 bytes.
  • The output itself is also limited to 255 bytes.
  • The program must have consistent output results when executed multiple times.
  • If your submission is not cracked within 7 days, you may mark it as "safe".
    • When marking it safe, post the intended solution and score it as c*n.
    • Only mark an answer as "safe" if you really want the +15 for an accepted answer; it's more fun to see how long you can go.

Winning

  • The uncracked post with the lowest c*n score, wins the cop's thread.
  • This will be decided after 10 safe answers, or a few weeks.

Caveats

  • If you feel cocky, you may tell the user the algorithm using a spoiler tag.

Uncracked Submissions:

fetch("https://api.stackexchange.com/2.2/questions/147635/answers?order=desc&sort=activity&site=codegolf&filter=!.Fjs-H6J36vlFcdkRGfButLhYEngU&key=kAc8QIHB*IqJDUFcjEF1KA((&pagesize=100").then(x=>x.json()).then(data=>{var res = data.items.filter(i=>!/^#.*cracked/im.test(i.body_markdown)).map(x=>{const matched = /^ ?#{1,3} ?(?:(?:(?:\[|<a href ?= ?".*?">)([^\]]+)(?:\]|<\/a>)(?:[\(\[][a-z0-9/:\.]+[\]\)])?)|([^, ]+)).*[^\d](\d+) ?\[?(?:.*(?:byte|block|codel)s?)(?:\](?:\(.+\))?)? ?(?:\(?(?!no[nt][ -]competing)\)?)?/gim.exec(x.body_markdown);if(!matched){return;}return {link: x.link, lang: matched[1] || matched[2], owner: x.owner}}).filter(Boolean).reverse().forEach(ans=>{var tr = document.createElement("tr");var add = (lang, link)=>{var td = document.createElement("td");var a = document.createElement("a");a.innerHTML = lang;a.href = link;td.appendChild(a);tr.appendChild(td);};add(ans.lang, ans.link);add(ans.owner.display_name, ans.owner.link);document.querySelector("tbody").appendChild(tr);});});
<html><body><h1>Uncracked Submissions</h1><table><thead><tr><th>Language</th><th>Author</th></tr></thead><tbody></tbody></table></body></html>

Improve this question
\$\endgroup\$
13
  • 1
    \$\begingroup\$ Are functions allowed? (Provided that they return a string, I suppose.) \$\endgroup\$
    – Arnauld
    Commented Nov 10, 2017 at 3:32
  • 1
    \$\begingroup\$ @cairdcoinheringaahing. OP has said: "The program must have consistent output results when executed multiple times." \$\endgroup\$
    – user72349
    Commented Nov 10, 2017 at 7:39
  • 5
    \$\begingroup\$ Just a suggestion for future CnRs: challenges where the user can choose an arbitrary fixed output are quite problematic for CnRs because people can basically mash their keyboard (barring syntax restrictions) and post the result, because there's no need for the cop to understand what their program is actually doing. Otherwise, this is a neat challenge idea. :) \$\endgroup\$
    – Martin Ender
    Commented Nov 10, 2017 at 8:07
  • 4
    \$\begingroup\$ @EriktheOutgolfer As I said "barring syntax restrictions". The point wasn't that you actually post a random stream of characters, but a random valid program which you don't need to understand. And especially in many esolangs, it's very easy to write a program that outputs a decent amount of random garbage without having to understand what that program does. \$\endgroup\$
    – Martin Ender
    Commented Nov 10, 2017 at 9:23
  • 1
    \$\begingroup\$ Considering that this challenge has already more than 30 answers, I suggest adding a code snippet which lists uncracked submissions like in this post. \$\endgroup\$
    – user72349
    Commented Nov 13, 2017 at 14:07

47 Answers 47

Reset to default
1
2
12
\$\begingroup\$

Haskell, 173 bytes, 8 unique, 1384 points, safe

"[tag:reverse_engineering]"

It looks like this answer wants to provide a relevant tag to the question, while using only 8 different bytes.

As usual, your solution should work by being pasted in the code block on TIO: Try it online!

Solution

'[':___':_'':_':':':__':__:__'':__:__':____:__:'_':__:___:_':_'_:___:__:__:__':_'_:___:_':']':[]
_:_:_'':_:_:_:__:_:_':_:_'_:_:_:_:_:___:_:_:_:__':____:___':_:__'':_=['_'..]

Yes, this is valid Haskell code: Try it online!

How it works

The underscore _ is used as a wild card in Haskell's pattern matching. ' is used for characters, e.g. 'a'. However, both _ and ' are also part of the allowed characters for identifier names (Within some restrictions, e.g. ' cannot occur at the beginning of the name.). Therefore __, _', _'_, _'' and so on are all valid identifier names. Using some more descriptive names, the above code becomes

'[':t:a:g:':':r:e:v:e:r:s:e:'_':e:n:g:i:n:e:e:r:i:n:g:']':[]
_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_=['_'..]

The first line yields the string "[tag:reverse_engineering]" if each variable is assigned to the correct character. This assignment is achieved in the second line: ['_'..] yields the string "_`abcdefghijklmnopqrstuvwxyz{|}~ ... ", witch is matched on the pattern _:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_ to get the desired assignment a='a', e='e' and so on.

Improve this answer
\$\endgroup\$
10
\$\begingroup\$

Brain-Flak, 62 total bytes, 6 unique, 372 points, Cracked

Here is your output:

10993592

There is something special about this number but its not on the OEIS ;)

In case you are thinking of using a computer tool to solve this, you're out of luck, the integer golfer gets 110 bytes for this number:

(((((((((((((((((((((()()()()){}){}){}){({}[()])}{}()()){})){}{}())){}{})){}{}){}){}){}())){}{}){}()){}){}){})

Try it online!

You're going to have to do this one by hand.

Tips

Here are some tips, I will reveal more an more helpful tips over time. Good luck!

10993592 is the 97th term of a sequence on OEIS, but does not appear because only a few terms are included.

My solution uses 3 loops, but they are not nested 3 levels deep.

My solution

((((((()()()){}){}){}){}){}())(({(({})[()])}{}){{({}[()])}{}})

Try it online!

This uses one of my favorite tricks, the code 

(({(({})[()])}{}){{({}[()])}{}})

computes the nth term of A090809. The full submission just pads the code with a 97 to make a large number.

Improve this answer
\$\endgroup\$
10
  • \$\begingroup\$ I can't help but notice that 10, 993 and 592 are present in PI at the decimal range 43-63... 592 is present within the first 10 too. I have no idea whether Brain-Flak could achieve that in 62 bytes though... \$\endgroup\$
    – Yytsi
    Commented Nov 10, 2017 at 12:57
  • \$\begingroup\$ ASCII mode or number mode? \$\endgroup\$
    – user202729
    Commented Nov 13, 2017 at 8:31
  • \$\begingroup\$ @user202729 I used number mode, so I would believe that robbers would need to use that too. I would be seriously surprised if this was possible in ASCII mode based on previous attempts, so it is probably not worth pursuing. \$\endgroup\$
    – Wheat Wizard ♦
    Commented Nov 13, 2017 at 19:58
  • 1
    \$\begingroup\$ @ThePirateBay I don't think "which OEIS sequence it belongs to" is always useful information, consider how esoteric Brain-flak is. It's also an element of A000027, but that observation is also useless. \$\endgroup\$
    – user202729
    Commented Nov 23, 2017 at 0:51
  • 1
    \$\begingroup\$ Cracked \$\endgroup\$
    – Riley
    Commented Nov 30, 2017 at 20:14
7
\$\begingroup\$

MATL, 6 bytes × 3 unique = 18 points. Cracked

1+0i 0+1i -1+0i 0-1i
Improve this answer
\$\endgroup\$
9
  • 2
    \$\begingroup\$ Damn you, floating point arithmetic! \$\endgroup\$
    – Stewie Griffin
    Commented Nov 10, 2017 at 10:41
  • 2
    \$\begingroup\$ @StewieGriffin I see you are having fun :-D \$\endgroup\$
    – Luis Mendo
    Commented Nov 10, 2017 at 10:56
  • \$\begingroup\$ By the way, i.^(0:3) doesn't give floating point inaccuracies in Octave, but J4:q^ does in MATL... \$\endgroup\$
    – Stewie Griffin
    Commented Nov 10, 2017 at 12:07
  • \$\begingroup\$ @StewieGriffin The difference arises because MATL's display function uses num2str(..., '%.15g '). See for example here. But that doesn't happen for MATL running on Matlab. The conclusion is that num2str works slightly differently in Matlab and in Octave \$\endgroup\$
    – Luis Mendo
    Commented Nov 10, 2017 at 12:24
  • \$\begingroup\$ Anyway, that doesn't affect this answer. The indicated output can be obtained with MATL running on Matlab and on Octave; and in particular on TIO \$\endgroup\$
    – Luis Mendo
    Commented Nov 10, 2017 at 12:26
7
\$\begingroup\$

Malbolge, 15 bytes, 13 unique, score 195. Safe!

Outputs:

PPCG

Safe! Intended code:

(&a`#""7[}4XE70

Try it online!

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ I'm certain of the procedure to crack this by building by brute force the program that outputs P and building on top of it another P, etc. Getting it to 15 probably takes advantage of the two Ps together. \$\endgroup\$
    – Joshua
    Commented Nov 17, 2017 at 17:42
  • \$\begingroup\$ Malbolge is evil. It's already too hard to write program in Malbolge, let alone crack a submission. \$\endgroup\$
    – user202729
    Commented Nov 18, 2017 at 7:47
7
\$\begingroup\$

JavaScript (ES8), 103 bytes, 42 unique (4,326 points) [SAFE]

Output hexdump:

3E 6E 6D 08 33 7A 22 7D 6C 37 7B 36 61 7B 65 71 3A 37 26 7E 7B 7B 38 7B 7D 69 6A 2B 3D 70 74 07 6F 6C 66 7E 1A 2A 3C 37 2D 36 31 38 6A 78 33 62 30 1E 34 3D 66 7B 37 10 26 6A 6A 32 27 6F 2E 33 1B 30 1E 76 27 27 7E 18 6F 68 26 2D 76 6A 6D 6D 2F 2E 0A 3F 17 7D 2B 73 7A 17 38 62 3A 29 20 0C 61 24 21 27 10 2B 20 63 71 72 17 5D 5F 12 5B 02 14 59 17 5A 11 1E 1D 10 16 07 5F 5F 58 58 4B 18 48 4B 04 5F 06 12 16 14 4D 45 5D 5D 16 3A 1C 1D 11 16 1F 51 59 4E 4B 4C 3D 16 1C 0F 2E 46 0E 08 4B 4B 13 45 21 10 06 0E 11 3F 51 57 3E 00 54 5F 49 05 0E 07 5A 51 3E 08 01 25 10 0B 51 36 43 0B 34 1A 43 47 04 46 0E 55 05 00 06 01 40 33 0F 00 53 36 42 42 45 5F 3D 3A 38 74 39 74 71 71 2C 7C 60 38 38 76 63 44 7F 64 28 66 3E 24 7A 66 57 79 24 3C 3C 21 6A 36 27 30 77 7E 36 7E 2A 3E 29

The score is abnormally big, I know, but anyway I think this one may be interesting to crack. The program is a function which returns a string (just to avoid confusion, this is not REPL).

It shouldn't be too hard, I suppose, everything is about finding the pattern.

Solution

It seems that it was harded than I had thought, according to the fact that nobody had cracked it. I believed there may be multiple solutions which are easy to craft. Anyways, here is the intended solution:

f=m=>[...m=f+f+f].map((a,p)=>p+1&256?'':String.fromCharCode((p&4?m[p^17]:a).charCodeAt^83^p*.3)).join

For some reason it is not displayed properly as code snippet. Here is the TIO link.

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ Marked as safe? \$\endgroup\$
    – user202729
    Commented Nov 17, 2017 at 10:39
  • \$\begingroup\$ @user202729. I agree, maybe the puzzle was harder than I thought, so it is now marked as safe. \$\endgroup\$
    – user72349
    Commented Nov 29, 2017 at 7:08
6
\$\begingroup\$

Jelly, 7 bytes × 6 unique = 42 points, cracked

843606888284160000

Try it online!

8!×16!¤

Improve this answer
\$\endgroup\$
5
  • 2
    \$\begingroup\$ cracked \$\endgroup\$
    – Jonathan Allan
    Commented Nov 10, 2017 at 22:57
  • \$\begingroup\$ Oh, haha I cracked it with a trailing zero by mistake! \$\endgroup\$
    – Jonathan Allan
    Commented Nov 10, 2017 at 23:18
  • \$\begingroup\$ @JonathanAllan Well, that's easily replaceable with ḷ, for example. Now it's too late I guess... \$\endgroup\$
    – Erik the Outgolfer
    Commented Nov 10, 2017 at 23:20
  • \$\begingroup\$ Well I cracked the same problem, with an unnecessary hurdle :p \$\endgroup\$
    – Jonathan Allan
    Commented Nov 10, 2017 at 23:23
  • \$\begingroup\$ @JonathanAllan Try to crack my new one if you'd like! \$\endgroup\$
    – Erik the Outgolfer
    Commented Nov 10, 2017 at 23:24
6
\$\begingroup\$

Octave, 13 bytes, 5 unique characters, score: 65. Safe!

20085918935040000

This one shouldn't be too hard. If you don't want to jump in to the most difficult ones straight away it might be a nice first challenge :)

Note: When I read the question, I though it said: Output a number, not output a string. The output looks like this on TIO:

ans =    2.0086e+16

And will look like this if you have format long

ans =  20085918935040000

or you may print it like this: 

printf('%i',ans)
20085918935040000

What I had, and explanation:

prod prodprod

Simple as that. =)

Explained:

Normally you'd write this as: prod('prodprod'), but Octave treats whatever comes after the function name as a string (array of characters). These are implicitly converted to their ASCII-values, and multiplied together.

Improve this answer
\$\endgroup\$
0
5
\$\begingroup\$

MATL, 11 bytes, 10 unique, 110 points. SAFE!

Output:

10803850202590

Just to "help" you one the way:

This is the product of:

[2, 5, 29, 89, 397, 499, 2113]

and it's one less than the 372884884433rd prime.

And here are some real tips. If it's not cracked in a few hours then I'll reveal the solution.

  1. - There's a q in there

  2. - There's a B in there

  3. - There's a ^ in there

  4. - There's a h in there

  5. - There's a t in there

The real code:

9K^ZqsBthXB

Explanation:

Push two numerals, 9 and K, and do exponentiation. Create a list of all primes below that number, and sum them. Convert to binary, duplicate the binary vector and concatenate it with itself. Convert back to decimal and output implicitly.

Improve this answer
\$\endgroup\$
0
4
\$\begingroup\$

MATL, 4 bytes, 4 unique, 16 points. Cracked

Output:

1388289520800

What I had:

1X%p
This pushes the number 1, checks which class it is, then multiplies the ASCII-values of the resulting string 'double'.

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Cracked \$\endgroup\$
    – Luis Mendo
    Commented Nov 10, 2017 at 9:29
4
\$\begingroup\$

Java 8 (full program), 97 total bytes, 34 unique, 3298 points (Cracked by @RobertoGraham)

Output:

1.4241570377303032

NOTE: This is a full program. If functions in the form of ()-> are allowed instead:

Java 8 (lambda function), 40 total bytes, 18 unique, 720 points (Cracked by @user202729)

It's probably quite hard, but whatever.. It's not like Java is going to win anything with this amount of points anyway..

Hints:

The intended code doesn't contain any single or double quotes. (The function returns a double.)
The intended code doesn't contain any digits (0-9).

Intended solution:

Pretty funny (and impressive) how both given cracks are completely different than what I had in mind, but chapeau to both of the crackers!

Function: ()->Math.log(Math.hypot(Math.PI,Math.E))
Full program: interface M{static void main(String[]a){System.out.print(Math.log(Math.hypot(Math.PI,Math.E)));}}

Improve this answer
\$\endgroup\$
8
  • \$\begingroup\$ Why do you seem to have two programs, but only one output? \$\endgroup\$
    – Okx
    Commented Nov 10, 2017 at 11:00
  • 1
    \$\begingroup\$ @Okx Because the second is a function. \$\endgroup\$
    – Erik the Outgolfer
    Commented Nov 10, 2017 at 11:16
  • \$\begingroup\$ @Okx As Erik mentioned, because they are both the same. The top as a program, bottom as a function. I'm still waiting for Arnauld's comment to be answered so I can remove one of the two.. \$\endgroup\$
    – Kevin Cruijssen
    Commented Nov 10, 2017 at 12:31
  • \$\begingroup\$ So close, a straightforward printing of the string is the right length but two uniques too many :-) – actually, 1 if you don't count the newline… \$\endgroup\$
    – Kevin
    Commented Nov 11, 2017 at 19:10
  • 1
    \$\begingroup\$ Unintended solution (function) with correct counts \$\endgroup\$
    – user202729
    Commented Nov 16, 2017 at 6:14
3
\$\begingroup\$

Haskell, 10 bytes, 3 unique, 30 points, cracked

2416508937

A nice number which contains every digit, though only 3 unique bytes are used.

The intended solution works by replacing the code part in the following TIO link: Try it online!

Improve this answer
\$\endgroup\$
2
  • 2
    \$\begingroup\$ Cracked! \$\endgroup\$
    – H.PWiz
    Commented Nov 10, 2017 at 19:52
  • \$\begingroup\$ @H.PWiz I didn't expect it to last long, but this was nevertheless very quick. I expected (or at least hoped) robbers would try arithmetic solutions first. \$\endgroup\$
    – Laikoni
    Commented Nov 10, 2017 at 19:58
3
\$\begingroup\$

Haskell, 29 bytes, 15 unique bytes, 435 points, cracked

"33333333333333333333333333333333333333333333334333333333333333333333333333"

This is a string containing 3 73 times, and a single sneaky 4.

The intended solution works by replacing the code part in the following TIO link: Try it online!

Edit: H.PWiz found a valid crack (which could even be golfed to 28 bytes), but not the intended solution.

Hints:

No arithmetic needed. There exists a single-expression solution.

Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Cracked \$\endgroup\$
    – H.PWiz
    Commented Nov 13, 2017 at 0:35
3
\$\begingroup\$

Mathematica, 8 bytes, 3 unique, 24 points Cracked

7448503425106854065710345345644475127957406351360000000
Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Cracked. \$\endgroup\$
    – user202729
    Commented Nov 13, 2017 at 9:06
3
\$\begingroup\$

Explode, 9 total bytes, 4 unique, 36 points

Output:

22k2Dk}D}

Note that the documentation does not completely align with the implementation for this language - I wrote this one day and haven't touched it since, so any bugs in implementation that may exist are now definitely features.

Also, I do not think this language is Turing-complete, so you could probably brute force it, but that's boring.

I'll give you a sizable bounty if you can automate reverse-engineering output into optimally short Explode code.

Improve this answer
\$\endgroup\$
7
  • \$\begingroup\$ The score of your code is 36 right? The output would score 36 points too, so I'm just making sure it's not a mistake. :) \$\endgroup\$
    – Stewie Griffin
    Commented Nov 10, 2017 at 9:02
  • \$\begingroup\$ @StewieGriffin yep, because when I first read the question I misread it and thought the code had to be the same length as the output. \$\endgroup\$
    – Stephen
    Commented Nov 10, 2017 at 13:40
  • \$\begingroup\$ How short should "golfed Explode code" be? \$\endgroup\$
    – user202729
    Commented Nov 13, 2017 at 10:14
  • \$\begingroup\$ @user202729 sorry, I should have explained - optimally short Explode code, since it's completely deterministic \$\endgroup\$
    – Stephen
    Commented Nov 13, 2017 at 13:59
  • \$\begingroup\$ But the problem is people may write brute-force code to found the output "in theory", but is impractical in practice. \$\endgroup\$
    – user202729
    Commented Nov 13, 2017 at 14:06
3
\$\begingroup\$

Jelly, 8 bytes, 2 unique, 8×2 = 16 points -- Safe!

-4.408500694095235e-05

(There are only 8,355,840 possible such programs so it should get cracked I guess.)

Get going at Try it online!

How?

⁽⁽°°°°°°
⁽⁽° is a base 250 literal yielding -27221
° converts from radians to degrees. Applying this five times:
-475.09607568537643
-8.291990784013993
-0.1447225407260702
-0.0025258848375215096
-4.408500694095235e-05

Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ Nice! Originally I think some double-byte may be related here, but then I dismissed it. I also considered °, but didn't think about ⁾ and thought you have to stick with starting from 0. \$\endgroup\$
    – user202729
    Commented Nov 19, 2017 at 9:52
  • \$\begingroup\$ @user202729 ⁽ is different from ⁾, they're not related in any way (except that they consume the two chars that follow). \$\endgroup\$
    – Erik the Outgolfer
    Commented Nov 20, 2017 at 11:30
  • \$\begingroup\$ @EriktheOutgolfer Sorry, I just mistyped the characters. I meant ⁽. \$\endgroup\$
    – user202729
    Commented Nov 20, 2017 at 11:31
3
\$\begingroup\$

C (two's complement machine, sizeof(int) = 4), 76 bytes and 35 unique bytes for a score of 2660, Safe

Output: 

10542949672924294967287429496729029742949672954294967287429496728808914294967289429496728742949672946944294967291429496728742949672914964294967294429496728742949672891980429496728842949672874294967295792

which is 203 bytes long.

#include<math.h>
main(){for(int
i=0;i<40;i++)printf("%u",(int)(cos(i)*10));}

Without the #include it won't work.

Improve this answer
\$\endgroup\$
6
  • \$\begingroup\$ Can we use some compiler-specific features like in gcc? \$\endgroup\$
    – user72349
    Commented Nov 13, 2017 at 0:14
  • 1
    \$\begingroup\$ @ThePirateBay: I didn't. \$\endgroup\$
    – Joshua
    Commented Nov 13, 2017 at 0:47
  • 1
    \$\begingroup\$ I found an interesting approach but I couldn't golf out the last byte, so I just post it here. main(i){for(;42>i;printf("%u","eirwtlegowvnfemuwphejsno"[abs(24-i++)]-'n'));} \$\endgroup\$
    – Colera Su
    Commented Nov 13, 2017 at 3:44
  • \$\begingroup\$ @ColeraSu Probably you can switch from lowercase to uppercase and change 'N' to 78 (char code of N). \$\endgroup\$
    – user202729
    Commented Nov 13, 2017 at 8:53
  • \$\begingroup\$ @user202729 but it would not fit the restriction of 35 unique bytes. \$\endgroup\$
    – Colera Su
    Commented Nov 13, 2017 at 9:03
3
\$\begingroup\$

CJam, 15 bytes * 10 unique = 150 points

453630781352162854505467929721140132016201833205823402832306035643819420004950

Bad score, but hopefully will be hard to crack.

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.

Improve this answer
\$\endgroup\$
7
  • \$\begingroup\$ Double answered :P flagged to be removed \$\endgroup\$
    – user63187
    Commented Nov 21, 2017 at 0:39
  • 1
    \$\begingroup\$ @Christopher2EZ4RTZ What do you mean? These are two separate answers with the same score breakdown, but different outputs. \$\endgroup\$
    – Esolanging Fruit
    Commented Nov 21, 2017 at 1:26
  • \$\begingroup\$ Oh wow my bad. XD \$\endgroup\$
    – user63187
    Commented Nov 21, 2017 at 19:39
  • \$\begingroup\$ Ahaha... you, sir, must be a cop that's 2 days from retirement forgetting the answer like that ;P \$\endgroup\$
    – Magic Octopus Urn
    Commented Mar 2, 2018 at 17:57
  • \$\begingroup\$ @MagicOctopusUrn Now I've retired, and have no interest in this anymore... \$\endgroup\$
    – Esolanging Fruit
    Commented Mar 2, 2018 at 19:43
3
\$\begingroup\$

CJam, 15 bytes * 10 unique = 150 points

355605126761554652609272416635107412217265861355621217687464016216276447790261274709847680

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Octave, 4 bytes, 3 unique, 12 points: cracked

1.6776e-05

Lets see how fast this one goes.

Improve this answer
\$\endgroup\$
2
  • 3
    \$\begingroup\$ Cracked \$\endgroup\$
    – Luis Mendo
    Commented Nov 10, 2017 at 23:34
  • \$\begingroup\$ @LuisMendo that would be the one. \$\endgroup\$
    – Tom Carpenter
    Commented Nov 11, 2017 at 8:48
2
\$\begingroup\$

Pyth, 7 bytes, 6 unique, 7*6=42 total score

312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596

Check out the Pyth tips thread for inspiration ;)

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Jelly, 3 bytes × 3 unique = 9 points, cracked

263409560461970212832400

Try it online!

Another attempt at Jelly, this time more challenging I hope.

ȷc⁵

Improve this answer
\$\endgroup\$
2
  • 1
    \$\begingroup\$ cracked \$\endgroup\$
    – Jonathan Allan
    Commented Nov 10, 2017 at 23:54
  • \$\begingroup\$ @JonathanAllan With my intended solution this time :p I guess it was too easy to brute-force right? There were obviously only 2763520 possible solutions...and, ironically, you use the same function to calculate this number as well as the number to be cracked. \$\endgroup\$
    – Erik the Outgolfer
    Commented Nov 11, 2017 at 8:41
2
\$\begingroup\$

Alice, 9 bytes x 8 unique = 72 points Cracked

KMOQSUWY[]_acegikmoqsuwusqomkigecegikmoqsuwy

Try it online!

This one should be funny to crack

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Cracked \$\endgroup\$
    – Nitrodon
    Commented Nov 13, 2017 at 6:21
2
\$\begingroup\$

Excel, 22 bytes, 16 unique, 352 points, Cracked

หนึ่งล้านห้าแสนสามหมื่นสองพันสี่ร้อยเก้าสิบห้าล้านห้าแสนสี่หมื่นแปดร้อยหกสิบห้าล้านแปดแสนเก้าหมื่นล้านล้านล้านล้านล้านล้านบาทถ้วน

This might not be very hard to crack but I get to use a function that I otherwise never get to use. Besides, the score won't win anything unless a lot of others get cracked.

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ cracked. Probably not your original code, but it works. \$\endgroup\$
    – wythagoras
    Commented Nov 12, 2017 at 13:42
2
\$\begingroup\$

PowerShell, 7 bytes, 5 unique = 35 points Cracked

Output:

1125899906842624
Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Jelly, 8 bytes * 6 unique = 48 (Cracked)

241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916

You can try to crack it here.

Intended solution: 7ẋ²Ḍ²ẋ4S

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ Partial answer (repeating pattern) \$\endgroup\$
    – user202729
    Commented Nov 13, 2017 at 9:46
  • \$\begingroup\$ @JonathanAllan Your crack is invalid, sorry (it doesn't print the correct result). You can see the difference here \$\endgroup\$
    – Mr. Xcoder
    Commented Nov 14, 2017 at 19:36
  • \$\begingroup\$ @JonathanAllan Heh, tried to solve another challenge at the same time (look at the arguments! :P) \$\endgroup\$
    – Mr. Xcoder
    Commented Nov 14, 2017 at 19:55
  • 1
    \$\begingroup\$ @JonathanAllan Nice, I added the intended solution in my answer too :D \$\endgroup\$
    – Mr. Xcoder
    Commented Nov 14, 2017 at 19:56
2
\$\begingroup\$

Haskell, 30 bytes, 17 unique, 510 points, cracked

"6666666444444455666666666566555533333334333333333"

The intended solution works by replacing the code part in the following TIO link: Try it online!

This uses the same approach as my previous answer, which was cracked using a different approach.

Some hints:

No arithmetic needed. I have a single-expression solution.

Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Cracked \$\endgroup\$
    – lynn
    Commented Nov 14, 2017 at 22:56
2
\$\begingroup\$

Javascript, 11 Bytes, 7 Unique Bytes (77 points) (Cracked)

0.022522522522522525

lambda function declaration included in byte count, function call is not.

This should be really easy.

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Fixed cracked with the help of @Milk \$\endgroup\$
    – Arnauld
    Commented Nov 10, 2017 at 22:54
2
\$\begingroup\$

Jelly, 4 bytes, 4 unique, 4 × 4 = 16 points -- Safe!

121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880

Note that the output is 255 bytes long, right at the limit.

Yep, same score as my other (as yet uncracked) Jelly entry.

Get going at Try it online!

How?

7ÆĊ⁺
7 is a literal seven
ÆĊ gets the nth Catalan number
the 7th Catalan number is 429
⁺ repeats the previous atom
the 429th Catalan number is 121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880.

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ My partial solution (very long) \$\endgroup\$
    – user202729
    Commented Nov 14, 2017 at 3:55
  • \$\begingroup\$ 72 bytes is a little long, yes. You could remove the spaces (62). Also you could use vectorised r between two code-page index lists and concatenate with another code-page index list to get it down to 35 bytes, but there are also still repeated bytes there and 35 >> 4... good luck! \$\endgroup\$
    – Jonathan Allan
    Commented Nov 14, 2017 at 8:13
2
\$\begingroup\$

Perl 5, 31 Bytes, 18 Unique Bytes (558 points) -- safe

1.76295255109024e+180

Intended solution (Try it online!):

$_=1;for$=(1..111){$_*=$=}print

(this calculates the factorial of 111)

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

Haskell, 37 bytes, 20 unique, 740 points, safe

The answer is an expression whose result equals the string literal:

"4F\\DLE\\C\"S\\T \\\\DC$EO!RUr\\K\\SSS1\\%S\\\\AN\\D&CDI#3SSC\\\\\\E\\C\\YC\\USB2SNN\\ED'\""

(That is, when putStr’d, you’d get:)

4F\DLE\C"S\T \\DC$EO!RUr\K\SSS1\%S\\AN\D&CDI#3SSC\\\E\C\YC\USB2SNN\ED'"

Safe! Intended expression:

[show['\r'..]!!rem(w^7)77|w<-[7..77]]
Improve this answer
\$\endgroup\$
1
2

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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