The Mystery String Printer (Cops)

Question

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

Your challenge

• 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.

This stack snippet generates leaderboards and lists all of the open submissions. If there are any problems with the snippet, please leave a comment.

/* 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 ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
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 */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;



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

function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {

  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();


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_HEADER_REG = /<h\d>.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<\/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 OVERRIDE_REG = /^Override\s*header:\s*/i;
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 = [];



  answers.forEach(function(a) {

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

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

    if (CRACKED_HEADER_REG.test(body)) 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] : "???",
        link: a.share_link,
        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) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SAFE}}", a.numberOfSubmissions)
      .replace("{{OPEN}}", a.open)
      .replace("{{CLOSED}}", a.expired)
      .replace("{{CRACKED}}", a.cracked)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });



  open.forEach(function(a) {
    var answer = jQuery("#open-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{LENGTH}}", a.length)
      .replace("{{LANGUAGE}}", a.language)
      .replace("{{TIME}}", a.timeStr)
      .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#opensubs").append(answer);
  });



}

body {
  text-align: left !important
}
#answer-list {
  padding: 10px;
  width: 350px;
  float: left;
}
#open-list {
  padding: 10px;
  width: 470px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

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

        <td>Cracked</td>
        <td>Late Entry</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

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

<div id="open-list">
  <h2>Open submissions</h2>
  <table class="open-list">
    <thead>
      <tr>
        <td>Author</td>
        <td>Length</td>
        <td>Language</td>
        <td>Time Remaining</td>
        <td>Link (open in new tab)</td>
      </tr>
    </thead>
    <tbody id="opensubs">
    </tbody>
  </table>
</div>

<table style="display: none">
  <tbody id="answer-template">
    <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><a target="_parent" href="{{LINK}}">Link</a>
      </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.

For cracked submissions, put cracked in your header.

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).

Answer 1

Pyth, Safe, Range ≤ 8

['ashva', 'cxedo', 'ecckc', 'hhzsq', 'jmwze', 'lrths', 'nwrog', 'pbowu', 'rgldi', 'uljlw', 'wpgsk', 'yuday'

The code:

%^T6`^G5

Explanation:

To clarify how this works: I generated all possible 5 character strings of lowercase letters (^G5). Then, I generated the string representation of this list: (`^G5). Finally, I took every 1,000,000th character of that list (%^T6). The result is something which looks like a list of strings, but is suspiciously missing its end bracket.

Answer 2

VBA , [Safe]

Range <= 128 bytes

Hint for where to output

Ran in Excel 2007, output was to Debug.print. Its VBA good luck getting anything under 128 bytes to run.

Output 255 bytes

 This array is fixed or temporarily locked THIS ARRAY IS FIXED OR TEMPORARILY LOCKED this array is fixed or temporarily locked This Array Is Fixed Or Temporarily Locked I n v a l i d   p r o c e d u r e   c a l l   o r   a r g u m e n t  ?????????????????

Solution

Well I hope someone had fun trying to crack this one. I can say that this is some of the worst error-handling I have ever done and feel bad for how bad this code is.

Code

    Sub e()
    On Error Resume Next
    Err.Raise 10
    For i = 0 To 128
    b = b & " " & StrConv(Err.Description, i)
    Next
    Debug.Print b
    End Sub'

Explained

First the code starts with one of the Major sins of VBA. On Error Resume next.
Once we have committed that horrid act we go ahead and just throw and error. this is the This array is fixed or temporarily locked Error that we will soon see in the output.

The next is the loop. We loop 128 times trying to Convert the Error Description, But the only valid inputs for i are 1,2,3,64,128. Because of this the first 4 loops print the Error with Various Formats. Then when i = 4 the code throws a new Error Invalid call Then that loops and nothing is assigned to b because the strconv function errors out each time.

This is where any normal program should have stopped, But because we have the On Error Resume Next every error is ignored and the code continues unfazed by the poor error-handling

Now we hit i=32 and we add the new error to b converted to Unicode and then continue looping until i = 128 at which point we convert our error FROM Unicode which results in the ????????????????? string being added to b

Finally Print out the mess of Errors we have concatenated together

Answer 3

Mathematica, safe, range ≤ 64

Output:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Source:

Print@@Characters["GATC"][[1+First@RealDigits[Pi,4,80]]]

Answer 4

ngn APL (safe)

0.675640430319848J0.8376870144941628

Range ≤ 8

Solution

*3○⍟⍣=42

Try it online.

How it works

• ⍟⍣=42 applies natural logarithm (⍟) repeatedly to 42 until a fixed point is reached (⍣=), yielding 0.31813150520476413J1.3372357014306895.

  The initial value doesn't really matter here, as long as it's neither 1 nor 0.

• 3○ applies tangent to its right argument, yielding 0.07343765001657206J0.8920713530605129.

• * applies the natural exponential function to its right argument, yielding the desired output.

Answer 5

Pyth, cracked by Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Range ≤ 8

Answer 6

><> (Safe)

Tested on the online and official interpreters.

Range: <= 16

String: 4621430504113348052246441337820019217490490

This is pretty 1337, huh?

Explanation:

Here's the source code (15 bytes):

f1-:0(?;::0g*n!

f pushes 15 (our counter) onto the stack (this is skipped by the ! at the end so as not to push more than one counter)

1- subtracts 1 from the counter

:0(?; The frowny face tests if the counter is less than 0, the rest ends the program if it is

:: Duplicates the counter twice

0g Grabs the character at the point (c,0) in the source code where c is the counter

* Multiplies the second duplicate of the counter by the ASCII representation of the character previously grabbed

n Prints the result.

So, split up, the output is [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. This corresponds to the ASCII interpretation of the code in reverse multiplied by the numbers 14 to 0 (i.e. [!*14, n*13, ... f*0]).

Probably the hardest part about cracking this would be figuring out how to split up the numbers correctly, but if you get the right ones it's just a matter of trying things until you get something that works.

Answer 7

Snowman 1.0.2

Range ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

The solution is:

"mO~(!#]/.}{k2'=+@|":2nBspsP;aE

Answer 8

Perl (safe)

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Range ≤ 32

Solution

print 2**y/124589//for-951..1048

Try it online.

How it works

• for-951..1048 executes the preceding command for each integer in this range, saving it in the implicit variable.

• y/124589// performs transliteration, eliminating the specified digits from the implicit variable.

  y/// will return the number of eliminations, i.e., the number of occurrences of those digits in the implicit variable.

• print 2** prints 2 to the power of eliminations (1, 2, 4 or 8).

Answer 9

Matlab, ≤16. Cracked by Wauzl

Range ≤16.

This works in Octave too.

The printed string is as follows:

ans =

     0     0     0     0     0     0     0     0     0
     0     0     0     0     9     4     0     0     0
     0     0     0     0    32    18     0     0     0
     0     0     0     9     1     0     3     0     0
     0     0     7     0     0     2    10     0     0
     0     0     3     0     2     2     3     0     0
     0     0     0    19    63    22     1     0     0
     0     0     0     4    13     4     0     0     0
     0     0     0     0     0     0     0     0     0

Answer 10

Python, <=16 (cracked by kennytm)

[[[22111101102001]]]

This was produced via REPL (running a command in Python shell).

While I'm editing this, I'll also summarize the comments for future spoiler-free robbers: this doesn't work in all Pythons. It does work in a build of Python 2.7 where sys.maxint = 9223372036854775807.

Answer 11

CJam, ≤ 8 [safe]

379005901358552706072646818049622056

I don't like long numbers so here's a short one. Feel free to fiddle both offline and online.

Since I find number-only submissions pretty boring, I'll be slowly putting out a few hints to compensate.

Hint 1: The program ends with a single number of the stack, and none of the A-K variables are used.
Hint 2: The number encodes information that is completely retrievable if you reverse the process (i.e. no information has been lost).
Hint 3: The "information" from hint 2 is a single string which is created after the first four chars.

---

Solution

The program was

0W#sWcib

0W# is 0^-1, which instead of erroring out gives Infinity. s then casts this to a string (note that ` gives 1d0/ instead).

For the other half, Wc converts -1 to a char, which becomes code point 65535 due to the wraparound for chars (see this tip). i then converts the char back to an int, i.e. 65535.

Finally, b converts the string Infinity to base 65535 to give the above number.

Answer 12

TI-BASIC, ≤4 bytes, cracked by Reto Koradi

This took 5 days 23 hours to crack. So close...

Output (10 bytes):

.495382547

Program:

³√(tanh(7°

Since it's basically impossible for someone to guess this, my goal in designing this program was to make brute force the only possible approach.

To do this, I prevented the output, or the output with one of these inverse functions applied, from showing up on the ISC. ISC doesn't have hyperbolic tangent, and I figured that no similar tool would have tanh(7°.

To add some security against brute force, I used degree-to-radian conversion, a slightly obscure feature, but it wasn't enough.

Answer 13

><>, ≤ 8 [cracked]

oooooooooooo

That's a total of 12 os. The program halts without error, and works with both the official interpreter and the online interpreter.

Answer 14

Javascript (console), <= 32 (cracked by insertusernamehere)

"a,a,0,a,b,a,a,b,a,a,4,a,b,a,a,a,a,6,a,b,a,a"

Tested in Chrome and Firefox web consoles. That's a 43 character string.

My intended solution was a bit more elaborate than the linked one (curse you, ES6!).

'a,b,a,a'.replace(/(a)/g,Array)

Explanation:

When you call replace with a Regular Expression with the /g flag and a function, it replaces everything matching the regex with the result of calling the function with these arguments: The matched string, every capture group in the matched string, the index the matched string has in the whole string, and the whole string. In this case, that'll be "a", "a", 0 or 4 or 6, and "a,b,a,a". All of these arguments are passed into the Array constructor, which simply creates an array of everything passed in. Then replace converts that to a string, e.g. "a,a,0,a,b,a,a" and replaces the "a" character with it.

Answer 15

Lua, ≤ 4 (cracked by feersum)

Output:

9.5367431640625e-07

You need to find a string for Lua REPL which results in "1/M" constant.
It is simple, but not very trivial.

Answer 16

Python, <= 32 (cracked by Egor Skriptunoff)

Output is 1832 bytes, including newlines:

163
485
559
1649
2707
8117
8415
24929
41891
124133
142639
423793
694675
2075317
2162655
6357089
10682531
31785445
36635183
108070513
177408659
531963829
551493855
1633771873
2745410467
8135173349
9347869999
27774121841
45526653331
136007297717
141733920735
416611827809
700079669411
2083059139045
2400886719023
7082401072753
11626476472979
34862249549749
36142149804255
107069239746913
179920475038627
533147175478501
612629840276783
1820177075697521
2983606407043475
8913418645908149
9288532499693535
27303489359118433
45881121294188707
136517446795592165
157346912904610351
464159319105013361
761964388609624723
2284767248741900213
2368648071721459935
7016996765293437281
11791448172606497699
34940303480791033061
40148795925132553519
119288945009988433777
195535487181321247123
584146895667469134517
608742554432415203295
1789334175149826506849
3006819284014656913571
8946670875749132534245
10311729937203639353903
30418680977547050616433
49935336207531756227219
149732221646300430475189
155229351380265876857055
459858883013505412260193
772752555991766826787747
2289849682101787770873061
2631225127929856733097263
7817601011229592008423281
12814491939404182769539475
38282841570818685533137589
39893943304728330352263135
117267593836794179779362913
197057915416468570144702627
586337969183970898896814565
675799844894514912336740911
1993549095225501056249169521
3272612129033008707863251603
9813000610033591312052461493
10173266001408484771580813535
30137771616056104203296268641
50643884262032422527188575139
150067460764265635881358255333
172437765505860562200296238383
512342117472953771456036566897
839818522529453467650609486227
2508891813142320379359897758389
2614529362361980586296269078495
7685131765672974922140201517153
12914190492831906312462400487587
38425658828364874610701007585765
44288542855785494654395594310191

Answer 17

CJam (cracked by Dennis)

Length <= 4

1737589973457545958193355601

I don't give this a very high chance of survival, but I wanted to try a 4 byte solution anyway.

My code was exactly what Dennis reverse engineered:

H     Push 17
J     Push 19.
K     Push 20.
#     Power.

CJam then prints all of the stack content, concatenated. So the output was 17 concatenated with 19^20.

Answer 18

Pip, <= 16 (safe)

This is my final Pip submission, I promise. :)

0123456789
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0123456789

I'll be surprised if anybody gets this down to 16 bytes--it took me quite a few tries to make it fit. (Take that as a challenge if you like!)

---

Answer:

Px:J,tLtP09JsX8x

This code makes use of the predefined variables t = 10 and s = space.

    ,t            Range(10)
   J              Join into string: "0123456789"
Px:               Assign to x and print
      Lt          Loop 10 times:
         09         This is a numeric literal, but it can act like a string "09" because
                    strings and numbers are the same data type in Pip
            sX8     8 spaces
           J        Join left arg on right arg: "0        9"
        P           Print
               x  Last expression in a program is autoprinted: "0123456789"

Answer 19

Python 2 (safe 16)

(1.06779146638-0.024105112278j)

Range ≤ 16. In case the version matters (for printing precision?), I'm using ideone.

I don't see a way of guessing the code without computer search, but you all have impressed me before.

---

Answer:

print.7j**8j**2j

Answer 20

Ruby, cracked by kennytm

Range: ≤64.

#<MatchData "@@" 1:"@" 2:"@">
"#<ArgumentError: unknown command \"\\x00\">\nu#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nk#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nw#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\nc#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\na#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nd#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n\\#<ArgumentError: unknown command \"\\x00\">\nx#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n"

(And yes, all output is to STDOUT.)

Intended solution:

test'@@'=~/(.)(.)/ rescue p"#{$!}#{p$~}".gsub(//,$!.inspect+$/)

Answer 21

TI-BASIC (cracked by Thomas Kwa)

TI-89 variant
Range: ≤8
Output length: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

I don't think you can use RIES on this but I doubt it will survive 7 days anyway. Oh well.

Code:

236!

Answer 22

MATLAB, cracked by Tom Carpenter

Range <= 16

ans =

        5760       22320
       13920       53940

Answer 23

Mathematica, Cracked by Sp3000

Range: <= 32

808017424794512875886459904961710757005754368000000000

Answer 24

CJam, ≤8 (safe)

\"3.341594\43181\

Original code:

P`_`_`er

That is, to start with 3.141592653589793 and replace each character in "3.141592653589793" with the corresponding character in "\"3.141592653589793\"". With the duplicates removed, it's actually replacing ".123456789 with ""35\.49831.

Answer 25

Thue - <= 64 Bytes, cracked by histocrat.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

That's 2016 5s; by the way.

Answer 26

GolfScript (safe)

44460233687688399109436699097976761322375660878906252846699686946304

Range ≤ 8

Solution

{9?7*}.%

Try it online.

How it works

• {9?7*} pushes that block on the stack.

• .% duplicates the block and maps it… over itself.

  GolfScript performs type casting like there's no tomorrow. In this case, the interpreter expects an iterable, so the original block gets cast to array, yielding the following array of character codes: [57 63 55 42].

• The block itself elevates each character code to the ninth power (9?), then multiplies the result by seven (7*).

  For the four character codes in the array, this pushes

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Before exiting, the interpreter prints the four integers, without separators.

Answer 27

C++ (Safe)

Was so close to getting the source below 64 bytes...

Here's the output:

0020002488100002416161816160248810000243232343232323436404042000241616181616323436404042000246464666464646668727274646464666880808280800248810000243232343232323436404042646464666880808280809698100104104106000241281281301281281281301321361361381281281281301321441441461441441281301321361361381281281281301321601601621601601601621641681681700002416161816163234364040420002464646664646466687272746464646668808082808012813013213613613812812812813013216016016216016016016216416816817019219219219419620820821020820822422622823223223400024256256258256256256258260264264266256256256258260272272274272272256258260264264266256256256258260288288290288288288290292296296298256

That's 664 bytes of output.

The source was <= 128 bytes

Solution:

#include
int main(){for(int i=0;i<300;i++)printf("%d",i&2*i+1+i&(i+5));}

Uses the 'bitwise and' operator.

Answer 28

JavaScript ES6, ≤128 bytes - Cracked

Output (1124 bytes):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Have fun, and good luck!

Original code:

new Array(254) .fill(0).map((x,s)=>s*s-s/((5-s)||3)).map(Math.floor).join``

Answer 29

Insomnia, ≤ 64 (Safe)

ProgrammingPuzzle&CodeGolf

I would like to assure everyone that I didn't just pick this string off the top of my head and post an answer without checking whether a solution exists or not :P

Interpreter@StackSnippet

Hint

Since instruction 8 is ambiguous, it's not implemented in the interpreter along with instruction 9. However, the solution doesn't contain instruction 8 or 9.

Regardless, I accept any solution which runs correctly with either of the two possible interpretations of instruction 8. Feel free to implement your own interpreter for it, or update the interpreter in the link.

Solution

(ddG=
pjyn><p"e=pdjj<LdtdFjuy~nod=nL<yf="f<ujgFutpt(p=<(oj!>o<pL

There is no trailing new line at the end. The solution is optimal or near optimal, so it's hard for human to actually derive this by hand.

Answer 30

Ruby, ≤ 64 bytes (safe)

213 bytes output:

pooppopooopoopopopoppopqooqooqpppqpqqoqppppproqopoppqprppoqptqrutqqqrqppqtppuqovsurprwprypsorqutsvppxpsaypqupsxavpqpxyqttvxwapuosabseogzrggxprtrceqduzrqtiawpjerbpdytupxlnlptqqbpojxxnnjklzepjuoshwgjfgnnequpcncebhub

Solution

Just some large number in all the bases from 2 to 36, with the digits shifted around a bit. The number 631381 was chosen because it stayed within the 26 first digits in all bases so that the final output, when rotated more than 10 places, would only contain letters.

When shifting the digits back, you can see that the string at first only contains zeros and ones, then a few twos, then some threes etc, making it the pattern quite obvious.

35.times{|i|$><<631381.to_s(i+2).tr("0-9a-z","o-za-n0-9")}

Answer 31

Java (safe)

Length <= 128

Output (1412 characters, # is the first character):

#-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0

The program was

class T{public static void main(String[]s){for(int i=18356,t=0;i>1;i-=13,t=i%97)System.out.print((char)(t>88?t%10+48:t+35));}}

J Atkin was on the right path when he mentioned the number 13 in the comments.

Answer 32

C, <= 64 (safe)

2000 bytes of output, including a trailing space (though that's not important, it could just as easily be left out):

cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog 

---

Code:

main(i){for(;++i<2002;){putchar("tg cdao"[i%4*2+i*i/97%2]);}}

What it does:

For each i, compute i*i/97 (integer division) and take the least significant bit of the result. This gives a fairly random-looking string of 1's and 0's: 0000000011110000110001100100110110100101... We use these bits to determine whether to take a letter from cat or from dog, and we use i%4 to cycle through characters 0 through 3 of the selected string. In Python, ungolfed, it might have been ("cat ","dog ")[i*i//97%2][i%4], but combining the subscripts with math is fewer characters and much easier in C. 97 was a nice divisor because 1) it meant the output only cycled after 388 characters and 2) it happened to begin the output with the actual words I was using.

Answer 33

TI-BASIC (cracked by Thomas Kwa)

Range: <= 2

String: -10

Code: Xmin

There's just no fooling this guy...

Answer 34

AppleScript, ≤ 2 Bytes Cracked

"Brute forced... grumble grumble..."

What's this? A short AppleScript answer? :o

missing value

(yes, this DOES print to stdout)

Answer 35

><> (Fish), Cracked by Sp3000

Length <= 8

>>>>>>>>>>>>>>>>>>>>>>>

The output is 23 >'s and the program produces no error.

Answer 36

CJam, Range <= 16

So, this is embarrassing... I lost the program. So this answer is unsafe for all eternity. Crap.

1012718281828459045273890560989306532008553692318766845459815003314423651484131591025766640342879349273517109663315842845858298095798704172839810308392757538410220264657948067181159874141715197821216275479141900392134424133920089205141202604284164776815326901737247211071688861105205078721724154952753575314718656599691373305114285

Answer 37

Stuck (cracked by Thomas Kwa)

Range: <= 8

String: 46411484401953

Code: 21 6b9^

Just a silly math op. Won't be doing that again :P

Answer 38

CJam, safe, <= 8

String (512 bytes):

31727830821534042803654900580041579944125099215829830038849883087237485384990372997137008773602561554524455355546965826217636264280531379575060368678123679591507670376378983011031372862444170088901246406464915421417735501844369384343529103866975162261323889938505690754099908479501571769966236353640152428123626259639270728536136695534152761505469883628985035665299649482133954805098589954263750507014493822638005349453618584045569842991716571963837585058144921186599068741714697983434201508077928870739706904563

Solution:

JK#)K#D-

The value is (19 ^ 20 + 1) ^ 20 - 13:

J   Push 19.
K   Push 20.
#   Power.
)   Increment.
K   Push 20.
#   Power.
D   Push 13.
-   Subtract.

Answer 39

CJam (safe)

2969522710354117782268728281657874436077523451779189557858587124583732510232011182279648629302843012289537453156332620095347999870372186093569331972697450949571859995882165462952598378969103716558199013336239649166612855864402550284067775310029003979877576199234109704434192635868502534981511417768215602068546604589986237229981031515030844801890461800301300586064632275590967524506584831641691973705609466213993115716532669668183228671719799797562347371977329411936519256700981805373719919563640081628731389259795576339314694437080532378397585079403456215187549555967563283027604516908978269967118530905535308199228549578026691375975460991281557011399137527701055702769707536280006211461419462578004525812149844993765514697489735731025966784896379532108289602755662085743159982449970234950573500056692724864838103316392136519596778919106341667367801619890408628376816766014332163973769272783086065478133370857238494654315760990599225291037789853075070883915266958971748930365643994352950540496292548233966198335335092270718914517713429711934658808391076425410875435074192671012252715659331835221032454345564515855711607560938486720828374134819056045908284745381899992891870848325899309936307806608248782453178135052097370046402306272117696828073734127833151006582338686565489219479914533172914156409774220012911422325101334215197613438518304374272539625228307215875879830003850943261471668455041684061881784918857016574652559502693026187748485672247569179975106384082858131188717254923758658030214195014268064074865548117365871337277792602175655153982608733754392934636625990612708894514702745610870084535682834239693756847083681367634543706897751979399419992664301243055818300975493542084844509307521718271958163217805654531672244843277091018869783464554836938615149100691788966169099253377254362419671264475928212313071437014017258081820799682807812996637402619207718937561360621651155389611664139610329091736456106709712362258586867241270561371701064645520801674199626189861414161065280851185396832

Range ≤ 8

Solution

5e!e``Bb

Try it online.

How it works

• 5e! pushes all possible permutations of [0 1 2 3 4] as an array.

• e` performs run-length encoding. Since all permutations are unique, that doesn't do a whole lot here. It simply turns, e.g., [0 1 2 3 4] into [1 [0 1 2 3 4]].

• ` pushes a string representation of the resulting array, i.e., "[[1 [0 1 2 3 4]] … [1 [4 3 2 1 0]]]".

• Bb converts that string from base 11 to integer.

Answer 40

PARI/GP (cracked by Dennis)

362871

Range <= 4

I don't expect it to last long.

Answer 41

Fourier - Cracked

Range: <=32

String:

2122483225681922097152171798691843602879701896396861897001964269013744956211222300745198530623141535718272648361505980416138034926935811275748695117245540509049022179443407731103250484475985923078281734093318688459300007823719828521854630505113020933460422206697013398219579016739551162884034438017811742724249103942534136789516705652419749018636744941816255385595553105603228478886817941913300018121834285351114635889972008122772634701221657915276159830132698815550650166683145752253825024130799390525667397576712042121582252265796485803898145439910936080365118545524429015283005226525373306591146596380999368308977696007362554150202362972394711962091891782522350896253352112577772728002370387610430602826927993986801361806220018873011021906386675753009547945073606343415825034633858252855578020596367555775021017581896705394774043140172299149272778867192103837211440298730978220217461771857441901426311729681383820569104974145481270877016012649453231348275519970913382122931358798794913451593854784081756995081772717065856294736122642489533802911558562892537346452028109264847224473615121287113076915002394139208578086177686115257497354785332151612870275311503343425837268382273205956262450375487052304152420010520592218930639911558485308199423713696620200782955806727269571220627865960521160791605471835355486134202329528196715632135831547021667820610489669276412307052313282798182724228494489571749785803184288017511963522262363914512187106605499089158487126931984998931607232391153536046707042953355790522537094715328944294216691664397407079523074157949383649613963144290903909350911775369346530804545543989831547266901148133975781331624980745497418452932259866320677062287020172601937538303131944333834647775468710319343284001431665213130766208748703580971865899367058864133080365305110228654823694689069629811633466999394638916807976061252245511624205865226492647247562826021570513721099219359990299022601672140852584716895460404747374717998459657246694308370646635919987895996736789540655850081764170577611893869560559643310988147153698816

That's 2047 characters for the doubting person ;)

Clue:

This is a variant of something very common, which is known and loved (possibly) by both mathematicians and programmers.

Answer 42

Python 2 (safe)

6827526938285133941673000231813168619941300497097936591748380508088909429445611165463624032127627532803234880684278865355076531262231840494975595460968129959347104225901744872847426849492584955132469122376660991207547055101929306267237604577722010893773043497283203607878662025645581606573723842423809514070028255417440212506882886554655415227255545579921342691580901906655429920934202998813117772871149920709038390132067329036138426507171331383525723381813108558141195500901960258557975441280

Range ≤ 32

Solution

a=b=9;exec"a*=b;b^=a;"*9;print b

Try it online.

Answer 43

PHP, Safe, Range ≤ 64

The length of the output was just to obfuscate. I left the --sign as a prefix to the numbers as a hint that trigonometric functions might be involved.

The function to calculate each number:

The source code, 42 bytes long:

for(;$i<607;)echo ceil(++$i*tan($i/pi()));

Outputs a 2044 characters long string:

12514-240-17-9-5-215102154-240-39-20-11-4292039111-240-57-29-15-54153162195-239-72-37-19-57224490333-238-83-43-21-5113059123599-236-92-48-23-41639761641319-235-98-52-24-121509621710552-233-104-55-2422862120285-2434-230-108-57-2353676147377-1234-228-111-58-22104592179507-880-225-112-58-191655109217704-710-222-113-57-1622661292621040-610-218-113-56-1230781523171741-542-215-112-53-738921783864110-494-211-111-50-247108208472-22745-456-206-108-46558126242586-3376-427-202-105-421269145281740-1922-402-196-102-372082167328962-1386-381-191-97-3129971923821310-1106-362-185-93-24391122194481935-932-346-179-87-17501302505273386-814-330-173-81-96214928562710550-727-316-166-74-076170325753-11334-661-303-159-671090193371920-3899-607-290-151-59211062194241151-2426-563-278-143-50331232474861491-1794-526-266-134-40451412795592044-1441-494-254-125-30591623146473103-1215-465-242-116-19731843547555958-1057-439-230-106-88920839988941232-939-416-218-9551062354501062-9088-848-394-206-84181252645081294-4231-774-374-194-73321442965761619-2810-713-354-181-61471663316552113-2130-661-336-169-48631893717492951-1729-616-318-156-34802144148624693-1464-577-301-142-2099241463100110548-1274-541-284-129-51182715191176-59009-1131-509-267-115111393035821404-8127-1019-480-250-100281623396541713-4459-928-452-234-85451863777372158-3112-852-426-217-69642124208352853-2411-787-402-200-53842404679524097-1978-731-379-184-3610527052010936978-1684-682-356-166-18127302579126821051-1470-638-334-149-01503376451491-22742-1306-597-313-131201753757211784-7593-1176-561-292-113402024178082188-4625-1070-526-271-95612304639092783-3355-981-495-250-758326151310283748-2648-905-464-230-5610629356911705592-2196-839-436-209-35131328631134410543-1881-780-408-188-14157366701156069591-1647-728-381-16781844077791838-15855-1466-680-355-146302134518692208-7251-1321-637-330-124542445009722729-4750-1202-596-305-1027927755310933517-3554-1101-559-281-8010431261212354852-2852-1015-523-256-5613135067614057623-2387-939-489-232-33160390748161516880-2056-873-457-207-81894348291878-98654

Answer 44

Python 3, Cracked

Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

<= 128 bytes. This one was posted earlier with a smaller byte count, but was deleted. I figured out how to do it in the <= 128 category.

My code (94 bytes):

p,__builtins__.print=print,lambda x:x;from this import*;p(''.join([d.get(c,c)for c in s])[4:])

Answer 45

><> Cracked by Sp3000

Requires the official Interpreter

String:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

Range <= 64

Original Code (poorly golfed, I know. x.x Was rushed as trying to do other stuff, Sp3000's code is far superior)

   "%e@"&b+:r\
;v?:-1&:*}:{:<
 >&:"=@"@%+o ^

Answer 46

CJam

Range <=8

31750158586652376823306770524160580239759220968490662365280697333523990463193796504719728904832671151360272625266534588786424734457574712153976494064953411059739792915722586949729210719621153746894802142918027970654609398438852308624078542639175128838831245786273442836511403960499435950211913983569988987209742058089855692071657841384645297208882183542051537989712878902231738195073256758864262540198959691481289564731544298150520509963645384433851976251199310574577965940322710082134532284930147152412624

Answer 47

MATLAB, <= 8

I believe we are allowed to post another answer in the same question as long as it is not in the same range. My last one was 8<r<=16 by my understanding of the rules, so for this one:

String:

    [51x51 double]

Note: This will produce ans=, but that is not part of the output string, it is simply MATLAB saying where the output ends up - but based on the comment on my last answer it is important to know.

---

Now that this one is safe, the code used is:

logo;{L}

As a bonus, you also get a picture of the MATLAB logo. Running the logo script produces a variable named L. If you wrap this in {} you get a cell array which because there is no semicolon MATLAB prints out the size of its contents.

Answer 48

Pyth, Cracked by Sp3000

Range: <= 4

New, valid answer

I'm sure this can be brute forced with such a small program size, but lets see.

3582409715080948947248394822102989658717877178836918915255342812682764990143662880

Answer 49

vim

Range: ≤16 (keystrokes).

Qb lbh qrznaq n fuehoorel?

Answer 50

Python, ≤ 64 bytes (safe)

range ≤ 64

output (1334 bytes)

cpKKhcKhcccpcE3lA!3 AKl!KllA cAlh  p!clAlhc!plhhE cpp3A33chEhKll ccphh  !3 l  lK!pEK3KhKEAK KK!3ph!c!3EKhKA!3AKp3lAK c3EpEp!33!EE Kl EAh!KAl3EhEccAA E3ppE3AA3pc  3pphEEK!A!!3cAhcpcEEc Al K3  33 hKpllplcKh3p3 phpAKE!Khcchp h 3 cc!hhc3EKpp!KcKcl  h!p!p3 l!clAlAch El!AE!pEhAlppAAhpK3chplApp!lApE!3 hAEKEp!AhKl3l Al3A3KEh!3 ElKK3pcp AppK33 !KKEphhpK3A EElp!lEEAEKKc h!h EhcpEEclKEp  lcllEK3lAK3E EK3KcA!cEpcpKKKllcEpAlEp!pKl3AKpAphhh!lhhhpAcKAAKlchcpA!lEhch3 hK3!l!cAcpA Ap cEl 3l ppAAAh A  !!EEKE !l!KhKEcKAc 3ch E!lhl3cAKElE3EAhlA33!pElA3c3lKl ! clp clAE3 AApA!c3cK Ac!c! hlhhhh!plcc! ppEE3chl 3!E!EE! AchpAlpAlEchchh3!lEhhEhhppK!EEE AKKEp!  lpp pKclhpAlAKA! lEAhhpAhE3 cpp!llllh lccKEcEhllKcEKEpEAcE!Ehlh3c!A 3l!EK  AAE 3 Ap3 Eplcl!!chlA3KEpE3KE!AhcKl3!p K E! KlAA3lEEKp !!p ph!!!!pA3pEK  3 c3lpp!A3!K3A! 3Kcl3pcA!AAAhA!cc!3!!Klh3 AEphppEcp3pccppAKlcpcl  pA!p!Ac3lAh!ll!phK3hKh!AAhh h!EK!pcAKhcpEAcEEEhKl lhhEpKpKlhAK3cA!!cphh!Kp c lhccEAhl3h3A! 3AElcEAlhhE hAlp3lEp E  3lEE!K3 hc3p p3 3lAlEK hKc3cEcKp   ph!K  !hhp!Alcpc3E p33 cEcplh33pA33h!pElhEc!hKEhcElcl!Ec3l3hphp! hEK 3AEAEhAplApAA! lppKApE3cEhplcclAcc3!!hA!lp3cp Kll!h!phhlllhl!clKEchElAlEcEKll p!3A KlK Kcp3EKEA!p33!c cAAAcAh3KE3K!AAhcE3hlcKhKK!! K!pE lEpcA lEl AElpEK 3EEpllA  hl  Ahl cA!ph phhp cAccK K!lp3 KhE3!Ehc  ! 3KEcc 3lE!c3KhEK EcAEApAAKK!ApEA!A c!A KE3 cl pKp l E

---

The code:

print(''.join(' Ac!hKlEp3'[int(i)]for i in str(2**4423-1)))

It exchanges the digit characters in the 20th Mersenne prime for some other characters.

Answer 51

JavaScript (cracked by NaN)

Range: ≤16

Output (17 bytes):

28274333882.30814

Answer 52

PHP, safe, <=128

Output (190 bytes):

2.550(3 6*117!> 9/:0 5;*<#<(? ;:":! "=9*%3%1;)'32'*0+=+0% .0-5,+469$081+=/6,7!5'8'9&9%:*?'<(>)%.!7"<&$ ;';%8<):((7*4*0(2,;))3!/'3/2-1(0+5#(87(6.;#9$9$;&<'?!?)<:'>#=&$$= "!!%=$6*3)0+=/+1#-54!

Update: I noticed that the output depends on certain system settings and also had contained non-printable characters, I had to change a few things to fix that, so now the result looks completely different.

Solution

<?$d=dDSzWmMtoYy;for($i=31;++$i<127;print(date($d[substr(sin(deg2rad($i)),9,2)%11],$i*1e9%14e8)^chr($i).chr(158-$i)|~ßß)&~"@@");

What it does

Use date() with parameters that result in strings with at least two characters (but independent from timezones) and with different timestamps, then XOR the result with two characters defined by a simple loop variable and restrict the result to the printable ASCII range with |" " and &~"@@".

substr(sin(deg2rad($i)),9,2)%11 is used for pseudorandom numbers between 0 and 11, $i*1e9%14e8 for timestamps between 1970 and 2014.

Answer 53

Python 3, <= 64 bytes [Safe!]

The length of the string is 2034

488281245549883988617831547692636280774840973865020014963780603107176397111896466371318141671145799999516100116931775007357195385943921474836432356840327258293593328268244373089608827337244259136765312454003133867435356466747291945665131452813556182860860218727636513199372703748751775964829808191999995882592301095002084771021688666210978063483117859223581264272609313550818776145126277071553066533716607531245177459141211894859378720218443227215584306532297162157724461180923260303751492768257439729421254663312499999953317250470135192575597373141342613954121932341877988764443287222534689782349049589822587524093784585536128124558450454750616819589076506099226468592894493722831489207613738508380161381300843610672778874252672293311999995980758867671030407487171082133122351136004711631192092895451250470044131311210285791374389534671440085519551508377812451579347857531653079000271729656516751809167643331891701606391977349652432066205078262158363261572253921691562352979999952455639992082562005678372672183305842786281390032904410747023026684525733153218240423284129803473419539558263559570312453704347371323853998571474008654314614168447601734333514067334503992014034680022447274861749110375049318519655242879999955442585720255648590729575861052993076080133428436305995942336538807467336778737998817025960632277280651600727542990312457813159388868091344702678377735416228672524020138975906372029288081735639609252820049939625819171027941045148106288199999510988071352161135738504077117369852840612127100026831252796098139129398036689313362867460951379739562107142436353469314701837812451517225821015156551557938716150793921591665944009853171813660204517716847617231826616509655188296029879719407450187071999999999995206075501878221230403011972186886527880225232483852323193868364202388104593053245851065268425306380369872604520249690268019128124527576856135182837038224507291828459307030014607036933086603051264317374864588332629350176813354200221677344758284264135431219999953640857352723374082910431738430780077293947645370363

My code:

print("".join([str(int((i**6)/32-5))for i in range(50,225)]))

---

_{I think I made it to hard...}

Answer 54

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`

Answer 55

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);}

Answer 56

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.

Answer 57

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

Answer 58

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 ;)

Answer 59

C <= 64 (cracked by kennytm)

111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011

(output is 1974 chars long)

Answer 60

Perl, <=32 (safe)

This one might be a bit tricky:

3241713134202822035372146147538395543335603758546591813832316426477542

(70 bytes of output)

---

Original source code:

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

Answer 61

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);

Answer 62

AppleScript, ≤ 32 bytes Cracked

Output

(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)

Total: 2044 bytes

Hint

There are FOUR STDOUT equivalents in AppleScript.

Answer 63

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

Answer 64

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

Answer 65

Python <=64 Cracked by @Sp3000

[1.0, 1.005037815259212, 1.0206207261596576, 1.0482848367219182, 1.0910894511799618, 1.1547005383792517, 1.25, 1.4002800840280099, 1.666666666666667, 2.294157338705618]

Just for clarity I'm running this in Python 3.4.1 64bit on Windows. I expect there will be slight floating point differences in the calculations on different platforms, so if you can get it to within 6 or 7 significant digits of each value you can call it cracked. Once cracked, I'll post the code and an explanation.

Hint: I take my inspiration from the universe itself :)

Code

print([1/(1-(i/10)**2)**(1/2) for i in range(10)])

Explaination

This comes from Einstein's theory of Special Relativity, specifically the Lorentz transformation for Time Dilation. An object traveling near the speed of light will be observed to experience less proper time than an observer at rest. The limit as V->C, time dilation becomes infinite and time will slow to a stop for the traveling object as observed by an observer at rest. Fun stuff to wrap your brain around :)

Answer 66

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.

Answer 67

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.

Answer 68

Thue, <= 64 (cracked by Thomas Kwa)

yellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowred

Working on ppperry's Thue puzzle made me think about what the next level up in difficulty could be. Here, the problem (if I've successfully avoided loopholes, anyway) is to make a nondeterministic language produce nontrivial deterministic output.

Answer 69

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.

Answer 70

CoffeeScript, ≤ 64 bytes (Cracked by kennytm)

Output (1437 bytes):

0bnQ=bXM=bGY=bmU=bGw=b24=YXk=b24=b24=ZGU=bnQ=bWU=dGU=b24=dHk=bmQ=bnQ=ZGU=aXA=b3I=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=ZnQ=ZXI=b20=b3I=dXM=dXM=bGU=dGg=c2U=b3I=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=ZnQ=b3I=bGU=dGg=dXM=aHQ=b3I=bGU=dGg=bmc=bGU=b3A=b3I=dXM=dXM=bGU=dGg=dGg=b20=b3c=bmc=bmc=ZGU=YXI=aXA=dGg=bGU=b3I=b24=cnM=bmc=bnQ=bnQ=ZXQ=b3I=Y3g=Y3k=b24=YXk=bmU=bHM=bmQ=bGw=dHk=bGU=ZXI=ZXg=aXM=b24=b3c=b3c=bms=YXA=YXQ=b3I=dHk=bnQ=bHk=bmc=emU=Y2g=bGU=bnQ=ZXM=aHQ=YWw=YWw=aHQ=bmc=b24=bnQ=ZnQ=bmc=b3I=aHQ=bGU=Z2U=b24=cGU=aW4=b20=ZnQ=aHQ=b3A=ZXI=bmQ=aWQ=cnQ=c2s=cGU=aHQ=dGg=b20=aHQ=dGg=b20=ZGU=aXQ=b24=dHk=ZXI=b24=bnM=bmU=b3I=ZXQ=bGU=dGg=b3c=YXA=d1g=d1k=bmc=b20=ZnQ=aHQ=b3A=Z2U=ZXI=cmU=ZGU=ZXI=dmU=aW4=dHM=b24=ZXM=cg==emU=aHQ=cng=cnk=bGQ=aW4=ZGU=bmc=emU=YWs=cmM=b3I=dHk=a2U=YXk=ZXQ=YXA=aW4=aXQ=dHk=dGg=emU=dXQ=Z24=b3I=b24=bnQ=b3c=bmc=b3c=cm0=b3A=b24=cm0=aW4=bGU=b24=YXk=b24=dHk=b24=ZGk=Z2U=b20=Y3Q=Z24=dHk=b24=Y2U=aXA=dGU=aW4=ZXI=b3I=bGU=dGg=cmU=b3I=bGU=dGg=bmQ=b3I=bGU=dGg=bmc=Z2U=cnQ=b3I=bGU=dGg=bmc=Z24=YWs=b24=ZXg=dXA=ZXM=dXA=bnQ=Y2s=Y3Q=dGg=ZXI=cmU=ZGU=bnQ=YXA=bGU=b3I=bGU=dGg=YW4=dGg=bnM=ZXI=Z3M=dGE=bmc=aHQ=ZXI=aW4=YWs=bXA=bGU=aHQ=dGg=ZXI=c2U=cmU=c2U=c2U=c2U=bmQ=cnQ=c2U=c2s=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=aXA=dGU=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=aHQ=dGg=aHQ=dGg=ZXI=cmU=bmQ=cnQ=blg=blk=c3Q=bmc=b24=b3I=bmU=Y3Q=aXM=b3I=b24=bGU=b3I=b24=dHk=a2U=b3I=dGg=blg=blk=blo=YWc=Znk=Y3Q=ZGU=Y2U=d3M=dGg=Z2U=YWs=bmc=YXA=ZGU=eA==eQ==ZXg=b20=eHQ=dGg=bGU=ZW0=dWU=dHk=dHk=dHk=

This output will get alerted when ran at the Try CoffeeScript page at CoffeeScript.org in Chrome 45.0.2454.101 m.

Edit: The output changed slightly in the newest version of Chrome. Here is the output for Chrome 46.0.2490.71 m (1453 bytes):

0bnQ=bXM=bGY=bmU=bGw=b24=YXk=b24=b24=ZGU=bnQ=bWU=dGU=b24=dHk=bmQ=bnQ=ZGU=aXA=b3I=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=ZnQ=ZXI=b20=b3I=dXM=dXM=bGU=dGg=c2U=b3I=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=ZnQ=b3I=bGU=dGg=dXM=aHQ=b3I=bGU=dGg=bmc=bGU=b3A=b3I=dXM=dXM=bGU=dGg=dGg=b20=b3c=bmc=bmc=ZGU=YXI=aXA=dGg=bGU=b3I=b24=cnM=bmc=bnQ=bnQ=ZXQ=b3I=Y3g=Y3k=b24=YXk=bmU=bHM=bGw=dHk=bGU=ZXI=ZXg=aXM=b24=b3c=b3c=bms=YXA=YXQ=b3I=dHk=bnQ=bHk=bmc=emU=Y2g=bGU=bnQ=ZXM=aHQ=YWw=YWw=aHQ=bmc=b24=bnQ=ZnQ=bmc=b3I=aHQ=bGU=Z2U=b24=cGU=aW4=b20=ZnQ=aHQ=b3A=ZXI=bmQ=aWQ=cnQ=c2s=cGU=aHQ=dGg=b20=aHQ=dGg=b20=ZGU=b24=ZXQ=dGg=b24=aXQ=b24=dHk=ZXI=b24=bnM=bmU=b3I=ZXQ=bGU=dGg=b3c=YXA=d1g=d1k=bmc=b20=ZnQ=aHQ=b3A=Z2U=ZXI=cmU=ZGU=ZXI=dmU=aW4=dHM=b24=ZXM=cg==emU=aHQ=cng=cnk=bGQ=aW4=ZGU=bmc=emU=YWs=cmM=b3I=dHk=a2U=YXk=ZXQ=YXA=aW4=aXQ=dHk=dGg=emU=dXQ=Z24=b3I=b24=bnQ=b3c=bmc=b3c=cm0=b3A=b24=cm0=aW4=bGU=b24=YXk=b24=dHk=b24=ZGk=Z2U=b20=Y3Q=Z24=dHk=b24=Y2U=aXA=dGU=aW4=ZXI=b3I=bGU=dGg=cmU=b3I=bGU=dGg=bmQ=b3I=bGU=dGg=bmc=Z2U=cnQ=b3I=bGU=dGg=bmc=Z24=YWs=b24=ZXg=dXA=ZXM=dXA=bnQ=Y2s=Y3Q=dGg=ZXI=cmU=ZGU=bnQ=YXA=bGU=b3I=bGU=dGg=YW4=dGg=bnM=ZXI=Z3M=dGE=bmc=aHQ=ZXI=aW4=YWs=bXA=bGU=aHQ=dGg=ZXI=c2U=cmU=c2U=c2U=c2U=bmQ=cnQ=c2U=c2s=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=aXA=dGU=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=aHQ=dGg=aHQ=dGg=ZXI=cmU=bmQ=cnQ=blg=blk=c3Q=bmc=b24=b3I=bmU=Y3Q=aXM=b3I=b24=bGU=b3I=b24=dHk=a2U=b3I=dGg=blg=blk=blo=YWc=Znk=Y3Q=ZGU=Y2U=d3M=dGg=Z2U=YWs=bmc=YXA=ZGU=eA==eQ==ZXg=b20=eHQ=dGg=bGU=YXQ=ZW0=dWU=dHk=dHk=dHk=

Original source code:

for x of new Image(a=0).style
 a+=btoa(x.substr(-2))
alert a

Answer 71

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])

Answer 72

><>, ≤16 Bytes, Cracked by Sp3000

!$'*-0369<?BEHKNQTWZ]`cfilorux{~

Output length of 32 bytes

...made sure it's ASCII this time :-/

Answer 73

Pyth (cracked by isaacg)

939524095

Range ≤ 4

Let's see how this goes...

Answer 74

Dyalog APL (cracked)

4.58302

Range ≤ 4

This should be cracked pretty quickly...

Answer 75

MATLAB, 2, Cracked

The syntax of the command is incorrect.

Took me a while to work out something in MATLAB that is only 2 chars but should be quite tricky to work out :) (he hopes).

p.s. that is the exact output. No ans=

---

Well that one went faster than I thought it would...

Answer 76

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.

Answer 77

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')

Answer 78

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.

Answer 79

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,800^th 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.

Answer 80

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('')

Answer 81

Haskell, <= 32

"[(\"[\",\"(\\\"[\\\",\\\"(\\\\\\\"[\\\\\\\",\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\")]\\\")]\")]"

This one is cute and easy.

Answer 82

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('')))

Answer 83

J (cracked)

4.81845e12

Range ≤ 4

Worth a shot.

Answer 84

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.

Answer 85

Pyth

10067283832263627132507444590041695034979992997150622392563276991517087210416125987872298759981924914598996739787601264046046893914007275634929310315058

Range ≤ 4

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

Answer 86

C++

String:

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

Range: <= 64

Answer 87

GolfScript

100100110010011100110001011101100001010011010111011101011000100000000100

Range: ≤ 8

Answer 88

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

Answer 89

Rust, cracked!

Here's the output

AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO

That's 98 characters long.

The source code is <=128 bytes

Here is the source

 fn main(){let mut i: u8 = 1;while i<99{print!("{}",(65+(i&(2*i))%25) as char);i+=1;}}

Since it was late at night I made the mistake of not making the output longer than the source code byte limit (which would have been really easy)... whoops! This might have been fun to crack otherwise. Oh well, Kudos to Doorknob.

Answer 90

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<

Answer 91

Macaroni 0.0.2—cracked by kennytm

Range: ≤64.

...................................................................................................

The intended solution:

set x 99 label l print "." set x add x -1 map slice " " 0 x 1 l

Answer 92

Python 2, safe

Output (400 bytes)

2243741369805258403802281453161847831993100895210761465122158243748106741965559879210950925986787187884683594462521622978061423199763328847096978817424056039876331594730426879701090232645796839130259328243206775429644682566205913609484054454294080314366063978878893188641070706588914162057003952773480796098824291229522724034240214526221641336067994669537082582022249580216662833919604859431735474099

Range ≤32

Original code (32 bytes)

b=1337;a=2**b/b-b-13**37;print a

Answer 93

Rust, Safe, ≤64

Output (440 bytes):

2EE5A53831925A9212038FBE5174381029212D926E994C46C69956F383F314D9912D4622FA13BF316AF3AFFA91A710FFAA454D5541C5B0800805B16B549B51195BFF081815B119B514EB599BC8169105BCA016D716241DDCA0941D3077697713F1D12ACA2C7E151775D80DD7ECB2B1557EF5D8132D885DF758C101DFA439E339384029EDB8405C9A9D9A17B4016EED78A11EFB61FB141A11374E4302171FB305C11202109AF17631485C8BD0EC63E61017C63128BD171BDD0C4CC71164C41131E15E1EBF25BCD2157251077F1547FB786B73315386105E0154E0B9E7

---

Solution:

fn main(){for i in 100..200{print!("{:^04X}",i*i*20051%99999)}}

Answer 94

Python 3

Range: ≤64
String length: 1759

1450311547121626824402528317931024696537261379649312109934174763622928813537772202492826340253595039354204170803308812108106614974615992407513462378342519772879316185201191244193032905219821112379362735436273595816306408247797551887198223078132707718613741551438816716228420855210133806030879152023807281213669870947286924104806420930386226909518122591340634826667470106070805067486916003620079860533420912887938893520117652588913717930472346176939267545884056248725814428845435505286970004504538242272311816219001799408190917981242794876906923463019563132633790465573335245790782921280224126868686724604452690148708017495170944952232407517716174996669514909784703378613104880109045294268293224189609735626833741340860353297694678641117508508320027700778717534109394267437425043810487352376005634156569975311491459838272217846207077798205457351267508638726235986344105746925264997271470391586921860841952986010216300093433468007980482444450140150202011970723666974568959542215223332447146301544007477846089467045557063881769289045618456873502484742102787141509146927089727415468957468932233888307541183405820990577010792332515397454508971114910082242913202656447784249727817413159197879472620373533325157697422584249026116957034499508087753326237517531666435897781090922126023766286557629116809405490739569657792496159821300551508419666991511554805528263403378295007848547483596991780931036386960716493272927989817021495881172814505517266227891225298564264160100926161641968167450456638252346252357682659194962887041698807928559518187059146398406957924003562078098158050469520030372646913304777752187530842640087708732247607019311163659185637734636533976160365822448025321873341358014966837103376648875774633227200456239875015114894085499417129719017106310570

Answer 95

Mathematica 10.1, range ≤64, cracked

String length 2022.

1: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

Hint:

The output of this program was only fixed a few centuries ago.

Program:

Print@Nest[Compress,ExampleData@{"Text","ToBeOrNotToBe"},13]

Answer 96

PHP, safe, <=64

Output (96 Bytes):

=WAVTBB_ZZSWsMQREFX[VPUD]LXR_SBJVPVVTpFAT@sE@THPP]]X\UBI|cBR[STBAVURLsWCTH^U^VMrpssrwpytqqpptxxy

The output depends on the source filename. I added the full path to the source file to the byte count. Note that it does not have to end in .php.

PHP notices should be suppressed.

Solution

<?=D.bcpow(9,99,9)^(y.new Exception([].[])|str_repeat(~¿,96));

saved in the file /g (as ISO-8859-1, ¿ is 0xBF )

What it does

• create a long number (9⁹⁹) with bcpow(9,99,9)
• create an exception with the message "ArrayArray" (two empty arrays concatenated with [].[])
• coerce both to strings with the concatenations D. and y. (D and y are undefined constants, treated as "D" and "y")
• bitwise OR each character of the exception with 01000000 to restrict it to printable characters and fill up to 96 characters.
• bitwise XOR the two strings

Answer 97

Pyth

Range: ≤ 8

String:

49177772591428004056910940816433485702518448313728069154605014641218367314521229637591075731850711078018713

Answer 98

Octave, <=4 bytes cracked by kennytm

ans =  4.8105

Cracked:

i^-i

Answer 99

Python 3 (<= 32 bytes)

REPL.

177172218082085052481067589112390245408383458973982190836613425027273840834324281100485149132551246778981339968190311073240776569178878685724789960654670348361662827252973483749744632038916925690939659916043492930278567489422231220073029774565250343832768238643314785908679491540640941915666237839942314696031493953803281287102418829064719403480444915114668250543498318227260440120029605628856083175765744363390702825101686789888725560296981834662758351030421544264559750221026406067121783807117962060340615730987604546604714155531342482083463681465130945512630675950142946922773503989053740822544224822808739521839720865290854356372141124499117074370897738546403209492027955454351993333035066859502938275568857093391457569773694819414826823687786033626122521592630462668886697269593537206139576741010831202963443941784967084810577008190387631080387860331107152262177887372170404448327177863200442345178285860750842841747607378523075424463460687928269706777288437394933478285113452249795657205511632132532278321265130924156213221634753820154649629494859389730150879262081109896155213238885748358893270681278721615531236111911030373024923666321800532386588112916399442185933551569956564864083732019627140517341497168342679467249158600970283106090236941217046682435095258063945957758115971959566229732597197779697266154520814140590150

Answer 100

bc -l (<= 8 bytes, cracked by SuperJedi224)

1.56024766824332863615

Answer 101

TI-BASIC, ≤8 bytes

-.3036143372

Answer 102

Grin, ≤8 bytes

0.27994163386353987

Answer 103

Python 2.7.9 - 64 Bytes - Safe

{qo'' y7hp t:uulo\nbtp om oo\nbo'ntsnyim o 't\yi'esp lstor:oit_r'co'bi'r'ecsd:,t p'esc'er lrfChlry'i<ep 't\ee>r lrfChlry''d_ t,t'elo<elno\nbes>i. ta<etmfChli\p .n .t m:uiruns'ds' y7s.,tfoN'eim ttr:oituy'oojn'djn' y7jn.,t ttOni:ui t,trotl mnSIm i t,a<ear:oiacusf .x:,o'denr:oio\tca<e' y7acrm fChl.,a<ear:oiactstna<ehi) nt'dusemP2\es'sto'ir:oirp tu li.' y7ust'xo<eesi)sa:usa 't\sap cm co\nbc'ntem tu 't\nte'eaknntem to 't\nte'mim r 't\minp c'd_o(- a<ec(- em eo\nbe'h:uh t,i:utOmP2 \gcta<ec' y7tacto:,k la 't\e.,r'diobi'<e 't\s>stN'iiin_e<eu_mP2\up .:,lo<elobi': usbi'e<et 't\ntiy'l'd_t t,t:ulmmP2\ocoom a(- .tnh:uh t,tpouslnoen4<eo.' y7en4ci< e'l>r<enuntyo_to'eo\nLcy'c<ea t,_a let 't\rs.,no' 't\si.,o._m dl1mP2\ia.,p lpfCh lpy'em:,r'd_nbi'_:,tn .N'i_i e<ed(- dc'den1fChlcs5'e'et:us'l>s:ua' y7hb>sp:,w ly 't\e.,twfnnga lcssr:oio\e'n'dfhmP2\c'rsm p 't\rs'sc:usc 't\scp ti:,y:uogmP2\r csm:urpfChleic_im hfChDhb>a:ur'l>tm ' y7sy'ib<eo. 't\ngs>sr:ueg' y7tet>nim e' y7 cty'<e 't\o>m'd__uns'ds' y7s.,t:,tr'dusur:oitr.,om pi)ihm c 't\ih'erN'usoend dh d<eo.ofChlcscp o<ecfChlbp tiN':uer:oitiy'to'tmP2\t>'dnungc:uepfChlnacs lao\nb.,l o' 't\_y'n<en 't\as>onner'ei.lm ti' y7usny' lsi)mi'eo'ep<eeo\nbs>seN'r<ea t,f lf 't\i.,t'eoo'(- kto'r' y7_ep .tnnti 'dt(- trcous:}

This submission requires that you use a fresh python interpreter without any previous commands executed in it.

Source code: import sys;from test import regrtest;print repr(sys.modules)[::6]

Answer 104

MATLAB, ≤ 4 bytes

String:

ans =
   0.4133 + 0.9106i

This also works with Octave and its online interpreter, though in that you will get the output:

ans =  0.41329 + 0.91060i

This will probably be solved quite quickly as there is very little you can do in MATLAB with only 4 bytes! But never the less...

Answer 105

Python, cracked by Sp3000

UUU UUC UUA UUG UCU UCC UCA UCG UAU UAC UAA UAG UGU UGC UGA UGG CUU CUC CUA CUG CCU CCC CCA CCG CAU CAC CAA CAG CGU CGC CGA CGG AUU AUC AUA AUG ACU ACC ACA ACG AAU AAC AAA AAG AGU AGC AGA AGG GUU GUC GUA GUG GCU GCC GCA GCG GAU GAC GAA GAG GGU GGC GGA GGG

Range ≤ 64

Answer 106

Snails, ≤ 2 bytes (cracked)

8

I thought I'd join in the fun of everyone posting self-written languages/interpreters that no one else knows how to use.

Note to anyone who tries to brute force this: Don't run the programs ~+ or ~,, lest the interpreter attempt to consume several terabytes of memory.

Answer 107

Bash

Length <= 64

This cop tries hard to be efficient, but feels trolled by inefficient bureaucracy.

UlRSelNVRkJRVUZCUVVGQlFTdDZSMjlSTUVGTlFXZEJUVXclTDBWUloxRnFVQzlFU1RZeGNWcGxa
bVplUm1OcFNXbEphVWxwU1dsSgphVWxwU1dsSmFVbHBTV2xKYVVscFNXbEphUXBKYVVscFNXbEph

Answer 108

JavaScript, ≤64

Output (467 bytes):

223C2194299201F9B31FF25032420290E1138229F9E53B25F5B25FE02903F105F09962F25F09962F2EF119E5229D25050F01CF029F2130EFF502213925253012029F0190CF501C2F030B25D3450C5C3B22209FF2C35912309F22F1F1003596535BF0822F4C313496FD3C929099235024252941251259229C2523592599255F592F91225F2255192225F92CF293009C1F09291C952592593B925A252F99F01F99009912399121253125391C131A25B25F5593325292525325255920920252559F0525322996999692F225329294E990C9B509352F9F51292F92525B29399325199325921C203A5FF8223

I tested this in the console of Firefox 41.0.1 at an empty web page.

Safe! Original code:

(btoa(Object.keys(this)).match(/[\dA-F]/g)+8223).replace(/,/g,'')

Answer 109

Matlab/Octave, range ≤16, cracked by kennytm

Desired output in Matlab is

ans =

        2650        2700        2750
        2703        2754        2805
        2756        2808        2860

And output on octave is

ans =

   2650   2700   2750
   2703   2754   2805
   2756   2808   2860

Good luck!

Answer 110

><>, ≤8 bytes - Cracked

That was fast.

Output (17 chars):

11059633333125108

Works on the official and online interpreter.

Answer 111

Python 3, <= 32 (Safe!)

This one is not a full program. You run this from the python REPL.

[False, True, False, False, False, False, False, True, False, True, True, False, True, False, False, True, True, False, False, False, False, True, True, False, False, False, False, False, False, False, False, False, True, False, False, True, False, False, False, True, True, True, False, True, False, True, False, False, True, False, False, False, True, True, True, True, True, False, True, False, True, False, False, False, False, False, False, False, True, False, False, True, True, False, False, True, True, False, False, False, True, False, False, False, False, False, False, True, True, False, False, False, True, True, False, True, False, False, True, False, False, True, False, True, True, False, True, True, True, False, False, False, True, True, False, True]

This one was fun ;)

My code:

[int(i) > 5 for i in str(64 ** 64)]

_{(spaces added for readability)}

Answer 112

PowerShell 4, (Safe) <= 64

817830,2180,26491570,269854650,290,2858936340,20,20,255794473916160,2890,23434185590,258371780,2876750,260,20,2181318319616730,2170,239970,28573390,24143634460,240,24180,20,230,28970,298454139597176550,20,20,285130,281680,2770,2746350,2840,20,2393979960,20,20,250,216134518751476350,26410,280,20,25570,250,268451577990,20,230,210,20,210,2731543879350,20,2753759190,27480,24134837490,2811158519194475560,266858480,230,2790,2664564410,240,284660,210,24537956764310,27430,240,290,2640,29390,240,2660,20,28410,2630,2379473440,21931131890,298897540,20,20,20,270,20,250,2190,20,20,240,2891335370,20,23568480,23990,2153780,28490,29349985134967880,20,21790,250,215414650,240,293880,26978738914850,23730,2771469340,2496710,25510,20,26474597990,26141560,230,21850,230,250,250,26550,298119160,264780,260,20,2430,2750,25533518530,2740,20,2390,28990,29830,27990,20,20,20,20,29990,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20

Edit - solution revealed:

([bigint]::Pow(9990,201)-split'2'-split'0'-join'0,2').trim(',2')

Gets a really big number ([bigint] requires PowerShell v4+), that coincidentally has a lot of 2's and 0's in it. Splits on 2's (i.e., removes every 2 and creates an array of strings), does the same with 0's, then joins the array back together with 0,2. Essentially, this replaces every 0 or 2 in the original number with 0,2. Finally, it trims off the last ,2 to make it cleaner and make the pattern look like ,20 rather than 0,2.

Answer 113

PowerShell, <= 2 (cracked by Sven the Surfer)

True

_Edit -- Assumes a newly opened PowerShell session.

Code:

$?

This is actually several short-hand aliases mushed together for "Did the previous command execute successfully?" Since we're starting a new session, there isn't a previous command, so "Did nothing execute successfully?" evaluates to True.

Answer 114

Lua, ≤ 32 (cracked by Doub)

Output:

1(222)33333(4444444)555555555(66666666666)7777777777777 7

You need to write a Lua program (not a REPL command).

Answer 115

Marbelous, Safe, ≤64

Output:

&')8~?'?*qmqAuu*`wA/0N'lX;(0<NCz55Z@+rDD{?8q]`

Online interpreter here. Assumes cylindrical boards.

Information on Marbelous.

Hint:

((3*x + 233)/2) mod 128 is used. A lot. Asides from calculating that, the only devices I used are: @n, \\, >n, !!, and calling the board that calculates that ((3*x + 233)/2) mod 128.

Code:

23@0
22{}
\\21
@0:)
::)
}0E5
<<
}0
E9
&0&0
>>\/
>V!!
\\
{</\{0

:) calculates (3x+233)/2 mod 128, and returns nothing if the result is not a printable ascii character. The top part used to just feed a marble in a loop until this condition was reached, but then I moved a couple of things around and have no idea what actually happens anymore...

Answer 116

Octave, ≤32 (Safe)

Fun with complex numbers!

Output:

ans =

   276.255 -   2.551i
   169.272 +  76.768i
   156.409 -  86.377i
   162.145 -  53.166i
    69.090 - 156.251i
    55.613 + 160.617i
    90.672 + 139.735i
   156.761 +  35.006i
   142.780 +  76.629i
    46.480 - 154.816i
    89.612 - 133.107i
   149.392 -  33.599i
   130.552 -  78.858i
   144.270 +  27.883i
    89.886 + 123.547i
    46.217 + 145.361i
   126.882 +  74.024i
   139.113 -  29.654i
   135.960 +  25.274i
   119.010 +  70.408i
    84.834 + 113.671i
   130.107 +  23.973i
   113.577 +  67.526i
   125.531 +  22.879i
   121.624 +  21.877i
   118.451 +  21.302i
   109.630 +  65.362i
   106.084 +  63.788i
   103.179 +  61.957i
    80.878 + 107.596i
    77.922 + 103.234i
    75.954 +  99.708i
    73.853 +  96.586i
    41.096 + 135.557i
   132.222 -  27.776i
   120.678 -  74.918i
   127.189 -  26.411i
   123.182 -  25.272i
   116.602 -  23.653i
   119.390 -  24.383i
    84.360 - 120.211i
    39.698 - 140.870i
   114.259 -  71.642i
   109.932 -  68.992i
   106.247 -  67.027i
   103.025 -  65.160i
   100.376 -  63.620i
    38.500 + 128.779i
    36.861 + 123.774i
    34.301 + 116.363i
    35.422 + 119.917i
    33.337 + 113.479i
    36.543 - 132.596i
    80.227 - 112.287i
    34.587 - 126.848i
    33.171 - 122.564i
    32.001 - 118.878i
    30.241 - 112.840i
    31.031 - 115.608i
    76.843 - 107.182i
    74.524 - 103.346i
    70.551 -  97.215i
    72.538 -  99.754i

Original code

eig(fft(magic(63))+45).^0.4759+1

Answer 117

Coffee Script, <= 16 bytes (Cracked by Sp3000)

Tested with online REPL.

2.177586090303602

17 byte output. This should go fast...

Original code:

Math.PI*Math.LN2

Answer 118

CJam, ≤8

487480661435681880634

Answer 119

Haskell, <= 64

"234269035277217371450204053788208058560799137025150410636234412255689818762656987340189922194199908934585754436770945621945227536480994122027390744842460652134286726113671600854494421884443688675047254139921459136558907251581541275435880046048108350763422072425649208447945247377494980796937940655701307997562317231177713235652338028417451236558995227590459444617827926812430772358074299811337678654829391325114470251619398332973724789690679216976966052216145384676794461656118897180025443680331132394850675017509197303075089601960100983874271959120860501629839988014042208671920682889138254667751623709396284481735303452673124139121777377846871850672033106472280969141703928366197810964922618740449515668724456268271448647699989156381445205967478469028588157734532905706524844819908323813305035658162074736928332593023809473156005356000353055733539612246442774946157819406373129208057258831053076086585508756487286954717132003621711976832374447894816733777893008621416274050484859334617085131384283216302606998622119582879282589199593973325446462015234491992064297172938689972846409163423245594572882877709043959807372637664123289304645760119286430615178518063617152788828056353625031963803801427210223721730258270231763792780768664884800062997419345647149704788982766859295443743499252375539507398523730009926333960108410757294547781696131123657453625024387016742581573855196031413093336350761030038596777874432933968895083735228717242953009263093968742573629027297647387126891761852949241957626049569804429541178011981933256268484794652351497560293391899479900814683813828949668729076822808628116446774100881521615133458539277068540778366277878840073320092074401621104369683572238945467129923105411003295755601858665112706827105134190951462194645064739837907120118633835684577553292202532275739715956095669642085664671234208045303605448727259339868163682440084839078742590621118695767964815678513010560919582968899674389139580927687507301062249730389625964423196961408134619058630786289121348398596872496242241800816316097838514854690220862576"

2046 bytes.

This is my first post here, hopefully I did something right!

Answer 120

Pip, <= 4 (cracked by Reto Koradi)

1101001

Took me a while to find something interesting that didn't involve PI or nasty implementation exploits.

Answer 121

QBasic, <= 32 (Cracked by fschmengler)

 1  2    3      4        5          6            7              8 

Uses pre-auto-formatter shortcut syntax. Tested with QB64.

---

Here's my original version:

FOR i=1TO 8
LOCATE,i*i
?i;
NEXT

The space before the 1 and also after the 8 is part of the output. (Though when you run the program, you can't exactly tell about the one at the end, unless you try to print something else immediately afterward.) QBasic prints a space before and after nonnegative numbers, though some emulators (like the one at repl.it) don't format their output correctly.

Answer 122

JavaScript, ≤16 bytes, cracked.

Ohhh, this one is a tough one.

31525197391593470

This is seventeen bytes.

Well, again, not the way I intended it, but here:

7/Number.EPSILON

I'm at -.5 points ;-;

Answer 123

Python, <= 64 (safe)

2048 bytes of output, counting the trailing newline (note as well the single leading space):

 z7D0R#r-Y!y6F.X!x4I*_!y6F-X!x5H+]!y7D/T"t/T"t/T"t0S#s.W!w4J)b"v3L'g$q,\!y7D0R#r-Y!y6F-X!x5G,\!y7D0S#r-X!x5H+]!y7D/T"t0S#s.V"v2M'h%m)c"u1O%m(e#s.V"v3L'g$p+\!y7D0R#r-Y!y6F-X!x5H+\!y7D0R#r-Y!y6F.X!x4I*_!y6F.X!x5H+^!y6E.V"v2N&j&k'h%m)c"u1O%l(f#r-Y!y6F-Y!y6F.W!x4I*_!x5G,[!y7D/T"t0R#r-Y!y6F-Y!x5G,Z!y6E.U"v2N&k&i%l'f#r-Y!y6F-Y!y6F-Z!y6E.W!w3K(d"t0S#s.V!w3L'f#r-Z!y6E.W!w4J)b"v2M&i%m(e#s/U"u1O%m(c"u1Q$p+^!y6E/U"u1P%n)b"v3L'g$p+]!y7D/S#s/U"u1O%m(e#s.V"v3L'g$o*^!y6E.V"v2M'h%n)b"v3L'g$o*^!y6E.W!w4J)a!w4J)b"v2M'h%n)c"v1O%l'f#q,Z!y7E/U"u1P$o*`!x5G,\!y7D0S#r.W!x4I*_!x5G,[!y7D/T"u0Q$q,\!y7D0R#r-Y!y6F-Y!x5G,[!y7D/T"t0S#r-X!x5H+\!y7D0R#r-Y!y6F-Z!y6E.W!w4J)b"v2N&j&j&j%k'h$o*`!x4I*_!y6F-X!x5G,[!y7D0S#s.V!w3K(e#s/U"u1Q$o*_!y6F-X!x5H+\!y7D0S#r-X!x5H+]!y7D/T"u0Q$p+\!y7D0R#r-Y!y6F.X!x4I*^!y6E.V"v3M'g$o*_!y6F.W!x4I*`!x5H,\!y7D0R#r-Y!y6F.X!x4I*_!y6F-X!x5H+]!y7D/T"t/T#t/T"u0R#q,[!y7D0S#s.W!w3K(c"u1P$o*`!x5H+]!y7D/S#s.U"v2N&j&j&k&i%m(d"u0Q$p+\!y7D0R#r-Y!y6F-X!x5G,\!y7D0R#r-Y!x5G,[!y7D/T"t0R#q-Z!y6E.V"v2N&j&j&j&j&k'h%n)c"v2N&k&i%l'g$p+]!y7D/T"t0R#r-Y!y6F-Y!y6F-X!x5H+\!y7D0R#r-Y!x5G,[!y7D0S#s.V"v2M'h$o*`!x4I*_!y6F-X!x5G,\!y7D0R#r-Y!y6F-X!x5H+^!y6E/U"u1O%l(e#r.W!x4I*`!x5G,\!y7D0R#r-Y!y6F-Z!y6F.W!w4I*`!x5H+^!y6E.V"v2M&i%l'f#q,[!y7D0S#s.V"v2M&i%m(c"u1Q$o*^!y6E.V!w3L'f#q,[!y7D/S#s/U"u1P%m(c"u1Q$o*_!y6F-Y!y6F-X!x5G,\!y7D0R#r-Y!x6F-Z!y6E.V!w3L(f#r-X!x5H+\!y7D0R#r-Y!y6F-X!x5H+\!y7D0R#r-Y!y6F-X!x5G,[!y7D0S#s.W!w3K(d"t/S#s/U"u1P$o*`!x5H+]!y7D/T"t/T"t/S#s.V"v2N&i%l'g$p+^!y6E.V"v2N&j%k'h$n)a!w4I*`!x5H+]!y7D/T"u0R$q,\!y7D0R#r-Y!x5G,[!y7D/T"t/T"t/T#t/T"u0Q$p+\!y7D0R#r-Y!y6F-Y!x5G-Z!y6E.V"v2M&i%l'g$p+^!y7E/U"u1P$o*`!x5H+]!y7D/T"t/T"t/T"t0S#s.V!w3K(e#s/U"u1P$n)a!w3K)c"u1O%m(d"u0Q$p+]!y7D/T"t/T"t/S#s/T"u0Q$p+]!y7D/T"t/T"t0R#r-X!x5H+\!y7D0R#r-Y!y6F-Z!y6F.W!w4I*`!x5H+]!y7D/S#s/U"u1O%m(d"u0R$q,\!y7D0R#r-Y!x5G,Z!y6E/U"u1P%n)b"v2N&j&j&j&j&k'h%n)c"v2N&k&h%m)c"u1P%m(c"u1P$n)b"w3L'f#q,\!y7D0R#r-X!x5G,\!y7D0R#r-Y!y6F.X!x4I*^!y6E.W!w3K(d"u0R#q,\!y7D0R#r-X!x5G,\!y7D0R#r-Y!y6F.X!x4I*^!y6E.V"v2M'h$n)a!w4I*`!x5H+^!y6E/U"u1P%n)c"v2N&k&i%m(c"u1Q$o*_!y6F-X!x5G,\!y7D0R#r-Y!

Can be solved in either Python 2 or 3.

---

Code:

x=0.0;s="";exec("x=x*x/40-60;s+=chr(92+int(x));"*2047);print(s)

Explanation:

The ASCII values of these characters are generated via chaos theory. The function f(x) = x^2 + c exhibits chaotic behavior for some choices of c; one such is -1.5. Starting from 0, here are the first few values when this function is iterated: 0.0000, -1.5000, 0.7500, -0.9375, -0.6211, -1.1142, -0.2585, -1.4332, 0.5541, -1.1930. Or, graphically:





The Python code scales this sequence of values to printable ASCII characters and spits out 2047 of them. The chaotic nature of the function creates numerous apparent cycles, such as /T"t, that degenerate as slight differences in the underlying floating-point values get magnified over successive iterations.

Answer 124

Pyth, ≤ 32 chars (cracked, but safe)

yx{z}|~qpsrutwvihkjmlona`cbedgfyx{z}|~qpsrutwvihkjmlona`cbedgf98;:=<?>10325476)(+*-,/.! #"%$'&98;:=<?>10325476)(+*-,/.! #"%$'&

Check this answer's source for a hint, if needed.

Answer 125

Pyth, <= 16 (safe)

tfzxsepjgyqbiolvakdcuhrmnw

Hint:

Here's the output from the same code with one number changed: whkoyjexfmcvbgpsztnrudaliq

Code:

VU5=G_.iFc3G)G

What it does:

Start with the lowercase alphabet G. Split it into three chunks (abcdefghi, jklmnopqr, stuvwxyz), then fold on .interleave. This interleaves the first two chunks (ajbkcldmenfogphqir), then interleaves the third chunk into that (asjtbukvcwlxdymzenfogphqir). Reverse and assign back to G. Repeat 5 times and print. (The hint is the result of one further iteration.)

Answer 126

VBA,[Safe]

Range <=64

Output

-21474836332792802484224001.05297830108845E+65

Number Answers are boring but I think this one is different Edit: I was really expecting more colorful questions but I guess number answers are only so exciting

Solution with code

    Sub q()
    Debug.Print vb3DFace & vbBlue ^ 2 & vbCyan ^ 9
    End Sub

This is a pretty boring answer. The vbColors are hard coded values in Excel I double checked online and all installs of excel assume Blue is Blue. then i did some math to obscure those constants and concatenated them together so they would display as a long string rather then it being shortened to SE format. Cyan is already shortened to SE notation so it make it look like one big number.

This was kind of a cheap shot but I wasn't sure if someone would notice that the middle of the number was the hex value of Pure Blue squared.

Answer 127

Pyth, safe, <= 16

16252320011828121914223211711247272693015813524610

This was output from a linear congruential generator.

Answer 128

CJam, <= 16 (safe)

 9 4 11 6 12 58 1 43 62 5 92 56 48 14 98 1 9

There is a single leading space.

---

Code:

Ps{i48-_*s)S\}%

What it does:

Convert the built-in P = pi variable to a string. For each character, subtract 48 from its ASCII value (giving the corresponding number for a digit and -2 for the decimal point). Square and convert to a string. Uncons the rightmost character from the string, push a space, and swap it with that character. This has the effect of converting a digit like 4 into 1 6. The stack is printed without delimiters, thereby obfuscating what's actually going on.

Answer 129

Powershell, ≤16

61788129934789836849895604649984

Answer 130

Python 3.5.0, Safe, ≤64

zwnj;zdot;yicy;xwedge;xoplus;xhArr;wp;vsupne;vnsub;vdash;varsigma;vangrt;utrif;urcorn;uparrow;ulcorn;udblac;uacutetscr;triangleright;topfork;timesb;thicksim;tdot;swnwar;supsetneq;suphsub;sup3succneqq;subsetneqq;submult;starf;square;sqsub;solbar;smeparsl;simgE;shy;sext;searhk;scnap;sc;rtimes;rppolint;roang;rightthreetimes;rhov;regrdldhar;rbrke;rarrtl;rarrap;radic;quotqfr;profline;precnsim;prap;plussim;plus;phiv;part;oumlorv;order;omid;oint;oelig;ocir;nwArr;nvgt;nu;nsupseteqq;nsubseteq;nsimeq;nrtrie;npre;notnivb;not;nles;nlE;nhArr;ngE;nearr;ncedil;natur;nVdash;nGt;models;middotmdash;maltese;lurdshar;ltdot;lsimg;lrhar;lowast;longleftrightarrow;lnapprox;llarr;lfr;lesges;leq;leftharpoondown;ldca;lbrack;larrsim;laquolHar;kjcy;jsercy;iukcy;iscr;intlarhk;in;iiota;iexcl;hyphen;homtht;hcirc;hArr;gtrapprox;gsime;gnapprox;ggg;ges;gbreve;frasl;frac25;frac12flat;fallingdotseq;ethequiv;epsilon;emsp;ell;efDot;easter;duarr;drcorn;dotminus;divonx;diamondsuit;deg;dbkarow;cwint;curlyvee;cupcap;ctdot;copy;compfn;cirscir;circlearrowright;chcy;ccupssm;caps;bumpe;bsim;boxvh;boxtimes;boxdl;boxVH;boxHD;bopf;blacktriangleright;biguplus;bigcirc;because;barvee;auml;aringaopf;angmsdag;ange;amalg;aelig;ac;Zdot;Ycy;Xi;Vopf;Vee;Uscr;UpTee;Union;Udblac;UacuteThinSpace;Tab;Sup;Sub;Square;Sfr;SHCHcy;RightVector;RightTeeArrow;RightArrowBar;Rcy;RBarr;Proportion;Poincareplane;OverBrace;Oscr;OgraveNu;NotSupersetEqual;NotSquareSuperset;NotPrecedes;NotLeftTriangleEqual;NotGreaterFullEqual;NotCongruent;NegativeVeryThinSpace;Mu;Lt;Longleftarrow;LessSlantEqual;LeftUpVectorBar;LeftTee;LeftArrowRightArrow;Lang;Kcy;Jfr;Iopf;Imacr;Iacute;HorizontalLine;Gscr;Gg;GT;Ffr;Equilibrium;Element;Eacute;DownTee;DownArrowUpArrow;DoubleLongLeftRightArrow;DotDot;DiacriticalAcute;DZcy;CounterClockwiseContourIntegral;CloseCurlyDoubleQuote;Cedilla;Cap;Bfr;AumlAogon;

Output is 1833 bytes. Full program (outside REPL). Should be easy ☺

---

Solution:

from html.entities import*;print(''.join(sorted(html5)[:13:-9]))

Answer 131

AppleScript, ≤ 64 Bytes Cracked

Ooh, yes, time for another AppleScript answer.

Output String:

688.0
317.0
946.0
575.0
204.0
833.0
462.0
91.0
720.0
349.0
978.0
607.0
236.0
865.0
494.0
123.0
752.0
381.0
10.0
639.0
268.0
897.0
526.0
155.0
784.0
413.0
42.0
671.0
300.0
929.0
558.0
187.0
816.0
445.0
74.0
703.0
332.0
961.0
590.0
219.0
848.0
477.0
106.0
735.0
364.0
993.0
622.0
251.0
880.0
509.0
138.0
767.0
396.0
25.0
654.0
283.0
912.0
541.0
170.0
799.0
428.0
57.0
686.0
315.0
944.0
573.0
202.0
831.0
460.0
89.0
718.0
347.0
976.0
605.0
234.0
863.0
492.0
121.0
750.0
379.0
8.0
637.0
266.0
895.0
524.0
153.0
782.0
411.0
40.0
669.0
298.0
927.0
556.0
185.0
814.0
443.0
72.0
701.0
330.0
959.0
588.0
217.0
846.0
475.0
104.0
733.0
362.0
991.0
620.0
249.0
878.0
507.0
136.0
765.0
394.0
23.0
652.0
281.0
910.0
539.0
168.0
797.0
426.0
55.0
684.0
313.0
942.0
571.0
200.0
829.0
458.0
87.0
716.0
345.0
974.0
603.0
232.0
861.0
490.0
119.0
748.0
377.0
6.0
635.0
264.0
893.0
522.0
151.0
780.0
409.0
38.0
667.0
296.0
925.0
554.0
183.0
812.0
441.0
70.0
699.0
328.0
957.0
586.0
215.0
844.0
473.0
102.0
731.0
360.0
989.0
618.0
247.0
876.0
505.0
134.0
763.0
392.0
21.0
650.0
279.0
908.0
537.0
166.0
795.0
424.0
53.0
682.0
311.0
940.0
569.0
198.0
827.0
456.0
85.0
714.0
343.0
972.0
601.0
230.0
859.0
488.0
117.0
746.0
375.0
4.0
633.0
262.0
891.0
520.0
149.0
778.0
407.0
36.0
665.0
294.0
923.0
552.0
181.0
810.0
439.0
68.0
697.0
326.0
955.0
584.0
213.0
842.0
471.0
100.0
729.0
358.0
987.0
616.0
245.0
874.0
503.0
132.0
761.0
390.0
19.0
648.0
277.0
906.0
535.0
164.0
793.0
422.0
51.0
680.0
309.0
938.0
567.0
196.0
825.0
454.0
83.0
712.0
341.0
970.0
599.0
228.0
857.0
486.0
115.0
744.0
373.0
2.0
631.0
260.0
889.0
518.0
147.0
776.0
405.0
34.0
663.0
292.0
921.0
550.0
179.0
808.0
437.0
66.0
695.0
324.0
953.0
582.0
211.0
840.0
469.0
98.0
727.0
356.0
985.0
614.0
243.0
872.0
501.0
130.0
759.0
388.0
17.0
646.0
275.0
904.0
533.0
162.0
791.0
420.0
49.0

(1,824 characters long)

Answer 132

><>, ≤64 Bytes, Cracked by Cole

"!#"$#%$&%'&(')(*)+*,+-,.-/.0/102132435465768798:9;:<;=<>=?>@?A@BACBDCEDFEGFHGIHJIKJLKMLNMONPOQPRQSRTSUTVUWVXWYXZY[Z\[]\^]_^`_a`bacbdcedfegfhgihjikjlkmlnmonpoqprqsrtsutvuwvxwyxzy{z|{}|~}{~z}y|x{wzvyuxtwsvruqtpsornqmploknjmilhkgjfiehdgcfbead`c_b^a]`\_[^Z]Y\X[WZVYUXTWSVRUQTPSORNQMPLOKNJMILHKGJFIEHDGCFBEAD@C?B>A=@<?;>:=9<8;7:69584736251403/2.1-0,/+.*-),(+'*&)%($'#&"%!$

Output length 368 bytes

Original source used:

48*v!1:*3f<.13p16-2p11p17-1p12:++aa*
:+2<o:-1o:^?)*9e:;?(*b3

Answer 133

Ruby, <= 64 (safe)

0
1
012
2
02
123
013
3
03
13
01234
234
0234
124
014
4
04
14
0124
24
024
12345
0134
34
0345
1345
01235
235
0235
125
015
5
05
15
0125
25
025
1235
0135
35
035
135
012345
2345
02345
1245
0145
45
045
145
01245
245
02456
12346
013456
3456
0346
1346
01236
236
0236
126
016
6
06
16
0126
26
026
1236
0136
36
036
136
012346
2346
02346
1246
0146
46
046
146
01246
246
0246
123456
01346
346
03456
13456
012356
2356
02356
1256
0156
56
056
156
01256

It took me the longest time to get this under 66 bytes... Hurrah for the Ruby golfing tips question!

---

Answer:

(1..99).map{|i|(0..9).map{|x|i+=(i>>x)%2>0?$><<x&&x :0}
puts}

The basic idea here is to print the binary places at which each number has 1's. The catch is that whenever a place does have a 1, we add that place's index to the number. So for example, when i is eleven:

• 2^0's place, 1011, output 0 and add 0 -> 11
• 2^1's place, 1011, output 1 and add 1 -> 12
• 2^2's place, 1100, output 2 and add 2 -> 14
• 2^3's place, 1110, output 3 and add 3 -> 17
• 2^4's place, 10001, output 4 and add 4 -> 21

I was wondering if anyone would catch the pattern at the beginnings of the numbers (01020103 etc.), but perhaps not.

Answer 134

Python3, <=128, safe

Output (2047 bytes):

["]'45625053676", '5444242', '04947233', '45395795', '61115179446404336055', '1699', '9626', '7', '1450', '2060579540', '941302396023', '43763345975992692602', '3511', '9970', '9454574', '724944929404', '', '13', '36145517660', '7243061363769519', '541175', '1', '3675533495406165', '453765010570950', '140', '33562', '43', '43446', '95921052', '3', '', '233176247199166562542', '', '12', '611629370', '9', '72', '1106327199', '964', '2', '439065339510155977233203717276', '354233356216750931043970220794929913961392', '633933', '99329', '71', '294', '1770446091', '', '6700030', '21411159', '7', '42292', '4112', '7626', '9015512756956952', '3', '052349110', '31433', '93467540', '036023662104', '10295475719', '35342', '', '4256460216150145', '2', '59427047', '9901730070390445551', '', '54', '0761', '1927322', '9736276799', '564965977', '590', '4', '', '399', '565', '902692601072445119752', '62370104660960596', '', '477391523990', '753', '09956', '041745692491123563', '354995961', '37777625076057', '7570735', '40520', '707409554', '311042911354445746753579759944996262523641325999700', '61014076359', '155932492943', '55294019352972126054', '5', '3955597', '25251', '', '0714219560377', '51042210', '', '2100', '926537625661', '90', '93915224761117505720911640440465', '2521637479904547646762696923', '15', '27353033027667052607159344699202916266232192649170', '61436', '2', '5294136761752472317903903977607754', '133556047', '2413345600', '46407', '3', '', '0307543034651930', '51921', '65', '1073015441105', '713112', '1310091135417433', '440360', '4575', '0', '9615', '42074677457', '399067261507971270271699741603647347602140691719', '003367', '7', '769106493671966', '761', '0520133', '707', '7063', '039', '996045713162390154', '36005797209770231', '560193159926439', '3732021207', '33', '010066', '51602', '9079100064164070695541073766315705', '573664390156561', '6403494973', '7', '4127314051527', '3364365', '4', '5', '473', '793710553529', '72940', '709095', '7710631011973506447709629293', '6', '0457045272264603430', "0799'["]

Code:

n=4**9;f=[0,1];o=str;
for i in range(n):f.append(f[i-1]+f[i-2])
print(o(o(o(f[n][:1564][::-1].split(' '))[::-1]).split('8'))

Answer 135

Retina, <= 128 (safe)

1025 bytes of output:

10998988798878776988787768776766598878776877676658776766576656554988787768776766587767665766565548776766576656554766565546554544398878776877676658776766576656554877676657665655476656554655454438776766576656554766565546554544376656554655454436554544354434332988787768776766587767665766565548776766576656554766565546554544387767665766565547665655465545443766565546554544365545443544343328776766576656554766565546554544376656554655454436554544354434332766565546554544365545443544343326554544354434332544343324332322198878776877676658776766576656554877676657665655476656554655454438776766576656554766565546554544376656554655454436554544354434332877676657665655476656554655454437665655465545443655454435443433276656554655454436554544354434332655454435443433254434332433232218776766576656554766565546554544376656554655454436554544354434332766565546554544365545443544343326554544354434332544343324332322176656554655454436554544354434332655454435443433254434332433232216554544354434332544343324332322154434332433232214332322132212110

The score is calculated as usual for Retina: the source code is spread over multiple files, with +1 byte for each file. Alternately, put all the source code in one file, separated with newlines, and count +1 for the -s flag. It's under 128 either way.

---

Nobody? Well, okay...

<empty>
1x012345678910
(`^\d
@$0
+`@(\d)(?=\d*x{1,99}\d*?\1(.0?))
$2@
)`@
x
^x(\d+).*
$1

This code implements OEIS A061511, in which each digit of a number is incremented by 1 and concatenated back together again. The Retina code walks a @ through the digits, incrementing the one after it using the lookup table generated in the first replacement. At the end of each pass, the @ is turned into an x:

@10xxxxxxxxxx01234567890
2@0xxxxxxxxxx01234567890
21@xxxxxxxxxx01234567890
21xxxxxxxxxxx01234567890

Once there are 100 x's, the third replacement doesn't match because it requires between 1 and 99 of them, and the loop exits. Finally, we clean up the x's and the lookup table.

Answer 136

Javascript (ES6, console), <= 64 Cracked by SLuck49

Original Version:

([].pop+[]).split('').sort().map((x)=>x.charCodeAt(0)).join('')

Crack:

[...[].pop+''].sort().map(x=>x.charCodeAt()+'').join('')

Merged and golfed, Just because, 53 Bytes:

[...[].pop+''].sort().map(x=>x.charCodeAt()).join('')

Due to browser differences...

Output in Firefox:

"10103232323232323240419193979999100101101102105105110110110111111111112112116116117118123125"

Output in Chrome:

"323232323240419193979999100101101102105105110110110111111111112112116116117118123125"

Answer 137

Javascript, <=32, CRACKED

(Not expecting to last long) In Chrome 45.0.2454.101 m:

0.1411200080598672

This is a full program. It actually prints 0.1411200090598672 if it is in a HTML5 document.

Oh I'm stupid, console.log(0.1411whatever); works. I was thinking of alert(Math.sin(3));

Answer 138

ngn APL (safe)

3.2406187300653406e+102

Range ≤ 16

Sixteen bytes of APL should be way to much to get cracked, so here's a hint: The only digits the code contains are 1, 2, 3, 4, 5, 6, 7 and 8, each one exactly once, and in that order.

Solution

|(*|)12.34J56.78

Try it online.

How it works

• 12.34J56.78 denotes the complex number 12.34 + 56.78i.

• (*|) is a train/fork.

  • | applies modulus to 12.34 + 56.78i, returning 58.105455853990165.

  • * calculates (12.34 + 56.78i)^{58.105455853990165}.

• | applies modulus to the result.

Answer 139

Commodore 64 Basic, ≤32 bytes - safe

Output: 200 bytes. Every blank line is a space followed by a newline.

/
7

*
1
1
3
?
?


?








4

9
6

!
?
?






"
(
2
!





!
(

(
'
(
'
(


?
?


!

!

,
(




(


)

"
(
"
(
?







#
,
-
8

'
'

'




(
'


<This line isn't actually output, it's a dummy line to get around the fact that SE doesn't like trailing spaces on code samples.>

Code:

1fOi=0to99:?cH(pE(i)aN63or32):nE

The first 138 or so bytes of the Commodore 64's memory are constant, or change in deterministic ways during the execution of the program. This program takes the first 100 bytes of that memory, turns it into text, and prints it to the screen. Getting this program down to 32 bytes limited the size of the constants I could use, with the side benefit that all the output is in the range where PETSCII and ASCII are identical. I would have preferred

1fOi=0to118:?cH(pE(i)aN127or32);:nE

for a richer set of characters in the output and a cleaner look, but that would put me in the next size category.

Answer 140

CJam (safe)

Range: <=16

String:

-1757998761424490676921016856999645582687172166771732990901023822919032113856474131322376304211808153619988283134008439274637725633868254103891368425285165026468770378090155135372308987708009431738653866423053902527963127906032288661788122437508856152696997908146296016521091199803229053377715671662942187527704135032400317135628637248506389262291879310836675157035298269773565002128572484249631883681915978366368348422763684673273940395075510502820393796214460557862527316465092717359768308614013715174354726471330845504297837476047888566285525771034491348417324909599453182115064413154332558333250875021070793798910049854644817559064573856721397747003126054061162347856585377448534690237788836012961397667542666722692935386425165604581402711433056617873627041251709641777614212372373696828558813318358124653096657585640957194959404589685428128317642065010497446792032482302568447660371023038445973792552314710542567265966630122643983375527917082186662519498233404401344837146447008437657457992594647903611528282318427533140206671065997969913543629153024916689707377967665079085509461263277920838560857104814273338655611983839393046785144278966861497797144865502969288669678711952606556690911517688871027804066141321298362142430813845600699520261708534251247924822880140866847159914428320312680337671139215536945422935222183014047914184629917144775390626

Code: 5345 363#~

Yay more numbers /sarcasm

Answer 141

><> (cracked by Sp3000)

Range: <= 32

Code:

ff*dd*$1-:?v$n;
           >$30.

String:

563894191846824322181557735263848163944611762131417907481282961909287815042114141071535925118959126585814601613352812123491114638156704068663512650264401513800791946239391603476080341849517532994005910896839888895899232312762154139810647195016820308009

Answer 142

CJam (cracked by Sp3000)

3.724191778237173

Range ≤ 4

Let's see how long this one lasts.

Answer 143

Wolfram programming language

Output (36 bytes)

{7, 11, 14, 11, 7, 10, 10, 10, 6, 9}

Range: ≤16

Answer 144

Wolfram programming language, cracked by alephalpha

Output (111 bytes)

{1, 4, 1, 18, 1, 1, 1, 4, 1, 9, 9, 2, 1, 1, 1, 2, 7, 1, 1, 7, 11, 1, 1, 1, 3, 1, 6, 1, 30, 1, 4, 1, 1, 4, 1, 3}

Range: ≤32

Answer 145

PoGo, safe, <=32 Bytes

Output (116 Bytes)

418823741706778235498161926738634336931815369322701079743198012261458790182-1935586134-558199202-1377386932819187730

Solution

enpobeosadpeadopuftogopoopufnigo

Answer 146

REPL Python (tested with version 2.7.10), <=32 - Safe

Output (1196 chars):

"{CL_UCIN:11 DPTP:4 IPAEFORDVD' 8 MPAD:17 BNR_O' 5 EDFNLY:8,'EUNVLE:8,'O_LC' 7 STPLO' 2,'UL_E' 0,'O_O' ,'XEDDAG:15 STPFNLY:12 IPAETU_IIE:2,'ALFNTO_W:11 IPAEAD:7,'EU_XET:11 SOENM' 0 IPR_AE:18 LA_LBL:16 LA_AE:11 FRIE' 3 EE_TT:8,'EEENM' 1 BIDLS' 0,'OPR_P:17 BNR_R:6,'NLC_UTPY:5,'TR_AT:15 CL_UCINVR:10 STAD:16 LA_OAS:8,'OTNELO' 1,'RN_XR:7,'EEEGOA' 8 GTIE' 8 SO_OE:0 UAYNT:1,'IAYLHF' 2 LA_LSR' 3,'MOTSA' 4 IPAEO' 9 BNR_UTAT:2,'TR_A' 4 IPAEAD:5,'NLC_SIT:7,'NLC_OUO:5,'TR_TR:9,'UL_A' 0,'EU_IH:13 BNR_IIE:2,'NLC_SIT:7,'RN_TMT' 3 UPC_EUNE:9,'IAYMLIL' 0 PITNWIET' 4 NP:9 LS_PED:9,'NLC_O' 8 SOEGOA' 7 IPAESBRC' 6 IPAEPWR:6,'O_OR:5 DLT_USR:6,'IAYAD:6,'RA_OP:8,'AEFNTO' 3,'EEESIE1:5,'EEESIE0:5,'U_OX:9,'ALFNTO_A_W:12 LA_TR:16 BNR_REDVD' 7 RTTO:2 IPR_RM:19 DLT_AT:16 BNR_D' 3 LA_OS' 0,'TR_EE' 3,'NR_EAIE:1,'NR_OIIE:1,'TR_USR:6,'UL_UL' 0,'IAYPWR:1,'UL_LS' 9 UAYCNET:1,'IAYMDL' 2 DLT_LC+' 3 DLT_LC+' 2 WT_LAU' 1 DLT_TR:9,'O_UPI_RE:15 JM_FFLEO_O' 1,'RN_TM:7,'AS_AAG' 3,'LC+' 0 SIE1:3,'LC+' 2 SIE3:3,'O_UPI_AS' 1,'ODDRF:16 LA_AT:14 JM_FTU_RPP:12 BNR_LO_IIE:2,'IAYRHF' 3 BNR_USR:2,'IL_AU' 6 RTTRE:3 SOESIE0:4,'TR_LC+' 1 SOESIE2:4,'TR_LC+' 3 UAYIVR' 5 PITNWIE:7,'NLC_IIE:5,'UL_LC' 3,'UPASLT' 1,'AECOUE:14 JM_OWR' 1}"

The Code (32 chars)

import dis;('%s'%dis.opmap)[::2]

Answer 147

J, Cracked by Dennis

Length <= 8

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

Answer 148

Pyth, safe, <= 8

128834756732407702383511125730021881412948585094402384

Probably easier to reverse than my last ones, but let's see...

Solution

*7C.B.!T

Answer 149

Retina, <= 32

Place code in multiple files and count +1 byte for each file beyond the first. 1358 bytes of output:

llaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllala

Answer 150

Mathematica (cracked by 2012rcampion)

Range: <= 64

String:

368921261379020282513891270954327186982974673706213278032469400595412966847044520376177106248857169605480346489563721888158441477887340357265444593721230093185417136793217614909721283425696418258308730582895596139457963926138833267594357117764501504

Code: GroupOrder[BabyMonsterGroupB[]]^9/10^54

Golfing this down to below 32 probably wouldn't have helped. Note to self: next time bigger is better

Answer 151

MATLAB, cracked <= 16 bytes

I'm going to post this, but feel free to call it invalid. The thing is although the output will always be the same on the PC I am using, it may be different on a different machines as it depends on installed licenses. If it is not valid, I'll delete the answer and will play around making something else.

String:

ans = 
Bioinformatics ToolboxCommunications System ToolboxControl System ToolboxCurve Fitting ToolboxDSP System ToolboxData Acquisition ToolboxFuzzy Logic ToolboxGlobal Optimization ToolboxImage Acquisition ToolboxImage Processing ToolboxInstrument Control ToolboxMATLABMATLAB CoderMATLAB CompilerMapping ToolboxModel Predictive Control ToolboxNeural Network ToolboxOptimization ToolboxParallel Computing ToolboxPartial Differential Equation ToolboxReal-Time Windows TargetRobust Control ToolboxSignal Processing ToolboxSimDrivelineSimMechanicsSimPowerSystemsSimscapeSimulinkSimulink CoderSimulink Control DesignSimulink Design OptimizationSimulink Verification and ValidationStateflowStatistics ToolboxSymbolic Math ToolboxSystem Identification ToolboxWavelet Toolbox

Answer 152

Groovy (cracked by kennytm)

Range <= 128

String:

eert.scireneg.tcelf
egami.tw
noitatonna.tcelf
epocs.scireneg.tcelf
snae
gniggol.li
elbat.gniws
oi
trec.ytiruce
piz.lit
resrap.scireneg.tcelf
elif.oi
ytilibissecca
emi
stcejbOevitcelfer.scireneg.tcelf
fer.gna
te
xeger.lit
snaeb.n
elif.locotorp.www.t
cs
tcelfer.gna
ytiruce
tnerrucnoc.lit
rednif.snaeb.n
yrotcaf.scireneg.tcelf
skcol.tnerrucnoc.lit
li
gna
falp.gniws
tneve.tw
eert.gniws
redrob.gniws
noitcnuf.lit
reep.tw
litu.ytiruc
lq
gniggol.lit
tcelf
lit
epip.d2av
maerts.lit
noitatonna.gna
o
laropmet.emi
rehcnu
noitca.ytiruc
tesrahc.oi
www.t
litu.snaeb.n
ekovni.gna
elacol.li
hta
yrotisoper.scireneg.tcelf
litu.t
mod.c
moeg.tw
t
dnd.tw
raj.locotorp.www.t
rotisiv.scireneg.tcelf
radnelac.li
cimota.tnerrucnoc.lit
tneve.gniws
mi.tw
tpircs
tw
txe
o
csim.tcelf
hc.o
raj.lit
sc.o
ips.tesrahc.oi
gniws

Code:

for(Package s : Package.getPackages())println new StringBuilder(s.getName().substring(6)).reverse()

Answer 153

Mathematica, cracked by kennytm

Output (74 bytes)

11111100001111110010000000100010010010010100100101100111001100000110010101

Range: ≤64

Answer 154

Math++, cracked by LegionMammal978.

Range: <=8

String: 19.86154370456891

Source: cbrt7835

Answer 155

Fishing, cracked by Mauris

Output (20 bytes)

18538111181203494721

Range: ≤32

Answer 156

Microscript, cracked by LegionMammal978.

Range: <=4

String:

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""0

(Length 253)

Original source:

'~cq

Answer 157

STATA, ≤ 32 bytes Cracked by @LegionMammal978

Cracked by @LegionMammal978, who also pointed out a bug in the interpreter and how to fix it, so thanks for that!

Note that this uses the free STATA interpreter. Output is 892 bytes. In the "real" STATA interpreter, the output is slightly different.

STATA is a programming language designed for statistical usage on datasets. The normal variables it has are essentially arrays of values where each one represents a different observation. It is used frequently in economics for regression analysis.

    a
1   1.125   
2   2.25    
3   3.375   
4   4.5 
5   5.625   
6   6.75    
7   7.875   
8   9   
9   10.125  
10  11.25   
11  12.375  
12  13.5    
13  14.625  
14  15.75   
15  16.875  
16  18  
17  19.125  
18  20.25   
19  21.375  
20  22.5    
21  23.625  
22  24.75   
23  25.875  
24  27  
25  28.125  
26  29.25   
27  30.375  
28  31.5    
29  32.625  
30  33.75   
31  34.875  
32  36  
33  37.125  
34  38.25   
35  39.375  
36  40.5    
37  41.625  
38  42.75   
39  43.875  
40  45  
41  46.125  
42  47.25   
43  48.375  
44  49.5    
45  50.625  
46  51.75   
47  52.875  
48  54  
49  55.125  
50  56.25   
51  57.375  
52  58.5    
53  59.625  
54  60.75   
55  61.875  
56  63  
57  64.125  
58  65.25   
59  66.375  
60  67.5    
61  68.625  
62  69.75   
63  70.875  
64  72  
65  73.125  
66  74.25   
67  75.375  
68  76.5    
69  77.625  
70  78.75   
71  79.875  
72  81  
73  82.125  
74  83.25   
75  84.375  
76  85.5    
77  86.625  
78  87.75   
79  88.875  
80  90  
81  91.125  
82  92.25   
83  .
84  .
85  .
86  .
87  .
88  .
89  .
90  .
91  .
92  .
93  .
94  .
95  .
96  .
97  .
98  .
99  .

Answer 158

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 :)}

Answer 159

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)

Answer 160

Python 2, <=64, cracked by squeamish ossifrage

Output length is 2042.

`..{{|{{{{| {|`{~`||{..{~~{~|~ |~~.~{{~.~|{~` {~|{||~{{{~ `{~`~ {{{~|~~{~{{~~~~ | ~.~~.  { {|{~~{{{`||`|{~{.{|{`~|{{|~{{.|~~|.|||~| | .{~~|{~. `~ {{{|{|{|{~{{{{`|{`{{{. |..{|~{~~ ~{{{|.|| {| .~||`|.||{{{  |` ~|~{~  .`| {||{~{{{ . |~{{{~{~.|{{.~.{| {`{~~|  |{`|`{~{ {~|.`~`||~|`|{{{~ { .{{..{{~{.{|~|{{.~{`| {{{~~`||{{{.{|{~|{|~{{|{.||~|~ {{`~{|``{{ ~`{~`{|{`..||.{|| ~{||~{.|{`|.~`{{~|`{~{{|~|~~~`|{ ..~|~{ {{{.{||.{{|~~.{~{`{{{``~.|||{~~|``~|{{|.{ ~|.|`{~~||{|{`{.|{ {`  |``|.| | {{~`|~~|.|{ |~|{{~{~|{~||{`.~~~|.{{|~~.{|``||~|~ |{{|||~   {.   .|~{||`{{{`{|| {~~~~~~`{{.{{~~`{{{``~~|`.` ~`~|~{ ~| |~ `.{| { ~.~.`{{~{ |~{{|`|{~|| {|`||`{~ || {``~.{~`` `||~ {`{...|`.~|{ {~..~`` `||~~{~||~{.|{.{~.|{|{. {.~  ~{~ `{{ ~{{{~.`~`{||{.~`~ |~|{.~{~{  {~~{|.{~`~.{~~~{{| {{{||`. || `.~{{~{| {.{{|{`~{.`.~`|`{{|~`.{{`{~{|~{~{ {|~~|{.{ `.~...{~{~|{~|~|| ..`~|`. ~{{{{|.~{`~~{|`{ `.`|{ |~{~|`{| |{|{~| .{~|`~|{{~.~`~ {{~{ .| |.{{{~{{{|{.  |~`|||``{  ~{``| ~ {|.{|~{`{`{~`..{.{{ .{| |`{{{`.~ ` `||~{|{{`~.{||~`|{.|{{~{. {{~|{| |{~ ~{.~||``|~{.`|.|{{.|||{~{|{{`~ `{|{ {`{{{~{{ {{~{|`..~{{{.||`|~|{|~ { .|`  .~|||{`|||...{{.|{{|~` {{~`.{~..{~{. |~{{.{ .{{ |`{{{~{~|~~{..{{`{{{~~|~|{||{`` ~` {``{~.|~.{{| {{~||..|{|{ |{{|{ |. {~{{~||~~|{ .|{~~~|{{|.{~| {{.`{|{~`{.~|. |{`{~{|``~{{{~.`.|||~|~~|{{~{.| ~{~|| .{|~~ ~~|.{{`` ..{.|.|` {`|`|`~ ~|{{`` ~{~~{|.{{| |~{~`~  `~.~~||~{{ {{{`~{`.| {|||{{|~`|~{~ {{.|.~|~{.||~|~.{{{~.|{.{ |{~~~ {~~{~{| . {{{{{|.~{||||.~`.~{{{{ ~`..|| ``~. {~{  ||{~|{{{| { ~{ {| |~|~ ~`{.~~|.~~|`|{ {.{{`~~~{|{~|{~~`{||{ |{|{     `{  {~~|{|.{{{{`{{{.|{~~{~ ~.`|.{. `~{{~` | ~.{ {|~`{~` || |{ {`{{~|{~ ~. {~`.||~.~{{`| ~{{ ~.~{`|{ {{{ {||~~{{` ~{{ {{ |{`|{{`~`~|{ {~ `{ { `{~|{.~ |.|{~~||~{{~|{.{{.~.~.~|~ {|{~{{|{. |{`~{~{ `.| .~ {.|| |.||| {{{`|{|~|`|{{{`. {`{{`{{{{ {{~`{{{~.~{{|{{{{{  .| ||`|``. .{~~.`{{{{ `|{{|~`  |{.{|{ | |~| |||~{`~~{|{{`|{{~`{ ~{~ ` .{|{~|{| {`.{|.{{ `|{{{{|{~ {{~{`~|~|`{ .`~~.~ |{{`{ |~.{.`{{{{{|{.{~{~~{{{`~~{{~ {.| {|{ ~|{ | `~``~{. ~{|.{|`|.~|~{` {| ~ | {{{{~{.{|{~|``{ {{ `{{ {{{{~{  ~{~`{{``.{{|`{{~{|`{||

Answer 161

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.

Answer 162

Stuck

Range ≤ 16

2168925562175809192559478076880588368582100483271088024043828990422001923191680863850623927595547346407714810113472269252167445496071576662478289717285985402906310835521027527551223189006697035136670796256477571739377544867088672367472233527480869967275139523178130025731319312921602024932416527919785339865272904868900012848483524127510716100537641614277573574462059561331647147876433531460016442645381487797364639134320718738374858305349145066235346421701046899192008585135320910686590358334772389749939817058285349456617996640297934416181996318720764083266638429376950594661304355191421796441827251161752628397770607648022218312442466693740602593303954106967643143879967574065179562865748076263514503762459279801408572553675472162386743096082350162062120214037257889728756909022864263379375738597404219166174950739087587328792127529972518158959401032154717619529403824671180089027084802477351400006470562610530999268201921660851034700237833520950293994236369814409915881847765798922163600648362507129799219704206457062827349157730605338819548543898424264022113532228663886032973001113547005761720813159628839520627038518851306849732407639408570749359897756114310076317041643531733090612401595935310458821896104323038853016334166784862248018581435244460900366876040515395441052395548390475535577670850547410979423430298278900620110320897529054942911446633753414917024919919970175026606169419394696679282133474997931378104086175342341496873847171157770912965204251521157297840312816827181319386756339172825611051401958874252691478690491454151253511925877986214195338260183452471566732756149036546096295611336151462030045364499809201812069206288576927495424514214051335116682064781777241395896257305784546830600542533969732797537338559370295863809192816636221714972687740188586708045310477861787585444454638371081424481726478254013214299647094097796582071081153602490233858110112041212790693523888275456000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Answer 163

Self-modifying Brainfuck, Range ≤ 8

Output:

\;*

Answer 164

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

Answer 165

Javascript (Cracked)

range<=64

My code:

 a=7;b=4;c="";for(;a<2000;){a=a+b;c=c+a;}c;

1728 chars

'111519232731353943475155596367717579838791959910310711111511912312713113513914314715115515916316717117517918318719119519920320721121521922322723123523924324725125525926326727127527928328729129529930330731131531932332733133533934334735135535936336737137537938338739139539940340741141541942342743143543944344745145545946346747147547948348749149549950350751151551952352753153553954354755155555956356757157557958358759159559960360761161561962362763163563964364765165565966366767167567968368769169569970370771171571972372773173573974374775175575976376777177577978378779179579980380781181581982382783183583984384785185585986386787187587988388789189589990390791191591992392793193593994394795195595996396797197597998398799199599910031007101110151019102310271031103510391043104710511055105910631067107110751079108310871091109510991103110711111115111911231127113111351139114311471151115511591163116711711175117911831187119111951199120312071211121512191223122712311235123912431247125112551259126312671271127512791283128712911295129913031307131113151319132313271331133513391343134713511355135913631367137113751379138313871391139513991403140714111415141914231427143114351439144314471451145514591463146714711475147914831487149114951499150315071511151515191523152715311535153915431547155115551559156315671571157515791583158715911595159916031607161116151619162316271631163516391643164716511655165916631667167116751679168316871691169516991703170717111715171917231727173117351739174317471751175517591763176717711775177917831787179117951799180318071811181518191823182718311835183918431847185118551859186318671871187518791883188718911895189919031907191119151919192319271931193519391943194719511955195919631967197119751979198319871991199519992003'

Answer 166

Hassium (in REPL) <= 32 Bytes

Range <= 32

truefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalse

Answer 167

Python 2.7.2, ≤ 64 bytes

[('__doc__', 'DEBUG'), ('__name__', 'DOTALL'), ('__package__', 'I'), ('acos', 'IGNORECASE'), ('acosh', 'L'), ('asin', 'LOCALE'), ('asinh', 'M'), ('atan', 'MULTILINE'), ('atan2', 'S'), ('atanh', 'Scanner'), ('ceil', 'T'), ('copysign', 'TEMPLATE'), ('cos', 'U'), ('cosh', 'UNICODE'), ('degrees', 'VERBOSE'), ('e', 'X'), ('erf', '_MAXCACHE'), ('erfc', '__all__'), ('exp', '__builtins__'), ('expm1', '__doc__'), ('fabs', '__file__'), ('factorial', '__loader__'), ('floor', '__name__'), ('fmod', '__package__'), ('frexp', '__version__'), ('fsum', '_alphanum'), ('gamma', '_cache'), ('hypot', '_cache_repl'), ('isinf', '_compile'), ('isnan', '_compile_repl'), ('ldexp', '_expand'), ('lgamma', '_pattern_type'), ('log', '_pickle'), ('log10', '_subx'), ('log1p', 'compile'), ('modf', 'copy_reg'), ('pi', 'error'), ('pow', 'escape'), ('radians', 'findall'), ('sin', 'finditer'), ('sinh', 'match'), ('sqrt', 'purge'), ('tan', 'search'), ('tanh', 'split'), ('trunc', 'sre_compile')]

I don't know if this will be easy or hard....

Answer 168

Powershell, ≤32

737784469951320029118050726512964156719794212568661655168720201723063235389283340737737814267464712527522846140016193996608429064661058322895893657034047363779079634027206122749152137684815809600182599895126968850669408878865633368185344895726788007432678130501271341728442605939659052374852779038168878407427980536208777811767898710413818785947185492107310928034987987504331382319406385208718840283454519601991959588878312550832315559921741591462280462948210386638061027843572023905437190100575987108524263909897885390736696917742316692409543025098600783974409744538115150523233950428962729802998336121720376672897228124096198982959715942250190149495981316652644361050065748827684252694810369927154522179963798781033591811

Answer 169

Matlab, <=64

The desired output is

ans =

     9
     9
     9
    10
    10
    12
    13
    15
    15
    15
    15
    13
    11
     8
     5
     2
    -1
    -4
    -7
    -9
   -11
   -12
   -12
   -12
   -11
    -9
    -8
    -6
    -3
    -1
     1
     3
     6
     8
     9
    10
    11
    11
    11
    10
     8
     7
     5
     3
     1
    -1
    -3
    -5
    -7
    -9
   -10
   -10
   -10
   -10
    -9
    -8
    -6
    -4
    -2
     0
     1
     3
     5
     7
     8
     9
    10
    10
     9
     9
     7
     6
     4
     3
     2
     0
     0

Good luck, robbers. Maybe there's a solution for octave but the one I have in mind does not work for octave.

Tested for Matlab R2009a and R2015a, but I think all fairly new Matlabs should give the same.

Answer 170

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

Answer 171

Ruby <= 32 (SAFE)

"8762504450324893848651280721691835717940669000462575484369396210258048929833970016297166254385132205202235180295079454023977826406979481295799194841934758121726118165990323332304568746264850532094544184088081482476162966282924240706855704443909297279711527256266149302299801021814740563741586350307136169051997209078653010929909330725a93586825476403753528022538421975387929896553841882810474799363453046018606169377669906563915966214068307559446990614728199972565468028975641938881008153501071577230002720943376a301775966920319271087407600489642777663287722163559579935799452303905473803281788975270137361183607848516570173259033490012009540073087632403050024902293445141468992599827814385979797481372233782966926361021702340409774146157255606565210355513797874130438807686870391470600158424066431303063375213722764844392000554833276485799316866946004195323665470580216216002583900494820220735082842592105660387965775910979959250091077095653612102696221426415a648773018022294769993224545803577a3763005527251908295636358910010513363179690021387446604533222751642813a8614089268a28012273422320162366569989922699128895234357942164566077868a49814885873137022055353a9846964630645022047290930125568794081376438232094470701310117203087247248634417152203131200635901456134613462592550208341287080896325568191584605164462850564148180507a062259043076691876231279478133327773460196580784756838442111201274379859744276598757985720380892316934394451373863238543152514271552134a04282987903a61885941443856a1713313317735297699830794002789480581428834630930216199054175159184988994760007300a79656926139784321218328804337480388158663865713a59654331635998377274152630834636272411578533575176582007320a703361775217144466335735439372357821466633028157921828931151a50a479279208a9016419708326819702203778835911523016342458872497769621161340668800a410301953081688442694810179113277816543124401448721857324972408282507447735612726405995653404a909146345587007109536191051a58398126a72597728470093a32078324098a634a2571552088a5057083729347915385829431416171"

source code:

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

Answer 172

BrainF***, <=64 bytes (cracked)

Not the most interesting, but

(P<RTVXZ\^`bdfh

That was fast.

Answer 173

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

Hint: My username might be helpful.

Code (60 bytes)

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

Answer 174

Python 2 (cracked by squeamish ossifrage), <=8

REPL
Output length is 2046.

56550386206054179162548017357607166877326950157664759075921413859637041669397059681541931877422025121256788162836088400165033570974119696468335773652909254170330164377894800079257448666099053623206382697492451971760308547104958445589133157534777018043222127988543134876613452644704759850800936953205799738580016218889332182571623100055512417089783688065420823946457447594057718076032062898420133153467680257337358757150883870017232039191113861064919471545198711249108334255880207361486470544933750513180321632870834623132014404230986442204021966286334790249690741298778020546006176853434874601354960441467281577522093672430442856498028744124837473118164554869017072520440299226812773762068658400830262998001716850918674872669415380486313573200129613863355262257158696796087045613414583091894739323523709977587718522979510033421977733039154028181774672291102216470928498134839523151867827533967685385583389265733951307766014557736071050412272700000103138880805368839091740333390987466511809550838391378366574471719695948662339861388921818773728641697498792389618912829421094414564430826315967252640705705355391466857707622261190415246891280358843190401958361815778174180433530772080212964467648374588450674577417599834611349560139046137965819475062392481412174008594126549402584696723064027103502213048689091863760516875594296477732290230660754619325574528925864460015063065896945372537214280443927053569172825326507421669896657133555074443620641276881241217748151235083009869241666409832403942898680315660811127286016399084677133462114944027018181198398191927537951299035483303847446935764723186489934280278507733148435577278184213066712159513578759803166554108576576748496080383180419238128895009010884863992209222313446817580767730125367184154002259324355017866013660533117830098852606050615247069229459748111343694655472797803674736940470112637452103829080400421952083750514134227202873323995964355616668906593351764656337351039360744044462509483339108670069907548847453283420832912274710222330634420141536739170107264032313922007829323371963L

Answer 175

Perl 5, SAFE, ≤32

Output:

85547195679171218736754503308731233555306328355775132346594959288367525592463131145153231485115872151324349953315183233154032535217535312775505540353147384384345753951213930993267528310951923507543975483255319544192079237930337715655555944071935651227146835247663241573532795427282356315271951195247514555671263393919951371523551968727034191501936033639407135793351615183951755475339911913075297918275031374753672103266737595511383169928472433051269140473291557145513663435913595091446726553615378357991611243910231059149199977137114935259528958194287495399492324511167278751995763117929311251379526733394715787146771129911971108317794455251118875751103512033219470755354119415545874095386711312355569131539151707359134952343554742632072619318342753514347121533637593567320745633807411506741794875187556074983317141314299639212729551539157520071515128742275451311134111335480310119155439296716833303571560316953447176743117833855987627198312273507248715992295497130272403591155117193735522337546354671510346114383164728715318314431222341074011285938747797233135369947918674863173138791275408337235079432392755834695539123914475499368746474815115526433471205520912523203118034743291362739271851531915271431279348321993819555111922113963228348271299437115031143249917434023300321152811548735432919110720672235425157398915151518756195127489921633387104713474947273946234527337590352951239365142155307138353792247439517914599423955954839144342352112312907963339420351635331167131593987257126073039254723195259807414344432367159204319477953999271543351071163527274479279953431815488720191659301522594539351926313327327405934351623258327514767579140756675703459564354152679390315631863546332555139504338911419

(1703 bytes)

Code:

print($==$=*12+135)while $=%=473

Answer 176

PBASIC (safe)

Range: <= 32

String: 000000184066073CB303FC6A6B901CFC14844C3543BA023499B966F6E05707C0

Code:

t VAR Byte
c VAR Word
FOR c=2016 TO 2048
  READ c, t
  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.

Answer 177

Javascript ES6 (in REPL), <=16 bytes

"0.7146314631463146323"

js for the lulz

EDIT: Here's what I had

.9.toString(8)+3

Answer 178

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.

Answer 179

Go, safe, <= 128

The solution is a function that returns a string

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

 Er`I=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$C77`PfyIU~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}

Answer 180

Javascript ≤ 32 bytes (Cracked)

Output to broswer console:

3.7376696182833684

I think this should be an easy one to crack :)

Answer 181

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.

Answer 182

Python

Output (642 bytes)

PPJRRE5SGGZJNZ6542MDZ0P63OFSMAV9H4HIVS211G8DNP9HCG8PZ80OXG1M4Z3G9IY7KM7ABJGZU6FDEFZ08WUONX12Z7NDZ0ARJIQUY17BUPO9LL4L5KFXQ3OW7GZ1228FXLLQTN5QCKVAFTO3D1PPBUY04D3ZCX3GH197UHZZKML7RWYFSBDJ3PM4H1009P5OHCZDM445PN0XA0KS9J40XS66UBNLE57X4YK0N1JUGG1QMWBU7RDH3USR67103NKNRO7YLKGCZ4GQHHHRBFCYCR7ZT5NS3WGTFNZV28OTWDE90B5UFO7U971O9MUS64VM2KM9Y4QB4HSN3N7ATROYL91EZT7OMJRG4RJU3MJVMPIRK6P77YWMXYMJCP4CERYR8ZOKR0QM6HJATFKTB9LG4WFBO24JVCEFS1ZJJTTIDBG0KTKKQ6S4FTTHI3JALK3STUDSSHL4605BVD0ZLQQ2DP07SH4E2UR7WS2DJRQ208FWCSQVQD4AXHSN7XWLASSERZMKOUXIX1SF7X4PF1LACIWBAGSPPR27CRQRDMGARR0YO0UQBSZ5CLVOPS2XY6N4Q0XM2Y4GH14C33U5G5J91Q4MOY8T3LZXO0L2PV6CK38RX04O7D5P6HNUTI2OXS

Range: ≤128

Answer 183

JavaScript, <=128

00358012905283655489681387343300226018309644130198260362721217094368488629994183590404114634239030553340577380700872201285119607788269124090823224360240193030803441349394723769282028569486430598787732717975019287728045155681160827279417346882416366135233161036698992604037049921949576723174944317111248204247049344351065178858829108731386362946563383737536326578078307362139981510824831845157219855804180793331892951977648790192144176446779637889945745179861103177267732169838447699101733367140795166477309527566921776354116556874970994340296441999477262815207718575097792124932847544962329445029141725463959033334260685824908474246704754802564783554165481524736423172709116794248364244586705999633058007798098332961412148731293303098179320921686978844245876697106606140568511730167487075252802104722975722646948940431590046859140943772126995315164357373334023484623029041724973481860693349391241460673665283664982738940557852863459316494285630822001663688764295910547169827240733550572529028567149028288669014271873567055995909615886243657162561111928500355946204316377505823894613678400884985233379281376397009921605127999892895750232950580210601932634603550162958693809260186624823850035456344096946392718695737536090762940491445189058460092376590329085766025273318075492759399744890292473420918371908385365150647502346180700840743486857589613318381345431850366526750179559657924663761015050227717528227556759816034980118051710382546156346747168679955551000533040609007788295740534384139573930944535893817362805990049284615329006400177479800499237213122612446840255782531513783630128583477004504177603180295784023844482078824939304925562889362636235301267113079934878387328567250130540814163709550788100595819650552271951336547808439542035000323703187263685818399760265227067797449302365339301139401093461461348866259841184270441908662733190853780689217452971238980692788822239251210320922127026630058291126644641906287260701388645158453092211553352831331266547505242978593018522814984718097697386851769976859263553375174403608111276407847927851

Output is 2048 bytes long.

This can be run in a browser and technically, when displayed, is surrounded by double quote marks. If that matters, shorten the output by 2 characters and add the quote marks.

Answer 184

Pyth, ≤8

41399754779690003073371865173

Answer 185

JavaScript, <=64

03466173801382013789090660287448084493755385432904982701050819994023780746035686706133611397893912853448991234305968272236477255727750157264016581090452025318476827471517482641864298121921289100585287388607442471878084935976649145036258648418413512666378145035800499922141984040717234397066591259492288326797804458255492874144952750047517452460147058619845424121247675620660733796233368720776034326362404794096634990164187345109949632290860517091770178113706461155145849636589065576781880641359836411760433902860336499810544243493912847452654493738201049327740264853969293929643966064027384885027194273808571014687803202049618801848303866801088592205340851282716051401144985791869047648726249487066847062548046369522854704087357799137237296731575514243513153579969851218003458027583365890865480244972230149605955753306762281021433821362647152457963086417205517324329127881287435675500435398965125557412644572316918702989215148190258444853371306431221182792036830306229972280715627421037633928881549951414764323338056907886229655549041269370463046487498514202352014795938421531313708858717904046307514199063026871499467395586069140243098366061446677108808301023099042039813004758930261276824462573614237406373259928082013303879606006089230435646012950259361222471908557806441215765421371843705727292053606341365590298522105608031744816162974333782078294681240184266489790333272582342198769582221563148276493810942870296904347800253901349102373330199357244918654760704713108993921551197485181351378162333277631045913408250977346252456096664365019635066713660893522173173496581143580328416349072963533050509728325370890079848468846551267997747954103432096372483412291118712612112465098600441803610014556687614321579644849155767610321827981798065046437930485381438233224600533288107710186090741130528323909147839757032751604707360414108342114067506933674596630261886079193622617656360272029373853948763996282094845323942766707480331950162921564490471880226270072182407764889652195408836851393705896998046436953814131340893804741979319883552549158094418

Output: 2048 characters long.

This can be run in a browser and technically, when displayed, is surrounded by double quote marks. If that matters, shorten the output by 2 characters and add the quote marks.

Answer 186

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.

Answer 187

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.

Answer 188

CJam (safe)

Range: <= 8

Code: 52 86#~

String:

-3769533025519801141444612600471707145120923043935146475096303581721089749532607198879063741123420792669738910020570009227839890520497940913522212865

Answer 189

VBA

Range <= 32

Output

-2147483625

Fun Fact: You can't Output in less then 16 bytes with VBA so this is the lowest class you can enter! I'm Sure this will be easy but I wanted to get something in the lowest possible Catagory for this Language

Answer 190

Pyth (safe)

Range: <= 16

Code: t_^745 342

String:

-18942848238846702000737756659973646779942967140220283256962974873234094651015038671495143989847386729680241862830119337956348747334505435496991960150131121034551982157083906586221042363353408334866251481833877575640325738380374503079168022891195104162339647595360613089361593444499080793276621647497053117734633055201755474710367919777029494004364776004138911600868453848171287452776512163863332098477484323757171405610690850019500967579254668662471619927914605780575892617912202737962562003554708579864138719448663400302560158574168412816418523381065735351001346267376142327158208030285036103491585408755540424848706251111628495962962429658113888676624984684325316931016006142566504870367481109174441236965833636556838972881583460166402936459951922530197633841563299276495092457476011321253117768971252551660133748392634552348895709075329070905022753303255226600059226372955583706070513126272846148280496645228763942426652598925307055362427834099836587711251922883093357086181640626

Answer 191

LOLCODE, <= 4, Cracked by Dennis

Output:

Segmentation fault (core dumped)

(I'm not expecting this to last 12 hours, to be honest.)

Edit: I realise now, this only works (as far as I know) in the official LOLCODE interpreter, justinmeza/lci and not in any of the online (javascript) ones.

Answer 192

CJam

Output (159 bytes)

217678233699230376274200601762191423470860646690253440687035259813072286171793618200693120655662580549470021092321494014584619026229869771791471554564431282176

Range: ≤8

Answer 193

dc (safe)

Range: <= 16

String:

199339092276008550131431539990658277331606397580853212910052122692972\
774962270058161510083607537469850717483606016495688567362868528504839\
312086200313771395859886273237465478825785462016628857818060996698109\
508463277753877223995999366056374895546219988417085601908866077450569\
127028454771902535032787281691702048189967745290542.733647326

Code: 9k567v237^p

Answer 194

gs2 (cracked by squeamish ossifrage)

Range: <= 8

155302392568755602954703791645117509171853024379829526053941914979869764308014137101580853703257316967419024475301219529235426499580989700492471117592130679578703743169643269465601721348541513593756461576285693343335323948307757460714948112300799739460308904920802096954409942913408096419432033412736062772643941590080446853373252364634969631941189995619518198884520714851905373673786301803818992437528114546902893524109693619934375650827402974283364443639166789257783558287754544152762072425073758073874087673853749491025245350759370202288198641756277483105286855126452445186433581045273785395216218774302137457946970241887040423778769507844532372395126914334350410060838193463467701758259122737262877689997254446028894627441507215258630083149823214021914691630385344730360124370246246101179225617171359948255502820724998630578414563433771734039885865200126640849581418101617590256731549974180011798541810287432442790284651150068406362365126351529058374781998017317605130002324359837801578063898318531549204801679097327112281643491227164405147112572736443606882046580363487549058621262011237393353206539463047834322740801769791931408446565925701470542859326548992533299683757135685782623491909977496699208378601007696438296190884956558923555954397532301018024430186240362810108284785909687389090161977695156919530083589605517157247030242165705875087062283656720276403790904286872963087972571265678945386772020563763263215540821764049192071134806571089438720182703434060588593593872862671044732442467813100983236427776

Code:

Hexdump: 12 17 2F 08 3E 09 33

Mnemonics: 2 7 range1 { pow } each

Answer 195

AppleScript, <= 16 Cracked

I have never made a code so obfuscated in AppleScript before.

Output:

8:9: execution error: Can’t make {true, false} into type number, date or text. (-1700)

(redirection of 2>&1 was used and counted in the byte count, counting the space as well)

The 8:9: bit WILL from execution environment to execution environment. Just needs to be noted. When I tested it a second time, it had changed to 10:11:, so don't let that part of the output mess with you. c:

Answer 196

Java, <= 128

13101310913101310131091310131013101310131013109131013101310131032321310131013101310913109131099131099932131099932131099131099131099131099131099131099131099131091310131013101310131091310999131099131013101310913109131091310131091310323232329131032323232323232321310323232323232323291310323232323232323232323232131032323232323232321310913109131060336879678489806932728477763280856676736732344547478751674747688468327284777632524648493284114971101151051161051111109710847476978343234104116116112584747119119119461195146111114103478482471041161091085247108111111115101461001161003462131060104116109108321089711010361341011104585833432120109108581089711010361341011104585833462131013106010410197100621310601091011169732104116116112451011131171051186134991111101161011101164511612111210134329911111011610111011661341161011201164710411610910859329910497114115101116618584704556344762131060109101116973211097109101613476971101031179710310134329911111011610111011661341011104585833447621310601091011169732110971091016134827966798483343299111110116101110116613473786869884470797676798734476213101310601161051161081016210697118974699111109583274971189732433289111117604711610511610810162131013109601091011169732110971091016134100101115991141051121161051111103432991111101161011101166134344762131096010910111697321109710910161341071011211191111141001153432991111101161011101166134106971189744321001111191101081119710011544321151111021161199711410134476213101310131060109101116973211097109101613410097116101343299111110116101110116613450484953454850454948344762101310131013101310131091310131013101310131091310321310131013106010810511010732114101108613411511612110810111510410110111634321041141011026134471039747991151154711599114101101110469911511534321161211121016134116101120116479911511534321091011001059761341159911410110111034329910497114115101116613411711610245563447621310601081051101073211410110861341151161211081011151041011011163432104114101102613447103974799115115471121141051101164699115115343211612111210161341161011201164799115115343210910110010597

Length: 2048

Good luck with this one. A couple notes (hints?) about the function used:

• java.lang.Closeable was the functional interface used for the lambda expression.
• The program relies on http://java.com for its output. Even so, I'm fairly certain that the output will not change anytime soon.

Answer 197

Python

Range <= 16

'.eoual ftj(er,eetrnr ph'

To be run in interactive mode.

Answer 198

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

Answer 199

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']

Answer 200

QBasic, <= 8 bytes (cracked by Mauris)

 8.851656E-03 

Note the leading and trailing space.

Answer 201

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").

Answer 202

J, ≤4, cracked by randomra

0.000198413

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

Answer 203

Retina, <= 64

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

itreinareinareinareinareiareinareiareinareiiareinareiiareinareiiiareinareiiiareintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinare

Answer 204

Javascript (Console) <= 128 Bytes

"xkvybybmhMxknadytmxadgjupalybuxsnqbEhehsnepcfsvqlqbehknytsdqtMpkfufililwrwhuxknidufilorCxitgjcfavwhknknytkvilybwrCnqtwzkfepcfybwrepsvsvgbgrEhuxsncnqtwzkfqborknidgruxUxidufsvilgbkvybehsnmxkngjEzozcfcfqlqborehcxkvybehsnYjwzsvqlmxadadojalybormhozCfilwrqborknidqbehehsnsdqtGjezaloruxidozmpilgbepsvsvGbsdqtgjezepsvybmhgrehadytItwzwzkfkvilybwraloruxidozMpilgbcnqtqtezqborehcxitwzCfqlkvilehcxkvybybmhmxknadYtqbehknytepcfybwrufililwrItgjwzupyjmpsvgbalybuxsncnQtqtezepcfsvqlcnqtwzkfqborKnidepsvsvgbsdqtgjezgruxadOjitgjcfavitwzwzkfkvilybwrKvybehsnyjwzsvqlozcfcfqlcnAdqtojozcfilwrqborknidsdgjGjupufsvilgbitwzcfqlwhuxqtOjkvybybmhyjwzmpkfqbehknytSdqtmpkfsdgjgjupufsvilgbqbEhknytepcfybwrufililwritgjWzupyjmpsvgbalybuxsncnqtqtEzepcfsvqlitwzcfqlwhuxqtojKvybybmhyjwzmpkfmxadgjupozMpilgbozcfcfqlqborehcxyjmpSvgbmxkngjezcnqtqtezqborehCxcnqtwzkfepcfybwrgruxuxidItgjwzupozcfilwrcnadwzupqbEhehsnepcfsvqlwhknqtezyjwzSvqlyjmpmpavalybormhepsvybMhsdqtmpkfitwzwzkfwhuxknidMxadgjupozmpilgbqbehehsnsdQtgjezaloruxidozmpilgbcnqtQtezqborehcxepsvybmhgrehadYtgruxuxiditgjwzupitwzcfqlWhuxqtojmxadadojalybormhmxAdgjupozmpilgbqbehehsnsdqtGjezqbehknytepcfybwrsdgjgjUpgrehuxsnyjmpsvgbalybuxsnAlororcxcnadqtojyjmpsvgbmxKngjezcnqtqtezqborehcxgruxAdojitgjcfavkvybybmhmxknadYtmxadgjupalybuxsnozcfcfqlCnadqtojqbehknytsdqtmpkfsdGjgjupufsvilgbcnqtwzkfqborKnidgruxuxidufsvilgbgruxadOjitgjcfavkvybybmhmxknadytCnqtwzkfqborknidepsvsvgbsdQtgjezkvybehsnmxkngjezmxadAdojozmpcfavsdgjmpavgrehadYtwhknknytkvilybwraloruxidCnadwzupepsvsvgbgrehuxsnyjMpsvgbmxkngjezalororcxozmpCfavcnqtwzkfepcfybwrepsvsvGbgrehuxsngruxadojufsvormhKvybybmhyjwzmpkfkvybehsnmxKngjezozcfcfqlqborehcxepsvYbmhsdqtmpkfgruxuxidufsvilGbmxadgjupozmpilgbozcfcfqlQborehcxmxadgjupalybuxsnqbEhehsnepcfsvqlufilorcxwhuxQtojyjmpmpavalybormhkvybehSnyjwzsvqlmxadadojalybormhOzcfilwrqborknidqbehehsnsdQtgjezaloruxidozmpilgbepsvSvgbsdqtgjezepsvybmhgrehadYtitwzwzkfkvilybwrqbehknytEpcfybwrsdgjgjupgrehuxsnyjMpsvgbalybuxsnalororcxcnadQtojgruxadojufsvormhkvybybMhyjwzmpkfozcfilwrqborknidSdgjgjupufsvil"

Answer 205

Python 3 - 32 bytes, Cracked

9511667971998764582180733448500755

REPL output.

Answer 206

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.

Answer 207

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.

Answer 208

Pyth, <= 64 bytes

01111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110111010111011111010111110111010111110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011111010111011111010111110111010111011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111100

That's exactly 2048 bytes :D

Answer 209

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

.1308996939

Maybe I can get out of the negatives...

Answer 210

JavaScript, <=64 bytes

Output: 2038 bytes

00NaN573100360487769457310036048776940NaN266247541047714640NaN65254190216760520NaN34568908272755050NaN038836263287495790NaN425130624407386360NaN118277804967331650NaN50457216608722220NaN19771934664716750NaN58401370776705810NaN277160888327003360NaN66345524944689390NaN35660243000683920NaN049749610566784510NaN43604397168667510NaN129191152246620370NaN51548551336651090NaN208632693926456230NaN59492705504634680NaN28807423560629210NaN67436859672618270NaN367515777286127940NaN060662957846073230NaN44695731896596380NaN14010449952590910NaN52639886064579970NaN219546041205744950NaN60584040232563550NaN29898758288558080NaN68528194400547140NaN378429124565416660NaN071576305125361950NaN45787066624525250NaN15101784680519780NaN53731220792508840NaN230459388485033670NaN61675374960492420NaN30990093016486950NaN0030481107248148120NaN38934247184470540NaN082489652404650670NaN468784013524541240NaN161931194084486530NaN54822555520437710NaN24137273576432240NaN6276670968842130NaN320814277444158250NaN0139614580041035330NaN40025581912399410NaN093402999683939390NaN479697360803829960NaN172844541363775250NaN55913890248366580NaN25228608304361110NaN63858044416350170NaN331727624723446970NaN0248748052833922540NaN41116916640328280NaN104316346963228110NaN49061070808311870NaN183757888643063970NaN57005224976295450NaN263199430322899830NaN64949379144279040NaN34264097200273570NaN0357881525626809750NaN422082513682571550NaN115229694242516830NaN50152405536240740NaN19467123592235270NaN58096559704224330NaN274112777602188550NaN66040713872207910NaN35355431928202440NaN0467014998419696960NaN432995860961860270NaN126143041521805550NaN51243740264169610NaN20558458320164140NaN5918789443215320NaN285026124881477270NaN67132048600136780NaN364467666561313130NaN057614847121258420NaN4439092082411490NaN137056388801094280NaN52335074992098480NaN216497930480930130NaN60279229160082070NaN2959394721607660NaN68223383328065660NaN375381013840601850NaN068528194400547140NaN45482255552043770NaN1479697360803830NaN53426409720027360NaN227411277760218860NaN61370563888010940.3068528194400547