El hilo de ladrones se puede encontrar aquí: The Mystery String Printer (Robbers)

Tu reto

• Escriba un programa, función o script REPL que imprima una cadena en STDOUT.
• Los ladrones intentarán crear un programa que imprima la misma cadena.
• Si pueden crear el programa con éxito dentro de los 7 días, su envío está agrietado.
• Si nadie puede crear un programa que imprima la misma cadena en 7 días, su envío es seguro. Puedes elegir revelar tu programa o dejarlo para desafiar a futuros ladrones. Sin embargo, si no lo revela, no puede obtener ningún punto de su envío (no ponga "seguro" en su encabezado de respuesta si elige hacer esto).

Restricciones

• El programa debe ser menor o igual a 128 bytes en total (más sobre esto más adelante).
• Si el programa depende del nombre del programa o del nombre / contenido de un archivo externo, debe decir que lo hace e incluirlo en su recuento total de bytes.
• La cadena impresa debe ser menor o igual a 2048 bytes.
• La cadena impresa debe constar solo de caracteres ASCII imprimibles (se pueden incluir nuevas líneas).
• El programa debe producir la misma salida cada vez que se ejecuta.
• No se permiten primitivas criptográficas incorporadas (incluye ningún rng, cifrado, descifrado y hash).
• El programa no debe tomar entrada.
• No hay lagunas estándar.

Puntuación

• Si un envío se agrieta antes de los siete días, el envío gana 0 puntos.
• Una presentación segura de ≤128 caracteres gana 1 punto.
• Una presentación segura de ≤64 caracteres gana 2 puntos. Si es menor o igual a 32 bytes, gana 4 puntos, y así sucesivamente.
• Cada envío seguro también gana una bonificación adicional de 3 puntos (independientemente de la duración).
• Hay una pequeña penalización (1/2 punto) por cada grieta después de la primera.
• Tenga en cuenta que la solución del ladrón debe estar en el mismo rango de duración del programa.
• Cada persona puede enviar un máximo de 1 programa por rango de bytes por idioma (diferentes versiones y sustituciones arbitrarias del mismo idioma no cuentan como idiomas separados). Ejemplo: puede publicar un programa pyth de 32 bytes y 64 bytes, pero no puede publicar un programa de 128 bytes en Java 7 y Java 8.
• La persona con el puntaje total más alto gana.

Envíos

Cada presentación debe tener la siguiente información:

• El nombre del idioma. Todas las soluciones de nuevos ladrones deben ser del mismo idioma.
• El rango del tamaño del programa (esta es la potencia más cercana de dos mayor que el tamaño del programa; por ejemplo, si su programa es de 25 bytes, esto sería "≤32").
• La cadena real que se imprimirá.
• Si un envío es seguro, ponga "seguro" y la longitud del programa (a la potencia más cercana de 2) en su encabezado. Si hay varios números en su encabezado, ponga la potencia de 2 al final.

Este fragmento de pila genera tablas de clasificación y enumera todas las presentaciones abiertas. Si hay algún problema con el fragmento, deje un comentario.

/* 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 los siguientes formatos para las entradas:

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

o

Language
=
Length <= 16

Tenga en cuenta que el fragmento solo colocará la primera palabra en el encabezado como idioma si no detecta una coma.

Para envíos seguros, ponga seguro en su encabezado. El fragmento colocará automáticamente su programa en la columna "segura" si el tiempo ha expirado, por lo que esto es más para decirle a los ladrones que su programa es seguro.

Para envíos agrietados, ponga agrietado en su encabezado.

El programa también debería poder reconocer si un comentario dice "agrietado" y tiene un enlace; Sin embargo, esto no está garantizado.

Orden de desempate: Puntos -> # de envíos seguros -> Cantidad mínima de envíos agrietados.

Tenga en cuenta que el fragmento se clasifica por envíos abiertos antes de que se agrieten, pero los envíos abiertos no se contarán al final del concurso.

Este desafío ahora está cerrado.

Ganador general con más puntos: Dennis

Envíos más seguros: DLosc

(Tenga en cuenta que la cantidad de envíos seguros no se traduce en una cantidad de puntos, ya que el tamaño de los programas se considera al calcular la puntuación).

Pyth, seguro, rango ≤ 8

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

El código:

%^T6`^G5

Explicación:

Para aclarar cómo funciona esto: generé todas las posibles cadenas de 5 caracteres de letras minúsculas ( ^G5). Luego, generé la representación de cadena de esta lista: ( `^G5). Finalmente, tomé cada carácter 1,000,000 de esa lista ( %^T6). El resultado es algo que parece una lista de cadenas, pero sospechosamente le falta su corchete final.

VBA, [Seguro]

Rango <= 128 bytes

Sugerencia de dónde salir

Ejecutado en Excel 2007, la salida fue a Debug.print. Es buena suerte que VBA obtenga algo menos de 128 bytes para ejecutarse.

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

Solución

Bueno, espero que alguien se haya divertido intentando descifrar este. Puedo decir que este es uno de los peores errores de manejo que he hecho y me siento mal por lo malo que es este 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

Primero, el código comienza con uno de los principales pecados de VBA. On Error Resume next.
Una vez que hemos cometido ese horrible acto, seguimos adelante y simplemente lanzamos y cometemos un error. Este es el This array is fixed or temporarily lockederror que pronto veremos en la salida.

El siguiente es el bucle. Hacemos un bucle 128 veces tratando de convertir la descripción del error, pero las únicas entradas válidas para i are 1,2,3,64,128. Debido a esto, los primeros 4 bucles imprimen el Error con varios formatos. Luego, cuando i = 4el código arroja un nuevo error, Invalid callentonces se repite y no se asigna nada bporque la strconvfunción falla cada vez.

Aquí es donde cualquier programa normal debería haberse detenido, pero debido a que On Error Resume Nexttodos los errores se ignoran y el código continúa sin inmutarse por el mal manejo de errores

Ahora golpeamosi=32y agregamos el nuevo error para bconvertirlo a Unicode y luego continuamos haciendo un bucle hasta i = 128el punto en que convertimos nuestro error de Unicode, lo que resulta en que la ?????????????????cadena se agregue a b

Finalmente imprima el desorden de errores que hemos concatenado juntos

Mathematica, seguro, rango ≤ 64

Salida:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Fuente:

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

ngn APL (seguro)

0.675640430319848J0.8376870144941628

Rango ≤ 8

Solución

*3○⍟⍣=42

Pruébalo en línea.

Cómo funciona

• ⍟⍣=42aplica el logaritmo natural ( ⍟) repetidamente a 42 hasta que se alcanza un punto fijo ( ⍣=), produciendo 0.31813150520476413J1.3372357014306895 .

  El valor inicial realmente no importa aquí, siempre que no sea ni 1 ni 0 .

• 3○aplica tangente a su argumento correcto, produciendo 0.07343765001657206J0.8920713530605129 .

• * aplica la función exponencial natural a su argumento correcto, produciendo el resultado deseado.

Pyth, agrietado por Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Rango ≤ 8

> <> (Seguro)

Probado en los intérpretes en línea y oficiales.

Rango: <= 16

Cuerda: 4621430504113348052246441337820019217490490

Esto es bonito 1337, ¿eh?

Explicación:

Aquí está el código fuente (15 bytes):

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

fempuja 15 (nuestro contador) en la pila (esto se omite !al final para no empujar más de un contador)

1- resta 1 del mostrador

:0(?; La cara fruncida prueba si el contador es menor que 0, el resto finaliza el programa si es

:: Duplica el contador dos veces

0gToma el carácter en el punto (c,0)del código fuente donde cestá el contador

* Multiplica el segundo duplicado del contador por la representación ASCII del personaje previamente capturado

n Imprime el resultado.

Entonces, dividido, la salida es [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. Esto corresponde a la interpretación ASCII del código en reversa multiplicado por los números 14 a 0 (es decir [!*14, n*13, ... f*0]).

Probablemente la parte más difícil de resolver esto sería descubrir cómo dividir los números correctamente, pero si obtienes los correctos, solo es cuestión de probar cosas hasta que obtengas algo que funcione.

Muñeco de nieve 1.0.2

Rango ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

La solucion es:

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

Matlab, ≤16. Agrietado por Wauzl

Rango ≤16 .

Esto también funciona en Octave .

La cadena impresa es la siguiente:

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

Rango ≤ 32

Solución

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

Pruébalo en línea.

Cómo funciona

• for-951..1048 ejecuta el comando anterior para cada número entero en este rango, guardándolo en la variable implícita.

• y/124589// realiza la transliteración, eliminando los dígitos especificados de la variable implícita.

  y/// devolverá el número de eliminaciones, es decir, el número de ocurrencias de esos dígitos en la variable implícita.

• print 2**imprime 2 al poder de las eliminaciones ( 1 , 2 , 4 u 8 ).

Python, <= 16 ( descifrado por kennytm )

[[[22111101102001]]]

Esto se produjo a través de REPL (ejecutando un comando en Python shell).

Mientras estoy editando esto, también resumiré los comentarios para futuros ladrones libres de spoilers: esto no funciona en todas las pitones. Funciona en una compilación de Python 2.7 donde sys.maxint = 9223372036854775807.

> <> , ≤ 8 [ agrietado ]

oooooooooooo

Eso es un total de 12 os. El programa se detiene sin error y funciona tanto con el intérprete oficial como con el intérprete en línea .

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

Esto tardó 5 días 23 horas en agrietarse. Tan cerca...

Salida (10 bytes):

.495382547

Programa:

³√(tanh(7°

Dado que es básicamente imposible que alguien adivine esto, mi objetivo al diseñar este programa era hacer de la fuerza bruta el único enfoque posible.

Para hacer esto, evité que la salida, o la salida con una de estas funciones inversas aplicadas, apareciera en el ISC. ISC no tiene una tangente hiperbólica, y pensé que ninguna herramienta similar tendría tanh(7°.

Para agregar algo de seguridad contra la fuerza bruta, utilicé la conversión de grado a radianes, una característica ligeramente oscura, pero no fue suficiente.

CJam, ≤ 8 [seguro]

379005901358552706072646818049622056

No me gustan los números largos, así que aquí hay uno corto. Siéntase libre de tocar el violín fuera de línea y en línea .

Como considero que las presentaciones solo con números son bastante aburridas, poco a poco voy a poner algunas pistas para compensar.

Sugerencia 1: el programa termina con un solo número de la pila y no A-Kse utiliza ninguna de las variables.
Sugerencia 2: el número codifica información que es completamente recuperable si invierte el proceso (es decir, no se ha perdido información).
Sugerencia 3: La "información" de la sugerencia 2 es una cadena única que se crea después de los primeros cuatro caracteres.

Solución

El programa fue

0W#sWcib

0W#es decir 0^-1, que en lugar de equivocarse da Infinity. sluego lanza esto a una cadena (nota que `da en su 1d0/lugar).

Para la otra mitad, Wcconvierte -1 en un carácter, que se convierte en el punto de código 65535 debido a la envoltura de caracteres (consulte este consejo ). iluego convierte el carácter nuevamente a un int, es decir, 65535.

Finalmente, bconvierte la cadena Infinitya la base 65535 para dar el número anterior.

Javascript (consola), <= 32 ( descifrado por insertusernamehere )

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

Probado en consolas web Chrome y Firefox. Esa es una cadena de 43 caracteres.

Mi solución prevista era un poco más elaborada que la vinculada (¡maldito sea, ES6!).

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

Explicación:

Cuando llama replacecon una expresión regular con el /gindicador y una función, reemplaza todo lo que coincide con la expresión regular con el resultado de llamar a la función con estos argumentos: la cadena coincidente, cada grupo de captura en la cadena coincidente, el índice que tiene la cadena coincidente en toda la cadena y toda la cadena. En este caso, será "a", "a", 0 o 4 o 6, y "a, b, a, a". Todos estos argumentos se pasan al constructor Array, que simplemente crea una matriz de todo lo que se pasa. Luego lo replaceconvierte en una cadena, por ejemplo, "a, a, 0, a, b, a, a" y reemplaza el "a" personaje con ella.

Python, <= 32 ( agrietado por Egor Skriptunoff)

La salida es de 1832 bytes, incluidas las nuevas líneas:

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

Longitud <= 4

1737589973457545958193355601

No le doy a este una posibilidad muy alta de supervivencia, pero de todos modos quería probar una solución de 4 bytes.

Mi código fue exactamente lo que Dennis realizó en ingeniería inversa:

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

CJam luego imprime todo el contenido de la pila, concatenado. Entonces la salida se 17concatenó con 19^20.

Lua, ≤ 4 ( agrietado por feersum)

Salida:

9.5367431640625e-07

Necesita encontrar una cadena para Lua REPL que resulte en la constante "1 / M".
Es simple, pero no muy trivial.

Pip , <= 16 (seguro)

Esta es mi presentación final de Pip, lo prometo. :)

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

Me sorprendería si alguien reduce esto a 16 bytes, me tomó varios intentos para que encajara. (¡Toma eso como un desafío si quieres!)

Responder:

Px:J,tLtP09JsX8x

Este código hace uso de las variables predefinidas t= 10 y s= espacio.

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

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

(Y sí, toda la salida es STDOUT).

Solución prevista:

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

TI-BASIC ( descifrado por Thomas Kwa )

Variante TI-89
Rango: ≤8
Longitud de salida: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

No creo que pueda usar RIES en esto, pero dudo que sobrevivirá 7 días de todos modos. Oh bien.

Código:

236!

MATLAB, roto por Tom Carpenter

Rango <= 16

ans =

        5760       22320
       13920       53940

Mathematica, agrietado por Sp3000

Rango: <= 32

808017424794512875886459904961710757005754368000000000

Jue - <= 64 Bytes, descifrado por el histocrat.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

Eso es 2016 5s; por cierto.

CJam, ≤8 (seguro)

\"3.341594\43181\

Código original:

P`_`_`er

Es decir, para comenzar 3.141592653589793y reemplazar cada carácter "3.141592653589793"con el carácter correspondiente en "\"3.141592653589793\"". Con los duplicados eliminados, en realidad se está reemplazando ".123456789con ""35\.49831.

Python 2 (seguro 16)

(1.06779146638-0.024105112278j)

Rango ≤ 16. En caso de que la versión importe (¿para precisión de impresión?), Estoy usando ideone .

No veo una forma de adivinar el código sin la búsqueda por computadora, pero todos ustedes me han impresionado antes.

Responder:

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

JavaScript ES6, ≤128 bytes - Agrietado

Salida (1124 bytes):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

¡Diviértete y buena suerte!

Código original:

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

TI-BASIC (descifrado por Thomas Kwa)

Rango: <= 2

Cuerda: -10

Código: Xmin

Simplemente no hay que engañar a este tipo ...

AppleScript, ≤ 2 bytes agrietados

"Bruto forzado ... gruñido gruñido ..."

¿Qué es esto? ¿Una respuesta corta de AppleScript? : o

valor que falta

(sí, esto se imprime en stdout)

> <> (Pez) , Agrietado por Sp3000

Longitud <= 8

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

La salida es de 23 >y el programa no produce ningún error.

GolfScript (seguro)

44460233687688399109436699097976761322375660878906252846699686946304

Rango ≤ 8

Solución

{9?7*}.%

Pruébalo en línea.

Cómo funciona

• {9?7*} empuja ese bloque en la pila.

• .% duplica el bloque y lo mapea ... sobre sí mismo.

  GolfScript realiza la conversión de tipos como si no hubiera un mañana. En este caso, el intérprete espera un iterable, por lo que el bloque original se convierte en matriz, produciendo la siguiente matriz de códigos de caracteres: [57 63 55 42] .

• El bloque en sí eleva cada código de caracteres al noveno poder ( 9?), luego multiplica el resultado por siete ( 7*).

  Para los cuatro códigos de caracteres en la matriz, esto empuja

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Antes de salir, el intérprete imprime los cuatro enteros, sin separadores.