O tópico dos ladrões pode ser encontrado aqui: The Mystery String Printer (Robbers)

Seu desafio

• Escreva um programa, função ou script REPL que imprima uma string em STDOUT.
• Os ladrões tentarão criar um programa que imprima a mesma string.
• Se eles conseguirem criar o programa dentro de 7 dias, seu envio será quebrado.
• Se ninguém puder criar um programa que imprima a mesma sequência dentro de sete dias, seu envio estará seguro. Você pode revelar seu programa ou deixá-lo para desafiar futuros ladrões. No entanto, se você não o revelar, não poderá obter pontos do seu envio (não coloque "seguro" no cabeçalho da resposta se optar por fazer isso).

Restrições

• O programa deve ser menor ou igual ao total de 128 bytes (mais sobre isso posteriormente).
• Se o programa depender do nome do programa ou do nome / conteúdo de um arquivo externo, você deve dizer que o faz e incluir isso na contagem total de bytes.
• A sequência impressa deve ser menor ou igual a 2048 bytes.
• A sequência impressa deve consistir apenas em caracteres ASCII imprimíveis (novas linhas podem ser incluídas).
• O programa deve produzir a mesma saída toda vez que é executado.
• Primitivas criptográficas incorporadas (inclui rng, criptografia, descriptografia e hash) não são permitidas.
• O programa não deve receber entrada.
• Sem brechas padrão.

Pontuação

• Se um envio for quebrado antes de sete dias, ele receberá 0 pontos.
• Um envio seguro de ≤128 caracteres ganha 1 ponto.
• Um envio seguro de ≤ 64 caracteres ganha 2 pontos. Se for menor ou igual a 32 bytes, ele ganha 4 pontos e assim por diante.
• Cada envio seguro também ganha um bônus adicional de 3 pontos (independente do comprimento).
• Existe uma pequena penalidade (1/2 ponto) para cada rachadura após a sua primeira.
• Observe que a solução do ladrão deve estar no mesmo intervalo de tamanhos de programa.
• Cada pessoa pode enviar no máximo 1 programa por intervalo de bytes por idioma (versões diferentes e substituições arbitrárias do mesmo idioma não contam como idiomas separados). Exemplo: você pode publicar um programa de 32 bytes e 64 bytes, mas não pode publicar um programa de 128 bytes no Java 7 e Java 8.
• A pessoa com o total de pontos mais alto ganha.

Submissões

Cada envio deve ter as seguintes informações:

• O nome do idioma. Todas as soluções de novos ladrões devem ter o mesmo idioma.
• O intervalo do tamanho do programa (esse é o poder mais próximo de dois acima do tamanho do programa; por exemplo, se o seu programa tiver 25 bytes, isso seria "≤32").
• A sequência real a ser impressa.
• Se um envio for seguro, coloque "safe" e a duração do programa (no máximo 2) no cabeçalho. Se houver vários números no seu cabeçalho, coloque a potência de 2 por último.

Esse snippet de pilha gera tabelas de classificação e lista todos os envios abertos. Se houver algum problema com o trecho, deixe um comentário.

/* Configuration */

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

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


/* App */

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



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

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

function getAnswers() {

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

}

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

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

      });

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

getAnswers();


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

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

function process() {

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



  answers.forEach(function(a) {

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

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

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

    // if (SUBTRACTCRACKEDPOINTS||!cracked) {

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

    var expired = createDate > (EXPIREDTIME);

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

    isOpen = !(cracked || safe);

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



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

    }

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

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



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


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

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

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

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

  });

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

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



  pointTotals.forEach(function(a) {


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


  });



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



}

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

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

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

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

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

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

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

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


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

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

Use os seguintes formatos para entradas:

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

ou

Language
=
Length <= 16

Observe que o snippet só colocará a primeira palavra no cabeçalho como idioma se não detectar uma vírgula.

Para envios seguros, coloque-os em seu cabeçalho. O snippet colocará automaticamente o seu programa na coluna "seguro" se o tempo expirar; portanto, isso significa mais para qualquer ladrão que seu programa está seguro.

Para envios rachados, coloque rachados no cabeçalho.

O programa também deve ser capaz de reconhecer se um comentário diz "rachado" e tem um link; no entanto, isso não é garantido.

Ordem de desempate: Pontos -> # de envios seguros -> Menor quantidade de envios rachados.

Observe que o snippet classifica por envios abertos antes que sejam menos rachados, mas os envios abertos não serão contados no final do concurso.

Este desafio está encerrado.

Vencedor geral com mais pontos: Dennis

Envios mais seguros: DLosc

(Observe que o número de envios seguros não se traduz em um valor em pontos, pois o tamanho dos programas é considerado no cálculo da pontuação).

Pitão, Seguro, Alcance ≤ 8

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

O código:

%^T6`^G5

Explicação:

Para esclarecer como isso funciona: gerei todas as sequências de cinco caracteres possíveis com letras minúsculas ( ^G5). Então, eu gerei a representação em string desta lista: ( `^G5). Por fim, peguei cada 1.000.000 de caracteres dessa lista ( %^T6). O resultado é algo que se parece com uma lista de seqüências de caracteres, mas suspeita estar faltando seu colchete final.

VBA, [Seguro]

Intervalo <= 128 bytes

Dica para onde produzir

Executado no Excel 2007, a saída foi para Debug.print. Sua boa sorte no VBA é conseguir qualquer coisa abaixo de 128 bytes para executar.

Saída 255 bytes

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

Solução

Bem, espero que alguém tenha se divertido tentando quebrar esse. Posso dizer que este é um dos piores erros de manipulação que já fiz e me sinto mal pelo quão ruim é esse código.

Código

    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'

Explicado

Primeiro, o código começa com um dos principais pecados do VBA. On Error Resume next.
Uma vez que cometemos esse ato horrível, seguimos em frente e apenas cometemos erros. este é o This array is fixed or temporarily lockederro que veremos em breve na saída.

O próximo é o loop. Fazemos um loop de 128 vezes, tentando converter a descrição do erro, mas as únicas entradas válidas para i are 1,2,3,64,128. Por esse motivo, os 4 primeiros loops imprimem o erro com vários formatos. Então, quando i = 4o código lança um novo erro, Invalid callisso é repetido e nada é atribuído, bporque a strconvfunção gera erros a cada vez.

É aqui que qualquer programa normal deveria ter parado, mas porque On Error Resume Nexttodos os erros são ignorados e o código continua imperturbável pela má manipulação de erros.

Agora, pressionamosi=32e adicionamos o novo erro a ser bconvertido para Unicode e, em seguida, continuamos repetindo até i = 128que convertemos o erro FROM Unicode, que resulta na ?????????????????inclusão da string em b

Finalmente, imprima a bagunça dos erros que concatenamos juntos

Mathematica, seguro, intervalo ≤ 64

Resultado:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Fonte:

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

ngn APL (seguro)

0.675640430319848J0.8376870144941628

Intervalo ≤ 8

Solução

*3○⍟⍣=42

Experimente online.

Como funciona

• ⍟⍣=42aplica logaritmo natural ( ⍟) repetidamente a 42 até que um ponto fixo seja alcançado ( ⍣=), resultando em 0,31813150520476413J1,3372357014306895 .

  O valor inicial realmente não importa aqui, desde que não seja 1 nem 0 .

• 3○aplica-se tangente ao seu argumento correto, produzindo 0,07343765001657206J0,8920713530605129 .

• * aplica a função exponencial natural ao seu argumento correto, produzindo a saída desejada.

Pyth, quebrado por Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Intervalo ≤ 8

> <> (Seguro)

Testado nos intérpretes online e oficiais.

Intervalo: <= 16

Corda: 4621430504113348052246441337820019217490490

Isso é bonito 1337, hein?

Explicação:

Aqui está o código fonte (15 bytes):

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

fempurra 15 (nosso contador) para a pilha (isso é ignorado !no final para não empurrar mais de um contador)

1- subtrai 1 do balcão

:0(?; O rosto carrancudo testa se o contador é menor que 0, o restante termina o programa se estiver

:: Duplica o contador duas vezes

0gAgarra o caractere no ponto (c,0)do código-fonte onde cestá o contador

* Multiplica a segunda duplicata do contador pela representação ASCII do personagem anteriormente obtido.

n Imprime o resultado.

Então, divida, a saída é [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0] . Isso corresponde à interpretação ASCII do código em sentido inverso multiplicado pelos números 14 a 0 (ie [!*14, n*13, ... f*0]).

Provavelmente, a parte mais difícil de quebrar isso seria descobrir como dividir os números corretamente, mas se você obtiver os números corretos, é apenas uma questão de tentar as coisas até obter algo que funcione.

Snowman 1.0.2

Faixa ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

A solução é:

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

Matlab, ≤16. Rachado por Wauzl

Alcance ≤16 .

Isso funciona no Octave também.

A sequência impressa é a seguinte:

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

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Faixa ≤ 32

Solução

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

Experimente online.

Como funciona

• for-951..1048 executa o comando anterior para cada número inteiro nesse intervalo, salvando-o na variável implícita.

• y/124589// realiza transliteração, eliminando os dígitos especificados da variável implícita.

  y/// retornará o número de eliminações, ou seja, o número de ocorrências desses dígitos na variável implícita.

• print 2**imprime 2 com o poder de eliminações ( 1 , 2 , 4 ou 8 ).

Python, <= 16 ( quebrado por kennytm )

[[[22111101102001]]]

Isso foi produzido via REPL (executando um comando no shell do Python).

Enquanto estiver editando isso, também resumirei os comentários para futuros ladrões sem spoilers: isso não funciona em todos os Pythons. Ele funciona em uma compilação do Python 2.7, onde sys.maxint = 9223372036854775807.

> <> , ≤ 8 [ rachado ]

oooooooooooo

Isso é um total de 12 os. O programa é interrompido sem erros e funciona com o intérprete oficial e o intérprete online .

TI-BASIC, ≤4 bytes, quebrado por Reto Koradi

Demorou 5 dias e 23 horas para quebrar. Tão perto...

Saída (10 bytes):

.495382547

Programa:

³√(tanh(7°

Como é basicamente impossível alguém adivinhar isso, meu objetivo ao projetar esse programa era tornar a força bruta a única abordagem possível.

Para fazer isso, impedi que a saída, ou a saída com uma dessas funções inversas aplicadas, aparecesse no ISC. O ISC não possui tangente hiperbólica, e imaginei que nenhuma ferramenta semelhante teria tanh(7°.

Para adicionar um pouco de segurança contra a força bruta, usei a conversão grau a radiano, um recurso um pouco obscuro, mas não era suficiente.

CJam, ≤ 8 [seguro]

379005901358552706072646818049622056

Eu não gosto de números longos, então aqui está um número curto. Sinta-se livre para mexer offline e online .

Como acho que as submissões apenas por número são bastante entediantes, vou apresentar algumas dicas lentamente para compensar.

Dica 1: O programa termina com um único número da pilha e nenhuma das A-Kvariáveis ​​é usada.
Dica 2: O número codifica informações que são completamente recuperáveis ​​se você reverter o processo (ou seja, nenhuma informação foi perdida).
Dica 3: As "informações" da dica 2 são uma sequência única criada após os quatro primeiros caracteres.

Solução

O programa foi

0W#sWcib

0W#é 0^-1, que em vez de errar dá Infinity. sem seguida, lança isso em uma string (observe que ele `fornece 1d0/).

Na outra metade, Wcconverte -1 em um caractere, que se torna o ponto de código 65535 devido à abrangência dos caracteres (consulte esta dica ). idepois converte o char de volta para um int, ou seja, 65535.

Por fim, bconverte a string Infinityna base 65535 para fornecer o número acima.

Javascript (console), <= 32 ( quebrado por insertusernamehere )

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

Testado nos consoles da web Chrome e Firefox. Essa é uma sequência de 43 caracteres.

Minha solução pretendida era um pouco mais elaborada que a vinculada (maldição, ES6!).

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

Explicação:

Quando você chama replaceuma Expressão Regular com o /gsinalizador e uma função, ele substitui tudo o que corresponde à regex pelo resultado da chamada da função com os seguintes argumentos: A sequência correspondida, cada grupo de captura na sequência correspondida, o índice que a sequência correspondente possui toda a cadeia e toda a cadeia. Nesse caso, serão "a", "a", 0 ou 4 ou 6 e "a, b, a, a". Todos esses argumentos são passados ​​para o construtor Array, que simplesmente cria uma matriz de tudo o que é passado. Em seguida, replaceconverte isso em uma string, por exemplo, "a, a, 0, a, b, a, a" e substitui o "a" personagem com ele.

Python, <= 32 ( rachado por Egor Skriptunoff)

A saída é 1832 bytes, incluindo novas linhas:

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 ( rachado por Dennis)

Comprimento <= 4

1737589973457545958193355601

Eu não dou uma chance muito alta de sobrevivência, mas eu queria tentar uma solução de 4 bytes de qualquer maneira.

Meu código foi exatamente o que Dennis fez engenharia reversa:

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

O CJam imprime todo o conteúdo da pilha, concatenado. Portanto, a saída foi 17concatenada com 19^20.

Lua, ≤ 4 ( rachado por feersum)

Resultado:

9.5367431640625e-07

Você precisa encontrar uma string para Lua REPL que resulte na constante "1 / M".
É simples, mas não muito trivial.

Pip , <= 16 (seguro)

Esta é a minha submissão final ao Pip, prometo. :)

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

Ficarei surpreso se alguém baixar isso em 16 bytes - levei algumas tentativas para ajustá-lo. (Aceite isso como um desafio, se quiser!)

Responda:

Px:J,tLtP09JsX8x

Este código utiliza as variáveis ​​predefinidas t= 10 e s= espaço.

    ,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, quebrado por kennytm

Faixa: ≤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 sim, toda saída é para STDOUT.)

Solução pretendida:

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

TI-BASIC ( rachado por Thomas Kwa )

Variante TI-89
Faixa: ≤8
Comprimento da saída: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

Eu não acho que você possa usar o RIES nisso, mas duvido que ele sobreviva 7 dias de qualquer maneira. Ah bem.

Código:

236!

MATLAB, rachado por Tom Carpenter

Intervalo <= 16

ans =

        5760       22320
       13920       53940

Mathematica, Rachado por Sp3000

Intervalo: <= 32

808017424794512875886459904961710757005754368000000000

Terça - <= 64 bytes, quebrada pelo histocrata.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

Isso é 2016 5s; a propósito.

CJam, ≤8 (seguro)

\"3.341594\43181\

Código original:

P`_`_`er

Ou seja, para começar com 3.141592653589793e substituir cada personagem "3.141592653589793"com o personagem correspondente "\"3.141592653589793\"". Com as duplicatas removidas, é realmente substituir ".123456789com ""35\.49831.

Python 2 (seguro 16)

(1.06779146638-0.024105112278j)

Intervalo ≤ 16. Caso a versão seja importante (para precisão de impressão?), Estou usando ideona .

Não vejo uma maneira de adivinhar o código sem a pesquisa no computador, mas todos vocês me impressionaram antes.

Responda:

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

JavaScript ES6, ≤128 bytes - Rachado

Saída (1124 bytes):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Divirta-se e boa sorte!

Código original:

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

TI-BASIC (rachado por Thomas Kwa)

Intervalo: <= 2

Corda: -10

Código: Xmin

Não há como enganar esse cara ...

AppleScript, ≤ 2 bytes rachado

"Bruto forçado ... resmungar resmungar ..."

O que é isso? Uma resposta AppleScript curta? : o

valor ausente

(sim, isso NÃO imprime em stdout)

> <> (Peixe) , Rachado por Sp3000

Comprimento <= 8

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

A saída é 23 >'s e o programa não produz erros.

GolfScript (seguro)

44460233687688399109436699097976761322375660878906252846699686946304

Intervalo ≤ 8

Solução

{9?7*}.%

Experimente online.

Como funciona

• {9?7*} empurra esse bloco na pilha.

• .% duplica o bloco e mapeia ... sobre si mesmo.

  O GolfScript realiza a conversão de tipos como se não houvesse amanhã. Nesse caso, o intérprete espera um iterável, para que o bloco original seja convertido em array, produzindo a seguinte matriz de códigos de caracteres: [57 63 55 42] .

• O próprio bloco eleva cada código de caractere à nona potência ( 9?) e multiplica o resultado por sete ( 7*).

  Para os quatro códigos de caracteres na matriz, isso empurra

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Antes de sair, o intérprete imprime os quatro números inteiros, sem separadores.