Le fil des voleurs peut être trouvé ici: L'imprimante à cordes mystère (Robbers)

Votre challenge

• Ecrivez un programme, une fonction ou un script REPL qui imprime une chaîne sur STDOUT.
• Les voleurs vont essayer de créer un programme qui imprime la même chaîne.
• S'ils réussissent à créer le programme dans les 7 jours, votre soumission est fissurée.
• Si personne ne peut créer un programme imprimant la même chaîne dans les 7 jours, votre soumission est sécurisée. Vous pouvez choisir de révéler votre programme ou de le laisser pour lancer un défi aux futurs voleurs. Cependant, si vous ne le révélez pas, vous ne pourrez obtenir aucun point de votre soumission (ne mettez pas "safe" dans l'en-tête de votre réponse si vous choisissez de le faire).

Restrictions

• Le programme doit être inférieur ou égal à 128 octets au total (plus d'informations à ce sujet ultérieurement).
• Si le programme dépend du nom du programme ou du nom / du contenu d'un fichier externe, vous devez le dire et l'inclure dans votre nombre total d'octets.
• La chaîne imprimée doit être inférieure ou égale à 2048 octets.
• La chaîne imprimée doit être composée uniquement de caractères ASCII imprimables (de nouvelles lignes peuvent être incluses).
• Le programme doit produire le même résultat à chaque exécution.
• Les primitives cryptographiques intégrées (y compris tous les rng, cryptages, décryptages et hachages) ne sont pas autorisées.
• Le programme ne doit pas prendre d’entrée.
• Aucune échappatoire standard.

Notation

• Si une soumission est fissurée avant sept jours, elle gagne 0 point.
• Une soumission sécurisée de ≤128 caractères rapporte 1 point.
• Une soumission sécurisée de ≤64 caractères rapporte 2 points. S'il est inférieur ou égal à 32 octets, il gagne 4 points, et ainsi de suite.
• Chaque soumission sécurisée gagne également un bonus supplémentaire de 3 points (indépendamment de la longueur).
• Il y a une pénalité minuscule (1/2 point) pour chaque fissure après votre première.
• Notez que la solution du voleur doit être dans la même plage de longueurs de programme.
• Chaque personne peut soumettre un maximum de 1 programme par plage d'octets par langue (les versions différentes et les substitutions arbitraires de la même langue ne comptent pas comme des langues séparées). Exemple: vous pouvez publier un programme python de 32 octets et un programme python de 64 octets, mais vous ne pouvez pas publier de programme de 128 octets dans Java 7 et Java 8.
• La personne avec le total de points le plus élevé gagne.

Les soumissions

Chaque soumission doit contenir les informations suivantes:

• Le nom de la langue Toutes les solutions de nouveaux voleurs doivent être le même langage.
• La plage de la taille du programme (il s'agit de la puissance la plus proche de deux fois supérieure à la taille du programme; par exemple, si votre programme est de 25 octets, il s'agirait de "≤32").
• La chaîne réelle à imprimer.
• Si une soumission est sécurisée, inscrivez "safe" et la longueur du programme (à la puissance 2 la plus proche) dans votre en-tête. S'il y a plusieurs numéros dans votre en-tête, mettez la puissance de 2 en dernier.

Cet extrait de pile génère des classements et répertorie toutes les soumissions en cours. S'il y a des problèmes avec l'extrait de code, laissez un commentaire.

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

Utilisez les formats suivants pour les entrées:

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

ou

Language
=
Length <= 16

Notez que l'extrait de code ne mettra le premier mot de l'en-tête que s'il ne détecte pas de virgule.

Pour des soumissions en toute sécurité, mettez le dans l’entête. L'extrait de code mettra automatiquement votre programme dans la colonne "safe" si le temps est écoulé. Par conséquent, il s'agit davantage d'indiquer aux voleurs que votre programme est sécurisé.

Pour les soumissions fissurées, mettez craqué dans votre en-tête.

Le programme devrait également être capable de reconnaître si un commentaire dit "fissuré" et comporte un lien; Cependant, cela n'est pas garanti.

Ordre de départ: Points -> Nombre de soumissions sécurisées -> Moins de soumissions fissurées.

Notez que l'extrait de code trie les soumissions ouvertes avant le moins craqué, mais les soumissions ouvertes ne seront pas comptées à la fin du concours.

Ce défi est maintenant fermé.

Plus grand nombre de points du vainqueur: Dennis

Les soumissions les plus sûres: DLosc

(Notez que le nombre de soumissions sécurisées ne se traduit pas par un nombre de points, car la taille des programmes est prise en compte dans le calcul du score).

Pyth, sûr, plage ≤ 8

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

Le code:

%^T6`^G5

Explication:

Pour clarifier comment cela fonctionne: J'ai généré toutes les chaînes de caractères possibles de 5 lettres minuscules ( ^G5). Ensuite, j'ai généré la représentation sous forme de chaîne de cette liste: ( `^G5). Enfin, j'ai pris chaque 1 000 000e caractère de cette liste ( %^T6). Le résultat est quelque chose qui ressemble à une liste de chaînes, mais manque de manière suspecte de son crochet final.

VBA, [Safe]

Plage <= 128 octets

Astuce pour savoir où sortir

Ran dans Excel 2007, la sortie était à Debug.print. VBA a de la chance d’obtenir un résultat inférieur à 128 octets.

Sortie 255 octets

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

Solution

J'espère que quelqu'un s'est amusé à essayer de déchiffrer celui-ci. Je peux dire que c'est l'une des pires erreurs de traitement des erreurs que je n'ai jamais faites et que je me sens mal à quel point ce code est mauvais.

Code

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

A expliqué

Tout d'abord, le code commence par l'un des péchés majeurs de VBA. On Error Resume next.
Une fois que nous avons commis cet acte horrible, nous allons de l'avant et ne faisons que lancer et erreur. c'est l' This array is fixed or temporarily lockederreur que nous verrons bientôt dans la sortie.

La prochaine est la boucle. Nous boucle 128 fois en essayant de convertir la description de l'erreur, mais les seules entrées valides pour i are 1,2,3,64,128. De ce fait, les 4 premières boucles affichent l’erreur avec différents formats. Ensuite, lorsque i = 4le code génère une nouvelle erreur, elle est Invalid callensuite bouclée et rien n’est assigné bcar la strconvfonction est erronée à chaque fois.

C'est là tout programme normal aurait dû arrêter, mais parce que nous avons la On Error Resume Nexttoute erreur est ignorée et le code continue imperturbable par la mauvaise gestion des erreurs

Maintenant , nous avons touchéi=32et nous ajoutons la nouvelle erreur de bconversion en Unicode, puis continuer en boucle jusqu'à i = 128à quel point nous transformons notre erreur Unicode qui se traduit par la ?????????????????chaîne ajoutés à b

Enfin Imprimer le désordre des erreurs que nous avons concaténés

Mathematica, sûr, plage ≤ 64

Sortie:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

La source:

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

ngn APL (safe)

0.675640430319848J0.8376870144941628

Gamme ≤ 8

Solution

*3○⍟⍣=42

Essayez-le en ligne.

Comment ça fonctionne

• ⍟⍣=42applique le logarithme naturel ( ⍟) à plusieurs reprises jusqu'à 42 jusqu'à atteindre un point fixe ( ⍣=), ce qui donne 0,31813150520476413J1.3372357014306895 .

  La valeur initiale n'a pas vraiment d'importance ici, tant que ce n'est ni 1 ni 0 .

• 3○applique une tangente à son argument de droite, ce qui donne 0,07343765001657206J0.8920713530605129 .

• * applique la fonction exponentielle naturelle à son argument de droite, produisant le résultat souhaité.

Pyth, fissuré par Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Gamme ≤ 8

> <> (Coffre-fort)

Testé sur les interprètes en ligne et officiels.

Plage: <= 16

Chaîne: 4621430504113348052246441337820019217490490

C'est joli 1337, hein?

Explication:

Voici le code source (15 octets):

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

fpousse 15 (notre compteur) sur la pile (ceci est ignoré !à la fin pour ne pas pousser plus d'un compteur)

1- soustrait 1 du comptoir

:0(?; Le visage furieux teste si le compteur est inférieur à 0, le reste termine le programme s'il est

:: Double le comptoir deux fois

0gRécupère le caractère au point (c,0)du code source où se ctrouve le compteur

* Multiplie le deuxième duplicata du compteur par la représentation ASCII du caractère précédemment saisi

n Imprime le résultat.

Donc, diviser, la sortie est [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. Cela correspond à l'interprétation ASCII du code inversé multiplié par les nombres 14 à 0 (c'est-à-dire [!*14, n*13, ... f*0]).

La partie la plus difficile de résoudre ce problème serait probablement de déterminer comment fractionner les chiffres correctement, mais si vous obtenez les bons chiffres, il vous suffit d’essayer jusqu’à ce que vous obteniez quelque chose qui fonctionne.

Bonhomme de neige 1.0.2

Plage ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

La solution est:

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

Matlab, ≤16. Fissuré par Wauzl

Plage ≤16 .

Cela fonctionne aussi dans Octave .

La chaîne imprimée est la suivante:

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 (sûr)

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Gamme ≤ 32

Solution

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

Essayez-le en ligne.

Comment ça fonctionne

• for-951..1048 exécute la commande précédente pour chaque entier de cette plage, en l'enregistrant dans la variable implicite.

• y/124589// effectue la translittération en éliminant les chiffres spécifiés de la variable implicite.

  y/// renverra le nombre d’éliminations, c’est-à-dire le nombre d’occurrences de ces chiffres dans la variable implicite.

• print 2**imprime 2 à la puissance des éliminations ( 1 , 2 , 4 ou 8 ).

Python, <= 16 ( fissuré par kennytm )

[[[22111101102001]]]

Cela a été produit via REPL (en exécutant une commande dans un shell Python).

Pendant que j'édite ceci, je vais également résumer les commentaires des futurs voleurs sans spoiler: cela ne fonctionne pas dans tous les Pythons. Cela fonctionne dans une version de Python 2.7 où sys.maxint = 9223372036854775807.

> <> , ≤ 8 [ fissuré ]

oooooooooooo

C'est un total de 12 os. Le programme s'arrête sans erreur et fonctionne à la fois avec l'interprète officiel et l' interprète en ligne .

TI-BASIC, ≤4 octets, fissuré par Reto Koradi

Cela a pris 5 jours et 23 heures pour craquer. Si proche ...

Sortie (10 octets):

.495382547

Programme:

³√(tanh(7°

Comme il est fondamentalement impossible pour quelqu'un de le deviner, mon objectif était de faire de la force brute la seule approche possible.

Pour ce faire, j'ai empêché l' affichage de la sortie, ou de la sortie avec l'une de ces fonctions inverses , sur l'ISC. ISC n'a pas de tangente hyperbolique, et j'ai pensé qu'aucun outil similaire ne l'aurait tanh(7°.

Pour ajouter un peu de sécurité contre la force brute, j'ai utilisé la conversion de degré en radian, une fonctionnalité légèrement obscure, mais cela ne suffisait pas.

CJam, ≤ 8 [sûr]

379005901358552706072646818049622056

Je n'aime pas les longs chiffres, alors en voici un court. Ne hésitez pas à tripoter à la fois hors ligne et en ligne .

Étant donné que je trouve les soumissions portant uniquement sur des chiffres plutôt ennuyeuses, je vais émettre lentement quelques astuces pour compenser.

Astuce 1: le programme se termine par un seul numéro de la pile et aucune des A-Kvariables n'est utilisée.
Astuce 2: Le nombre code des informations qui sont complètement récupérables si vous inversez le processus (c'est-à-dire qu'aucune information n'a été perdue).
Astuce 3: "l'information" de l'indice 2 est une chaîne unique qui est créée après les quatre premiers caractères.

Solution

Le programme était

0W#sWcib

0W#est 0^-1, qui au lieu d'erreur donne donne Infinity. spuis jette ceci à une chaîne (note qui `donne à la 1d0/place).

Pour l'autre moitié, Wcconvertit -1 en caractère, qui devient le point de code 65535 en raison du bouclage des caractères (voir cette astuce ). iconvertit ensuite le caractère en un entier, c'est-à-dire 65535.

Enfin, bconvertit la chaîne Infinityen base 65535 pour obtenir le numéro ci-dessus.

Javascript (console), <= 32 ( fissuré par insertusernamehere )

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

Testé dans les consoles Web Chrome et Firefox. C'est une chaîne de 43 caractères.

La solution que je visais était un peu plus élaborée que celle liée (vous maudissez, ES6!).

'a, b, a, a'.remplace (/ (a) / g, Tableau)

Explication:

Lorsque vous appelez replaceavec une expression régulière avec l' /gindicateur et une fonction, il remplace tout ce qui correspond à l'expression rationnelle par le résultat de l'appel de la fonction avec les arguments suivants: La chaîne correspondante, chaque groupe de capture de la chaîne correspondante, l'index de la chaîne correspondante la chaîne entière et la chaîne entière. Dans ce cas, ce sera "a", "a", 0 ou 4 ou 6 et "a, b, a, a". Tous ces arguments sont passés dans le constructeur Array, qui crée simplement un tableau de tout ce qui a été passé. replaceConvertit ensuite cela en chaîne, par exemple "a, a, 0, a, b, a," et remplace le "a". personnage avec elle.

Python, <= 32 ( fissuré par Egor Skriptunoff)

La sortie est de 1832 octets, y compris les nouvelles lignes:

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 ( fissuré par Dennis)

Longueur <= 4

1737589973457545958193355601

Je ne lui donne pas une très grande chance de survie, mais je voulais quand même essayer une solution à 4 octets.

Mon code était exactement ce que Dennis inversait:

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

CJam imprime alors tout le contenu de la pile, concaténé. Donc, la sortie a été 17concaténée avec 19^20.

Lua, ≤ 4 ( fissuré par le feersum)

Sortie:

9.5367431640625e-07

Vous devez rechercher une chaîne pour Lua REPL qui génère une constante "1 / M".
C'est simple, mais pas très trivial.

Pip , <= 16 (sûr)

Ceci est ma dernière soumission de Pip, je le promets. :)

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

Je serais surpris que quelqu'un réduise ce nombre à 16 octets - il m'a fallu plusieurs essais pour l'adapter. (Prenez cela comme un défi si vous aimez!)

Répondre:

Px:J,tLtP09JsX8x

Ce code utilise les variables prédéfinies t= 10 et s= space.

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

Ruby, fissuré par Kenny

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

(Et oui, toute la sortie est sur STDOUT.)

Solution envisagée:

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

TI-BASIC ( fissuré par Thomas Kwa )

Variante TI-89
Gamme: ≤8
Longueur de sortie: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

Je ne pense pas que vous puissiez utiliser RIES à cet égard, mais je doute qu’il puisse survivre 7 jours de toute façon. Tant pis.

Code:

236!

MATLAB, fissuré par Tom Carpenter

Plage <= 16

ans =

        5760       22320
       13920       53940

Mathematica, fissuré par Sp3000

Plage: <= 32

808017424794512875886459904961710757005754368000000000

Thue - <= 64 octets, fissuré par l'histocrate.

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

C'est 2016 5s; au fait.

CJam, ≤8 (sûr)

\"3.341594\43181\

Code d'origine:

P`_`_`er

C'est-à-dire, pour commencer 3.141592653589793et remplacer chaque caractère "3.141592653589793"par le caractère correspondant dans "\"3.141592653589793\"". Avec les doublons supprimés, il remplace en fait ".123456789par ""35\.49831.

Python 2 (coffre 16)

(1.06779146638-0.024105112278j)

Plage ≤ 16. Si la version est importante (pour une précision d'impression?), J'utilise idéone .

Je ne vois aucun moyen de deviner le code sans effectuer de recherche sur ordinateur, mais vous m'avez tous impressionné auparavant.

Répondre:

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

JavaScript ES6, ≤128 octets - fissuré

Sortie (1124 octets):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Amuse-toi bien et bonne chance!

Code d'origine:

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

TI-BASIC (fissuré par Thomas Kwa)

Plage: <= 2

Chaîne: -10

Code: Xmin

Il n'y a pas moyen de tromper ce gars ...

AppleScript, ≤ 2 octets fissuré

"Brute forcée ... grommelle grogne ..."

Qu'est-ce que c'est ça? Une courte réponse AppleScript? : o

valeur manquante

(oui, ceci n'imprime que sur la sortie standard)

> <> (Poisson) , fissuré par le Sp3000

Longueur <= 8

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

La sortie est 23 >et le programme ne produit aucune erreur.

GolfScript (safe)

44460233687688399109436699097976761322375660878906252846699686946304

Gamme ≤ 8

Solution

{9?7*}.%

Essayez-le en ligne.

Comment ça fonctionne

• {9?7*} pousse ce bloc sur la pile.

• .% duplique le bloc et le mappe… sur lui-même.

  GolfScript effectue le typage comme s'il n'y avait pas de lendemain. Dans ce cas, l'interpréteur s'attend à une valeur itérable, ainsi le bloc d'origine est converti en tableau, produisant le tableau de codes de caractères suivant: [57 63 55 42] .

• Le bloc lui-même élève chaque code de caractère à la neuvième puissance ( 9?), puis multiplie le résultat par sept ( 7*).

  Pour les quatre codes de caractères du tableau, cela pousse

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  Avant de quitter, l'interprète imprime les quatre nombres entiers, sans séparateurs.