From code to golf (Cops' thread)

Question

This is a cops-and-robbers challenge, the robbers' thread is here

You can change the word code into golf by changing a letter at a time in four steps:

CODE
COLE
COLD
GOLD
GOLF

Today, we’ll be doing the same thing with programs.

Your challenge is to:

• choose a programming language
• write two programs / functions, one that outputs code and one that outputs golf
• Such that you can repeatedly change a single character and get a program that outputs an English word until you get to the golf program.
• Share the code program and the number of times you need to change a character, but not any of the intermediate programs or the golf program, which robbers will try to discover.
• No two programs can output the same word.

For example, if the program abcde outputs code in a certain language, and the program abcdf outputs potato, then changing that e to an f is a valid step.

And if the program aqcdf outputs golf, then abcde -> abcdf -> aqcdf is a valid chain in which you change a character twice.

You should only share the code program and the number of programs not counting the code program, the rest is for the robbers to guess.

Your solution is cracked when your entire chain of programs is found. It does not have to be your intended solution, only one with the same initial program and same or less length. (If someone finds a longer chain, it’s not a crack.)

If your answer is not cracked after a week, you may mark it as safe and reveal your solution.

Casing can be whatever you want - You can output Code, CODE, coDe, etc. Output may contain a trailing newline.

The dictionary used is /dict/words, which I've put in a gist for convenience.

Scoring

Your score is the number of programs not counting the code or golf ones, multiplied by the length in bytes of your code program. The safe answer with the lowest score wins.

Answer 1

JavaScript (ES6), 32 bytes, 4 changes, cracked by Dom Hastings

Should be easier to crack than it was to build. :-p

There are 4 intermediate steps, for a total of 6 programs.

_=>(0x63044+185886).toString(36)

Try it online!

Answer 2

Pari/GP, 28 bytes, 1 step, cracked by M Virts

Let's start from an easy one.

go="co";lf="de";print(go,lf)

Try it online!

Answer 3

Charcoal, 7 bytes * 9 steps = score 63, cracked by Dom Hastings

⍘⍘$zPγβ

Try it online! I had to use the full dictionary for this, because there is only one common word that is one source character away from the program for golf and that is gold, after which you would get stuck, however the words nearer the code end are less uncommon.

Answer 4

Perl 5 + -M5.10.0, 43 bytes, 15 changes: score 645: SAFE

17 steps total, 15 excluding code and golf.

Yeah, I don't think this one's going to be a winner! Might be too easy anyway, as I'm pretty sure there's a shorter route than the one I ended up taking but I couldn't quite get it working!

$_=$!=35;/.(.)..(.). (.)(.)/;say$2.$1.$3.$4

Try it online!

Solution

I noticed that I could have saved a byte on my solution too using:

$_=$!=35;/.(.)..(.). (.)(.)/;say"$2$1$3$4"; # code

but only after posting and didn't think it was fair to adjust, a whole 15 off my score!

$_=$!=35;/.(.)..(.). (.)(.)/;say$2.$1.$3.$4; # code
$_=$!=35;/.(.)..(.). (.)(.)/;say$3.$1.$3.$4; # dode
$_=$!=35;/.(.)..(.). (.)(.)/;say$3.$1.$3.$1; # dodo
$_=$!=95;/.(.)..(.). (.)(.)/;say$3.$1.$3.$1; # nana
$_=$!=95;/.(.)..(.). (.)(.)/;say$3.$2.$3.$1; # nona
$_=$!=95;/.(.)..(.). (.)(.)/;say$3.$2.$3.$2; # nono
$_=$!=75;/.(.)..(.). (.)(.)/;say$3.$2.$3.$2; # lolo
$_=$!=75;/.(.)..(.). (.)(.)/;say$3.$4.$3.$2; # lalo
$_=$!=75;/.(.)..(.). (.)(.)/;say$3.$4.$3.$3; # lall
$_=$!=75;/.(.)..(.). (.)(.)/;say$5.$4.$3.$3; # all
$_=$!=75;/ (.)..(.). (.)(.)/;say$5.$4.$3.$3; # off
$_=$!=75;/ (.)..(.). (.)(.)/;say$5.$4.$5.$3; # of
$_=$!=75;/ (.)..(.). (.)(.)/;say$5.$4.$5.$5; # o
$_=$!=75;/ (.)..(.). (.)(.)/;say$2.$4.$5.$5; # go
$_=$!=75;/ (.)..(.). (.)(.)/;say$2.$4.$4.$5; # goo
$_=$!=75;/ (.)..(.). (.)(.)/;say$2.$4.$4.$3; # goof
$_=$!=75;/ (.)..(.). (.)(.)/;say$2.$4.$1.$3; # golf

Try it online!

I approached this by first printing out all the 2 digit error messages and looking for words that contained g, o, l and f. Once I had some target regexes I checked if any of them would match code and then refined to pick a regex that would have spaces in (at least some of) the right places. From there I worked manually (because I found it interesting!) to pick a route, although automation would have probably resulted in a better score.

Answer 5

Pari/GP, 26 bytes, 3 changes, cracked by M Virts

Another easy one, using a similar trick.

g=c;f=e;l=d;print(g,o,l,f)

Try it online!

M Virts found a simple answer with only two changes that I didn't expect. Here is my intended solution:

g=c;f=e;l=d;print(g,o,l,f) /* code */

g=c;f=e l=d;print(g,o,l,f) /* cold */

g c;f=e l=d;print(g,o,l,f) /* gold */

g c f=e l=d;print(g,o,l,f) /* golf */

Answer 6

Vyxal, 4 bytes, 9 changes, crick craked by Aaroneous Miller

«ƛ↔ƒ

Try it Online!

This was kinda fun to create. I'll see what happens!

Programs:

«ƛ↔ƒ outputs code
«ƛ↔ṙ outputs coal
«ƛ℅ṙ outputs fear
«ƛ℅ṫ outputs feat
«ƛFṫ outputs dent
«ƛF` outputs dell
«ƛ¾` outputs foci
`ƛ¾` outputs program
`ƛ₅` outputs then
`»₅` outputs golf

Try it Online! (last two characters of each line are to print)

Vyxal has two types of string compression. The first, delimited by «, takes the bytes within as a base-255 integer then converts that to base 27 and indexes it into a space plus the alphabet.

We switch through a bunch of these until we get to one where the last character is `, allowing us to change the first character to ` to get into a dictionary compressed regular string.

Vyxal's dictionary compression is fairly simple - it replaces pairs of non-ASCII characters with words from its dictionary, then remaining non-ASCII characters are replaced with words from a shorter dictionary.

This means that a string containing three characters shouldn't be able to return golf. But, I forgot that the short dictionary isn't complete (some slots aren't taken) and those just disappear, which Aaroneous's crack exploited.

Then, we iterate through a few words before getting to the 2-char compression code of golf.

Answer 7

!@#$%^&*()_+, 13 bytes * 4 steps = score 52, cracked by Dom Hastings

3130<202(^+@)

Try it online!

Answer 8

Perl 5, 35 bytes, 5 steps: score 175: SAFE

7 steps total, 5 excluding code and golf.

$_=$!=56;/(.)(o)(.)/;say$1.$2.$3.$'

Try it online!

---

When attempting to crack my own previous post, I noticed another way to crack it (using "$2$1$3$4" would have prevented this and also saved a byte...). Changing the variable names (as per some of the other posts) is both efficient and relatively straightforward with the right set of words. The regex match against the error is purely a red herring in this instance.

$_=$!=56;/(.)(o)(.)/;say$1.$2.$3.$'; # code
$_=$!=56;/(.)(o)(.)/;say$1.$2.$3.$f; # cod
$_=$!=56;/(.)(o)(.)/;say$g.$2.$3.$f; # od
$_=$!=56;/(.)(o)(.)/;say g.$2.$3.$f; # god
$_=$!=56;/(.)(o)(.)/;say g.$2.$l.$f; # go
$_=$!=56;/(.)(o)(.)/;say g.$2. l.$f; # gol
$_=$!=56;/(.)(o)(.)/;say g.$2. l. f; # golf

Try it online!

Answer 9

Python 2, 34 bytes * 2 steps = score 68, cracked by ThisFieldIsRequired

golf="code"
goof="cold"
print golf

Try it online!

Easier than you think

Answer 10

Python 3, 55 bytes * 2 steps = 110 score, cracked by Aaron

golf="code"
try:exec("print( golf )")
except:print("a")

Try it online!