The Mystery String Printer (Cops)

Question

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

Your challenge

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

Restrictions

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

Scoring

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

Submissions

Each submission must have the following pieces of information:

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

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

/* Configuration */

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

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


/* App */

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



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

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

function getAnswers() {

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

}

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

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

      });

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

getAnswers();


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

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

function process() {

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



  answers.forEach(function(a) {

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

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

    if (CRACKED_HEADER_REG.test(body)) cracked = true;

    // if (SUBTRACTCRACKEDPOINTS||!cracked) {

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

    var expired = createDate > (EXPIREDTIME);

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

    isOpen = !(cracked || safe);

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



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

    }

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

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



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


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

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

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

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

  });

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

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



  pointTotals.forEach(function(a) {


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


  });



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



}

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

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

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

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

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

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

<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SAFE}}</td>
      <td>{{OPEN}}</td>

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


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

<table style="display: none">
  <tbody id="open-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{LENGTH}}</td>
      <td>{{LANGUAGE}}</td>
      <td>{{TIME}}</td>
      <td><a target="_parent" href="{{LINK}}">Link</a>
      </td>
    </tr>
  </tbody>
</table>

Use the following formats for entries:

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

or

Language
=
Length <= 16

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

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

For cracked submissions, put cracked in your header.

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

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

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

This challenge is now closed.

Most points overall winner: Dennis

Most safe submissions: DLosc

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

Answer 1

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

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 3

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 4

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 5

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 6

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 7

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 8

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 9

C <= 64 (cracked by kennytm)

111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011

(output is 1974 chars long)

Answer 10

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 11

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 12

Haskell, <= 32

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

This one is cute and easy.

Answer 13

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 14

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 15

Dyalog APL (cracked)

4.58302

Range ≤ 4

This should be cracked pretty quickly...

Answer 16

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 17

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 18

J (cracked)

4.81845e12

Range ≤ 4

Worth a shot.

Answer 19

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 20

J (safe)

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

Range ≤ 16

Solution

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

Try it online.

How it works

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

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

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

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

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

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

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

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

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

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

Answer 21

ES6, safe, <= 128

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

""3,<$.,42C>1D4I&K3#9L/?=';?C08L-H/5&36*D>+"")B'7L4")$1=%FF@@I'4AG%::LF4%':5B.BI-<#(D+8"-0I6L"'/1A&BI"JG&+G5-#=)H$#E$)AJ(GF:7CIHA7",D3.LJ<$6#.B",5K0@83"@?FD>$?1:4>?0C#CHH5/<"4&%7@%BG:>CB1+F<(&8"1;:J/.H"67;25>&?7?4/=A"2$FBB2514,&?>770I-8CE=B-I."6A)9I$2",/0K,-8"4J*JJ?LL+D$*(H.B3@>,,'&)B.*44H2A$";GC(8EG""'%9#GJ01*K:,=K;2B1=I0+%:/=ELBG4,$<#+#79E"@"2B';1"CJE'E61>.5A*9;J*9@>%?C(3AI<3A2=?AE#=")<1;"E(L1A1F"9B:@<%CL+@7EF9ID@>K85+%AH8;L6"3J+;5,D/A)1"J.;K0'0"/:/.3?*/(K-5(7H3G<-K+>"$$'::+=)*@1GF;5FL'"$4*:JHE"%2$G*.<=%+#%55G"#::3L&J2+A9(K-J5*'.52;KDH"):D)9>/"F*D5LH#K"6D@B3F<*8GFB9G@208A@H@@?H@$)A%<>".@3C(4D"<"9#C75.JA:0$1E+16).8LD#9J7/586K)>'>KG*44"3F"2B*."2E.<:&G<GL0K1/DE846A.4A1@96H*(,+>49-B"/,*"8L<L1KC"(=#*[email protected],&;>-C4?2C)$G>?G(56JC"6(*KG9(4$K"='+;KA-"I5CC(/@-A7G+K+B#F0%<E/;"#B4$?3CA=K260.9GA"B-E*:7B"?-81JI';>B=F-)A=".2$;B80*13=4#9L'AD%'4>?7"G34D)-,"5%-JA89I;"36:'@,),?71*5>1K2+)>/,<7+?I:C7-"L9#3C#A"+H"88'K,8-)&G%?F0*LJ'=2L8:1DI.%7&-=.@@H/#"&?="2D+"L@B&/A2:58JA)#>57(.2H%//?)02>IFB;#$H7F"'D"+E,<L:@"B87?&0DH2C@16L=$>&;E>8,=FC/K39<"%D67.L'J:"0KF+;0*"80,-HJ++/#6LCJ<>E$H-4K)K"2.9()2-::H&%',B0"5&5E*&?".(LF?9=9,.,<%H;-L"*@*3&.)L-'HD(8$0/@G-1:&":,$4DG)"$KA46($G)9",2F:G(K7(KF#<0;,@=4IC9&A/>362G"?2>#3=>"EC6"-B6*&DCG?D96/ID;A.KJ7*+.2$?##G(I59;*="D8-="3(";;+;$1H8#$97LB8%6G&#7AH->D*G'?5.8=:8,?@"3"I>G,<)="13K)FK/FK//'.@7?=E36-)E;E3)5G/+9"3L'#EEE)"#D6F+J'"'+@B=:A)H:%B;>6.DC@I#<BIL"(#<JLD7)3AEKJ=J"(J%5E@<"H#504)(7EEF2H<5HKA"1D$?,(<'<1:B$LJE0<&$5@"-%?$46&">F*I+C:EB%<"*:47'?/D:7<:/+&*&*8/6@,J3,)-6"2+.>#,;"4>J7"2L(?02=783&.=<,0J9H6E%CFE.:K6>9*2.%,"71H-="%"*6?%DL36<;(-D62@5;I?&26+=4$1;5$E5,%(L83H""<77G,C:"K.4>;;ED9FIH&41/<9+'GE39D##J0%E%J"7BC>8@C"A=&6F9$"A&),2*,'6&?8320IC78:=-0GK="8%@;04CI1:D=89"FC@%5/9"7IIE)D>5315(@0/8J5E"3@-*',L&E01;I90K1JB0/"KI/?$%#"-A>3K3%C0<+C"..'&3'5)(*8.FK?:K'F3/B:(%G(%"%$I.>F8"#93LB"7&-GL3/,-A-14HJ;'F55J-/;H&H%))J+LKF"**8H-<""D1(:9<I4*'B#<*,04/A0@#$)<$IF$+>12F;CA1&C<"/0'7G27":)H(0+0B'28>I(+J;-#C66L7C>H4DF4<G<"287+;2"46A&6(L"0L=A'EB%$=..+&*9B+0+,IIEJ-G"96*G124L/=03("9<0@%I6"&D2/I4)3LH$I8$)(I)=>"1F(&GF;.&K'F(F;&C5+I">BJ"

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 22

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 23

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 24

Pyth

10067283832263627132507444590041695034979992997150622392563276991517087210416125987872298759981924914598996739787601264046046893914007275634929310315058

Range ≤ 4

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

Answer 25

C++

String:

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

Range: <= 64

Answer 26

GolfScript

100100110010011100110001011101100001010011010111011101011000100000000100

Range: ≤ 8

Answer 27

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 28

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 29

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 30

Python 3

Range: ≤64
String length: 1759

1450311547121626824402528317931024696537261379649312109934174763622928813537772202492826340253595039354204170803308812108106614974615992407513462378342519772879316185201191244193032905219821112379362735436273595816306408247797551887198223078132707718613741551438816716228420855210133806030879152023807281213669870947286924104806420930386226909518122591340634826667470106070805067486916003620079860533420912887938893520117652588913717930472346176939267545884056248725814428845435505286970004504538242272311816219001799408190917981242794876906923463019563132633790465573335245790782921280224126868686724604452690148708017495170944952232407517716174996669514909784703378613104880109045294268293224189609735626833741340860353297694678641117508508320027700778717534109394267437425043810487352376005634156569975311491459838272217846207077798205457351267508638726235986344105746925264997271470391586921860841952986010216300093433468007980482444450140150202011970723666974568959542215223332447146301544007477846089467045557063881769289045618456873502484742102787141509146927089727415468957468932233888307541183405820990577010792332515397454508971114910082242913202656447784249727817413159197879472620373533325157697422584249026116957034499508087753326237517531666435897781090922126023766286557629116809405490739569657792496159821300551508419666991511554805528263403378295007848547483596991780931036386960716493272927989817021495881172814505517266227891225298564264160100926161641968167450456638252346252357682659194962887041698807928559518187059146398406957924003562078098158050469520030372646913304777752187530842640087708732247607019311163659185637734636533976160365822448025321873341358014966837103376648875774633227200456239875015114894085499417129719017106310570