Il thread dei ladri è disponibile qui: The Mystery String Printer (Robbers)

La tua sfida

• Scrivi un programma, una funzione o uno script REPL che stampa una stringa su STDOUT.
• I ladri proveranno a creare un programma che stampa la stessa stringa.
• Se riescono a creare il programma con successo entro 7 giorni, la tua richiesta verrà decifrata.
• Se nessuno può creare un programma che stampa la stessa stringa entro 7 giorni, l'invio è sicuro. Puoi scegliere di rivelare il tuo programma o lasciarlo per sfidare i futuri rapinatori. Tuttavia, se non lo mostri, non puoi ottenere alcun punto dal tuo invio (non mettere "sicuro" nell'intestazione della risposta se scegli di farlo).

restrizioni

• Il programma deve essere inferiore o uguale a 128 byte totali (ne parleremo più avanti).
• Se il programma dipende dal nome del programma o dal nome / contenuto di un file esterno, è necessario dire che lo fa e includerlo nel conteggio totale dei byte.
• La stringa stampata deve essere inferiore o uguale a 2048 byte.
• La stringa stampata deve contenere solo caratteri ASCII stampabili (è possibile includere nuove righe).
• Il programma deve produrre lo stesso output ogni volta che viene eseguito.
• Non sono consentite primitive crittografiche integrate (include rng, crittografia, decrittografia e hash).
• Il programma non deve accettare input.
• Nessuna scappatoia standard.

punteggio

• Se un invio viene infranto prima di sette giorni, l'invio guadagna 0 punti.
• Un invio sicuro di ≤128 caratteri guadagna 1 punto.
• Una sottomissione sicura di ≤64 caratteri guadagna 2 punti. Se è inferiore o uguale a 32 byte, guadagna 4 punti e così via.
• Ogni invio sicuro guadagna anche un bonus aggiuntivo di 3 punti (indipendentemente dalla lunghezza).
• C'è una penalità minuscola (1/2 punto) per ogni crack dopo il tuo primo.
• Si noti che la soluzione del ladro deve essere nella stessa gamma di lunghezze del programma.
• Ogni persona può presentare un massimo di 1 programma per intervallo di byte per lingua (versioni diverse e sostituzioni arbitrarie della stessa lingua non contano come lingue separate). Esempio: è possibile pubblicare un programma pyth a 32 byte e 64 byte, ma non è possibile pubblicare un programma a 128 byte in Java 7 e Java 8.
• Vince la persona con il punteggio più alto.

Inseriti

Ogni invio deve contenere le seguenti informazioni:

• Il nome della lingua Tutte le nuove soluzioni dei ladri devono essere nella stessa lingua.
• L'intervallo della dimensione del programma (questa è la potenza più vicina di due superiore alla dimensione del programma; ad esempio, se il programma è di 25 byte, questo sarebbe "≤32").
• La stringa effettiva da stampare.
• Se un invio è sicuro, inserisci "safe" e la durata del programma (alla potenza più vicina di 2) nella tua intestazione. Se ci sono più numeri nella tua intestazione, metti la potenza di 2 per ultimo.

Questo frammento di stack genera classifiche ed elenca tutti gli invii aperti. In caso di problemi con lo snippet, lascia un commento.

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

Utilizzare i seguenti formati per le voci:

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

o

Language
=
Length <= 16

Tieni presente che lo snippet inserirà la prima parola nell'intestazione come lingua solo se non rileva una virgola.

Per comunicazioni sicure, inserisci la sicurezza nell'intestazione. Lo snippet inserirà automaticamente il tuo programma nella colonna "sicuro" se il tempo è scaduto, quindi questo è più per dire a tutti i ladri che il tuo programma è sicuro.

Per invii incrinati, inserisci incrinato nell'intestazione.

Il programma dovrebbe anche essere in grado di riconoscere se un commento dice "incrinato" e ha un collegamento; tuttavia, questo non è garantito.

Ordine di pareggio: Punti -> N. di invii sicuri -> Minimo numero di invii non funzionanti.

Tieni presente che lo snippet ordina per invii aperti prima almeno crackati, ma gli invii aperti non verranno conteggiati alla fine del contest.

Questa sfida è ora chiusa.

Vincitore del maggior numero di punti: Dennis

Argomenti più sicuri: DLosc

(Si noti che il numero di invii sicuri non si traduce in un importo in punti, poiché la dimensione dei programmi viene considerata nel calcolo del punteggio).

Pyth, Safe, Range ≤ 8

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

Il codice:

%^T6`^G5

Spiegazione:

Per chiarire come funziona: ho generato tutte le possibili 5 stringhe di caratteri di lettere minuscole ( ^G5). Quindi, ho generato la rappresentazione in formato stringa di questo elenco: ( `^G5). Alla fine, ho preso ogni 1.000.000 di carattere di quell'elenco ( %^T6). Il risultato è qualcosa che assomiglia a un elenco di stringhe, ma sospettosamente manca la sua parentesi finale.

VBA, [sicuro]

Intervallo <= 128 byte

Suggerimento per dove produrre

Eseguito in Excel 2007, l'output era Debug.print. La fortuna di VBA è quella di far funzionare qualsiasi cosa con meno di 128 byte.

Uscita 255 byte

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

Soluzione

Beh, spero che qualcuno si sia divertito cercando di rompere questo. Posso dire che questo è uno dei peggiori errori di gestione che io abbia mai fatto e mi sento male per quanto sia cattivo questo codice.

Codice

    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'

spiegato

Innanzitutto il codice inizia con uno dei peccati principali di VBA. On Error Resume next.
Una volta che abbiamo commesso quell'atto orribile, andiamo avanti e lanciamo ed errore. questo è l' This array is fixed or temporarily lockederrore che vedremo presto nell'output.

Il prossimo è il ciclo. Ripetiamo 128 volte cercando di convertire la descrizione dell'errore, ma gli unici input validi per i are 1,2,3,64,128. Per questo motivo i primi 4 loop stampano l'errore con vari formati. Quindi, quando i = 4il codice genera un nuovo errore, il Invalid callloop viene eseguito e non viene assegnato nulla bperché la strconvfunzione si spegne ogni volta.

Questo è dove qualsiasi programma normale avrebbe dovuto fermarsi, ma poiché abbiamo On Error Resume Nextogni errore viene ignorato e il codice continua a non essere disturbato dalla cattiva gestione degli errori

Ora abbiamo colpitoi=32e aggiungiamo il nuovo errore da bconvertire in Unicode e quindi continuiamo il looping fino i = 128a quel momento convertiamo il nostro errore DA Unicode che risulta nella ?????????????????stringa da aggiungere a b

Infine Stampa il pasticcio di Errori che abbiamo concatenato insieme

Mathematica, sicuro, intervallo ≤ 64

Produzione:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Fonte:

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

ngn APL (sicuro)

0.675640430319848J0.8376870144941628

Intervallo ≤ 8

Soluzione

*3○⍟⍣=42

Provalo online.

Come funziona

• ⍟⍣=42applica il logaritmo naturale ( ⍟) ripetutamente a 42 fino a raggiungere un punto fisso (⍣= ), ottenendo 0,31813150520476413J1.3372357014306895 .

  Il valore iniziale non ha molta importanza qui, purché non sia né 1 né 0 .

• 3○ applica tangente alla sua giusta argomentazione, cedendo 0,07343765001657206J0.8920713530605129 .

• * applica la funzione esponenziale naturale al suo argomento giusto, producendo l'output desiderato.

Pyth, crackato da Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Intervallo ≤ 8

> <> (Sicuro)

Testato su interpreti online e ufficiali.

Intervallo: <= 16

Corda: 4621430504113348052246441337820019217490490

Questo è carino 1337, eh?

Spiegazione:

Ecco il codice sorgente (15 byte):

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

fspinge 15 (il nostro contatore) sullo stack (questo viene saltato dalla !fine in modo da non spingere più di un contatore)

1- sottrae 1 dal contatore

:0(?; La faccia accigliata verifica se il contatore è inferiore a 0, il resto termina il programma se lo è

:: Duplica due volte il contatore

0gAfferra il carattere nel punto (c,0)nel codice sorgente in cui si ctrova il contatore

* Moltiplica il secondo duplicato del contatore per la rappresentazione ASCII del personaggio precedentemente afferrato

n Stampa il risultato.

Quindi, diviso, l'output è [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. Ciò corrisponde all'interpretazione ASCII del codice al contrario moltiplicata per i numeri da 14 a 0 (cioè [!*14, n*13, ... f*0]).

Probabilmente la parte più difficile nel decifrare questo sarebbe capire come dividere correttamente i numeri, ma se ottieni quelli giusti è solo una questione di provare cose finché non ottieni qualcosa che funzioni.

Snowman 1.0.2

Intervallo ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

La soluzione è:

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

Matlab, ≤16. Incrinato da Wauzl

Intervallo ≤16 .

Questo funziona anche in Octave .

La stringa stampata è la seguente:

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

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Intervallo ≤ 32

Soluzione

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

Provalo online.

Come funziona

• for-951..1048 esegue il comando precedente per ogni numero intero in questo intervallo, salvandolo nella variabile implicita.

• y/124589// esegue la traslitterazione, eliminando le cifre specificate dalla variabile implicita.

  y/// restituirà il numero di eliminazioni, ovvero il numero di occorrenze di quelle cifre nella variabile implicita.

• print 2**stampa 2 alla potenza delle eliminazioni ( 1 , 2 , 4 o 8 ).

Python, <= 16 ( crackato da kennytm )

[[[22111101102001]]]

Questo è stato prodotto tramite REPL (eseguendo un comando nella shell Python).

Mentre lo sto modificando, riassumerò anche i commenti per i futuri ladri senza spoiler: questo non funziona in tutti i Python. Funziona in una build di Python 2.7 dove sys.maxint = 9223372036854775807.

> <> , ≤ 8 [ rotto ]

oooooooooooo

Sono in totale 12 os. Il programma si arresta senza errori e funziona sia con l'interprete ufficiale che con l'interprete online .

TI-BASIC, ≤4 byte, crackato da Reto Koradi

Ci sono voluti 5 giorni e 23 ore per decifrare. Così vicino...

Uscita (10 byte):

.495382547

Programma:

³√(tanh(7°

Dal momento che è praticamente impossibile per qualcuno indovinarlo, il mio obiettivo nel progettare questo programma era di rendere la forza bruta l'unico approccio possibile.

Per fare ciò, ho impedito che l'output, o l'output con una di queste funzioni inverse applicate, venisse visualizzato sull'ISC. ISC non ha una tangente iperbolica e ho pensato che nessuno strumento simile avrebbe avuto tanh(7°.

Per aggiungere un po 'di sicurezza alla forza bruta, ho usato la conversione da grado a radiante, una caratteristica leggermente oscura, ma non era abbastanza.

CJam, ≤ 8 [sicuro]

379005901358552706072646818049622056

Non mi piacciono i numeri lunghi, quindi eccone uno breve. Sentiti libero di giocherellare sia offline che online .

Dal momento che trovo che le presentazioni solo numeriche siano piuttosto noiose, fornirò lentamente alcuni suggerimenti per compensare.

Suggerimento 1: il programma termina con un singolo numero dello stack e nessuna delle A-Kvariabili viene utilizzata.
Suggerimento 2: il numero codifica informazioni completamente recuperabili se si inverte il processo (ovvero nessuna informazione è andata persa).
Suggerimento 3: Le "informazioni" del suggerimento 2 sono una singola stringa creata dopo i primi quattro caratteri.

Soluzione

Il programma era

0W#sWcib

0W#è 0^-1, che invece di sbagliare dà Infinity. squindi lo lancia in una stringa (nota che `dà1d0/ invece).

Per l'altra metà, Wcconverte -1 in un carattere, che diventa il punto di codice 65535 a causa del wraparound per i caratteri (vedere questo suggerimento ).iquindi converte nuovamente il carattere in un int, ovvero 65535.

Infine, bconverte la stringa Infinityin base 65535 per fornire il numero sopra.

Javascript (console), <= 32 ( crackato da insertusernamehere )

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

Testato su console web Chrome e Firefox. Questa è una stringa di 43 caratteri.

La mia soluzione prevista era un po 'più elaborata di quella collegata (maledizione, ES6!).

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

Spiegazione:

Quando chiami replacecon un'espressione regolare con il /gflag e una funzione, sostituisce tutto ciò che corrisponde alla regex con il risultato della chiamata della funzione con questi argomenti: La stringa corrispondente, ogni gruppo di acquisizione nella stringa corrispondente, l'indice in cui si trova la stringa corrispondente l'intera stringa e l'intera stringa. In questo caso, sarà "a", "a", 0 o 4 o 6 e "a, b, a, a". Tutti questi argomenti vengono passati al costruttore di array, che crea semplicemente un array di tutto ciò che passa. Quindi lo replaceconverte in una stringa, ad esempio "a, a, 0, a, b, a, a" e sostituisce "a" personaggio con esso.

Python, <= 32 ( crackato da Egor Skriptunoff)

L'output è di 1832 byte, inclusi i newline:

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 ( incrinato da Dennis)

Lunghezza <= 4

1737589973457545958193355601

Non ho molte possibilità di sopravvivere, ma volevo comunque provare una soluzione a 4 byte.

Il mio codice era esattamente quello che Dennis ha progettato al contrario:

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

CJam stampa quindi tutto il contenuto dello stack, concatenato. Quindi l'output è stato 17concatenato con 19^20.

Lua, ≤ 4 ( rotto dal febbre)

Produzione:

9.5367431640625e-07

È necessario trovare una stringa per Lua REPL che dia come risultato la costante "1 / M".
È semplice, ma non molto banale.

Pip , <= 16 (sicuro)

Questa è la mia ultima presentazione Pip, lo prometto. :)

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

Sarò sorpreso se qualcuno arriva a 16 byte - ci sono voluti un paio di tentativi per adattarlo. (Prendilo come una sfida se vuoi!)

Risposta:

Px:J,tLtP09JsX8x

Questo codice utilizza le variabili predefinite t= 10 e s= spazio.

    ,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, incrinato da kennytm

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

(E sì, tutto l'output è su STDOUT.)

Soluzione prevista:

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

TI-BASIC ( crackato da Thomas Kwa )

Variante TI-89
Gamma: ≤8
Lunghezza uscita: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

Non credo che tu possa usare RIES su questo, ma dubito che sopravviverà comunque 7 giorni. Oh bene.

Codice:

236!

MATLAB, incrinato da Tom Carpenter

Intervallo <= 16

ans =

        5760       22320
       13920       53940

Mathematica, crackato da Sp3000

Intervallo: <= 32

808017424794512875886459904961710757005754368000000000

Quindi - <= 64 byte, incrinato dall'istocratico.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

Sono i 5 del 2016; a proposito.

CJam, ≤8 (sicuro)

\"3.341594\43181\

Codice originale:

P`_`_`er

Cioè, per iniziare 3.141592653589793e sostituire ogni personaggio "3.141592653589793"con il personaggio corrispondente in "\"3.141592653589793\"". Con i duplicati rimossi, si sta effettivamente sostituendo ".123456789con ""35\.49831.

Python 2 (sicuro 16)

(1.06779146638-0.024105112278j)

Intervallo ≤ 16. Nel caso in cui la versione sia importante (per la precisione di stampa?), Sto usando ideone .

Non vedo un modo per indovinare il codice senza la ricerca al computer, ma tutti voi mi avete già colpito.

Risposta:

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

JavaScript ES6, ≤128 byte - Incrinato

Uscita (1124 byte):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Buon divertimento e buona fortuna!

Codice originale:

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

TI-BASIC (crackato da Thomas Kwa)

Intervallo: <= 2

Corda: -10

Codice: Xmin

Non c'è proprio da scherzare con questo ragazzo ...

AppleScript, ≤ 2 byte crackati

"Bruto forzato ... brontolare brontolare ..."

Che cos'è questo? Una breve risposta AppleScript? : o

valore mancante

(si, stampa su stdout)

> <> (Pesce) , Incrinato di Sp3000

Lunghezza <= 8

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

L'output è di 23 >'e il programma non produce errori.

GolfScript (sicuro)

44460233687688399109436699097976761322375660878906252846699686946304

Intervallo ≤ 8

Soluzione

{9?7*}.%

Provalo online.

Come funziona

• {9?7*} spinge quel blocco in pila.

• .% duplica il blocco e lo mappa ... su se stesso.

  GolfScript esegue il casting del tipo come se non ci fosse un domani. In questo caso, l'interprete si aspetta un iterabile, quindi il blocco originale viene castato in array, producendo il seguente array di codici carattere: [57 63 55 42] .

• Il blocco stesso eleva ciascun codice di carattere alla nona potenza ( 9?), quindi moltiplica il risultato per sette (7* ).

  Per i quattro codici di caratteri nella matrice, questo spinge

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Prima di uscire, l'interprete stampa i quattro numeri interi, senza separatori.