title: The Mystery String Printer (Cops)

text:
# Question
Title: The Mystery String Printer (Cops)
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 = /(?:<=|≤|<=)\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
> 19 votes
# 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
> 16 votes
# 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
> 13 votes
# Mathematica, safe, range ≤ 64

Output:

```
CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

```

Source:

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

```

# Answer
> 11 votes
# 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
> 10 votes
# Pyth, cracked by Sp3000

```
1234465889612101271616181215168242024142718209323236243032163621242510

```

Range **≤ 8**

# Answer
> 8 votes
## \>\<\> (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
> 8 votes
# 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
> 7 votes
# 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
> 7 votes
## Snowman 1.0.2

Range ≤32.

```
110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

```

The solution is:

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

```

# Answer
> 7 votes
# 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
> 7 votes
# 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
> 6 votes
# 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
> 6 votes
# 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
> 6 votes
# \>\<\>, ≤ 8 \[cracked\]

```
oooooooooooo

```

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

# Answer
> 5 votes
# 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
> 5 votes
# 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
> 5 votes
# 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
> 4 votes
## 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
> 4 votes
## 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
> 4 votes
# 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
> 4 votes
# MATLAB, cracked by Tom Carpenter

Range \<= 16

```
ans =

        5760       22320
       13920       53940

```

# Answer
> 4 votes
# 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
> 4 votes
# Mathematica, Cracked by Sp3000

Range: \<= 32

```
808017424794512875886459904961710757005754368000000000

```

# Answer
> 4 votes
# 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
> 4 votes
# **Thue** \- \<= 64 Bytes, cracked by histocrat.

`555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555`

That's 2016 5s; by the way.

# Answer
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# 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
> 3 votes
# TI-BASIC (cracked by Thomas Kwa)

Range: \<= 2

String: `-10`

Code: `Xmin`

There's just no fooling this guy...

# Answer
> 3 votes
# 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
> 3 votes
# \>\<\> (Fish), Cracked by Sp3000

Length \<= 8

```
>>>>>>>>>>>>>>>>>>>>>>>

```

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

# Answer
> 3 votes
# CJam, Range \<= 16

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

```
1012718281828459045273890560989306532008553692318766845459815003314423651484131591025766640342879349273517109663315842845858298095798704172839810308392757538410220264657948067181159874141715197821216275479141900392134424133920089205141202604284164776815326901737247211071688861105205078721724154952753575314718656599691373305114285

```

# Answer
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# PARI/GP (cracked by Dennis)

```
362871

```

Range \<= 4

I don't expect it to last long.

# Answer
> 2 votes
# 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
> 2 votes
# Python 2 (safe)

```
6827526938285133941673000231813168619941300497097936591748380508088909429445611165463624032127627532803234880684278865355076531262231840494975595460968129959347104225901744872847426849492584955132469122376660991207547055101929306267237604577722010893773043497283203607878662025645581606573723842423809514070028255417440212506882886554655415227255545579921342691580901906655429920934202998813117772871149920709038390132067329036138426507171331383525723381813108558141195500901960258557975441280

```

Range **≤ 32**

### Solution

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

```

Try it online.

# Answer
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# \>\<\> 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
> 2 votes
# CJam

Range \<=8

```
31750158586652376823306770524160580239759220968490662365280697333523990463193796504719728904832671151360272625266534588786424734457574712153976494064953411059739792915722586949729210719621153746894802142918027970654609398438852308624078542639175128838831245786273442836511403960499435950211913983569988987209742058089855692071657841384645297208882183542051537989712878902231738195073256758864262540198959691481289564731544298150520509963645384433851976251199310574577965940322710082134532284930147152412624

```

# Answer
> 2 votes
# 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
> 2 votes
## vim

Range: ≤16 (keystrokes).

```

Qb lbh qrznaq n fuehoorel?
```

# Answer
> 2 votes
# 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
> 2 votes
# JavaScript (cracked by NaN)

**Range:** ≤16

### Output (17 bytes):

```
28274333882.30814

```

# Answer
> 2 votes
# 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
> 2 votes
# 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)]))

```

---

<sub>I think I made it to hard...</sub>

# Answer
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# C \<= 64 (cracked by kennytm)

```
111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011

```

(output is 1974 chars long)

# Answer
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# AppleScript, ≤ 32 bytes Cracked

Output

```
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)

```

Total: 2044 bytes

Hint

> There are ***FOUR*** STDOUT equivalents in AppleScript.

# Answer
> 2 votes
# **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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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 `alert`ed 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
> 2 votes
# 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
> 2 votes
## \>\<\>, ≤16 Bytes, Cracked by Sp3000

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

```

Output length of 32 bytes

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

# Answer
> 2 votes
# Pyth (cracked by isaacg)

```
939524095

```

Range **≤ 4**

Let's see how this goes...

# Answer
> 2 votes
# Dyalog APL (cracked)

```
4.58302

```

Range **≤ 4**

This should be cracked pretty quickly...

# Answer
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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
> 2 votes
# 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<sup>th</sup>** 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
> 2 votes
# 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
> 2 votes
# Haskell, \<= 32

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

```

This one is cute and easy.

# Answer
> 2 votes
# 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
> 2 votes
# (cracked)

```
4.81845e12

```

Range **≤ 4**

Worth a shot.

# Answer
> 1 votes
# 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
> 1 votes
## Pyth

```
10067283832263627132507444590041695034979992997150622392563276991517087210416125987872298759981924914598996739787601264046046893914007275634929310315058

```

Range ≤ 4

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

# Answer
> 1 votes
# C++

String:

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

```

Range: \<= 64

# Answer
> 1 votes
# GolfScript

```
100100110010011100110001011101100001010011010111011101011000100000000100

```

Range: **≤ 8**

# Answer
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
## Macaroni 0.0.2cracked 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
> 1 votes
# 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
> 1 votes
# Rust, Safe, ≤64

Output (440 bytes):

```
2EE5A53831925A9212038FBE5174381029212D926E994C46C69956F383F314D9912D4622FA13BF316AF3AFFA91A710FFAA454D5541C5B0800805B16B549B51195BFF081815B119B514EB599BC8169105BCA016D716241DDCA0941D3077697713F1D12ACA2C7E151775D80DD7ECB2B1557EF5D8132D885DF758C101DFA439E339384029EDB8405C9A9D9A17B4016EED78A11EFB61FB141A11374E4302171FB305C11202109AF17631485C8BD0EC63E61017C63128BD171BDD0C4CC71164C41131E15E1EBF25BCD2157251077F1547FB786B73315386105E0154E0B9E7

```

---

Solution:

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

# Answer
> 1 votes
# Python 3

Range: ≤64
String length: 1759

```
1450311547121626824402528317931024696537261379649312109934174763622928813537772202492826340253595039354204170803308812108106614974615992407513462378342519772879316185201191244193032905219821112379362735436273595816306408247797551887198223078132707718613741551438816716228420855210133806030879152023807281213669870947286924104806420930386226909518122591340634826667470106070805067486916003620079860533420912887938893520117652588913717930472346176939267545884056248725814428845435505286970004504538242272311816219001799408190917981242794876906923463019563132633790465573335245790782921280224126868686724604452690148708017495170944952232407517716174996669514909784703378613104880109045294268293224189609735626833741340860353297694678641117508508320027700778717534109394267437425043810487352376005634156569975311491459838272217846207077798205457351267508638726235986344105746925264997271470391586921860841952986010216300093433468007980482444450140150202011970723666974568959542215223332447146301544007477846089467045557063881769289045618456873502484742102787141509146927089727415468957468932233888307541183405820990577010792332515397454508971114910082242913202656447784249727817413159197879472620373533325157697422584249026116957034499508087753326237517531666435897781090922126023766286557629116809405490739569657792496159821300551508419666991511554805528263403378295007848547483596991780931036386960716493272927989817021495881172814505517266227891225298564264160100926161641968167450456638252346252357682659194962887041698807928559518187059146398406957924003562078098158050469520030372646913304777752187530842640087708732247607019311163659185637734636533976160365822448025321873341358014966837103376648875774633227200456239875015114894085499417129719017106310570

```

# Answer
> 1 votes
# 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
> 1 votes
# 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<sup>99</sup>) 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
> 1 votes
# Pyth

Range: ≤ 8

String:

```
49177772591428004056910940816433485702518448313728069154605014641218367314521229637591075731850711078018713

```

# Answer
> 1 votes
# Octave, \<=4 bytes cracked by kennytm

```
ans =  4.8105

```

Cracked:

```
i^-i

```

# Answer
> 1 votes
# Python 3 (\<= 32 bytes)

REPL.

```
177172218082085052481067589112390245408383458973982190836613425027273840834324281100485149132551246778981339968190311073240776569178878685724789960654670348361662827252973483749744632038916925690939659916043492930278567489422231220073029774565250343832768238643314785908679491540640941915666237839942314696031493953803281287102418829064719403480444915114668250543498318227260440120029605628856083175765744363390702825101686789888725560296981834662758351030421544264559750221026406067121783807117962060340615730987604546604714155531342482083463681465130945512630675950142946922773503989053740822544224822808739521839720865290854356372141124499117074370897738546403209492027955454351993333035066859502938275568857093391457569773694819414826823687786033626122521592630462668886697269593537206139576741010831202963443941784967084810577008190387631080387860331107152262177887372170404448327177863200442345178285860750842841747607378523075424463460687928269706777288437394933478285113452249795657205511632132532278321265130924156213221634753820154649629494859389730150879262081109896155213238885748358893270681278721615531236111911030373024923666321800532386588112916399442185933551569956564864083732019627140517341497168342679467249158600970283106090236941217046682435095258063945957758115971959566229732597197779697266154520814140590150

```

# Answer
> 1 votes
# bc -l (\<= 8 bytes, cracked by SuperJedi224)

```
1.56024766824332863615

```

# Answer
> 1 votes
# TI-BASIC, ≤8 bytes

```
-.3036143372

```

# Answer
> 1 votes
# Grin, ≤8 bytes

```
0.27994163386353987

```

# Answer
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# Bash

Length \<= 64

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

```
UlRSelNVRkJRVUZCUVVGQlFTdDZSMjlSTUVGTlFXZEJUVXclTDBWUloxRnFVQzlFU1RZeGNWcGxa
bVplUm1OcFNXbEphVWxwU1dsSgphVWxwU1dsSmFVbHBTV2xKYVVscFNXbEphUXBKYVVscFNXbEph

```

# Answer
> 1 votes
# 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
> 1 votes
## 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
> 1 votes
## \>\<\>, ≤8 bytes - Cracked

That was fast.

Output (17 chars):

```
11059633333125108

```

Works on the official and online interpreter.

# Answer
> 1 votes
# 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)]

```

<sub>(spaces added for readability)</sub>

# Answer
> 1 votes
# 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
> 1 votes
# PowerShell, \<= 2 (cracked by Sven the Surfer)

```
True

```

<sub>Edit</sub> -- 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# CJam, ≤8

```
487480661435681880634

```

# Answer
> 1 votes
# Haskell, \<= 64

```
"234269035277217371450204053788208058560799137025150410636234412255689818762656987340189922194199908934585754436770945621945227536480994122027390744842460652134286726113671600854494421884443688675047254139921459136558907251581541275435880046048108350763422072425649208447945247377494980796937940655701307997562317231177713235652338028417451236558995227590459444617827926812430772358074299811337678654829391325114470251619398332973724789690679216976966052216145384676794461656118897180025443680331132394850675017509197303075089601960100983874271959120860501629839988014042208671920682889138254667751623709396284481735303452673124139121777377846871850672033106472280969141703928366197810964922618740449515668724456268271448647699989156381445205967478469028588157734532905706524844819908323813305035658162074736928332593023809473156005356000353055733539612246442774946157819406373129208057258831053076086585508756487286954717132003621711976832374447894816733777893008621416274050484859334617085131384283216302606998622119582879282589199593973325446462015234491992064297172938689972846409163423245594572882877709043959807372637664123289304645760119286430615178518063617152788828056353625031963803801427210223721730258270231763792780768664884800062997419345647149704788982766859295443743499252375539507398523730009926333960108410757294547781696131123657453625024387016742581573855196031413093336350761030038596777874432933968895083735228717242953009263093968742573629027297647387126891761852949241957626049569804429541178011981933256268484794652351497560293391899479900814683813828949668729076822808628116446774100881521615133458539277068540778366277878840073320092074401621104369683572238945467129923105411003295755601858665112706827105134190951462194645064739837907120118633835684577553292202532275739715956095669642085664671234208045303605448727259339868163682440084839078742590621118695767964815678513010560919582968899674389139580927687507301062249730389625964423196961408134619058630786289121348398596872496242241800816316097838514854690220862576"

```

2046 bytes.

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

# Answer
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
## 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
> 1 votes
# 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 `.i`nterleave. 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
> 1 votes
# 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
> 1 votes
# Pyth, safe, \<= 16

```
16252320011828121914223211711247272693015813524610

```

This was output from a linear congruential generator.

# Answer
> 1 votes
# 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
> 1 votes
# Powershell, ≤16

```
61788129934789836849895604649984

```

# Answer
> 1 votes
# 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
> 1 votes
# 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
> 1 votes
## \>\<\>, ≤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
> 1 votes
# 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, 101**1**, output 0 and add 0 -\> 11
* 2^1's place, 10**1**1, output 1 and add 1 -\> 12
* 2^2's place, 1**1**00, output 2 and add 2 -\> 14
* 2^3's place, **1**110, output 3 and add 3 -\> 17
* 2^4's place, **1**0001, 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
> 1 votes
## 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
> 1 votes
# 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
> 1 votes
## 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
> 1 votes
# 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
> 1 votes
# 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)<sup>58.105455853990165</sup>**.
* `|` applies modulus to the result.

# Answer
> 1 votes
# 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
> 1 votes
# CJam (safe)

Range: \<=16

String:

```
-1757998761424490676921016856999645582687172166771732990901023822919032113856474131322376304211808153619988283134008439274637725633868254103891368425285165026468770378090155135372308987708009431738653866423053902527963127906032288661788122437508856152696997908146296016521091199803229053377715671662942187527704135032400317135628637248506389262291879310836675157035298269773565002128572484249631883681915978366368348422763684673273940395075510502820393796214460557862527316465092717359768308614013715174354726471330845504297837476047888566285525771034491348417324909599453182115064413154332558333250875021070793798910049854644817559064573856721397747003126054061162347856585377448534690237788836012961397667542666722692935386425165604581402711433056617873627041251709641777614212372373696828558813318358124653096657585640957194959404589685428128317642065010497446792032482302568447660371023038445973792552314710542567265966630122643983375527917082186662519498233404401344837146447008437657457992594647903611528282318427533140206671065997969913543629153024916689707377967665079085509461263277920838560857104814273338655611983839393046785144278966861497797144865502969288669678711952606556690911517688871027804066141321298362142430813845600699520261708534251247924822880140866847159914428320312680337671139215536945422935222183014047914184629917144775390626

```

Code: `5345 363#~`

Yay more numbers /sarcasm

# Answer
> 1 votes
# \>\<\> (cracked by Sp3000)

Range: \<= 32

Code:

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

```

String:

```
563894191846824322181557735263848163944611762131417907481282961909287815042114141071535925118959126585814601613352812123491114638156704068663512650264401513800791946239391603476080341849517532994005910896839888895899232312762154139810647195016820308009

```

# Answer
> 1 votes
# CJam (cracked by Sp3000)

```
3.724191778237173

```

Range **≤ 4**

Let's see how long this one lasts.

# Answer
> 1 votes
# Wolfram programming language

Output (36 bytes)

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

```

Range: **≤16**

# Answer
> 1 votes
# 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
> 1 votes
# PoGo, safe, \<=32 Bytes

Output (116 Bytes)

```
418823741706778235498161926738634336931815369322701079743198012261458790182-1935586134-558199202-1377386932819187730

```

### Solution

```
enpobeosadpeadopuftogopoopufnigo

```

# Answer
> 1 votes
# 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
> 1 votes
# , 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
> 1 votes
# Pyth, safe, \<= 8

```
128834756732407702383511125730021881412948585094402384

```

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

## Solution

```
*7C.B.!T

```

# Answer
> 1 votes
# Retina, \<= 32

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

```
llaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllala

```

# Answer
> 1 votes
# 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
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
# Mathematica, cracked by kennytm

Output (74 bytes)

```
11111100001111110010000000100010010010010100100101100111001100000110010101

```

Range: **≤64**

# Answer
> 0 votes
# Math++, cracked by LegionMammal978.

Range: \<=8

String: `19.86154370456891`

Source: `cbrt7835`

# Answer
> 0 votes
# Fishing, cracked by Mauris

Output (20 bytes)

```
18538111181203494721

```

Range: **≤32**

# Answer
> 0 votes
# Microscript, cracked by LegionMammal978.

Range: \<=4

String:

```
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""0

```

(Length 253)

Original source:

`'~cq`

# Answer
> 0 votes
## 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
> 0 votes
# 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

```

<sub> I'm a little surprised that this survived, but that's ok :) </sub>

# Answer
> 0 votes
# Python 2, \<=64, cracked by squeamish ossifrage

Output length is 2042.

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

```

# Answer
> 0 votes
# 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
> 0 votes
# Stuck

Range ≤ 16

```
2168925562175809192559478076880588368582100483271088024043828990422001923191680863850623927595547346407714810113472269252167445496071576662478289717285985402906310835521027527551223189006697035136670796256477571739377544867088672367472233527480869967275139523178130025731319312921602024932416527919785339865272904868900012848483524127510716100537641614277573574462059561331647147876433531460016442645381487797364639134320718738374858305349145066235346421701046899192008585135320910686590358334772389749939817058285349456617996640297934416181996318720764083266638429376950594661304355191421796441827251161752628397770607648022218312442466693740602593303954106967643143879967574065179562865748076263514503762459279801408572553675472162386743096082350162062120214037257889728756909022864263379375738597404219166174950739087587328792127529972518158959401032154717619529403824671180089027084802477351400006470562610530999268201921660851034700237833520950293994236369814409915881847765798922163600648362507129799219704206457062827349157730605338819548543898424264022113532228663886032973001113547005761720813159628839520627038518851306849732407639408570749359897756114310076317041643531733090612401595935310458821896104323038853016334166784862248018581435244460900366876040515395441052395548390475535577670850547410979423430298278900620110320897529054942911446633753414917024919919970175026606169419394696679282133474997931378104086175342341496873847171157770912965204251521157297840312816827181319386756339172825611051401958874252691478690491454151253511925877986214195338260183452471566732756149036546096295611336151462030045364499809201812069206288576927495424514214051335116682064781777241395896257305784546830600542533969732797537338559370295863809192816636221714972687740188586708045310477861787585444454638371081424481726478254013214299647094097796582071081153602490233858110112041212790693523888275456000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

```

# Answer
> 0 votes
# Self-modifying Brainfuck, Range ≤ 8

Output:

```
\;*

```

# Answer
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
# Hassium(in REPL) \<= 32 Bytes

Range \<= 32

```
truefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalse

```

# Answer
> 0 votes
# 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
> 0 votes
# Powershell, ≤32

```
737784469951320029118050726512964156719794212568661655168720201723063235389283340737737814267464712527522846140016193996608429064661058322895893657034047363779079634027206122749152137684815809600182599895126968850669408878865633368185344895726788007432678130501271341728442605939659052374852779038168878407427980536208777811767898710413818785947185492107310928034987987504331382319406385208718840283454519601991959588878312550832315559921741591462280462948210386638061027843572023905437190100575987108524263909897885390736696917742316692409543025098600783974409744538115150523233950428962729802998336121720376672897228124096198982959715942250190149495981316652644361050065748827684252694810369927154522179963798781033591811

```

# Answer
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
# Ruby \<= 32 (SAFE)

```
"8762504450324893848651280721691835717940669000462575484369396210258048929833970016297166254385132205202235180295079454023977826406979481295799194841934758121726118165990323332304568746264850532094544184088081482476162966282924240706855704443909297279711527256266149302299801021814740563741586350307136169051997209078653010929909330725a93586825476403753528022538421975387929896553841882810474799363453046018606169377669906563915966214068307559446990614728199972565468028975641938881008153501071577230002720943376a301775966920319271087407600489642777663287722163559579935799452303905473803281788975270137361183607848516570173259033490012009540073087632403050024902293445141468992599827814385979797481372233782966926361021702340409774146157255606565210355513797874130438807686870391470600158424066431303063375213722764844392000554833276485799316866946004195323665470580216216002583900494820220735082842592105660387965775910979959250091077095653612102696221426415a648773018022294769993224545803577a3763005527251908295636358910010513363179690021387446604533222751642813a8614089268a28012273422320162366569989922699128895234357942164566077868a49814885873137022055353a9846964630645022047290930125568794081376438232094470701310117203087247248634417152203131200635901456134613462592550208341287080896325568191584605164462850564148180507a062259043076691876231279478133327773460196580784756838442111201274379859744276598757985720380892316934394451373863238543152514271552134a04282987903a61885941443856a1713313317735297699830794002789480581428834630930216199054175159184988994760007300a79656926139784321218328804337480388158663865713a59654331635998377274152630834636272411578533575176582007320a703361775217144466335735439372357821466633028157921828931151a50a479279208a9016419708326819702203778835911523016342458872497769621161340668800a410301953081688442694810179113277816543124401448721857324972408282507447735612726405995653404a909146345587007109536191051a58398126a72597728470093a32078324098a634a2571552088a5057083729347915385829431416171"

```

source code:

> p((691\**723).to\_s.gsub /67/,'a')

# Answer
> 0 votes
# BrainF\***, \<=64 bytes (cracked)

Not the most interesting, but

```
(P<RTVXZ\^`bdfh

```

That *was* fast.

# Answer
> 0 votes
# 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
> 0 votes
# Python 2 (cracked by squeamish ossifrage), \<=8

REPL
Output length is 2046.

```
56550386206054179162548017357607166877326950157664759075921413859637041669397059681541931877422025121256788162836088400165033570974119696468335773652909254170330164377894800079257448666099053623206382697492451971760308547104958445589133157534777018043222127988543134876613452644704759850800936953205799738580016218889332182571623100055512417089783688065420823946457447594057718076032062898420133153467680257337358757150883870017232039191113861064919471545198711249108334255880207361486470544933750513180321632870834623132014404230986442204021966286334790249690741298778020546006176853434874601354960441467281577522093672430442856498028744124837473118164554869017072520440299226812773762068658400830262998001716850918674872669415380486313573200129613863355262257158696796087045613414583091894739323523709977587718522979510033421977733039154028181774672291102216470928498134839523151867827533967685385583389265733951307766014557736071050412272700000103138880805368839091740333390987466511809550838391378366574471719695948662339861388921818773728641697498792389618912829421094414564430826315967252640705705355391466857707622261190415246891280358843190401958361815778174180433530772080212964467648374588450674577417599834611349560139046137965819475062392481412174008594126549402584696723064027103502213048689091863760516875594296477732290230660754619325574528925864460015063065896945372537214280443927053569172825326507421669896657133555074443620641276881241217748151235083009869241666409832403942898680315660811127286016399084677133462114944027018181198398191927537951299035483303847446935764723186489934280278507733148435577278184213066712159513578759803166554108576576748496080383180419238128895009010884863992209222313446817580767730125367184154002259324355017866013660533117830098852606050615247069229459748111343694655472797803674736940470112637452103829080400421952083750514134227202873323995964355616668906593351764656337351039360744044462509483339108670069907548847453283420832912274710222330634420141536739170107264032313922007829323371963L

```

# Answer
> 0 votes
# Perl 5, SAFE, ≤32

Output:

```
85547195679171218736754503308731233555306328355775132346594959288367525592463131145153231485115872151324349953315183233154032535217535312775505540353147384384345753951213930993267528310951923507543975483255319544192079237930337715655555944071935651227146835247663241573532795427282356315271951195247514555671263393919951371523551968727034191501936033639407135793351615183951755475339911913075297918275031374753672103266737595511383169928472433051269140473291557145513663435913595091446726553615378357991611243910231059149199977137114935259528958194287495399492324511167278751995763117929311251379526733394715787146771129911971108317794455251118875751103512033219470755354119415545874095386711312355569131539151707359134952343554742632072619318342753514347121533637593567320745633807411506741794875187556074983317141314299639212729551539157520071515128742275451311134111335480310119155439296716833303571560316953447176743117833855987627198312273507248715992295497130272403591155117193735522337546354671510346114383164728715318314431222341074011285938747797233135369947918674863173138791275408337235079432392755834695539123914475499368746474815115526433471205520912523203118034743291362739271851531915271431279348321993819555111922113963228348271299437115031143249917434023300321152811548735432919110720672235425157398915151518756195127489921633387104713474947273946234527337590352951239365142155307138353792247439517914599423955954839144342352112312907963339420351635331167131593987257126073039254723195259807414344432367159204319477953999271543351071163527274479279953431815488720191659301522594539351926313327327405934351623258327514767579140756675703459564354152679390315631863546332555139504338911419

```

(1703 bytes)

Code:

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

```

# Answer
> 0 votes
# 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
> 0 votes
# Javascript ES6 (in REPL), \<=16 bytes

```
"0.7146314631463146323"

```

js for the lulz

EDIT: Here's what I had

> .9.toString(8)+3

# Answer
> 0 votes
# bc, ≤16 bytes (safe)

```
283657696154934170362301055758600650791598269398973436504

```

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

---

### Original code:

OK, this was horrible. I'm sorry.

```
21^48/88-46^37

```

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

# Answer
> 0 votes
# 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
> 0 votes
## Javascript ≤ 32 bytes (Cracked)

Output to broswer console:

```
3.7376696182833684

```

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

# Answer
> 0 votes
# 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
> 0 votes
# Python

Output (642 bytes)

```
PPJRRE5SGGZJNZ6542MDZ0P63OFSMAV9H4HIVS211G8DNP9HCG8PZ80OXG1M4Z3G9IY7KM7ABJGZU6FDEFZ08WUONX12Z7NDZ0ARJIQUY17BUPO9LL4L5KFXQ3OW7GZ1228FXLLQTN5QCKVAFTO3D1PPBUY04D3ZCX3GH197UHZZKML7RWYFSBDJ3PM4H1009P5OHCZDM445PN0XA0KS9J40XS66UBNLE57X4YK0N1JUGG1QMWBU7RDH3USR67103NKNRO7YLKGCZ4GQHHHRBFCYCR7ZT5NS3WGTFNZV28OTWDE90B5UFO7U971O9MUS64VM2KM9Y4QB4HSN3N7ATROYL91EZT7OMJRG4RJU3MJVMPIRK6P77YWMXYMJCP4CERYR8ZOKR0QM6HJATFKTB9LG4WFBO24JVCEFS1ZJJTTIDBG0KTKKQ6S4FTTHI3JALK3STUDSSHL4605BVD0ZLQQ2DP07SH4E2UR7WS2DJRQ208FWCSQVQD4AXHSN7XWLASSERZMKOUXIX1SF7X4PF1LACIWBAGSPPR27CRQRDMGARR0YO0UQBSZ5CLVOPS2XY6N4Q0XM2Y4GH14C33U5G5J91Q4MOY8T3LZXO0L2PV6CK38RX04O7D5P6HNUTI2OXS

```

Range: **≤128**

# Answer
> 0 votes
# 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
> 0 votes
# Pyth, ≤8

```
41399754779690003073371865173

```

# Answer
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
# 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 **P**rintable **A**SCII characters.
* Unary `X` converts to a Pattern (rege**x**) 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 **t**ri**m** 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
> 0 votes
# CJam (safe)

Range: \<= 8

Code: `52 86#~`

String:

```
-3769533025519801141444612600471707145120923043935146475096303581721089749532607198879063741123420792669738910020570009227839890520497940913522212865

```

# Answer
> 0 votes
# 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
> 0 votes
# Pyth (safe)

Range: \<= 16

Code: `t_^745 342`

String:

```
-18942848238846702000737756659973646779942967140220283256962974873234094651015038671495143989847386729680241862830119337956348747334505435496991960150131121034551982157083906586221042363353408334866251481833877575640325738380374503079168022891195104162339647595360613089361593444499080793276621647497053117734633055201755474710367919777029494004364776004138911600868453848171287452776512163863332098477484323757171405610690850019500967579254668662471619927914605780575892617912202737962562003554708579864138719448663400302560158574168412816418523381065735351001346267376142327158208030285036103491585408755540424848706251111628495962962429658113888676624984684325316931016006142566504870367481109174441236965833636556838972881583460166402936459951922530197633841563299276495092457476011321253117768971252551660133748392634552348895709075329070905022753303255226600059226372955583706070513126272846148280496645228763942426652598925307055362427834099836587711251922883093357086181640626

```

# Answer
> 0 votes
# 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
> 0 votes
# CJam

Output (159 bytes)

```
217678233699230376274200601762191423470860646690253440687035259813072286171793618200693120655662580549470021092321494014584619026229869771791471554564431282176

```

Range: **≤8**

# Answer
> 0 votes
# dc (safe)

Range: \<= 16

String:

```
199339092276008550131431539990658277331606397580853212910052122692972\
774962270058161510083607537469850717483606016495688567362868528504839\
312086200313771395859886273237465478825785462016628857818060996698109\
508463277753877223995999366056374895546219988417085601908866077450569\
127028454771902535032787281691702048189967745290542.733647326

```

Code: `9k567v237^p`

# Answer
> 0 votes
# gs2 (cracked by squeamish ossifrage)

Range: \<= 8

```
155302392568755602954703791645117509171853024379829526053941914979869764308014137101580853703257316967419024475301219529235426499580989700492471117592130679578703743169643269465601721348541513593756461576285693343335323948307757460714948112300799739460308904920802096954409942913408096419432033412736062772643941590080446853373252364634969631941189995619518198884520714851905373673786301803818992437528114546902893524109693619934375650827402974283364443639166789257783558287754544152762072425073758073874087673853749491025245350759370202288198641756277483105286855126452445186433581045273785395216218774302137457946970241887040423778769507844532372395126914334350410060838193463467701758259122737262877689997254446028894627441507215258630083149823214021914691630385344730360124370246246101179225617171359948255502820724998630578414563433771734039885865200126640849581418101617590256731549974180011798541810287432442790284651150068406362365126351529058374781998017317605130002324359837801578063898318531549204801679097327112281643491227164405147112572736443606882046580363487549058621262011237393353206539463047834322740801769791931408446565925701470542859326548992533299683757135685782623491909977496699208378601007696438296190884956558923555954397532301018024430186240362810108284785909687389090161977695156919530083589605517157247030242165705875087062283656720276403790904286872963087972571265678945386772020563763263215540821764049192071134806571089438720182703434060588593593872862671044732442467813100983236427776

```

Code:

Hexdump: `12 17 2F 08 3E 09 33`

Mnemonics: `2 7 range1 { pow } each`

# Answer
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
# Python

Range \<= 16

```
'.eoual ftj(er,eetrnr ph'

```

To be run in interactive mode.

# Answer
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
# QBasic, \<= 8 bytes (cracked by Mauris)

```
 8.851656E-03

```

Note the leading and trailing space.

# Answer
> 0 votes
# 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
> 0 votes
# J, ≤4, cracked by randomra

```
0.000198413

```

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

# Answer
> 0 votes
# Retina, \<= 64

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

```
itreinareinareinareinareiareinareiareinareiiareinareiiareinareiiiareinareiiiareintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinare

```

# Answer
> 0 votes
## Javascript (Console) \<= 128 Bytes

```
"xkvybybmhMxknadytmxadgjupalybuxsnqbEhehsnepcfsvqlqbehknytsdqtMpkfufililwrwhuxknidufilorCxitgjcfavwhknknytkvilybwrCnqtwzkfepcfybwrepsvsvgbgrEhuxsncnqtwzkfqborknidgruxUxidufsvilgbkvybehsnmxkngjEzozcfcfqlqborehcxkvybehsnYjwzsvqlmxadadojalybormhozCfilwrqborknidqbehehsnsdqtGjezaloruxidozmpilgbepsvsvGbsdqtgjezepsvybmhgrehadytItwzwzkfkvilybwraloruxidozMpilgbcnqtqtezqborehcxitwzCfqlkvilehcxkvybybmhmxknadYtqbehknytepcfybwrufililwrItgjwzupyjmpsvgbalybuxsncnQtqtezepcfsvqlcnqtwzkfqborKnidepsvsvgbsdqtgjezgruxadOjitgjcfavitwzwzkfkvilybwrKvybehsnyjwzsvqlozcfcfqlcnAdqtojozcfilwrqborknidsdgjGjupufsvilgbitwzcfqlwhuxqtOjkvybybmhyjwzmpkfqbehknytSdqtmpkfsdgjgjupufsvilgbqbEhknytepcfybwrufililwritgjWzupyjmpsvgbalybuxsncnqtqtEzepcfsvqlitwzcfqlwhuxqtojKvybybmhyjwzmpkfmxadgjupozMpilgbozcfcfqlqborehcxyjmpSvgbmxkngjezcnqtqtezqborehCxcnqtwzkfepcfybwrgruxuxidItgjwzupozcfilwrcnadwzupqbEhehsnepcfsvqlwhknqtezyjwzSvqlyjmpmpavalybormhepsvybMhsdqtmpkfitwzwzkfwhuxknidMxadgjupozmpilgbqbehehsnsdQtgjezaloruxidozmpilgbcnqtQtezqborehcxepsvybmhgrehadYtgruxuxiditgjwzupitwzcfqlWhuxqtojmxadadojalybormhmxAdgjupozmpilgbqbehehsnsdqtGjezqbehknytepcfybwrsdgjgjUpgrehuxsnyjmpsvgbalybuxsnAlororcxcnadqtojyjmpsvgbmxKngjezcnqtqtezqborehcxgruxAdojitgjcfavkvybybmhmxknadYtmxadgjupalybuxsnozcfcfqlCnadqtojqbehknytsdqtmpkfsdGjgjupufsvilgbcnqtwzkfqborKnidgruxuxidufsvilgbgruxadOjitgjcfavkvybybmhmxknadytCnqtwzkfqborknidepsvsvgbsdQtgjezkvybehsnmxkngjezmxadAdojozmpcfavsdgjmpavgrehadYtwhknknytkvilybwraloruxidCnadwzupepsvsvgbgrehuxsnyjMpsvgbmxkngjezalororcxozmpCfavcnqtwzkfepcfybwrepsvsvGbgrehuxsngruxadojufsvormhKvybybmhyjwzmpkfkvybehsnmxKngjezozcfcfqlqborehcxepsvYbmhsdqtmpkfgruxuxidufsvilGbmxadgjupozmpilgbozcfcfqlQborehcxmxadgjupalybuxsnqbEhehsnepcfsvqlufilorcxwhuxQtojyjmpmpavalybormhkvybehSnyjwzsvqlmxadadojalybormhOzcfilwrqborknidqbehehsnsdQtgjezaloruxidozmpilgbepsvSvgbsdqtgjezepsvybmhgrehadYtitwzwzkfkvilybwrqbehknytEpcfybwrsdgjgjupgrehuxsnyjMpsvgbalybuxsnalororcxcnadQtojgruxadojufsvormhkvybybMhyjwzmpkfozcfilwrqborknidSdgjgjupufsvil"

```

# Answer
> 0 votes
# Python 3 - 32 bytes, Cracked

`9511667971998764582180733448500755`

REPL output.

# Answer
> 0 votes
# 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
> 0 votes
# 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
> 0 votes
## Pyth, \<= 64 bytes

```
01111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110111010111011111010111110111010111110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011111010111011111010111110111010111011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111100

```

That's exactly 2048 bytes :D

# Answer
> 0 votes
# TI-BASIC, ≤2 bytes, Cracked by Thomas Kwa

```
.1308996939

```

Maybe I can get out of the negatives...

# Answer
> 0 votes
# JavaScript, \<=64 bytes

Output: 2038 bytes

```
00NaN573100360487769457310036048776940NaN266247541047714640NaN65254190216760520NaN34568908272755050NaN038836263287495790NaN425130624407386360NaN118277804967331650NaN50457216608722220NaN19771934664716750NaN58401370776705810NaN277160888327003360NaN66345524944689390NaN35660243000683920NaN049749610566784510NaN43604397168667510NaN129191152246620370NaN51548551336651090NaN208632693926456230NaN59492705504634680NaN28807423560629210NaN67436859672618270NaN367515777286127940NaN060662957846073230NaN44695731896596380NaN14010449952590910NaN52639886064579970NaN219546041205744950NaN60584040232563550NaN29898758288558080NaN68528194400547140NaN378429124565416660NaN071576305125361950NaN45787066624525250NaN15101784680519780NaN53731220792508840NaN230459388485033670NaN61675374960492420NaN30990093016486950NaN0030481107248148120NaN38934247184470540NaN082489652404650670NaN468784013524541240NaN161931194084486530NaN54822555520437710NaN24137273576432240NaN6276670968842130NaN320814277444158250NaN0139614580041035330NaN40025581912399410NaN093402999683939390NaN479697360803829960NaN172844541363775250NaN55913890248366580NaN25228608304361110NaN63858044416350170NaN331727624723446970NaN0248748052833922540NaN41116916640328280NaN104316346963228110NaN49061070808311870NaN183757888643063970NaN57005224976295450NaN263199430322899830NaN64949379144279040NaN34264097200273570NaN0357881525626809750NaN422082513682571550NaN115229694242516830NaN50152405536240740NaN19467123592235270NaN58096559704224330NaN274112777602188550NaN66040713872207910NaN35355431928202440NaN0467014998419696960NaN432995860961860270NaN126143041521805550NaN51243740264169610NaN20558458320164140NaN5918789443215320NaN285026124881477270NaN67132048600136780NaN364467666561313130NaN057614847121258420NaN4439092082411490NaN137056388801094280NaN52335074992098480NaN216497930480930130NaN60279229160082070NaN2959394721607660NaN68223383328065660NaN375381013840601850NaN068528194400547140NaN45482255552043770NaN1479697360803830NaN53426409720027360NaN227411277760218860NaN61370563888010940.3068528194400547

```

---
Tags: kolmogorov-complexity, cops-and-robbers
---