# The Mystery String Printer (Cops)

The robbers thread can be found here: The Mystery String Printer (Robbers)

• Write a program, function, or REPL script that prints a string to STDOUT.
• The robbers will try to create a program that prints the same string.
• If they successfully can create the program within 7 days, your submission is cracked.
• If nobody can create a program that prints the same string within 7 days, your submission is safe. You may choose to reveal your program, or leave it to challenge future robbers. However, if you don't reveal it, you can't get any points from your submission (don't put "safe" in your answer header if you choose to do this).

# Restrictions

• The program must be less than or equal to 128 bytes total (more on this later).
• If the program depends on the program name, or the name/contents of an external file, you must say that it does so, and include this in your total byte count.
• The printed string must be less than or equal to 2048 bytes.
• The printed string must consist of only printable ASCII characters (new lines can be included).
• The program must produce the same output every time that it is run.
• Built-in cryptographic primitives (includes any rng, encryption, decryption, and hash) aren't allowed.
• The program must not take input.
• No standard loopholes.

# Scoring

• If a submission is cracked before seven days, the submission earns 0 points.
• A safe submission of ≤128 characters earns 1 point.
• A safe submission of ≤64 characters earns 2 points. If it's less than or equal to 32 bytes, it earns 4 points, and so on.
• Each safe submission also earns an additional 3 point bonus (independent of the length).
• There is a tiny (1/2 point) penalty for every cracked after your first one.
• Note that the robber's solution has to be in the same range of program lengths.
• Each person may submit a maximum of 1 program per byte range per language (different versions and arbitrary substitutions of the same language don't count as separate languages). Example: you can post a 32 byte and a 64 byte pyth program, but you can't post a 128 byte program in both Java 7 and Java 8.
• The person with the highest point total wins.

## Submissions

Each submission must have the following pieces of information:

• The name of the language. All new robbers' solutions must be the same language.
• The range of the program size (this is the nearest power of two higher than the size of the program; for example, if your program is 25 bytes, this would be "≤32").
• The actual string to be printed out.
• If a submission is safe, put "safe" and the program length (to the nearest power of 2) in your header. If there are multiple numbers in your header, put the power of 2 last.

/* Configuration */

var QUESTION_ID = 60328; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 167084; // This should be the user ID of the challenge author.

var SECONDSINDAY = 86400;
var SAFECUTOFFDAYS = 7;
var SORTBYTIME = true;
var SUBTRACTCRACKEDPOINTS = true;
var EXPIREDTIME = 1446336000;

/* App */

comment_page;

return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function(data) {
data.items.forEach(function(a) {
});
comment_page = 1;
}
});

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function(data) {
data.items.forEach(function(c) {

});

else process();
}
});
}

var SAFE_REG = /<h\d>.*?[sS][aA][fF][eE].*<\/\h\d>/;
var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var CRACKED_COMMENT_REG = /(.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<a href=.*)|(.*<a href=.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*)/
var LANGUAGE_REG = /<h\d>\s*(.+?),.*<\/h\d>/;
var LANGUAGE_REG_ALT = /<h\d>\s*(<a href=.+<\/a>).*<\/h\d>/
var LANGUAGE_REG_ALT_2 = /<h\d>\s*(.+?)\s.*<\/h\d>/;
var LANGUAGE_REG_ALT_3 = /<h\d>(.+?)<\/h\d>/;

function getAuthorName(a) {
return a.owner.display_name;
}

function process() {

var valid = [];
var open = [];

var body = a.body;
var cracked = false;

var was_safe = (c.creation_date + (SECONDSINDAY * SAFECUTOFFDAYS) > a.creation_date);
if (CRACKED_COMMENT_REG.test(c.body) && !was_safe)
cracked = true;
});

// if (SUBTRACTCRACKEDPOINTS||!cracked) {

var createDate = a.creation_date;
var currentDate = Date.now() / 1000;
var timeToSafe = (createDate + (SECONDSINDAY * SAFECUTOFFDAYS) - currentDate) / SECONDSINDAY;
var SafeTimeStr = (timeToSafe > 2) ? (Math.floor(timeToSafe) + " Days") :
(timeToSafe > 1) ? ("1 Day") :
(timeToSafe > (2 / 24)) ? (Math.floor(timeToSafe * 24) + " Hours") :
(timeToSafe > (1 / 24)) ? ("1 Hour") :
"<1 Hour";

var expired = createDate > (EXPIREDTIME);

var safe = timeToSafe < 0;
var points = body.match(POINTS_REG);
if (!points) points = body.match(POINTS_REG_ALT);
safe = safe && !cracked

isOpen = !(cracked || safe);

if (points) {
var length = parseInt(points[1]);
var safepoints = 0;
if (length <= 4) safepoints = 32;
else if (length <= 8) safepoints = 16;
else if (length <= 16) safepoints = 8;
else if (length <= 32) safepoints = 4;
else if (length <= 64) safepoints = 2;
else if (length <= 128) safepoints = 1;

valid.push({
user: getAuthorName(a),
numberOfSubmissions: (safe && !expired) ? 1 : 0,
points: (safe && !expired) ? safepoints : 0,
open: (isOpen && !expired) ? 1 : 0,
cracked: (cracked && !expired) ? 1 : 0,
expired: (expired) ? 1 : 0
});

}

if ((isOpen || expired) && points) {

var language = body.match(LANGUAGE_REG);
if (!language) language = body.match(LANGUAGE_REG_ALT);
if (!language) language = body.match(LANGUAGE_REG_ALT_2);
if (!language) language = body.match(LANGUAGE_REG_ALT_3);

open.push({
user: getAuthorName(a),
length: points ? points[1] : "???",
language: language ? language[1] : "???",
timeToSafe: timeToSafe,
timeStr: (expired) ? "Challenge closed" : SafeTimeStr
});
}
// }
});

if (SORTBYTIME) {
open.sort(function(a, b) {
return a.timeToSafe - b.timeToSafe;
});
} else {
open.sort(function(a, b) {
var r1 = parseInt(a.length);
var r2 = parseInt(b.length);
if (r1 && r2) return r1 - r2;
else if (r1) return r2;
else if (r2) return r1;
else return 0;
});
}

var pointTotals = [];
valid.forEach(function(a) {

var index = -1;
var author = a.user;
pointTotals.forEach(function(p) {
if (p.user == author) index = pointTotals.indexOf(p);
});

if (index == -1) pointTotals.push(a);
else {
pointTotals[index].points += a.points;
pointTotals[index].numberOfSubmissions += a.numberOfSubmissions;
pointTotals[index].cracked += a.cracked;
pointTotals[index].expired += a.expired;
pointTotals[index].open += a.open;
if (SUBTRACTCRACKEDPOINTS && a.cracked && pointTotals[index].cracked > 1) pointTotals[index].points -= .5;
}

});

pointTotals.forEach(function(a) {
a.points += (a.numberOfSubmissions) ? ((a.numberOfSubmissions) * 3) : 0;
});

pointTotals.sort(function(a, b) {
if (a.points != b.points)
return b.points - a.points;
else if (a.numberOfSubmissions != b.numberOfSubmissions)
return b.numberOfSubmissions - a.numberOfSubmissions;
else if (a.open != b.open)
return b.open - a.open;
else if (a.cracked != b.cracked)
return a.cracked - b.cracked;
else return 0;
});

pointTotals.forEach(function(a) {

.replace("{{NAME}}", a.user)
.replace("{{SAFE}}", a.numberOfSubmissions)
.replace("{{OPEN}}", a.open)
.replace("{{CLOSED}}", a.expired)
.replace("{{CRACKED}}", a.cracked)
.replace("{{POINTS}}", a.points);

});

open.forEach(function(a) {
.replace("{{NAME}}", a.user)
.replace("{{LENGTH}}", a.length)
.replace("{{LANGUAGE}}", a.language)
.replace("{{TIME}}", a.timeStr)
});

}
body {
text-align: left !important
}
width: 350px;
float: left;
}
#open-list {
width: 470px;
float: left;
}
font-weight: bold;
vertical-align: top;
}
table td {
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<tr>

<td>Author</td>
<td>Safe</td>
<td>Open</td>

<td>Cracked</td>
<td>Late Entry</td>
<td>Score</td>
</tr>

</tbody>
</table>
</div>

<div id="open-list">
<h2>Open submissions</h2>
<table class="open-list">
<tr>
<td>Author</td>
<td>Length</td>
<td>Language</td>
<td>Time Remaining</td>
</tr>
<tbody id="opensubs">
</tbody>
</table>
</div>

<table style="display: none">
<tr>
<td>{{NAME}}</td>
<td>{{SAFE}}</td>
<td>{{OPEN}}</td>

<td>{{CRACKED}}</td>
<td>{{CLOSED}}</td>
<td>{{POINTS}}</td>

</tr>
</tbody>
</table>

<table style="display: none">
<tbody id="open-template">
<tr>
<td>{{NAME}}</td>
<td>{{LENGTH}}</td>
<td>{{LANGUAGE}}</td>
<td>{{TIME}}</td>
</td>
</tr>
</tbody>
</table>

Use the following formats for entries:

Language, (any text with the program size as the last number)
=


or

Language
=
Length <= 16


Note that the snippet will only put the first word in the header as the language if it doesn't detect a comma.

For safe submissions, put safe in your header. The snippet will automatically put your program in the "safe" column if the time is expired, so this is more to tell any robbers that your program is safe.

The program should also be able to recognize if a comment says "cracked" and has a link; however, this is not guaranteed.

Tiebreaking order: Points -> # of Safe submissions -> Least amount of cracked submissions.

Note that the snippet sorts by open submissions before least cracked, but open submissions will not be counted at the end of the contest.

This challenge is now closed.

Most points overall winner: Dennis

Most safe submissions: DLosc

(Note that the number of safe submissions doesn't translate to a point amount, as the size of the programs are considered in calculating the score).

• We should remind the cops that the output should better be longer than the program size, to reduce trivial solutions like codegolf.stackexchange.com/a/60395 and codegolf.stackexchange.com/a/60359 – kennytm Oct 11 '15 at 16:56
• @bmarks There has to exist a way to execute the language, and the language must be able to display a string of ASCII characters. If you want to use HQ9+, congratulations, you have just gotten yourself a cracked submission. – Daniel M. Oct 12 '15 at 20:35
• @bmarks I'd prefer not, but I'm not going to stop you. – Daniel M. Oct 12 '15 at 21:30
• All the number-only outputs are super boring. – mbomb007 Oct 13 '15 at 20:06
• Please consider using the Sandbox the next time. Preferably, the rules of a challenge shouldn't change at all after it has been posted. I've lost track of how many times the rules have changed here... – Dennis Oct 17 '15 at 20:01

# Lua 5.3, Cracked, ≤128 bytes

This is a REPL command. Output (1,954 bytes):

haha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555


Original code:

(table.concat{({pcall(string.find,'',('('):rep(50))})[2]:byte(1,-1)}:gsub('.',('%0'):rep(9)):gsub('[019]+','haha')):rep(13,'ha')

• Cracked. – Dennis Oct 19 '15 at 4:27
• @Dennis OK, that's much simpler than I thought. My actual code was much more complex, as you can see above. Apparently I'm not very good at this. :P – jcgoble3 Oct 19 '15 at 5:29

# Ruby, <= 16 (safe)

13692278437523182704300881


Solution:

p"5#{9**28}".oct

Explanation:

9**28 is the only two-digit power of nine (possibly the highest power) that has no 8s or 9s in its base 10 representation--which is to say, it can be interpreted as octal. I convert it to a string, prepend an extra five digit at the beginning because I'm a jerk, call .oct to convert the string, base 8, into a Numeric value, and p prints the result in base 10.

# C, safe, <= 64

String length is 2023

:;;::;;;;;:;;;;;:::;:;:::;;:;:::;:;;;::;:;::;:;;;:::;;::;:;;:;;;;;::;;:;:::;;;;;::;:;;:::;;;::;;;:;;:;;;;:;:;;:;::;:::;;::;;:;:;;;;;;;:::;:::::;;:;:;:::;;;::::;:;;:;;::;::;;:;;;;:;;;;:;::;:;::;::;;:::;;:;;;;;:;;;:;:::;:;:;::;:;:::::;;:::;:::;;;;:;:;:;;::;:::::;;;;:;:::;;::;::;:;;;;;:;;::;:::;:;;;;:;:;::;::;::::;;:;;:;::;;;:;;::;;;:;:;;;;;:;:::;:::;::;:;:;:;:;;::::::::;;;::::::;;:;;::::;;;:;;;::;;:;:;:;;;;;:::::;:::;;:::;:;:;;;;:;::::;::;::;::;:;;:;;:;;::;;:;;:;;;;;;:;;:;::::;:;;::;::;::;;;;:;;:;;;::;:;;:;:;;;::;;:::;:;;;;;;:;::;::::;::;;:;::;:;;;;::;;::;::;;;;;;;:;;;:::::;:;:;;:::;::::;;;:;:;::;;:;::::;;;;::;::;;::;;;:;;;;;;;:;:;:::::;::::;:::;:;::;:;:;:::;;:::::;:;;;;:::;::;::;;:;:;;:;;;;:::;;:;::;;:;;;::;;;;:;:;;;;::;:::;::;;;:;:;:;;;:;:::::;:;::;:::;:::;;:;:;:;:;;;:::::::;:;;:::::;::;;;:::;:;;;:;;:;::;:;:;;::;;::::;;;;;;;::;;:::::;;;;;;:::;;::::;;:;;;;::;;;:;::;;;;:;::;;;::;::;;;:;;;:;;;:;:;:;:;:;::::::::::;::::::::;:;::::::;:::;::::;:;:;:;::;:::::::;;:;:::::;;;::;:::;;:;;;:;:;;;:;:;:::;:;::::;:;:::;::;:::;:;:;;:;:;::::;;::::;::;;;;::;:;;;::;;;::;:;;;;:;;;::;::;:;:;;;:;;::::;:;:;;;::;::::;:;;;:;::;::;:;::;;:;;:::;;;;:;;;:;;::;:;:;:;;;;::::::;::;;::::;:;;;;;::;::;:::;;;:;;:;:;;:;:;;:::;;:::;;;:;;;;:;;:;:;::;:;;::::;;::;;;::;;;;;;:;;;;::::;:;::;;::;:::;;;;;;:;:;;::::;:::;;;::;:;:;;:;;;::::;;:;:;;::;;;:::;;;;;:;;:;;:::;:;;:;;;:;::;;:;:;::;;;;::::;;;::;;::;;:;;;;;;;;;:;:::::::;::;:::::;:;;:;:::;::;;::;:;:;;;;;;::::;::::;;::;:;::;;;;;:::;;;:::;;:;;:;;:;;;:;;:;;:;:;:;;:;;:::::;;:;;;:::;;;:;:;;:;;:;:::;;:;;::;:;;;:;;;;::;:;:;::;;;:::::;;;:;;:::;;:;:;;;:;;;:::;:;:;:;;:;::::::;;::;::::;;;;;:;::;;:::;::;;;;;:;:;;;:::;:::;:;;:;:;:;::;;::::::;;;;;::::;;:::;;::;;;;:;;;;;;::;:;::::;;;:::;::;;:;;:;:;;;;:;;:::;::;:;;;:;:;;::;:;:::;;;;:::;:;;::;;:;::;;;;;;::;;;::::;;;;:;;::;;::;:;;;;;;;;::;::::::;;;:;::::;;:;::;::;;;::;;:;;;:;;;;;:;:;:;:::;::::::;:;:;::::;:::::;::;:;:::;:;;:::;:;::;;;:;:::;;;:;::;:;;:;::;;::;;::;;;;;;;;;;;:::::::::;;:::::::;;;;:::::;;::;;:::;;;;;;;;:;;::::::;:;;;::::;::;:;;::;:;;::;;;;


Solution:

main(a,b){for(a=b=2022;putchar(58+a%2),b--;a=a/2^-(a%2)&1280);}

# Befunge-93, <= 16 (safe)

65 72 4680 65 6120 77 6080 46 1470 58 0


Tested here. Will give different results in Befunge-98, but the output should be reliable in any Befunge-93 interpreter.

## Original source code:

">:#*._@MUHAHAHA


After the initial double quote, everything that follows is pushed onto the stack as a series of ASCII values, one byte at a time. On reaching the end of the line, the program flow wraps around to the first character again, which is now treated as a closing quote.

After that, the characters >:#*._@ are interpreted as follows:

• >: process instructions from left to right
• :: duplicate topmost value on stack
• #: skip next instruction
• *: replace top two values on stack with their product
• .: pop value from stack and print as numerical value
• _: pop value from stack; change direction to L→R if zero, R→L otherwise
• @: halt

# Scala 2.11.x, <=128 (Safe!)

Using the REPL:

***********+++------+++*********+++------------+++*********+++-------------+++*****************+++----------+++**************+++-------------+++***********+++-------------+++****************+++-----------------+++***************+++-----------------+++***********

My code:

val x=Math.PI.toString.map(_.toInt-40)
val y=for(y <- x.indices)yield (if(y%2==0)"*" else "-")*x(y)
y.mkString("+++")


This is only 117 bytes so I had some room to replace PI with somthing more interesting (like "asjdfaterwerhndsfyser") but I was kinda stuck on PI ;)

# Pip, <= 2 (cracked by Reto Koradi)

{Name(a,None,None)}{Name(a,None,None)}


This works in the current version of Pip as of this posting (0.15.10.04), and a couple versions prior. Future updates may change this output. I felt a bit bad about posting something so implementation-dependent, but including a <=2 that isn't blindingly obvious was too fun to pass up.

The code is O_.

• _ is the identity function. It's syntactic sugar for the longer form {a}, which is equivalent to lambda a: a in Python.
• In the current version of Pip, I haven't finalized the format of Blocks when converting to Scalars (i.e. strings). Eventually, it's going to look like {a}, but at the moment it wraps the parse tree in curly braces, resulting in the above {Name(a,None,None)} business.
• O is a unary operator that outputs its operand (after casting to Scalar) sans newline.
• Since O is an operator, the whole O_ is an expression that evaluates to the same identity function. If a Pip program ends with an expression, that expression is auto-printed. Thus, {Name(a,None,None)} gets output a second time.

# C <= 64 (cracked by kennytm)

111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011


(output is 1974 chars long)

• Is this the binary solo from Flight of the Conchords' "The Humans Are Dead?" – AdmBorkBork Oct 12 '15 at 20:18
• I would be very surprised if it were – tucuxi Oct 12 '15 at 20:34
• – kennytm Oct 19 '15 at 16:21

# Perl, <=32 (safe)

This one might be a bit tricky:

3241713134202822035372146147538395543335603758546591813832316426477542


(70 bytes of output)

for(b..z){$x=3+$x*7%887;print$x}  This generates the following sequence of numbers: 3 24 171 313 420 282 203 537 214 614 753 839 554 333 560 375 854 659 181 383 23 164 264 77 542  # Python, 128 bytes - safe 660683327594476238907838932164883150043152487972265621586853747350018950043398241174734510500438932288265866081053722653747103105372265374710194487843821420414263599196956978488088314633969572265621599199414510512777203769809075969078413898191547525125351794463394487842685619178954944883376732710310525621623887080436463396956732734885845868512778438954957221648336500433993769772038932288265866081177179443870436488088314757426243870559858458685498167098191546389322882658648587080436414014229325327592018706883150043152487972265621599198192041376974734756265866092411747350043399376977192288290554981547599199425868537353747103080680907596932530290311821421648090747352512535179446328090759689549572265866092535204021648337648580907967302900660682191792018461130061154510488088303399401666092658710310536979648466092782080680907843846110537225401668561670994266092782093026574880883147574263599199425868537354981670981914241424093024117472315248808461130064858214191792007103105369796362414014240683352169796485796730278708043641401422932532759201858463623646290557439201870800660683376977203646315132759448759692019201870801895250080680907350018952512535179446328090759690784016735001895004339824117473438705599201870801895250093026586362352289549572216483365127796727821177154754981424092910537226537469796979648579673027870804364016685621648337648582130559895493253152537471030806808958685374685619179201870801895250093026586362352290784140117717933029031294487843858458685127796614240930241173500683352283376731574508067843845996956979623890772535204135228461179446339448784268561917883150043646315246339694537471030806796735228584562162377350018950043399401668561671006490784140117716710559895493253274784384610930265868561917895495710806809073500066105372265374710194487843821421648090759690784138981915475251241179673029006606821917920183376732759693253029031182142164809074735251253517944632796730290066068335228584562162377473475740166732784384611053722540166856154754981917920184611299475742635745068338932288265866081177179443870554 By the way, len(output) == 2046 Source code - 98 bytes: z=lambda k:"".join(map(lambda k:str(ord(k)),k));print int(z(z(z(z(z(z(z(z(z(z("79")))))))))))/81^5  • This is an actual number, obtained by math, not a sequence of numbers without spaces between them. – pppery Oct 15 '15 at 18:53 • Well I'm not going to try factoring it, lol. There's a reason why large-numbered answers are so boring. – mbomb007 Oct 15 '15 at 21:16 • @mbomb007 Factoring wouldn't help. In any case,I obtained this number by dividing an even larger number (2048 digits) by another number. That number was not mathematically obtained(You'l see if you find it). – pppery Oct 16 '15 at 0:17 # Pyth, safe, <= 32 My first try at Pyth, I'm curious how fast this will be solved :) Output (40 Bytes): =fu(NMVU\_RQPSnmvu~}twjihkfe^]&%,/"! #>=&%.-  ### Solution j""+]"=fu("CMmx=T+2Td.f.&TZ40 65  # Pyth, safe, <=16 Output (112 Bytes, 32 Numbers) [9, 15, 11, 9, 7, 25, 27, 25, 31, 25, 27, 25, 5, 11, 15, 13, 3, 5, 7, 5, 3, 61, 63, 61, 1, 7, 3, 1, 15, 1, 3, 1]  ### Solution mx=T+1Td.f.&TZ32  # Haskell, <= 32 "[(\"[\",\"(\\\"[\\\",\\\"(\\\\\\\"[\\\\\\\",\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\")]\\\")]\")]"  This one is cute and easy. # QBasic, <= 64 (safe) 11""111111"""11111""""1111"11""1111111""1111111""1111111""1111111""1111111""11111  Tested on QB64. There is no newline at the end of the output. Disclaimer/hint: It's possible that the output will look slightly different in DOS QBasic, though the concept will still work. Don't even think about using Repl.it for this one. Answer: SCREEN 9 FOR j=1TO 8 FOR i=1TO 9 ?CHR$(49-POINT(i,j));
NEXT
NEXT


It helps to break the output into 8 rows of 9 characters each:

11""11111
1"""11111
""""1111"
11""11111
11""11111
11""11111
11""11111
11""11111
11""11111


The code loops over an 8x9 rectangle of pixels near the upper-left corner of the screen, printing 1 for a black pixel (color code 0) and " for a white pixel (color code 15). At first the screen is all black, so the first character printed is 1. But afterwards, that very 1 (plus the tip of the second one) provides the data for the remaining iterations:

The ASCII math was chosen to put double quotes in the output, which should make it impossible to generate this string any other way.

# R, <= 32 (safe)

It outputs the following string (34 characters. I hope there isn't a more trivial way to print this!)

pi - 4*(4*atan(1/5) - atan(1/239))

Edit: Hints: (1) This is very crackable. (2) No mathematical calculations are involved. (3) The program that outputs this is 24 characters long.

To crack, search Google for pi - 4*(4*atan(1/5) - atan(1/239)) R language. (String chosen so that searching for it doesn't give obvious references to R!) Note that this line appears in example(pi). Note that the text of the example will be outputted if you include the give.lines=T option in example(). Arrive at the solution:

cat(example(pi,g=T)[10])

• Gah. I tried looking for R sample text but found nothing. – ev3commander Oct 20 '15 at 20:55

# Dyalog APL (cracked)

4.58302


Range ≤ 4

This should be cracked pretty quickly...

• Ack - 5 bytes is easy, but 4... – Sp3000 Oct 17 '15 at 15:34
• – Lynn Oct 22 '15 at 8:09

# Lua, ≤ 64 (safe)

Output:

value   attempt
call    attempt
value   call
to      call
call    a
string  call
call    string
to      call
call    a
value   to
string  attempt
a       attempt
string  a


You need to write a Lua program or REPL command of length 64 or less.
My code size = 58 bytes.

Code:

_,s=pcall''table.sort({s:match(('.-(%S+)'):rep(6))},print)

Ungolfed code:

t = {'attempt', 'to', 'call', 'a', 'string', 'value'}
table.sort (t, print)

Lua table sorting exhibits non-trivial behavior, even when any permutation of elements is accepted as possible by comparison function.

# Groovy, <= 64 [Safe!]

This is from the REPL

'11111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000001110011110010001110011111001000111001000011100111100100011100111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000001110011110010001110011111001000111001000011100111100100011100111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000000011100111100100011100111110010001110010000111001111001000111001111110010001110010000111001111001000111001000001110011110010001110011111001000111001000011100111100100011100111111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001111111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000011100111100100011100111110010001110010000111001111001000111001111110010001110010000111001111001000111001000001110011110010001110011111001000111001000011100111100100011100111111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001'

Yes, those 's belong, and no, that's not a leading space

Have fun!

Original code:

t=[]
f={n->t+=n
n<2?n:f(n-2)+f(n-1)}
f(15)
t*.mod(2).join("")


I used fibonacci to create a very large number and mod each digit by 2.

# J (cracked)

4.81845e12


Range ≤ 4

Worth a shot.

# J (safe)

0 0 0 0 1 9 495 1287 3003 6435 12870 24310 43758 0 0 0 0 45 165


Range ≤ 8

### Solution

8!/:#:!9


Try it online.

### How it works

• !9 calculates the factorial of 9, i.e., 362880.

• #: converts the result to binary, yielding 1 0 1 1 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0.

• /: "grades up", i.e., sorts the indices of the above list by the values at those indices.

This yields 1 4 5 6 8 9 12 13 14 15 16 17 18 0 2 3 7 10 11.

• 8! calculates nC8 for each n from above, returning the specified output.

# J (safe)

0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 1 1 1 1 1
1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 1 0 1 0 0 0 1 0 0 0 1 1
1 0 1 0 1 1 0 1 1 0 0 0 1 1 0 0 0 1 0 0 0 0 1 1 0 0 1 1 0 1
1 0 1 1 0 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0


Range ≤ 16

### Solution

|:9|.#:\:#:p:!11


Try it online.

### How it works

• !11 calculates the factorial of 11, yielding 39,916,800.

• p: calculates the 39,916,800th odd prime, yielding 774,825,437.

• #: gives the primes' binary digits, i.e., 1 0 1 1 1 0 0 0 1 0 1 1 1 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 0 1.

• \: "grades down", i.e., sorts the indices of the above list by the values at those indices in descending order. This gives

0 2 3 4 8 10 11 12 14 15 16 19 21 22 23 25 26 27 29 1 5 6 7 9 13 17 18 20 24 28

• #: gives each index's binary digits, i.e.,

0 0 0 0 0
0 0 0 1 0
0 0 0 1 1
0 0 1 0 0
0 1 0 0 0
0 1 0 1 0
0 1 0 1 1
0 1 1 0 0
0 1 1 1 0
0 1 1 1 1
1 0 0 0 0
1 0 0 1 1
1 0 1 0 1
1 0 1 1 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 0
1 1 0 1 1
1 1 1 0 1
0 0 0 0 1
0 0 1 0 1
0 0 1 1 0
0 0 1 1 1
0 1 0 0 1
0 1 1 0 1
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 1 0 0 0
1 1 1 0 0

• 9|. rotates the rows nine units up, yielding

0 1 1 1 1
1 0 0 0 0
1 0 0 1 1
1 0 1 0 1
1 0 1 1 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 0
1 1 0 1 1
1 1 1 0 1
0 0 0 0 1
0 0 1 0 1
0 0 1 1 0
0 0 1 1 1
0 1 0 0 1
0 1 1 0 1
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 1 0 0 0
1 1 1 0 0
0 0 0 0 0
0 0 0 1 0
0 0 0 1 1
0 0 1 0 0
0 1 0 0 0
0 1 0 1 0
0 1 0 1 1
0 1 1 0 0
0 1 1 1 0

• |: transposes rows and columns, yielding the final output.

# ES6, safe, <= 128

Console output from Chrome 46 including "'s in case those matter

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


## Source

128 characters including the var decl, you can actually leave this off and everything works fine.

 var m=25,a=11,c=17,z=3,r=(v)=>z=(a*z+c+v)%m,f=(_,i)=>String.fromCharCode(34+(i*r(i>>1)%43));Array(...Array(2046)).map(f).join


### Golfed Version of Source

103 characters

  z=3,r=(v)=>z=(11*z+17+v)%25;[...Array(2046)].map((_,i)=>String.fromCharCode(34+(i*r(i>>1)%43))).join


## How it works

First setup a basic linear congruential generator simplified from https://bocoup.com/weblog/random-numbers

var rand = function rand(offset){
// Establish the parameters of the generator
var m = 25,
// a - 1 should be divisible by m's prime factors
a = 11,
// c and m should be co-prime
c = 17;
// Setting the seed
var z = 3;
var rand = function(offset) {
// define the recurrence relationship
z = (a * z + c + offset) % m;
// return an integer
// Could return a float in (0, 1) by dividing by m
return z;
};
};


Next create symbol table lookup function (less overhead than the symbol table)

var lookup = function(index){
// From the 34th character use the next 43 characters
// i* keeps us moving forward through the table with less predictability
// i>>i reduces i to also make for lower predictability
var charCode = 34+(i*rand(i>>1)%43);
return String.fromCharCode(charCode);
};


Using the ...rest (or splat) operator create an array of 2046 (to stay under 2048 limit), execute the lookup function against every element, and then join the array back into a string. Default behavior of browsers is to output the last computed value to the console.

Array(...Array(2046)).map(lookup).join('')


# Groovy, <= 128 (Safe!)

Have fun with this one!

Groovy Rocks!scrocoRoo kosv cRooooGrRsokyry o!yRvyr GsoooRoy o GR rRrysrv o ov ocv!c!!v!oroookoo o yGr okcG!RRoyo!o oor !k!oR rkRo!coooooooovv kkkrk RoyroroRRR!o!GGo vyovyo GoocvcGRGkokroRGcs!oGokR!orrsGvGsy!vv!rRoooR y kokvvvRo rr!kk GRRRoroyokvokosoRoG!cvRv ssooooRrGkGs rv!ooRcsoosRyyGvkykysokGvrRskskvkoRooookoysyycyGykocooc!vocGoksssRRyrv yksosGRGookkoRcRGGyccGvoskGoko oso krrsGyRGvovGrcrooG!ykksssvocrGGGovsokcGroyRoGyysrsG! rr!oGokR!c rvccRsoR! !ookccvoRoskv okGor! RyossosGRRyr!yvorcoRRyorGos!G oov Gr ccvosGkGyoycooc voRoysrrvrRyyrovkyoRRysyrk rso!cyoscrvoccyrkvy!o GRoGRook sorcvovkokrook ooGsos ryoooc oroG!sooko!oooR osocGoocorrkvGosycovysRcRG yvcosyocGrGcrGr!sooG!ovRrcRksGsyGco sooy!GGGyyr!okkoGRcvk cc cGrGG GcosoyGsvGksoR krocvs!orGRRs! sorvvRosyvvoks co !oocRoysrroorooooykGvovk!rGroscyyooGscooyyr ooooGsGosoo oosorrovooGooR!ssGvs!oo yvcoo cyc!oyR! koG ovGoko!ck oovvc o!s!ocGsovvGycsysoooRyRkkRrok!coovrkooysGRocGGorRooocGos!Roo!skRsRvsokosk y RGksvycGvvv!ovo oo GGcv rvRGyR !Rsvo o !scr!vRvoRy!!yo Royycovor!ocooo!yGcookryoorrso!oro oosRcrovcGk!ccoocGkosG ovyovo vcGookok o s!vR!Roycoo RkocoGGksrryv osrkoossvG Rkokso!RR!rk !sRcooc!vRvRkccvskGoooooro!GsR!osscoRcGGcoR soyoRR!rv!oGR!scv!y!rrcoGoRooGoGRork ookvrGRcoRvoro!oro!RvG sycsoyosRyG yoyooco oRrovGyc RGoycGorG c!royo orsrGysr! ookcssG okrGRvroy roRRvGoo!so oGoo!kRo! kvGGoovGsRoco !s oRvkoG GsGRrkk!o!c ooc skyoocvvckRcrookcGy!c rGcoosGcy!ok!ysRov GcooGcGooookoooc ycoGv RGGso RG kRycGyoGoyG Gkyov!vGorovr!RosyGkrcyrc!r orc ovy!!cGRvr!Go krksRcRovo!korvkcsRy yyoGoc vGo!crcorrosvvoGoooGyyRrkckoGsRG voyoGoRo r RGcRsv!vkrrkGGk RyvovrGcGor!oRRk yyoG! oR!!r! Rr!cG RR ssrororcvcksvoGy ocvcoGo!s y r!oo o oo ooyGkoookr!vskko !GoRGrysGv r okkskRo GRvooossGoGs!voorr!y!scovGovkcc!kRvGco!ros!!okooooroo v!yvo rGvkGscRvoyovvGs!G!r osGGGrcyyork ooryGooovoyrGco rGGk R osc!GvovGryccc !r! cRG!r!RrorGkGko vyyGkks!GoRoooGrrorc!G!oko RoGookovyrkRR

This was run as a groovy script.

Original code:

 s='Groovy Rocks!'
println(s+((89**98**20-5).toString().split("(?<=\\G.{2})").collect{s[(it as int)%13]}.join('')))


# PHP 5.3+ (safe)

range <= 128 bytes

482424112994923113297121090242411210353292651229460112228399109149751282614311166121153929147198351001411661211559915116999341919231910671297471013731035012512152995121145118302468310841232211292074121155012771143923278512115501816119651154811292412150661212263019861153871918242691210635477119627297174572129747102223127312255412195242990704515918206269100332226149786699441136214126754710137310350125121529951211451183024683108412322112920741212263019861153871918242691210944191722683984510232122312004200000000000000000000000000000011224241129752128729183000000000000000000000000000000427344126627112312961782933097521287291121806311106811548172725429797110845159182062691014391471169293309747101373103501251215299512122630198611538719182426912115392115726311323861094413211027131990121094419172268398451023212239412100414296118911539278825


843 digits.

The code with some whitespace added:

ob_start();
phpcredits();
$d='';$c=0;
foreach (str_split(ob_get_clean()) as $x) {$d .= ord($x^$c);
$c=$x;
}
echo substr(\$d,0,843);

• Safe means that it has been open for 7 days and hasn't been cracked. – Daniel M. Oct 13 '15 at 1:18
• Limit is 2048 bytes. – J Atkin Oct 13 '15 at 2:00
• OK then let's keep only the first 843 digits. This will not disadvantage those who are already on my trail, the changes to be only 843 digits instead of 14401 does not change the trick. I also verified the code produces this output from PHP 5.3 onwards. Originally I verified only on PHP 5.6. @DanielM. I hope it will stay uncracked, obvs :) – chx Oct 13 '15 at 3:08

## Pyth

10067283832263627132507444590041695034979992997150622392563276991517087210416125987872298759981924914598996739787601264046046893914007275634929310315058


Range ≤ 4

I think there's a somewhat reasonable way to guess the solution, not just by trying lots of expressions.

• Cracked – Sp3000 Oct 11 '15 at 7:37

# C++

String:

65033056-9151491210111217-182023222117182724-272924313024373435-363433363947444142-454342454854554853-544851585761626360-635768676668657071-727877727575727778-818786818482838489-909295949389909996-991019610310296109106107-108106105108111119116113114-117115114117120126127120125-12612012312012612712012511412012311411311711811911612111310810710610810511011196102101969999961011028795948992909192819484878685818275726977727978726966677666656871636057585159586148545548535848514241454647443341363534363338394030292427272429303123221720181920961215141391030135076


Range: <= 64

# GolfScript

100100110010011100110001011101100001010011010111011101011000100000000100


Range: ≤ 8

# gs2

4p2G<4p2<G4pG2<4pG<24p<2G4p<G242pG<42p<G42Gp<42G<p42<pG42<Gp4Gp2<4Gp<24G2p<4G2<p4G<p24G<2p4<p2G4<pG24<2pG4<2Gp4<Gp24<G2pp42G<p42<Gp4G2<p4G<2p4<2Gp4<G2p24G<p24<Gp2G4<p2G<4p2<4Gp2<G4pG42<pG4<2pG24<pG2<4pG<42pG<24p<42Gp<4G2p<24Gp<2G4p<G42p<G2424pG<24p<G24Gp<24G<p24<pG24<Gp2p4G<2p4<G2pG4<2pG<42p<4G2p<G42G4p<2G4<p2Gp4<2Gp<42G<4p2G<p42<4pG2<4Gp2<p4G2<pG42<G4p2<Gp4G4p2<G4p<2G42p<G42<pG4<p2G4<2pGp42<Gp4<2Gp24<Gp2<4Gp<42Gp<24G24p<G24<pG2p4<G2p<4G2<4pG2<p4G<4p2G<42pG<p42G<p24G<24pG<2p4<4p2G<4pG2<42pG<42Gp<4Gp2<4G2p<p42G<p4G2<p24G<p2G4<pG42<pG24<24pG<24Gp<2p4G<2pG4<2G4p<2Gp4<G4p2<G42p<Gp42<Gp24<G24p<G2p4


Range ≤ 8. This one should be a little more fun...

• Does the solution contain non-ASCII characters? – kennytm Oct 11 '15 at 16:27
• 4p2G<\x05\x93, boring. – Mitch Schwartz Oct 19 '15 at 3:44
• Mitch: dammit! No idea how I missed that. (It's originally fizzbuzz mod something plus something.) – Lynn Oct 19 '15 at 7:19

# TI-BASIC (cracked by NinjaBearMonkey)

Am currently away from my computer, will post code later.

Range: <= 7

String: 115572735

Code: πE8/e

Ran on a default calculator - the program may have different output on calculators with a certain setting changed. I hope that is OK.

• – NinjaBearMonkey Oct 11 '15 at 4:01
• Damn. That was fast. Nice job! – a spaghetto Oct 11 '15 at 4:04
• Oh, because of pi? Hm. – a spaghetto Oct 11 '15 at 4:08
• The rules have been modified, this is OK – Daniel M. Oct 11 '15 at 4:20

# Python 2.5 - 2.7.9

Range: <=64

>r otnfn-lu<.liamcdaka btnymsgachu ssee
rtfn gaco lkls ldmsh bddvr P h girW
wlbdbrsd)kecnicu h s n D aon itom tebso it eeo
tic  adla bo entis ldmsh ne mtetrF
otten uuim onictD- nabt
yrmo wn h .otten uuim eisdynNbTeT)itib ss ldm>inicu itib


NOTE: This entry has been modified because it came to my attention that the output would change depending on certain factors about your computer. The above output should be possible with the same code as I have across all python 2 installations, the old output below only works on certain linux installations. I will accept a crack to be a program that can produce either output.

>cps/.nhy/i/s/ of'o ldm
ebtpo rwcbe o a enh cs;ealreuu ienh tyei ieuo ity eiopIAeT:nna
.oe eice (ch
otnfeteudaEIn tit rpio lisps irvwH.prsas elce tdden ieuo itgibei h o
niandisogbaf otee -ynna
.ce nsokeS niandisogbasspe na a h>n-lu('y'euo<d otnfn-lu<

• Oh boy. If this does what I think it does it's going to take longer than The Programming Language Quiz to solve :P (just in case, can I ask which exact Python version you tested on?) – Sp3000 Oct 11 '15 at 12:14
• 2.7.6 and what do you think it does? Ok, the program does different stuff depending on certain things that I don't think are fair, shall I change it to remove that or not? – Blue Oct 11 '15 at 12:49
• Ok, I have a new version that's almost identical except it shouldn't matter what os you're on or other things that I don't want to say if I am allowed to replace it - if I did, it would be quite a big hint – Blue Oct 11 '15 at 12:57
• In the interest of cracking it... @Sp3000, are you thinking that it's at least one __doc__ string (maybe multiple or multiplied) sliced? That's what I think. The > at the front encourages that theory. – mbomb007 Oct 13 '15 at 19:42

# Python 3

Range: ≤64
String length: 1759

1450311547121626824402528317931024696537261379649312109934174763622928813537772202492826340253595039354204170803308812108106614974615992407513462378342519772879316185201191244193032905219821112379362735436273595816306408247797551887198223078132707718613741551438816716228420855210133806030879152023807281213669870947286924104806420930386226909518122591340634826667470106070805067486916003620079860533420912887938893520117652588913717930472346176939267545884056248725814428845435505286970004504538242272311816219001799408190917981242794876906923463019563132633790465573335245790782921280224126868686724604452690148708017495170944952232407517716174996669514909784703378613104880109045294268293224189609735626833741340860353297694678641117508508320027700778717534109394267437425043810487352376005634156569975311491459838272217846207077798205457351267508638726235986344105746925264997271470391586921860841952986010216300093433468007980482444450140150202011970723666974568959542215223332447146301544007477846089467045557063881769289045618456873502484742102787141509146927089727415468957468932233888307541183405820990577010792332515397454508971114910082242913202656447784249727817413159197879472620373533325157697422584249026116957034499508087753326237517531666435897781090922126023766286557629116809405490739569657792496159821300551508419666991511554805528263403378295007848547483596991780931036386960716493272927989817021495881172814505517266227891225298564264160100926161641968167450456638252346252357682659194962887041698807928559518187059146398406957924003562078098158050469520030372646913304777752187530842640087708732247607019311163659185637734636533976160365822448025321873341358014966837103376648875774633227200456239875015114894085499417129719017106310570
`