Wątek złodziei można znaleźć tutaj: The Mystery String Printer (Robbers)

Twoje wyzwanie

• Napisz program, funkcję lub skrypt REPL, który drukuje ciąg do STDOUT.
• Rabusie spróbują stworzyć program, który wydrukuje ten sam ciąg.
• Jeśli uda im się utworzyć program w ciągu 7 dni, zgłoszenie zostanie złamane.
• Jeśli nikt nie może utworzyć programu, który wydrukuje ten sam ciąg w ciągu 7 dni, przesłanie jest bezpieczne. Możesz zdecydować się na ujawnienie swojego programu lub pozostawić go jako wyzwanie przyszłym rabusiom. Jeśli jednak tego nie ujawnisz, nie możesz zdobyć żadnych punktów za przesłanie (nie umieszczaj słowa „bezpieczne” w nagłówku odpowiedzi, jeśli zdecydujesz się to zrobić).

Ograniczenia

• Program musi być mniejszy lub równy 128 bajtom ogółem (więcej na ten temat później).
• Jeśli program zależy od nazwy programu lub nazwy / zawartości pliku zewnętrznego, musisz powiedzieć, że tak się dzieje, i uwzględnić to w całkowitej liczbie bajtów.
• Wydrukowany ciąg musi być mniejszy lub równy 2048 bajtów.
• Wydrukowany ciąg musi składać się wyłącznie z drukowalnych znaków ASCII (można dodać nowe wiersze).
• Program musi generować to samo wyjście przy każdym uruchomieniu.
• Wbudowane operacje podstawowe kryptograficzne (w tym wszelkie rng, szyfrowanie, deszyfrowanie i mieszanie) są niedozwolone.
• Program nie może pobierać danych wejściowych.
• Brak standardowych luk.

Punktacja

• Jeśli zgłoszenie zostanie złamane przed upływem siedmiu dni, zgłoszenie otrzymuje 0 punktów.
• Bezpieczne przesłanie ≤ 128 znaków daje 1 punkt.
• Bezpieczne przesłanie ≤64 znaków daje 2 punkty. Jeśli jest mniejszy lub równy 32 bajtom, zarabia 4 punkty i tak dalej.
• Każde bezpieczne poddanie się zapewnia również dodatkowy 3 punktowy bonus (niezależnie od długości).
• Za każde pęknięcie po pierwszym jest niewielka (1/2 punktu) kara.
• Zauważ, że rozwiązanie rabusia musi mieć ten sam zakres długości programu.
• Każda osoba może przesłać maksymalnie 1 program na zakres bajtów na język (różne wersje i arbitralne podstawienia tego samego języka nie liczą się jako osobne języki). Przykład: możesz opublikować 32-bajtowy i 64-bajtowy program pyth, ale nie możesz opublikować 128-bajtowego programu zarówno w Javie 7, jak i Javie 8.
• Osoba z najwyższą sumą punktów wygrywa.

Zgłoszenia

Każde zgłoszenie musi zawierać następujące informacje:

• Nazwa języka Wszystkie nowe rozwiązania złodziei muszą być w tym samym języku.
• Zakres rozmiaru programu (jest to najbliższa potęga o dwa razy większa niż rozmiar programu; na przykład, jeśli twój program ma 25 bajtów, będzie to „≤32”).
• Rzeczywisty ciąg do wydrukowania.
• Jeśli przesyłanie jest bezpieczne, w nagłówku wpisz „bezpieczny” i długość programu (z dokładnością do najbliższej potęgi 2). Jeśli w nagłówku jest wiele liczb, umieść potęgę 2 na końcu.

Ten fragment stosu generuje tabele wyników i zawiera listę wszystkich otwartych zgłoszeń. Jeśli występują jakieś problemy z fragmentem kodu, zostaw komentarz.

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

Użyj następujących formatów wpisów:

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

lub

Language
=
Length <= 16

Pamiętaj, że fragment kodu umieści pierwsze słowo w nagłówku jako język, jeśli nie wykryje przecinka.

W celu bezpiecznego przesyłania umieść bezpiecznie w swoim nagłówku. Urywek automatycznie umieści Twój program w kolumnie „bezpieczny”, jeśli upłynie czas, więc jest to bardziej informacja dla złodziei, że Twój program jest bezpieczny.

W przypadku zgłoszeń z krakowaniem umieść crack w nagłówku.

Program powinien także być w stanie rozpoznać, czy komentarz mówi „pęknięty” i zawiera link; nie jest to jednak gwarantowane.

Kolejność złamań: Punkty -> Liczba bezpiecznych zgłoszeń -> Najmniejsza liczba złamanych zgłoszeń.

Pamiętaj, że fragment jest sortowany według otwartych zgłoszeń przed ich najmniejszym pęknięciem, ale otwarte zgłoszenia nie będą liczone na koniec konkursu.

To wyzwanie jest już zamknięte.

Zwycięzca największej liczby punktów: Dennis

Najbezpieczniejsze zgłoszenia: DLosc

(Należy pamiętać, że liczba bezpiecznych zgłoszeń nie przekłada się na liczbę punktów, ponieważ przy obliczaniu wyniku bierze się pod uwagę rozmiar programów).

Pyth, Safe, zakres ≤ 8

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

Kod:

%^T6`^G5

Wyjaśnienie:

Aby wyjaśnić, jak to działa: Wygenerowałem wszystkie możliwe 5 ciągów znaków małych liter ( ^G5). Następnie wygenerowałem ciąg reprezentujący tę listę: ( `^G5). W końcu wziąłem co 1 000 000 znak tej listy ( %^T6). Rezultatem jest coś, co wygląda jak lista ciągów, ale podejrzanie brakuje jej nawiasu końcowego.

VBA, [Bezpieczny]

Zakres <= 128 bajtów

Podpowiedź, gdzie wydrukować

Uruchomiony w programie Excel 2007, dane wyjściowe były do ​​Debug.print. Powodzenia w VBA - uruchomienie czegoś poniżej 128 bajtów.

Wyjście 255 bajtów

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

Rozwiązanie

Mam nadzieję, że ktoś dobrze się bawił próbując go złamać. Mogę powiedzieć, że jest to jedna z najgorszych metod radzenia sobie z błędami, jakie kiedykolwiek zrobiłem, i szkoda mi, jak zły jest ten kod.

Kod

    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'

Wyjaśniono

Najpierw kod zaczyna się od jednego z głównych grzechów VBA. On Error Resume next.
Kiedy popełniamy ten okropny czyn, idziemy dalej i po prostu rzucamy i popełniamy błąd. jest to This array is fixed or temporarily lockedbłąd, który wkrótce zobaczymy w danych wyjściowych.

Następna jest pętla. Zapętlamy 128 razy, próbując przekonwertować opis błędu, ale jedyne prawidłowe dane wejściowe dla i are 1,2,3,64,128. Z tego powodu pierwsze 4 pętle wypisują błąd z różnymi formatami. Potem, gdy i = 4kod zgłasza nowy błąd. Invalid callTo zapętla się i nic nie jest przypisane, bponieważ strconvfunkcja wyskakuje za każdym razem.

Tu powinien zatrzymać się każdy normalny program, ale ponieważ mamy On Error Resume Nextkażdy błąd, jest on ignorowany, a kod jest nadal niezauważony przez słabą obsługę błędów.

Teraz trafiamyi=32i dodajemy nowy błąd do bkonwersji na Unicode, a następnie kontynuujemy zapętlanie, aż i = 128do tego momentu przekonwertujemy nasz błąd z Unicode, co powoduje ?????????????????dodanie łańcucha do b

Ostatecznie Wydrukuj bałagan błędów, które połączyliśmy razem

Matematyka, bezpieczna, zakres ≤ 64

Wynik:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Źródło:

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

ngn APL (bezpieczny)

0.675640430319848J0.8376870144941628

Zakres ≤ 8

Rozwiązanie

*3○⍟⍣=42

Wypróbuj online.

Jak to działa

• ⍟⍣=42stosuje logarytm naturalny ( ⍟) wielokrotnie do 42, aż do osiągnięcia stałego punktu ( ⍣=), dając 0.31813150520476413J1.3372357014306895 .

  Wartość początkowa nie ma tu tak naprawdę znaczenia, o ile nie jest to ani 1, ani 0 .

• 3○stosuje styczną do swojego prawego argumentu, uzyskując 0,07343765001657206J0,8920713530605129 .

• * stosuje naturalną funkcję wykładniczą do swojego prawego argumentu, uzyskując pożądany wynik.

Pyth, złamany przez Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Zakres ≤ 8

> <> (Bezpieczne)

Testowany na internetowych i oficjalnych tłumaczach.

Zakres: <= 16

Strunowy: 4621430504113348052246441337820019217490490

To jest ładne 1337, prawda?

Wyjaśnienie:

Oto kod źródłowy (15 bajtów):

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

fwypycha 15 (nasz licznik) na stos (jest on pomijany !na końcu, aby nie pchać więcej niż jednego licznika)

1- odejmuje 1 od licznika

:0(?; Frowny face sprawdza, czy licznik jest mniejszy niż 0, reszta kończy program, jeśli tak jest

:: Dwukrotnie duplikuje licznik

0gPobiera znak w punkcie (c,0)kodu źródłowego, w którym cznajduje się licznik

* Mnoży drugi duplikat licznika przez reprezentację ASCII poprzednio chwytanej postaci

n Wyświetla wynik.

Tak więc, podzielmy, wynik jest [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. Odpowiada to interpretacji kodu ASCII w odwrotnej kolejności pomnożonej przez liczby 14 do 0 (tj [!*14, n*13, ... f*0].).

Prawdopodobnie najtrudniejszą częścią łamania tego byłoby wymyślenie, jak poprawnie podzielić liczby, ale jeśli dostaniesz właściwe, to tylko kwestia wypróbowania rzeczy, dopóki nie dostaniesz czegoś, co działa.

Bałwan 1.0.2

Zakres ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

Rozwiązaniem jest:

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

Matlab, ≤16. Pęknięty przez Wauzla

Zakres ≤16 .

Działa to również w Octave .

Wydrukowany ciąg jest następujący:

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

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Zakres ≤ 32

Rozwiązanie

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

Wypróbuj online.

Jak to działa

• for-951..1048 wykonuje poprzednie polecenie dla każdej liczby całkowitej w tym zakresie, zapisując je w zmiennej niejawnej.

• y/124589// wykonuje transliterację, eliminując określone cyfry ze zmiennej niejawnej.

  y/// zwróci liczbę eliminacji, tj. liczbę wystąpień tych cyfr w zmiennej niejawnej.

• print 2**wypisuje 2 do potęgi eliminacji ( 1 , 2 , 4 lub 8 ).

Python, <= 16 ( cracked przez kennytm )

[[[22111101102001]]]

Zostało to stworzone przez REPL (uruchomienie polecenia w powłoce Pythona).

Podczas edytowania tego streszczę również komentarze przyszłych rabusiów wolnych od spoilerów: nie działa to we wszystkich Pythonach. Działa w kompilacji Python 2.7 gdzie sys.maxint = 9223372036854775807.

> <> , ≤ 8 [ pęknięty ]

oooooooooooo

To łącznie 12 osekund. Program zatrzymuje się bezbłędnie i współpracuje zarówno z oficjalnym tłumaczem, jak i tłumaczem online .

TI-BASIC, ≤4 bajty, pęknięty przez Reto Koradi

Pęknięcie zajęło 5 dni 23 godzin. Tak blisko...

Wyjście (10 bajtów):

.495382547

Program:

³√(tanh(7°

Ponieważ w zasadzie nikt nie zgadnie, moim celem w zaprojektowaniu tego programu było uczynienie brutalnej siły jedynym możliwym podejściem.

Aby to zrobić, zablokowałem wyświetlanie danych wyjściowych lub danych wyjściowych z zastosowaniem jednej z tych funkcji odwrotnych na ISC. ISC nie ma stycznej hiperbolicznej i doszedłem do wniosku, że żadne podobne narzędzie nie miałoby tanh(7°.

Aby dodać pewne zabezpieczenie przed brutalną siłą, użyłem konwersji stopnia na radian, nieco niejasnej funkcji, ale to nie wystarczyło.

CJam, ≤ 8 [bezpieczny]

379005901358552706072646818049622056

Nie lubię długich liczb, więc oto krótki. Nie krępuj się bawić w trybie offline i online .

Ponieważ uważam, że przesyłanie tylko liczb jest dość nudne, będę powoli podawał kilka wskazówek, aby to zrekompensować.

Wskazówka 1: Program kończy się na jednej liczbie stosu i żadna ze A-Kzmiennych nie jest używana.
Wskazówka 2: Liczba koduje informacje, które można całkowicie odzyskać, jeśli cofniesz proces (tzn. Żadna informacja nie zostanie utracona).
Podpowiedź 3: „Informacja” z podpowiedzi 2 to pojedynczy ciąg znaków, który jest tworzony po pierwszych czterech znakach.

Rozwiązanie

Program był

0W#sWcib

0W#jest 0^-1, co zamiast błędu daje Infinity. snastępnie rzutuje to na ciąg znaków (uwaga, która `daje 1d0/zamiast tego).

Dla drugiej połowy Wckonwertuje -1 na znak, który staje się punktem kodowym 65535 z powodu oblewania znakami (patrz ta wskazówka ). inastępnie konwertuje char z powrotem na int, tj. 65535.

Na koniec bkonwertuje ciąg Infinityna bazę 65535, aby podać powyższą liczbę.

JavaScript (konsola), <= 32 ( pęknięty przez inserttusernamehere )

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

Testowane w konsolach internetowych Chrome i Firefox. To ciąg 43 znaków.

Moje zamierzone rozwiązanie było nieco bardziej skomplikowane niż połączenie (przekleństwo, ES6!).

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

Wyjaśnienie:

Gdy wywołujesz replacewyrażenie regularne z /gflagą i funkcją, zastępuje ono wszystko pasujące do wyrażenia regularnego wynikiem wywołania funkcji tymi argumentami: dopasowany ciąg, każda grupa przechwytywania w dopasowanym ciągu, indeks, w którym znajduje się dopasowany ciąg cały ciąg i cały ciąg. W tym przypadku będą to „a”, „a”, 0 lub 4 lub 6 oraz „a, b, a, a”. Wszystkie te argumenty są przekazywane do konstruktora Array, który po prostu tworzy tablicę wszystkiego, co przekazuje. Następnie replacekonwertuje to na ciąg znaków, np. „A, a, 0, a, b, a, a” i zastępuje „a” postać z tym.

Python, <= 32 ( cracked by Egor Skriptunoff)

Dane wyjściowe to 1832 bajtów, w tym znaki nowego wiersza:

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 ( cracked by Dennis)

Długość <= 4

1737589973457545958193355601

Nie daję temu bardzo dużej szansy na przeżycie, ale i tak chciałem wypróbować rozwiązanie 4-bajtowe.

Mój kod był dokładnie tym, co Dennis poddał inżynierii wstecznej:

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

Następnie CJam drukuje całą zawartość stosu, łącząc. Tak więc wynik został 17połączony 19^20.

Lua, ≤ 4 ( pęknięty przez feersum)

Wynik:

9.5367431640625e-07

Musisz znaleźć ciąg dla Lua REPL, który daje stałą „1 / M”.
To proste, ale niezbyt trywialne.

Pip , <= 16 (bezpieczny)

To jest moje ostatnie przesłanie Pipa, obiecuję. :)

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

Będę zaskoczony, jeśli ktoś sprowadzi to do 16 bajtów - zajęło mi to sporo prób dopasowania. (Weź to za wyzwanie, jeśli chcesz!)

Odpowiedź:

Px:J,tLtP09JsX8x

Ten kod wykorzystuje predefiniowane zmienne t= 10 i s= spacja.

    ,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, rozbity przez KennyTM

Zakres: ≤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"

(I tak, wszystkie dane wyjściowe są w STDOUT.)

Zamierzone rozwiązanie:

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

TI-Basic ( pęknięty przez Thomasa Kwa )

Wariant TI-89
Zakres: ≤8
Długość wyjściowa: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

Nie sądzę, że możesz użyć na tym RIES, ale wątpię, czy i tak przetrwa 7 dni. No cóż.

Kod:

236!

MATLAB, rozbity przez Toma Carpentera

Zakres <= 16

ans =

        5760       22320
       13920       53940

Mathematica, Cracked by Sp3000

Zakres: <= 32

808017424794512875886459904961710757005754368000000000

Wt - <= 64 bajtów, pęknięty przez histokrata.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

To 2016 5s; tak poza tym.

CJam, ≤8 (bezpieczny)

\"3.341594\43181\

Oryginalny kod:

P`_`_`er

Oznacza to, że należy zacząć od 3.141592653589793i zastąpić każdy znak "3.141592653589793"odpowiednim znakiem w "\"3.141592653589793\"". Po usunięciu duplikatów zastępuje ".123456789je ""35\.49831.

Python 2 (bezpieczny 16)

(1.06779146638-0.024105112278j)

Zakres ≤ 16. Jeśli wersja ma znaczenie (dla precyzji drukowania?), Używam ideone .

Nie widzę sposobu na odgadnięcie kodu bez przeszukiwania komputera, ale wszyscy już wcześniej zrobili na mnie wrażenie.

Odpowiedź:

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

JavaScript ES6, ≤ 128 bajtów - pęknięty

Wyjście (1124 bajtów):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Baw się dobrze i powodzenia!

Oryginalny kod:

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

TI-BASIC (cracked Thomas Kwa)

Zakres: <= 2

Strunowy: -10

Kod: Xmin

Tego faceta po prostu nie można oszukać ...

AppleScript, pęknięty ≤ 2 bajty

„Brutal zmuszony ... narzekanie narzekanie ...”

Co to jest? Krótka odpowiedź AppleScript? : o

brakująca wartość

(tak, drukuje to na standardowe wyjście)

> <> (Fish) , Cracked by Sp3000

Długość <= 8

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

Dane wyjściowe to 23 >, a program nie powoduje błędu.

GolfScript (bezpieczny)

44460233687688399109436699097976761322375660878906252846699686946304

Zakres ≤ 8

Rozwiązanie

{9?7*}.%

Wypróbuj online.

Jak to działa

• {9?7*} wypycha ten blok na stos.

• .% powiela blok i odwzorowuje go… na sobie.

  GolfScript wykonuje rzutowanie, jakby nie było jutra. W takim przypadku interpreter oczekuje iterowalności, więc oryginalny blok zostaje rzutowany na tablicę, uzyskując następującą tablicę kodów znaków: [57 63 55 42] .

• Sam blok podnosi kod każdego znaku do dziewiątej potęgi ( 9?), a następnie mnoży wynik przez siedem ( 7*).

  W przypadku kodów czteroznakowych w tablicy powoduje to przesunięcie

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Przed wyjściem interpreter drukuje cztery liczby całkowite bez separatorów.