23
\$\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>

\$\endgroup\$
  • 1
    \$\begingroup\$ Are functions allowed? (Provided that they return a string, I suppose.) \$\endgroup\$ – Arnauld Nov 10 '17 at 3:32
  • 1
    \$\begingroup\$ @cairdcoinheringaahing. OP has said: "The program must have consistent output results when executed multiple times." \$\endgroup\$ – user72349 Nov 10 '17 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 Nov 10 '17 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 Nov 10 '17 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 Nov 13 '17 at 14:07

46 Answers 46

11
\$\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.

\$\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.

\$\endgroup\$
  • \$\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 Nov 10 '17 at 12:57
  • \$\begingroup\$ ASCII mode or number mode? \$\endgroup\$ – user202729 Nov 13 '17 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 Nov 13 '17 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 Nov 23 '17 at 0:51
  • 1
    \$\begingroup\$ Cracked \$\endgroup\$ – Riley Nov 30 '17 at 20:14
7
\$\begingroup\$

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

1+0i 0+1i -1+0i 0-1i
\$\endgroup\$
  • 2
    \$\begingroup\$ Damn you, floating point arithmetic! \$\endgroup\$ – Stewie Griffin Nov 10 '17 at 10:41
  • 2
    \$\begingroup\$ @StewieGriffin I see you are having fun :-D \$\endgroup\$ – Luis Mendo Nov 10 '17 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 Nov 10 '17 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 Nov 10 '17 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 Nov 10 '17 at 12:26
6
\$\begingroup\$

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

843606888284160000

Try it online!

8!×16!¤

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

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

Outputs:

PPCG

Safe! Intended code:

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

Try it online!

\$\endgroup\$
  • \$\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 Nov 17 '17 at 17:42
  • \$\begingroup\$ Malbolge is evil. It's already too hard to write program in Malbolge, let alone crack a submission. \$\endgroup\$ – user202729 Nov 18 '17 at 7:47
6
\$\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.

\$\endgroup\$
  • \$\begingroup\$ Marked as safe? \$\endgroup\$ – user202729 Nov 17 '17 at 10:39
  • \$\begingroup\$ @user202729. I agree, maybe the puzzle was harder than I thought, so it is now marked as safe. \$\endgroup\$ – user72349 Nov 29 '17 at 7:08
5
\$\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.

\$\endgroup\$
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'.

\$\endgroup\$
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)));}}

\$\endgroup\$
  • \$\begingroup\$ Why do you seem to have two programs, but only one output? \$\endgroup\$ – Okx Nov 10 '17 at 11:00
  • 1
    \$\begingroup\$ @Okx Because the second is a function. \$\endgroup\$ – Erik the Outgolfer Nov 10 '17 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 Nov 10 '17 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 Nov 11 '17 at 19:10
  • 1
    \$\begingroup\$ Unintended solution (function) with correct counts \$\endgroup\$ – user202729 Nov 16 '17 at 6:14
4
\$\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.

\$\endgroup\$
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!

\$\endgroup\$
  • 2
    \$\begingroup\$ Cracked! \$\endgroup\$ – H.PWiz Nov 10 '17 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 Nov 10 '17 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.

\$\endgroup\$
  • 1
    \$\begingroup\$ Cracked \$\endgroup\$ – H.PWiz Nov 13 '17 at 0:35
3
\$\begingroup\$

Mathematica, 8 bytes, 3 unique, 24 points Cracked

7448503425106854065710345345644475127957406351360000000
\$\endgroup\$
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.

\$\endgroup\$
  • \$\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 Nov 10 '17 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 Nov 10 '17 at 13:40
  • \$\begingroup\$ How short should "golfed Explode code" be? \$\endgroup\$ – user202729 Nov 13 '17 at 10:14
  • \$\begingroup\$ @user202729 sorry, I should have explained - optimally short Explode code, since it's completely deterministic \$\endgroup\$ – Stephen Nov 13 '17 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 Nov 13 '17 at 14:06
3
\$\begingroup\$

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

1.6776e-05

Lets see how fast this one goes.

\$\endgroup\$
  • 3
    \$\begingroup\$ Cracked \$\endgroup\$ – Luis Mendo Nov 10 '17 at 23:34
  • \$\begingroup\$ @LuisMendo that would be the one. \$\endgroup\$ – Tom Carpenter Nov 11 '17 at 8:48
2
\$\begingroup\$

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

312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596

Check out the Pyth tips thread for inspiration ;)

\$\endgroup\$
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⁵

\$\endgroup\$
  • 1
    \$\begingroup\$ cracked \$\endgroup\$ – Jonathan Allan Nov 10 '17 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 Nov 11 '17 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

\$\endgroup\$
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.

\$\endgroup\$
  • \$\begingroup\$ cracked. Probably not your original code, but it works. \$\endgroup\$ – wythagoras Nov 12 '17 at 13:42
2
\$\begingroup\$

PowerShell, 7 bytes, 5 unique = 35 points Cracked

Output:

1125899906842624
\$\endgroup\$
2
\$\begingroup\$

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

241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916

You can try to crack it here.

Intended solution: 7ẋ²Ḍ²ẋ4S

\$\endgroup\$
  • \$\begingroup\$ Partial answer (repeating pattern) \$\endgroup\$ – user202729 Nov 13 '17 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 Nov 14 '17 at 19:36
  • \$\begingroup\$ @JonathanAllan Heh, tried to solve another challenge at the same time (look at the arguments! :P) \$\endgroup\$ – Mr. Xcoder Nov 14 '17 at 19:55
  • 1
    \$\begingroup\$ @JonathanAllan Nice, I added the intended solution in my answer too :D \$\endgroup\$ – Mr. Xcoder Nov 14 '17 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.

\$\endgroup\$
  • 1
    \$\begingroup\$ Cracked \$\endgroup\$ – Lynn Nov 14 '17 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.

\$\endgroup\$
  • \$\begingroup\$ Fixed cracked with the help of @Milk \$\endgroup\$ – Arnauld Nov 10 '17 at 22:54
2
\$\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

\$\endgroup\$
  • \$\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 Nov 19 '17 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 Nov 20 '17 at 11:30
  • \$\begingroup\$ @EriktheOutgolfer Sorry, I just mistyped the characters. I meant . \$\endgroup\$ – user202729 Nov 20 '17 at 11:31
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.

\$\endgroup\$
  • \$\begingroup\$ My partial solution (very long) \$\endgroup\$ – user202729 Nov 14 '17 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 Nov 14 '17 at 8:13
2
\$\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.

\$\endgroup\$
  • \$\begingroup\$ Can we use some compiler-specific features like in gcc? \$\endgroup\$ – user72349 Nov 13 '17 at 0:14
  • 1
    \$\begingroup\$ @ThePirateBay: I didn't. \$\endgroup\$ – Joshua Nov 13 '17 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 Nov 13 '17 at 3:44
  • \$\begingroup\$ @ColeraSu Probably you can switch from lowercase to uppercase and change 'N' to 78 (char code of N). \$\endgroup\$ – user202729 Nov 13 '17 at 8:53
  • \$\begingroup\$ @user202729 but it would not fit the restriction of 35 unique bytes. \$\endgroup\$ – Colera Su Nov 13 '17 at 9:03
2
\$\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.

\$\endgroup\$
  • \$\begingroup\$ Double answered :P flagged to be removed \$\endgroup\$ – Christopher Nov 21 '17 at 0:39
  • \$\begingroup\$ @Christopher2EZ4RTZ What do you mean? These are two separate answers with the same score breakdown, but different outputs. \$\endgroup\$ – Esolanging Fruit Nov 21 '17 at 1:26
  • \$\begingroup\$ Oh wow my bad. XD \$\endgroup\$ – Christopher Nov 21 '17 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 Mar 2 '18 at 17:57
  • \$\begingroup\$ @MagicOctopusUrn Now I've retired, and have no interest in this anymore... \$\endgroup\$ – Esolanging Fruit Mar 2 '18 at 19:43
2
\$\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.

\$\endgroup\$
2
\$\begingroup\$

Japt, 5 bytes, 5 unique bytes (25 points) (Cracked by Scrooble)

Output: 3628801

\$\endgroup\$
  • \$\begingroup\$ Cracked \$\endgroup\$ – Khuldraeseth na'Barya Nov 10 '17 at 22:06
  • \$\begingroup\$ @Scrooble, not the intended solution but nicely done. Will update as cracked when I get back to a computer. I'm thinking now the 4 byte version I had might have been a bit trickier, may yet post it. \$\endgroup\$ – Shaggy Nov 10 '17 at 22:51
  • \$\begingroup\$ What was the intended solution? \$\endgroup\$ – Khuldraeseth na'Barya Feb 28 '18 at 22:07
1
\$\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)

\$\endgroup\$

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.