Den Räuber-Thread finden Sie hier: The Mystery String Printer (Robbers)

Deine Herausforderung

• Schreiben Sie ein Programm, eine Funktion oder ein REPL-Skript, das eine Zeichenfolge an STDOUT ausgibt.
• Die Räuber werden versuchen, ein Programm zu erstellen, das den gleichen String ausgibt.
• Wenn sie das Programm innerhalb von 7 Tagen erfolgreich erstellen können, ist Ihr Beitrag geknackt.
• Wenn niemand innerhalb von 7 Tagen ein Programm erstellen kann, das denselben String druckt, ist Ihre Eingabe sicher. Sie können entscheiden, ob Sie Ihr Programm veröffentlichen oder es künftigen Räubern überlassen möchten. Wenn Sie es jedoch nicht preisgeben, können Sie keine Punkte aus Ihrer Einreichung erhalten (tragen Sie "sicher" nicht in Ihren Antwortkopf ein, wenn Sie dies tun).

Beschränkungen

• Das Programm muss kleiner oder gleich 128 Bytes sein (dazu später mehr).
• Wenn das Programm vom Programmnamen oder vom Namen / Inhalt einer externen Datei abhängt, müssen Sie dies bestätigen und dies in Ihre Gesamtbytezahl einbeziehen.
• Die gedruckte Zeichenfolge muss kleiner oder gleich 2048 Byte sein.
• Die gedruckte Zeichenfolge darf nur aus druckbaren ASCII-Zeichen bestehen (neue Zeilen können eingefügt werden).
• Das Programm muss bei jeder Ausführung dieselbe Ausgabe erzeugen.
• Eingebaute kryptografische Grundelemente (einschließlich Rng, Verschlüsselung, Entschlüsselung und Hash) sind nicht zulässig.
• Das Programm darf keine Eingaben annehmen.
• Keine Standardlücken.

Wertung

• Wenn eine Einreichung vor sieben Tagen geknackt wird, erhält die Einreichung 0 Punkte.
• Eine sichere Übermittlung von ≤128 Zeichen bringt 1 Punkt.
• Eine sichere Einreichung von ≤64 Zeichen bringt 2 Punkte. Wenn er kleiner oder gleich 32 Bytes ist, werden 4 Punkte vergeben und so weiter.
• Für jede sichere Einreichung erhalten Sie zusätzlich einen Bonus von 3 Punkten (unabhängig von der Länge).
• Es gibt eine kleine Strafe (1/2 Punkt) für jeden geknackten nach dem ersten.
• Beachten Sie, dass die Räuberlösung im selben Bereich von Programmlängen liegen muss.
• Jede Person darf maximal 1 Programm pro Byte-Bereich pro Sprache einreichen (unterschiedliche Versionen und beliebige Ersetzungen derselben Sprache zählen nicht als separate Sprachen). Beispiel: Sie können ein 32-Byte- und ein 64-Byte-Pyth-Programm bereitstellen, jedoch kein 128-Byte-Programm in Java 7 und Java 8.
• Die Person mit der höchsten Punktzahl gewinnt.

Einreichungen

Jede Einreichung muss die folgenden Informationen enthalten:

• Der Name der Sprache. Alle neuen Räuberlösungen müssen dieselbe Sprache haben.
• Der Bereich der Programmgröße (dies ist die nächsthöhere Zweierpotenz als die Programmgröße; wenn Ihr Programm beispielsweise 25 Byte umfasst, ist dies "≤32").
• Die tatsächliche Zeichenfolge, die ausgedruckt werden soll.
• Wenn eine Einsendung sicher ist, geben Sie "sicher" und die Programmlänge (auf die nächste Potenz von 2) in Ihren Header ein. Wenn Ihre Kopfzeile mehrere Zahlen enthält, setzen Sie die Potenz auf 2 als letztes.

Dieses Stack-Snippet generiert Bestenlisten und listet alle offenen Einreichungen auf. Wenn es Probleme mit dem Snippet gibt, hinterlassen Sie bitte einen Kommentar.

/* 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>

Verwenden Sie für die Einträge die folgenden Formate:

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

oder

Language
=
Length <= 16

Beachten Sie, dass das Snippet nur dann das erste Wort als Sprache in die Kopfzeile einfügt, wenn es kein Komma erkennt.

Geben Sie für sichere Übermittlungen safe in Ihren Header ein. Das Snippet fügt Ihr Programm automatisch in die Spalte "Sicher" ein, wenn die Zeit abgelaufen ist. Auf diese Weise können Räuber besser erkennen, dass Ihr Programm sicher ist.

Fügen Sie für geknackte Einsendungen geknackte in Ihre Kopfzeile ein.

Das Programm sollte auch erkennen können, ob ein Kommentar "geknackt" lautet und einen Link hat. Dies ist jedoch nicht garantiert.

Tiebreaking-Reihenfolge: Punkte -> Anzahl sicherer Einreichungen -> Geringste Anzahl geknackter Einreichungen.

Beachten Sie, dass das Snippet nach offenen Einsendungen sortiert wird, bevor es am wenigsten geknackt wurde. Offene Einsendungen werden jedoch am Ende des Wettbewerbs nicht gezählt.

Diese Herausforderung ist jetzt geschlossen.

Die meisten Punkte Gesamtsieger: Dennis

Am sichersten Einsendungen: DLosc

(Beachten Sie, dass die Anzahl der sicheren Einreichungen keinen Punkt ergibt, da die Größe der Programme bei der Berechnung der Punktzahl berücksichtigt wird.)

Pyth, Safe, Range ≤ 8

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

Der Code:

%^T6`^G5

Erläuterung:

Um zu verdeutlichen, wie das funktioniert: Ich habe alle möglichen 5 Zeichenketten aus Kleinbuchstaben ( ^G5) generiert . Dann habe ich die Zeichenfolgendarstellung dieser Liste generiert: ( `^G5). Schließlich nahm ich jedes 1.000.000ste Zeichen dieser Liste ( %^T6). Das Ergebnis sieht aus wie eine Liste von Zeichenfolgen, es fehlt jedoch verdächtig die Endklammer.

VBA, [Sicher]

Bereich <= 128 Bytes

Hinweis, wo ausgegeben werden soll

In Excel 2007 lief die Ausgabe in Debug.print. Es ist VBA, viel Glück, wenn etwas unter 128 Bytes ausgeführt wird.

255 Bytes ausgeben

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

Lösung

Nun, ich hoffe, es hat jemand Spaß gemacht, diesen zu knacken. Ich kann sagen, dass dies eine der schlimmsten Fehlerbehandlungen ist, die ich je gemacht habe, und fühle mich schlecht, wie schlecht dieser Code ist.

Code

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

Erklärt

Zuerst beginnt der Code mit einer der Hauptsünden von VBA. On Error Resume next.
Sobald wir diese schreckliche Tat begangen haben, gehen wir voran und werfen und irren einfach. Dies ist der This array is fixed or temporarily lockedFehler, den wir bald in der Ausgabe sehen werden.

Das nächste ist die Schleife. Wir schleifen 128 Mal, um die Fehlerbeschreibung zu konvertieren, aber die einzigen gültigen Eingaben für i are 1,2,3,64,128. Aus diesem Grund geben die ersten 4 Schleifen den Fehler mit verschiedenen Formaten aus. Wenn i = 4der Code dann einen neuen Fehler Invalid callauslöst, wird dieser wiederholt und nichts zugewiesen, bda die strconvFunktion jedes Mal fehlschlägt.

Hier hätte jedes normale Programm aufhören sollen, aber da wir haben, wird On Error Resume Nextjeder Fehler ignoriert und der Code bleibt unbeeindruckt von der schlechten Fehlerbehandlung.

Jetzt schlagen wir zui=32und wir fügen den neuen Fehler hinzu, bder in Unicode konvertiert werden soll, und setzen dann die Schleife fort, bis i = 128wir unseren Fehler FROM Unicode konvertieren, was dazu führt, dass die ?????????????????Zeichenfolge hinzugefügt wird, b

um das Durcheinander der Fehler, die wir zusammen verkettet haben, schließlich auszudrucken

Mathematica, sicher, Bereich ≤ 64

Ausgabe:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Quelle:

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

ngn APL (sicher)

0.675640430319848J0.8376870144941628

Bereich ≤ 8

Lösung

*3○⍟⍣=42

Probieren Sie es online aus.

Wie es funktioniert

• ⍟⍣=42Wendet den natürlichen Logarithmus ( ⍟) wiederholt auf 42 an, bis ein fester Punkt erreicht ist ( ⍣=), was 0,31813150520476413J1,3372357014306895 ergibt .

  Der Anfangswert spielt hier keine Rolle, solange er weder 1 noch 0 ist .

• 3○Wendet eine Tangente auf das rechte Argument an und ergibt 0.07343765001657206J0.8920713530605129 .

• * Wendet die natürliche Exponentialfunktion auf das richtige Argument an und liefert die gewünschte Ausgabe.

Pyth, geknackt von Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Bereich ≤ 8

> <> (Sicher)

Auf den Online- und offiziellen Dolmetschern getestet.

Bereich: <= 16

Zeichenfolge: 4621430504113348052246441337820019217490490

Das ist ziemlich 1337, oder?

Erläuterung:

Hier ist der Quellcode (15 Bytes):

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

fschiebt 15 (unseren Zähler) auf den Stapel (dies wird !am Ende übersprungen, um nicht mehr als einen Zähler zu schieben)

1- subtrahiert 1 vom Zähler

:0(?; Das Stirnrunzeln prüft, ob der Zähler kleiner als 0 ist, der Rest beendet das Programm, wenn dies der Fall ist

:: Kopiert den Zähler zweimal

0gErgreift das Zeichen an der Stelle (c,0)im Quellcode, an der csich der Zähler befindet

* Multipliziert das zweite Duplikat des Zählers mit der ASCII-Darstellung des zuvor erfassten Zeichens

n Druckt das Ergebnis.

Die Ausgabe ist also aufgeteilt [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. Dies entspricht der ASCII-Interpretation des Codes in umgekehrter Reihenfolge multipliziert mit den Zahlen 14 bis 0 (dh [!*14, n*13, ... f*0]).

Das Schwierigste am Knacken ist wahrscheinlich, herauszufinden, wie man die Zahlen richtig aufteilt. Wenn Sie jedoch die richtigen Zahlen finden, müssen Sie nur Dinge ausprobieren, bis Sie etwas finden, das funktioniert.

Schneemann 1.0.2

Bereich ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

Die Lösung ist:

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

Matlab, ≤16. Von Wauzl geknackt

Bereich ≤16 .

Dies funktioniert auch in Octave .

Die gedruckte Zeichenfolge lautet wie folgt:

ans =

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

Perl (sicher)

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Bereich ≤ 32

Lösung

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

Probieren Sie es online aus.

Wie es funktioniert

• for-951..1048 Führt den vorhergehenden Befehl für jede Ganzzahl in diesem Bereich aus und speichert ihn in der impliziten Variablen.

• y/124589// führt eine Transliteration durch, wobei die angegebenen Ziffern aus der impliziten Variablen entfernt werden.

  y/// Gibt die Anzahl der Eliminierungen zurück, dh die Anzahl der Vorkommen dieser Ziffern in der impliziten Variablen.

• print 2**druckt 2 hoch ( 1 , 2 , 4 oder 8 ).

Python, <= 16 ( geknackt von kennytm )

[[[22111101102001]]]

Dies wurde über REPL (Ausführen eines Befehls in der Python-Shell) erzeugt.

Während ich das bearbeite, werde ich auch die Kommentare für zukünftige spoilerfreie Räuber zusammenfassen: Dies funktioniert nicht in allen Pythons. Es funktioniert in einem Build von Python 2.7, in dem sys.maxint = 9223372036854775807.

> <> , ≤ 8 [ geknackt ]

oooooooooooo

Das sind insgesamt 12 os. Das Programm wird fehlerfrei angehalten und funktioniert sowohl mit dem offiziellen Dolmetscher als auch mit dem Online-Dolmetscher .

TI-BASIC, ≤4 Bytes, geknackt von Reto Koradi

Das Knacken dauerte 5 Tage und 23 Stunden. So nah...

Ausgabe (10 Bytes):

.495382547

Programm:

³√(tanh(7°

Da es für jemanden im Grunde unmöglich ist, dies zu erraten, bestand mein Ziel bei der Entwicklung dieses Programms darin, Brute Force zum einzig möglichen Ansatz zu machen.

Zu diesem Zweck habe ich verhindert, dass die Ausgabe oder die Ausgabe mit einer dieser Umkehrfunktionen auf dem ISC angezeigt wird. ISC hat keine hyperbolische Tangente, und ich nahm an, dass es kein ähnliches Werkzeug geben würde tanh(7°.

Um etwas mehr Sicherheit gegen Brute Force zu bieten, habe ich die Grad-zu-Radian-Konvertierung verwendet, eine etwas undurchsichtige Funktion, die aber nicht ausreichte.

CJam, ≤ 8 [sicher]

379005901358552706072646818049622056

Ich mag keine langen Zahlen, also hier ist eine kurze. Fühlen Sie sich frei, sowohl offline als auch online zu fummeln .

Da ich nur Nummern-Einsendungen ziemlich langweilig finde, werde ich langsam ein paar Hinweise herausgeben, um das zu kompensieren.

Tipp 1: Das Programm endet mit einer einzelnen Nummer des Stapels, und keine der A-KVariablen wird verwendet.
Tipp 2: Die Nummer verschlüsselt Informationen, die vollständig abrufbar sind, wenn Sie den Vorgang umkehren (dh es sind keine Informationen verloren gegangen).
Tipp 3: Die "Information" aus Tipp 2 ist eine einzelne Zeichenfolge, die nach den ersten vier Zeichen erstellt wird.

Lösung

Das Programm war

0W#sWcib

0W#ist 0^-1, was statt fehler heraus gibt Infinity. sWirft dies dann in eine Zeichenfolge (Notiz, `die 1d0/stattdessen gibt ).

Für die andere Hälfte Wcwird -1 in ein Zeichen konvertiert, das aufgrund des Umlaufs für Zeichen zum Codepunkt 65535 wird (siehe diesen Tipp ). ikonvertiert dann das Zeichen zurück in ein int, dh 65535.

Schließlich bwandelt die Zeichenfolge Infinity65535 zur Basis der obigen Nummer zu geben.

Javascript (Konsole), <= 32 ( geknackt von insertusernamehere )

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

Getestet in Chrome- und Firefox-Webkonsolen. Das ist eine 43-stellige Zeichenfolge.

Meine beabsichtigte Lösung war etwas ausgefeilter als die verknüpfte (Fluch, ES6!).

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

Erläuterung:

Wenn Sie replacemit dem /gFlag und einer Funktion einen regulären Ausdruck aufrufen , wird alles, was mit dem regulären Ausdruck übereinstimmt, durch das Ergebnis des Aufrufs der Funktion mit den folgenden Argumenten ersetzt: Die übereinstimmende Zeichenfolge, jede Erfassungsgruppe in der übereinstimmenden Zeichenfolge, der Index, in dem sich die übereinstimmende Zeichenfolge befindet die ganze Saite und die ganze Saite. In diesem Fall ist das "a", "a", 0 oder 4 oder 6 und "a, b, a, a". Alle diese Argumente werden an den Array-Konstruktor übergeben, der einfach ein Array von allem erstellt, was übergeben wird. replaceKonvertiert das dann in einen String, z. B. "a, a, 0, a, b, a, a" und ersetzt das "a". Charakter damit.

Python, <= 32 ( geknackt von Egor Skriptunoff)

Die Ausgabe beträgt 1832 Byte, einschließlich Zeilenumbrüchen:

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

CJam ( geknackt von Dennis)

Länge <= 4

1737589973457545958193355601

Ich gebe dem keine sehr hohe Überlebenschance, aber ich wollte trotzdem eine 4-Byte-Lösung ausprobieren.

Mein Code war genau das, was Dennis rückentwickelt hat:

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

CJam druckt dann den gesamten Stapelinhalt verkettet aus. Also wurde die Ausgabe mit 17verkettet 19^20.

Lua, ≤ 4 ( durch Feersum geknackt )

Ausgabe:

9.5367431640625e-07

Sie müssen einen String für Lua REPL finden, der die Konstante "1 / M" ergibt.
Es ist einfach, aber nicht sehr trivial.

Pip , <= 16 (sicher)

Ich verspreche, dass dies meine letzte Pip-Einreichung ist. :)

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

Es würde mich überraschen, wenn irgendjemand das auf 16 Bytes bringt - ich habe einige Versuche gebraucht, um es fit zu machen. (Nimm das als Herausforderung, wenn du magst!)

Antworten:

Px:J,tLtP09JsX8x

Dieser Code verwendet die vordefinierten Variablen t= 10 und s= space.

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

Ruby, geknackt von Kennytm

Bereich: ≤64.

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

(Und ja, die gesamte Ausgabe erfolgt nach STDOUT.)

Beabsichtigte Lösung:

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

TI-BASIC ( geknackt von Thomas Kwa )

TI-89-Variante
Reichweite: ≤8 Ausgabelänge
: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

Ich glaube nicht, dass Sie RIES dafür verwenden können, aber ich bezweifle, dass es trotzdem 7 Tage überleben wird. Naja.

Code:

236!

MATLAB, geknackt von Tom Carpenter

Bereich <= 16

ans =

        5760       22320
       13920       53940

Mathematica, geknackt von Sp3000

Bereich: <= 32

808017424794512875886459904961710757005754368000000000

Thue - <= 64 Bytes, geknackt von einem Histokraten.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

Das ist 2016 5s; Apropos.

CJam, ≤8 (sicher)

\"3.341594\43181\

Originalcode:

P`_`_`er

Beginnen Sie also mit 3.141592653589793jedem Zeichen in und ersetzen Sie es "3.141592653589793"durch das entsprechende Zeichen in "\"3.141592653589793\"". Mit den Duplikate entfernt, ist ersetzt sie tatsächlich ".123456789mit ""35\.49831.

Python 2 (sicher 16)

(1.06779146638-0.024105112278j)

Bereich ≤ 16. Falls es auf die Version ankommt (für die Druckgenauigkeit?), Verwende ich ideone .

Ich sehe keine Möglichkeit, den Code ohne Computersuche zu erraten, aber Sie haben mich alle schon einmal beeindruckt.

Antworten:

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

JavaScript ES6, ≤128 Bytes - Gebrochen

Ausgabe (1124 Bytes):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Viel Spaß und viel Glück!

Originalcode:

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

TI-BASIC (geknackt von Thomas Kwa)

Bereich: <= 2

Zeichenfolge: -10

Code: Xmin

Es gibt nur keinen Grund, diesen Kerl zum Narren zu halten ...

AppleScript, ≤ 2 Bytes geknackt

"Brute gezwungen ... meckern meckern ..."

Was ist das? Eine kurze AppleScript-Antwort? :O

fehlender Wert

(Ja, dies druckt nach Standard)

> <> (Fisch) , rissige von SP3000

Länge <= 8

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

Die Ausgabe ist 23 >und das Programm erzeugt keinen Fehler.

GolfScript (sicher)

44460233687688399109436699097976761322375660878906252846699686946304

Bereich ≤ 8

Lösung

{9?7*}.%

Probieren Sie es online aus.

Wie es funktioniert

• {9?7*} schiebt diesen Block auf den Stapel.

• .% dupliziert den Block und ordnet ihn zu ... über sich selbst.

  GolfScript führt Typ-Casting durch, als gäbe es kein Morgen. In diesem Fall erwartet der Interpreter einen iterablen Wert, sodass der ursprüngliche Block in ein Array umgewandelt wird und das folgende Array von Zeichencodes ergibt: [57 63 55 42] .

• Der Block selbst erhöht jeden Zeichencode auf die neunte Potenz ( 9?) und multipliziert das Ergebnis mit sieben ( 7*).

  Für die vier Zeichencodes im Array wird diese Taste gedrückt

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Vor dem Beenden druckt der Interpreter die vier Ganzzahlen ohne Trennzeichen.