60
\$\begingroup\$

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

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

210 Answers 210

1
\$\begingroup\$

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 (999) 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
\$\endgroup\$
1
\$\begingroup\$

Rust, Safe, ≤64

Output (440 bytes):

2EE5A53831925A9212038FBE5174381029212D926E994C46C69956F383F314D9912D4622FA13BF316AF3AFFA91A710FFAA454D5541C5B0800805B16B549B51195BFF081815B119B514EB599BC8169105BCA016D716241DDCA0941D3077697713F1D12ACA2C7E151775D80DD7ECB2B1557EF5D8132D885DF758C101DFA439E339384029EDB8405C9A9D9A17B4016EED78A11EFB61FB141A11374E4302171FB305C11202109AF17631485C8BD0EC63E61017C63128BD171BDD0C4CC71164C41131E15E1EBF25BCD2157251077F1547FB786B73315386105E0154E0B9E7

Solution:

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

\$\endgroup\$
1
\$\begingroup\$

Python 3, <= 32 (Safe!)

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

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

This one was fun ;)

My code:

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

(spaces added for readability)

\$\endgroup\$
  • \$\begingroup\$ Took a big number, converted it to binary, converted that to a list of BOOLs, Yes / NO as an array separated by "" ;) \$\endgroup\$ – Albert Renshaw Oct 14 '15 at 8:25
  • \$\begingroup\$ That would be too long, but good guess! \$\endgroup\$ – J Atkin Oct 14 '15 at 13:27
  • \$\begingroup\$ @AlbertRenshaw Use an ASCII string instead of a number. \$\endgroup\$ – mbomb007 Oct 14 '15 at 14:04
  • \$\begingroup\$ Uh-oh, I see this being cracked soon :) \$\endgroup\$ – J Atkin Oct 14 '15 at 14:12
  • 1
    \$\begingroup\$ @AlbertRenshaw I have posted my code \$\endgroup\$ – J Atkin Oct 19 '15 at 13:57
1
\$\begingroup\$

Pip, <= 4 (cracked by Reto Koradi)

1101001

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

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ magic( should be a method in all languages. \$\endgroup\$ – Addison Crump Oct 19 '15 at 20:28
1
\$\begingroup\$

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]

\$\endgroup\$
  • 1
    \$\begingroup\$ Are you using the REPL? If so, you need to state that. \$\endgroup\$ – feersum Oct 12 '15 at 6:34
  • \$\begingroup\$ Yes. I am using the REPL for this, though it should work if the ocde is the only thing in it's python file and you don't have a customized version of python. \$\endgroup\$ – pppery Oct 12 '15 at 12:27
  • \$\begingroup\$ And are using exactly python 2.7.9. This sample doesn't work on ideone. It produces totally different output. Or in PyPy. \$\endgroup\$ – pppery Oct 12 '15 at 12:32
  • \$\begingroup\$ Using a lot of __doc__ strings? \$\endgroup\$ – mbomb007 Oct 14 '15 at 14:03
  • \$\begingroup\$ @mbomb007 No doc strings. \$\endgroup\$ – pppery Oct 14 '15 at 17:59
1
\$\begingroup\$

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"
\$\endgroup\$
  • \$\begingroup\$ Is cracking one sufficient to be considered cracked? \$\endgroup\$ – SLuck49 Oct 19 '15 at 12:13
  • \$\begingroup\$ The crack should match both, as the difference is due to differences in the browser js interpreter. However, if you match only one, I would be interested in your method. \$\endgroup\$ – Shaun H Oct 19 '15 at 13:08
  • \$\begingroup\$ Cracked, ended up cracking both anyway when I realized what it must be doing \$\endgroup\$ – SLuck49 Oct 19 '15 at 13:14
1
\$\begingroup\$

><>, ≤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
\$\endgroup\$
  • \$\begingroup\$ Cracked. \$\endgroup\$ – cole Oct 17 '15 at 20:23
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

Pyth, <= 16 (safe)

tfzxsepjgyqbiolvakdcuhrmnw

Hint:

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

Code:

VU5=G_.iFc3G)G

What it does:

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

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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'))
\$\endgroup\$
  • \$\begingroup\$ someone should at least try... \$\endgroup\$ – cat Oct 22 '15 at 3:18
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

Pyth, safe, <= 16

16252320011828121914223211711247272693015813524610

This was output from a linear congruential generator.

\$\endgroup\$
1
\$\begingroup\$

Retina, <= 32

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

llaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllala
\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

ngn APL (safe)

3.2406187300653406e+102

Range ≤ 16

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

Solution

|(*|)12.34J56.78

Try it online.

How it works

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

  • (*|) is a train/fork.

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

    • * calculates (12.34 + 56.78i)58.105455853990165.

  • | applies modulus to the result.

\$\endgroup\$
  • 1
    \$\begingroup\$ I wanted to make this a ≤ 8 submission, but I already had one, unfortunately. :/ \$\endgroup\$ – Dennis Oct 17 '15 at 0:53
  • 1
    \$\begingroup\$ Look ma, no Unicode! \$\endgroup\$ – Dennis Oct 24 '15 at 6:48
1
\$\begingroup\$

CJam (safe)

Range: <=16

String:

-1757998761424490676921016856999645582687172166771732990901023822919032113856474131322376304211808153619988283134008439274637725633868254103891368425285165026468770378090155135372308987708009431738653866423053902527963127906032288661788122437508856152696997908146296016521091199803229053377715671662942187527704135032400317135628637248506389262291879310836675157035298269773565002128572484249631883681915978366368348422763684673273940395075510502820393796214460557862527316465092717359768308614013715174354726471330845504297837476047888566285525771034491348417324909599453182115064413154332558333250875021070793798910049854644817559064573856721397747003126054061162347856585377448534690237788836012961397667542666722692935386425165604581402711433056617873627041251709641777614212372373696828558813318358124653096657585640957194959404589685428128317642065010497446792032482302568447660371023038445973792552314710542567265966630122643983375527917082186662519498233404401344837146447008437657457992594647903611528282318427533140206671065997969913543629153024916689707377967665079085509461263277920838560857104814273338655611983839393046785144278966861497797144865502969288669678711952606556690911517688871027804066141321298362142430813845600699520261708534251247924822880140866847159914428320312680337671139215536945422935222183014047914184629917144775390626

Code: 5345 363#~

Yay more numbers /sarcasm

\$\endgroup\$
1
\$\begingroup\$

Ruby, <= 64 (safe)

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

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


Answer:

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

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

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

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

\$\endgroup\$
1
\$\begingroup\$

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:

First 4 values under x^2-1.5

First 30 values under x^2-1.5

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.

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

J, Cracked by Dennis

Length <= 8

0 1 0 0 1
0 1 0 0 0
0 1 0 1 0
0 0 1 1 1
0 1 0 1 1
0 0 1 1 0
0 1 1 0 0
0 0 1 0 1
0 1 1 0 1
0 0 1 0 0
0 1 1 1 0
0 0 0 1 1
0 1 1 1 1
0 0 0 1 0
1 0 0 0 0
0 0 0 0 1
1 0 0 0 1
0 0 0 0 0
1 0 0 1 0
\$\endgroup\$
  • \$\begingroup\$ Cracked. \$\endgroup\$ – Dennis Oct 26 '15 at 18:58
1
\$\begingroup\$

PoGo, safe, <=32 Bytes

Output (116 Bytes)

418823741706778235498161926738634336931815369322701079743198012261458790182-1935586134-558199202-1377386932819187730

Solution

enpobeosadpeadopuftogopoopufnigo
\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ cracked \$\endgroup\$ – 2012rcampion Oct 26 '15 at 19:44
  • \$\begingroup\$ By the way, I'm interested to see what your method was, since my crack is pretty boring. \$\endgroup\$ – 2012rcampion Oct 26 '15 at 20:28
  • \$\begingroup\$ baby monster group ^ 9 with the trailing zeros stripped. Will post the exact code when I get home. \$\endgroup\$ – a spaghetto Oct 26 '15 at 20:35
1
\$\begingroup\$

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]
\$\endgroup\$
  • \$\begingroup\$ If someone could explain how to make that line wrap, and be all visible at once instead of moving out the right side of the screen I would appreciate that. \$\endgroup\$ – rp.beltran Oct 19 '15 at 21:51
  • 1
    \$\begingroup\$ Does this depend on the OS? \$\endgroup\$ – kennytm Oct 20 '15 at 3:17
  • \$\begingroup\$ Hmm, not positive, to be honest. I have OS X though. Sorry I wasn't more helpful. I'll try to check whenever I get the chance. \$\endgroup\$ – rp.beltran Oct 22 '15 at 23:52
1
\$\begingroup\$

Pyth, safe, <= 8

128834756732407702383511125730021881412948585094402384

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

Solution

*7C.B.!T
\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Cracked Very likely that you did something completely different though. \$\endgroup\$ – Jakube Oct 19 '15 at 14:20
  • \$\begingroup\$ Yeah, I did. I actually got it in 17 chars, maybe I should golf off a byte. \$\endgroup\$ – clap Oct 21 '15 at 19:42
  • 1
    \$\begingroup\$ Your submission is either cracked or safe. It can't be both. \$\endgroup\$ – Dennis Nov 1 '15 at 2:39
  • \$\begingroup\$ It was cracked after the seven-day period. Is that safe? \$\endgroup\$ – clap Nov 1 '15 at 2:40
1
\$\begingroup\$

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,'')
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.