# 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

# Python 3, ≤128 bytes [Safe!]

This should be a little easier than last time. I am using ideone.

36925814736925814736925814736925814736912355881042757396194265881134578032649729518416487133567902254871941746386093255780124477931639628508315477023466992153861840735376992245689114376830629527598214467913365982052851749724366891235588104275739619426588113457803264972951841648713356790225487194174638609325578012447793163962850831547702346699215386184073537699224568911437683062952759821446791336598205285174972


My original code:

def x(l,s):
c=0
while c<l:
c+=s;yield c
print("".join([str(x)[3:] for x in x(55, 0.23)]))
#                     ^ prevent the decimal giving it away


I'm a little surprised that this survived, but that's ok :)

• Everyone was scared away by the ≤128, methinks. – lirtosiast Oct 19 '15 at 3:11
• That's pretty funny if it's true :) – J Atkin Oct 19 '15 at 3:12

# PARI/GP, Safe, Range <= 64.

The length of the output is 1557 bytes.

[10198915455094544621318593833517827113941236668275800803422300605473264501228701176571207355673915359047589570012179004928924996617242563905260799277458127569243448675406492846784496764016885371194185950813604860878771421657693039656920271487283968253039538308762344610230588023468513742360221574901366698781123/1390850702467075795241114474390003408252843025448488882438982890080738085642918329463921793002578761788851088890659905691858080746334995926468671148408518063869783106085777065055369052888193447504834444431389346342797865670014961942566194805796394211697450360223302790031973242065440102303295943418353061321841, 1027369661779751465941892905024822165374792952387501091593211203375412887612069334808749236810643255223134928449822698643878798854882458635803971803547074577448858759278322033899548442741877740162606529397527110937173452360953944250398157922468181390769328078779367505847117721492367335900039476715713665490971138185839661316157694612644383692939250474535566322640507948199488628220911447122810686685553437021658875825524356849113058344567101537356993661412682766485/51870540243305805735743939415521909462178499404364382485689596078393079989266664322690298081807096491621007536316969401152067668042137403387151011624838853793458344005899930831636627017239539766216901163767865589096985131780130592334602757021171335802629188079413730951316795626341036506687586575115902526441692716278384872013204556755198478038688235855197745660830486458017564619806171647169368268130640685223561384077291512451309269740413281604997223718146331639]


ellpow(ellinit([0,0,0,0,-2]),[3,5],23)

# Ruby, <= 32 (safe)

-1666267650187848374768490813093409259520003


Solution:

eval e="p~e.bytes.reduce(:*)*3"

Explanation:

Generates a big number by multiplying together the ASCII values of the characters in its own source code, then bitwise negates and multiples by 3 just to make it harder. I don't know how you'd possibly solve this one without just intuiting most of the structure out of nowhere.

# VBScript (safe) <= 64

Output: 364821338334719204270000000000000000000000000000.000000008

You need to run it with cscript /Nologo whatevername.vbs. I'm counting cscript /Nologo as 15 bytes, the actual program is <=49 bytes.

Now that it's safe:

wscript.echo 36482&FormatNumber(Exp(97),8,,,0)&8


# bc, ≤16 bytes (safe)

283657696154934170362301055758600650791598269398973436504


<EvilGrin> Have fun with this one :-) </EvilGrin>

### Original code:

OK, this was horrible. I'm sorry.

21^48/88-46^37


15 bytes, including the (required) newline at the end.

# JavaScript ES6, ≤64, (Safe)

### Output (377 bytes):

8713370611242731842302768403441017430132011165981526145517926807202299880256290214031488282511181647338813342970322431043762227838853600373724704524160049611722180653681845NaNNaNNaNNaNNaNNaN4940323333485005257626222668708025806893266675605952299071946499761627602800859131688906303445754712870133544819968037268118863281489690576296578800898958501055636801125338543990117123977


REPL, tested this in the Firefox 41.0.1 console.

### Original

(x=_=>[...x+q+x].map((y,z)=>q+=y.charCodeAt(y)*z))(q='871337');q


# PBASIC (safe)

Range: <= 32

String: 000000184066073CB303FC6A6B901CFC14844C3543BA023499B966F6E05707C0

Code:

t VAR Byte
c VAR Word
FOR c=2016 TO 2048
DEBUG HEX2 t
NEXT
END


This is kind of a quine. In BS2, the program code is always encoded at the end of the EEPROM. So, what this does is reads 32 bytes between 2016 and 2048, which happens to correspond with where this program is stored.

(note that this was run on a regular BS2, it may not work on the BS2e or similar)

The big guns.

This is not a math op. I will give a hint in a day.

Hint: 16% of people in the world cannot do this.

# Python, safe

Output (2015 bytes)

['2', '1', '0', '5', '6', '6', '6', '4', '8', '5', '5', '9', '9', '5', '4', '1', '4', '2', '8', '6', '5', '0', '5', '2', '3', '5', '0', '0', '3', '0', '7', '9', '8', '8', '0', '3', '9', '2', '7', '2', '4', '2', '1', '4', '4', '3', '0', '8', '8', '6', '7', '0', '0', '8', '9', '5', '7', '2', '0', '0', '3', '9', '2', '2', '6', '6', '3', '2', '9', '0', '9', '8', '0', '2', '2', '1', '0', '7', '8', '2', '0', '9', '2', '5', '0', '5', '6', '9', '4', '2', '6', '4', '4', '4', '7', '7', '4', '9', '3', '3', '1', '6', '4', '9', '8', '3', '2', '4', '0', '7', '9', '9', '6', '8', '5', '7', '6', '3', '1', '0', '2', '2', '0', '0', '8', '6', '7', '2', '0', '2', '8', '4', '1', '5', '3', '5', '1', '4', '0', '9', '5', '7', '3', '1', '4', '2', '8', '1', '6', '6', '6', '4', '6', '5', '1', '4', '2', '7', '9', '0', '7', '2', '7', '8', '2', '8', '5', '1', '9', '5', '7', '2', '6', '7', '9', '9', '7', '6', '6', '2', '9', '4', '5', '4', '4', '3', '3', '8', '5', '7', '4', '3', '7', '0', '1', '2', '3', '9', '1', '9', '2', '0', '8', '3', '7', '4', '9', '6', '3', '1', '4', '3', '2', '2', '9', '2', '7', '1', '7', '0', '8', '7', '3', '8', '2', '5', '6', '7', '1', '1', '4', '2', '0', '8', '3', '7', '9', '9', '2', '3', '1', '5', '8', '2', '2', '0', '4', '5', '6', '7', '0', '4', '8', '0', '0', '2', '8', '5', '1', '9', '0', '0', '6', '8', '3', '9', '4', '0', '6', '5', '1', '2', '3', '1', '0', '8', '2', '9', '3', '9', '2', '3', '6', '2', '9', '9', '8', '6', '7', '0', '8', '6', '9', '9', '9', '8', '9', '6', '7', '2', '8', '9', '1', '3', '6', '6', '6', '8', '3', '5', '8', '2', '3', '1', '0', '7', '1', '6', '5', '8', '8', '0', '1', '4', '1', '6', '9', '4', '4', '7', '6', '9', '8', '8', '4', '3', '7', '8', '1', '3', '4', '0', '4', '3', '9', '2', '6', '9', '2', '4', '4', '9', '4', '1', '7', '1', '8', '8', '8', '3', '9', '1', '9', '3', '6', '8', '6', '4', '7', '1', '0', '1', '6', '0', '5', '3', '2', '6', '2', '2', '4', '0', '7', '3', '5', '8', '1', '8', '8', '7', '9', '5', '1', '9', '2', '2', '3', '4', '7', '0', '2', '6', '0']


Range: ≤64

Code (60 bytes)

x=[]
for i in range(1,413):a=str(612**i);b=a[i];x+=b
print x


# CJam, ≤16 (safe)

354341221131.2923xyz


The code to generate that constant has 11 bytes. So I padded it with "xyz".

Original code:

PsKmesPser"xyz"


Actually golfed a byte from my original code.

# Perl 5, SAFE, ≤32

Output:

85547195679171218736754503308731233555306328355775132346594959288367525592463131145153231485115872151324349953315183233154032535217535312775505540353147384384345753951213930993267528310951923507543975483255319544192079237930337715655555944071935651227146835247663241573532795427282356315271951195247514555671263393919951371523551968727034191501936033639407135793351615183951755475339911913075297918275031374753672103266737595511383169928472433051269140473291557145513663435913595091446726553615378357991611243910231059149199977137114935259528958194287495399492324511167278751995763117929311251379526733394715787146771129911971108317794455251118875751103512033219470755354119415545874095386711312355569131539151707359134952343554742632072619318342753514347121533637593567320745633807411506741794875187556074983317141314299639212729551539157520071515128742275451311134111335480310119155439296716833303571560316953447176743117833855987627198312273507248715992295497130272403591155117193735522337546354671510346114383164728715318314431222341074011285938747797233135369947918674863173138791275408337235079432392755834695539123914475499368746474815115526433471205520912523203118034743291362739271851531915271431279348321993819555111922113963228348271299437115031143249917434023300321152811548735432919110720672235425157398915151518756195127489921633387104713474947273946234527337590352951239365142155307138353792247439517914599423955954839144342352112312907963339420351635331167131593987257126073039254723195259807414344432367159204319477953999271543351071163527274479279953431815488720191659301522594539351926313327327405934351623258327514767579140756675703459564354152679390315631863546332555139504338911419


(1703 bytes)

Code:

print($==$=*12+135)while $=%=473  # Pip, <= 8 (safe) Here's one that doesn't involve math: ?:\ \!\"\#\$\%\&\'\*\+\,\-\.\/0123456789\:\;\<\=\>\?\@ABCDEFGHIJKLMNOPQRSTUVWXYZ$\\$\^_\abcdefghijklmnopqrstuvwxyz\{\|\}\~


Original code:

TMST XPA


Runs of three or more uppercase letters in Pip are broken up into groups of two, so the code scans as follows: TM ST X PA.

• PA is a built-in variable that contains all Printable ASCII characters.
• Unary X converts to a Pattern (regex) object. This does two things: first, it escapes all characters except letters, numbers, and underscore with backslashes; second, it wraps the whole thing in a non-capturing group (?:...).
• ST converts back to a string.
• TM is the trim operator, which removes characters from the beginning and end of a string. The binary version allows you to specify how many characters to trim from each end. But this is the unary version, which defaults to trimming one character from each end (here, the parentheses).

The result is then auto-printed.

• Really? What are these then?_________⤴︎ (Seriously though — yes, this does make a change.) – r3mainer Oct 13 '15 at 21:23
• @squeamishossifrage Edited to please your pedantry. ;^) – DLosc Oct 13 '15 at 21:27

# Ruby <= 32 (SAFE)

"8762504450324893848651280721691835717940669000462575484369396210258048929833970016297166254385132205202235180295079454023977826406979481295799194841934758121726118165990323332304568746264850532094544184088081482476162966282924240706855704443909297279711527256266149302299801021814740563741586350307136169051997209078653010929909330725a93586825476403753528022538421975387929896553841882810474799363453046018606169377669906563915966214068307559446990614728199972565468028975641938881008153501071577230002720943376a301775966920319271087407600489642777663287722163559579935799452303905473803281788975270137361183607848516570173259033490012009540073087632403050024902293445141468992599827814385979797481372233782966926361021702340409774146157255606565210355513797874130438807686870391470600158424066431303063375213722764844392000554833276485799316866946004195323665470580216216002583900494820220735082842592105660387965775910979959250091077095653612102696221426415a648773018022294769993224545803577a3763005527251908295636358910010513363179690021387446604533222751642813a8614089268a28012273422320162366569989922699128895234357942164566077868a49814885873137022055353a9846964630645022047290930125568794081376438232094470701310117203087247248634417152203131200635901456134613462592550208341287080896325568191584605164462850564148180507a062259043076691876231279478133327773460196580784756838442111201274379859744276598757985720380892316934394451373863238543152514271552134a04282987903a61885941443856a1713313317735297699830794002789480581428834630930216199054175159184988994760007300a79656926139784321218328804337480388158663865713a59654331635998377274152630834636272411578533575176582007320a703361775217144466335735439372357821466633028157921828931151a50a479279208a9016419708326819702203778835911523016342458872497769621161340668800a410301953081688442694810179113277816543124401448721857324972408282507447735612726405995653404a909146345587007109536191051a58398126a72597728470093a32078324098a634a2571552088a5057083729347915385829431416171"


source code:

p((691**723).to_s.gsub /67/,'a')

# Go, safe, <= 128

The solution is a function that returns a string

Output (192 Bytes, the first one is a space):

 ErI=a3ESiqO3v59:cdx5P1F]CN?%p[.AB.R"3X_KPTlV*iX_Pa_Tj@&09f&J"3MF,dozs1,HT!9eq0]M;xHz9jZq\B^iiAbXv>g=TuPhAJVT"T@tJfp5dsQ..oQB$C77PfyIU~W"f']=qve,nY,~"aLmI4&s)K4h3':{/0,\@sVLq{{(r}]!RXR{((h  ### Solution func g()(r string){ for i:=0;i<192;i++{v:=(((i*i*i*i*i*13-i*17)^(i*i*i*i-7*i*i*i+9*i*i-42*i))%95+95)%95+32 r+=string(v)} return}  # Python3 <= 64 ### Output: (2048 bytes) [contains a leading newline+space] ["[''", " ''", " '506'", " '2100844'", " '16480885768015478006134261'", " '31'", " '51231064846783567164130'", " '658'", " ''", " '373251426066'", " '0024374'", " '38'", " '887770'", " '1152843762281757078500'", " '423382'", " '785'", " '05438367603'", " '567564'", " '5303820606723374556206653'", " ''", " '44268'", " '88848667402548'", " '7174'", " '316'", " '306'", " ''", " '32'", " '853287'", " ''", " '5456'", " '6816008713205300041141531'", " '825'", " '76775'", " ''", " '545744'", " '83831'", " '2'", " '50421844620533737'", " '10152874572'", " '172'", " '668404688425061364680351'", " '845681'", " '37064070604810'"," '80'", " '4503'", " '7174453542130084662522727424383'", " ''", " '163125818'", " '26235757161487074433'", " '3433'", " ''", " '50511264748182'", " '5'", " '141576'", " '17'", " '7842335331482816'", " '0476674000'", " '425'", " '632632114258277'", " ''", " '22750381646086'", " '305030'", " '65'", " '5470444856387302712'", " '241145634858'", " '463'", " '42476803865'", " ''", " '13'", " '076'", " '8470'", " '854'", " '0344742'", " '61710278451047182564725'", " '5'", " '775'", " '17406521743617037663'", " '276202103'", " '8116413802'", " '51314465751'", " '52'", " '1'", " '22220'", " '888754384182'", " '3'", " '52836216418812853'", " '650361012'", " '112886663785'", " '7107'", " '047605'", " ''", " '02667'", " '188'", " '40584682045865342463662230'", " ''", " '322610688'", " '03'", " '705455'", " '446822'", " '82778633614610542447738587614445361428447386630305'", " ''", " '015403786'", " '106350626864643072234'", " ''", " ''", " '68872'", " '0625373650345'", " '83522283151523347525'", " '0624'", " ''", " '80'", " '65'", " '4568'", " '44436666612024335084654048550'", " '0'", " '841162'", " '468272'", " '808418278561140'", " '7876460'", " '74'", " '156458528033241'", " ''", " ''", " '6238'", " '4062330115717'", " '36'", " '44253041385'", " '7178'", " '063'", " '6458'", " '6'", " '621308376514372046'", " '138006421426205'", " '4201'", " '677704737'", " '65185344857310527713'", " '112434'", " '4355103 # Python3 <= 32 ### Output: (2044 bytes) ['35629008113313067636835628350892', '303090550382', '382510656', '0', '12', '98917522299926', '137283', '386083871359278870685', '191325258786013', '69', '702628960091270', '9680', '3', '789', '62987198082992568711182568985', '7383', '2', '961820028892922056', '', '55910', '5', '1270', '98167352', '8801', '53868', '', '1537', '0681318075', '39868850', '280', '625', '88109906657915173110951', '273', '03511397768', '673', '927875717', '75829953783710259666936638967265577588770317733258336', '153', '516650', '3710', '95995', '77580893911', '9099239663159822396138768811239', '386', '2017879013510390', '86619699065875232795', '521879', '56911', '3198803', '951132391', '0997897', '626', '62236251923', '05066', '537', '13717309887895', '195069062965521', '57939', '3', '50376916612802967926098', '90791', '8178669692776880339308801890992619251957', '03812', '1871327921659198980711', '52635832176863626979', '', '2378139868', '509', '76', '360', '6133107', '57', '1', '819', '0673896', '10181', '2', '3760986203123', '1553056', '892', '2', '21216800311', '931509651', '5778', '85160', '2868810712906093959', '78', '33959186650623532562665305', '20', '560582300625888182072839396', '608092253786296', '08378865665599770130273683051519933', '32738172163006197', '5372', '85', '3063225609522398736', '6357988', '966356029109321501582953761833705', '8', '52109797059265572736551068263857859', '8', '90', '256759083233180186756987093270662365', '191099', '', '390', '1869015', '0719338193', '786331381796777925855608', '1187', '30', '811', '312', '35283779919700302109018721998572115390687', '1', '58113', '21508113000', '8525', '', '333198576', '05180', '072', '2033593510190', '68586265', '18657285682325', '', '02171225975028293', '32075152', '72606', '55053759', '', '757330833', '6978591', '69189681', '099225', '79368', '6', '250889083606', '212803600913136137785', '060362519', '70', '3', '788082786820', '220159805', '1860077138960020', '7551339892', '5', '', '3', '5776870513', '71270589678751875385', '270600', '6', '213236', '71001'] # QBasic, <= 8 bytes (cracked by Mauris)  8.851656E-03  Note the leading and trailing space. • – Lynn Oct 22 '15 at 7:38 # QBasic, <= 16 bytes (cracked by Mauris) """  Yes, the output is shorter than the program. However, double quotes in QBasic are not trivial to output. ... Although there's more than one way to do it, it seems. Original code: WRITE CHR$(34)


Should've done my original idea, which was ?"hi";:WRITE"hi" (for an output of hi"hi").

• – Lynn Oct 22 '15 at 7:29

# J, ≤4, cracked by randomra

0.000198413


(Blah blah blah blah blah. This is filler.)

# Retina, <= 64

As usual, this is multiple files with +1 byte counted for each file after the first. 1013 bytes of output:

itreinareinareinareinareiareinareiareinareiiareinareiiareinareiiiareinareiiiareintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinare


## Javascript (Console) <= 128 Bytes

"xkvybybmhMxknadytmxadgjupalybuxsnqbEhehsnepcfsvqlqbehknytsdqtMpkfufililwrwhuxknidufilorCxitgjcfavwhknknytkvilybwrCnqtwzkfepcfybwrepsvsvgbgrEhuxsncnqtwzkfqborknidgruxUxidufsvilgbkvybehsnmxkngjEzozcfcfqlqborehcxkvybehsnYjwzsvqlmxadadojalybormhozCfilwrqborknidqbehehsnsdqtGjezaloruxidozmpilgbepsvsvGbsdqtgjezepsvybmhgrehadytItwzwzkfkvilybwraloruxidozMpilgbcnqtqtezqborehcxitwzCfqlkvilehcxkvybybmhmxknadYtqbehknytepcfybwrufililwrItgjwzupyjmpsvgbalybuxsncnQtqtezepcfsvqlcnqtwzkfqborKnidepsvsvgbsdqtgjezgruxadOjitgjcfavitwzwzkfkvilybwrKvybehsnyjwzsvqlozcfcfqlcnAdqtojozcfilwrqborknidsdgjGjupufsvilgbitwzcfqlwhuxqtOjkvybybmhyjwzmpkfqbehknytSdqtmpkfsdgjgjupufsvilgbqbEhknytepcfybwrufililwritgjWzupyjmpsvgbalybuxsncnqtqtEzepcfsvqlitwzcfqlwhuxqtojKvybybmhyjwzmpkfmxadgjupozMpilgbozcfcfqlqborehcxyjmpSvgbmxkngjezcnqtqtezqborehCxcnqtwzkfepcfybwrgruxuxidItgjwzupozcfilwrcnadwzupqbEhehsnepcfsvqlwhknqtezyjwzSvqlyjmpmpavalybormhepsvybMhsdqtmpkfitwzwzkfwhuxknidMxadgjupozmpilgbqbehehsnsdQtgjezaloruxidozmpilgbcnqtQtezqborehcxepsvybmhgrehadYtgruxuxiditgjwzupitwzcfqlWhuxqtojmxadadojalybormhmxAdgjupozmpilgbqbehehsnsdqtGjezqbehknytepcfybwrsdgjgjUpgrehuxsnyjmpsvgbalybuxsnAlororcxcnadqtojyjmpsvgbmxKngjezcnqtqtezqborehcxgruxAdojitgjcfavkvybybmhmxknadYtmxadgjupalybuxsnozcfcfqlCnadqtojqbehknytsdqtmpkfsdGjgjupufsvilgbcnqtwzkfqborKnidgruxuxidufsvilgbgruxadOjitgjcfavkvybybmhmxknadytCnqtwzkfqborknidepsvsvgbsdQtgjezkvybehsnmxkngjezmxadAdojozmpcfavsdgjmpavgrehadYtwhknknytkvilybwraloruxidCnadwzupepsvsvgbgrehuxsnyjMpsvgbmxkngjezalororcxozmpCfavcnqtwzkfepcfybwrepsvsvGbgrehuxsngruxadojufsvormhKvybybmhyjwzmpkfkvybehsnmxKngjezozcfcfqlqborehcxepsvYbmhsdqtmpkfgruxuxidufsvilGbmxadgjupozmpilgbozcfcfqlQborehcxmxadgjupalybuxsnqbEhehsnepcfsvqlufilorcxwhuxQtojyjmpmpavalybormhkvybehSnyjwzsvqlmxadadojalybormhOzcfilwrqborknidqbehehsnsdQtgjezaloruxidozmpilgbepsvSvgbsdqtgjezepsvybmhgrehadYtitwzwzkfkvilybwrqbehknytEpcfybwrsdgjgjupgrehuxsnyjMpsvgbalybuxsnalororcxcnadQtojgruxadojufsvormhkvybybMhyjwzmpkfozcfilwrqborknidSdgjgjupufsvil"


# CJam (safe)

Range: <= 8

Code: 52 86#~

String:

-3769533025519801141444612600471707145120923043935146475096303581721089749532607198879063741123420792669738910020570009227839890520497940913522212865


# Pyth (safe)

Range: <= 16

Code: t_^745 342

String:

-18942848238846702000737756659973646779942967140220283256962974873234094651015038671495143989847386729680241862830119337956348747334505435496991960150131121034551982157083906586221042363353408334866251481833877575640325738380374503079168022891195104162339647595360613089361593444499080793276621647497053117734633055201755474710367919777029494004364776004138911600868453848171287452776512163863332098477484323757171405610690850019500967579254668662471619927914605780575892617912202737962562003554708579864138719448663400302560158574168412816418523381065735351001346267376142327158208030285036103491585408755540424848706251111628495962962429658113888676624984684325316931016006142566504870367481109174441236965833636556838972881583460166402936459951922530197633841563299276495092457476011321253117768971252551660133748392634552348895709075329070905022753303255226600059226372955583706070513126272846148280496645228763942426652598925307055362427834099836587711251922883093357086181640626


# Python 3 - 32 bytes, Cracked

9511667971998764582180733448500755

REPL output.

• – kennytm Oct 24 '15 at 14:31

## Pyth, <= 64 bytes

01111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110111010111011111010111110111010111110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011111010111011111010111110111010111011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111100


That's exactly 2048 bytes :D

# APL (safe)

Range: ≤16

ADGJMPSVBEHKNQTZCFILORUWXY


Code:

⎕AV[65+⍒9|7*⍳26]


It is obvious that the formula must have the form ⎕AV[65+⍒???????] where ??????? is sorted downwards by the permutation

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


for example, ??????? might be

"dcbdcbdcbdcbdcbdcbdcbdaaac"


but coding that in 7 bytes seems to be impossible.

The solution has ??????? equal to

7 4 1 7 4 1 7 4 1 7 4 1 7 4 1 7 4 1 7 4 1 7 0 0 0 4


The 7 4 1 pattern eventually fails because IEEE double precision is no longer adequate to represent the correct integers.

# JavaScript, <=64 bytes

Output: 2038 bytes

00NaN573100360487769457310036048776940NaN266247541047714640NaN65254190216760520NaN34568908272755050NaN038836263287495790NaN425130624407386360NaN118277804967331650NaN50457216608722220NaN19771934664716750NaN58401370776705810NaN277160888327003360NaN66345524944689390NaN35660243000683920NaN049749610566784510NaN43604397168667510NaN129191152246620370NaN51548551336651090NaN208632693926456230NaN59492705504634680NaN28807423560629210NaN67436859672618270NaN367515777286127940NaN060662957846073230NaN44695731896596380NaN14010449952590910NaN52639886064579970NaN219546041205744950NaN60584040232563550NaN29898758288558080NaN68528194400547140NaN378429124565416660NaN071576305125361950NaN45787066624525250NaN15101784680519780NaN53731220792508840NaN230459388485033670NaN61675374960492420NaN30990093016486950NaN0030481107248148120NaN38934247184470540NaN082489652404650670NaN468784013524541240NaN161931194084486530NaN54822555520437710NaN24137273576432240NaN6276670968842130NaN320814277444158250NaN0139614580041035330NaN40025581912399410NaN093402999683939390NaN479697360803829960NaN172844541363775250NaN55913890248366580NaN25228608304361110NaN63858044416350170NaN331727624723446970NaN0248748052833922540NaN41116916640328280NaN104316346963228110NaN49061070808311870NaN183757888643063970NaN57005224976295450NaN263199430322899830NaN64949379144279040NaN34264097200273570NaN0357881525626809750NaN422082513682571550NaN115229694242516830NaN50152405536240740NaN19467123592235270NaN58096559704224330NaN274112777602188550NaN66040713872207910NaN35355431928202440NaN0467014998419696960NaN432995860961860270NaN126143041521805550NaN51243740264169610NaN20558458320164140NaN5918789443215320NaN285026124881477270NaN67132048600136780NaN364467666561313130NaN057614847121258420NaN4439092082411490NaN137056388801094280NaN52335074992098480NaN216497930480930130NaN60279229160082070NaN2959394721607660NaN68223383328065660NaN375381013840601850NaN068528194400547140NaN45482255552043770NaN1479697360803830NaN53426409720027360NaN227411277760218860NaN61370563888010940.3068528194400547

• Just fyi: new posts aren't scored since the challenge is closed as of Nov. 1. – mbomb007 Nov 4 '15 at 16:44
• OK, at least I had fun doing this, and hopefully someone else will have fun cracking this. – Grant Davis Nov 4 '15 at 20:32

# Python 2, ≤ 32 (SAFE)

Done in a REPL.

'xr<oane0p   ej xtr>gbtecxr<oane'


33 bytes of output >:D

### Solution:

(9*(i for i in[])[9:~7])[::-7] # (i for i in[]) results in: "<generator object <genexpr> at 0x24d1680>" # (or some other address) # Yes, it is deterministic. I sliced off the memory address of the generator expression, along with the beginning. # Then, I copy it 9 times and take every 7th char in reverse.

• Regarding your comment from here, yes __doc__ was my thought. However, docs depend a lot on the specific minor version, so I never posted a cop with one myself. Having said that, if this does use __docs__ it'd be good to mention the minor version, although that'd probably give a few things away... – Sp3000 Oct 13 '15 at 21:41
• @Sp3000 It does not depend on a minor version, and I would expect it to work in all versions of Python 2. – mbomb007 Oct 14 '15 at 3:36
• Sigh. I just deleted my solution for good, then realized I hadn't posted it yet... I roughly know what it was at least... ugh. – mbomb007 Nov 6 '15 at 21:47
• Oh man, I am so lucky. Following my same train of thought got me the solution quickly. – mbomb007 Nov 6 '15 at 21:57

# TI-BASIC, ≤2 bytes, Cracked by Thomas Kwa

.1308996939


Maybe I can get out of the negatives...

• Is this in Radian or Degree mode? – Lynn Nov 2 '15 at 18:16
• @Mauris Radian mode. – Conor O'Brien Nov 2 '15 at 18:17
• Just fyi: new posts aren't scored since the challenge is closed as of Nov. 1. – mbomb007 Nov 4 '15 at 16:42
• Well, it's π/24. Now to figure out how to get that in 2 bytes. – Arcturus Nov 5 '15 at 1:45
• @mbomb007 Thanks :) I know – Conor O'Brien Nov 5 '15 at 1:46

# Insomnia, ≤ 16 (Safe)

nhahtdh


Interpreter@StackSnippet

This should be easier to crack than the other challenge. Command 8 and 9 are not used, but you are free to implement your own interpreter. I don't think they are useful in this case.

### Solution

opot~dFjyf=jdLt


Similar to the other answer, it's a machine generated program, so it's optimal or near optimal. For this challenge, the most optimal solution my program could find has 15 bytes, which was intended to make the challenge a slight bit easier, but it seems that no one bothered to crack it.

# dc (safe)

Range: <= 16

String:

199339092276008550131431539990658277331606397580853212910052122692972\
774962270058161510083607537469850717483606016495688567362868528504839\
312086200313771395859886273237465478825785462016628857818060996698109\
508463277753877223995999366056374895546219988417085601908866077450569\
127028454771902535032787281691702048189967745290542.733647326


Code: 9k567v237^p `