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.

Afficher l'extrait de code

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

Développer l'extrait

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).

kolmogorov-complexity cops-and-robbers Daniel M.
la source

5

Nous devrions rappeler aux flics que la sortie devrait être plus longue que la taille du programme, afin de réduire les solutions triviales telles que codegolf.stackexchange.com/a/60395 et codegolf.stackexchange.com/a/60359

kennytm

2

@bmarks Il doit exister un moyen d'exécuter le langage, lequel doit pouvoir afficher une chaîne de caractères ASCII. Si vous souhaitez utiliser HQ9 +, félicitations, vous venez de recevoir une soumission fissurée.

Daniel M.

3

@bmarks Je ne préférerais pas, mais je ne vais pas vous arrêter.

Daniel M.

15

Toutes les sorties numériques sont super ennuyeuses.

mbomb007

4

S'il vous plaît, envisagez d'utiliser le bac à sable la prochaine fois. De préférence, les règles d'un défi ne devraient pas changer du tout après sa publication. J'ai oublié combien de fois les règles ont changé ici ...

Dennis

20

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.

isaacg
la source

n'y a-t-il pas de fermeture ]?

Maltysen

1

@Maltysen Nope.

isaacg

4

A vu le deuxième élément comme "xCode" brouillé, j'ai pensé qu'il pourrait s'agir d'une liste d'EDI brouillés mais je n'ai pu identifier aucun des autres: o

Albert Renshaw

1

Dur! J'ai trouvé le modèle dans les chaînes, mais je ne sais pas comment le générer avec <= 8 octets.

Fabian Schmengler

16

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

JimmyJazzx
la source

14

Mathematica, sûr, plage ≤ 64

Sortie:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

La source:

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

la source

6

Maintenant, je vais devoir GenomeLookuptout faire ...

LegionMammal978

3

Vraiment! Qu'est-ce qui l'a donné?

2

J'aurais peut-être dû changer les lettres!

1

Lol, avec autant de caractères de répétition et de 64 octets à utiliser, vous pouvez facilement créer une fonction simplement imprimer cette chaîne. xD

Albert Renshaw

4

J'ai ajouté la source. Ce n'est bien sûr PAS quelque chose qui a trait aux génomes, mais plutôt à 80 chiffres de pi en base 4, codés en utilisant "GATC" pour faire penser aux gens en double hélice.

12

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é.

Dennis
la source

La valeur absolue n'est pas tout à fait 1. Intéressant.

lirtosiast

9

Pyth, fissuré par Sp3000

1234465889612101271616181215168242024142718209323236243032163621242510

Gamme ≤ 8

Dennis
la source

Cracked :)

Sp3000

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.

Cole
la source

8

Bonhomme de neige 1.0.2

Plage ≤32.

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

La solution est:

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

Poignée de porte
la source

C'est un langage tellement étrange ... il faut le comprendre avant d'essayer de craquer ...

GamrCorps

3

Presque là ... continue à avoir un segfault 11 cependant ...

GamrCorps

7

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

Luis Mendo
la source

3

Bon travail, j'ai essayé de proposer quelque chose comme ça, mais celui-ci est vraiment sympa, je ne sais vraiment pas comment cela devrait fonctionner =)

flawr

Cracked

Wauzl

7

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 ).

Dennis
la source

7

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.

histocrate
la source

2

C'est très difficile.

J Atkin

1

Est-ce que cela fonctionne à la fois en Python 2 et en Python 3?

DLosc

1

Eep. Python 2 seulement, désolé.

Histocrat

1

Cela signifie-t-il catégoriquement que cela ne fonctionne pas dans Python 3?

DLosc

1

C'est une allusion, mais oui, je vous promets que cela ne fonctionnera pas en Python 3.

histocrat

6

> <> , ≤ 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 .

Sp3000
la source

Fissuré.

randomra

6

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.

lirtosiast
la source

10

@Conor O'Brien, vous n'avez besoin que de 10 octets pour écrire le nombre décimal lui-même!

Arcturus

1

Voici une liste de toutes les commandes TI-84 + BASIC, ainsi qu'une documentation complète.

lirtosiast

2

Pour que ce soit aussi clair, Thomas (et je suppose que la plupart des gens) considèrent que les choses sont comme sin(1 octet sur TI-BASIC. Donc, quelque chose comme sin(sin(sin(ene serait que 4 octets.

Albert Renshaw

1

En fait, à notre connaissance, il pourrait utiliser fPart(.

LegionMammal978

1

@ AlbertRenshaw Oui, j'avais compris cela. La documentation que Thomas a liée répertorie une "taille de jeton" pour chaque opérateur. Je suppose que c'est ce que nous comptons et que les opérateurs qu'il utilise proviendraient probablement de cette liste: tibasicdev.wikidot.com/one-byte-tokens .

Reto Koradi

6

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.

Sp3000
la source

6

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.

histocrate
la source

Je l'ai eu à 37 octets. Cela ressemble à un sortilège, alors espérons que cela aide.

mbomb007

Fissuré? :)

insertusernamehere

1

Je ne peux plus voter à nouveau, mais c'est un très bon programme.

insertusernamehere

5

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

DLosc
la source

Je vois un motif de 4s.

J Atkin

fissuré?

Egor Skriptunoff

@EgorSkriptunoff Yep - J'ai utilisé une structure de boucle différente, mais sinon, c'est la même logique.

DLosc

@DLosc - Peut-il être encore plus court avec une autre boucle?

Egor Skriptunoff

@EgorSkriptunoff J'ai utilisé une technique de golf Python - je ne vais pas poster mon code, car je pourrais faire quelque chose de similaire dans une autre réponse, mais vous pouvez trouver le concept sur la page des astuces Python .

DLosc

5

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.

Reto Koradi
la source

Fissuré.

Dennis

@ Dennis Ok, officiellement marqué comme fissuré. Je ne m'attendais pas vraiment à ce que ça tienne le coup, mais ça m'intéresse quand même: est-ce que tu l'as forcé brutalement? Ou aviez-vous une bonne idée de ce que j'ai probablement fait?

Reto Koradi

1

La sortie est trop grande pour être tout sauf une factorielle ou une puissance, et des factorielles aussi grandes auraient quelques zéros à la fin. J'ai commencé avec KK#, essayé quelques pouvoirs supplémentaires et finalement trouvé JK#.

Dennis

5

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.

Egor Skriptunoff
la source

@ LegionMammal978 - Astuce: Dans Lua 5.3 REPL, on peut omettre =avant l'expression.

Egor Skriptunoff

Ce que je ne sais, cependant, est qu'il n'y a pas de réponse ici ...

LegionMammal978

@ LegionMammal978 - Oui, le lien que vous avez donné est le bon endroit pour lire. Vous avez déjà toutes les informations dont vous avez besoin. Juste le résoudre.

Egor Skriptunoff

craqué

feersum

intéressant non-solution:0x2p-21

daurnimator

5

Pip , <= 16 (sûr)

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

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"

DLosc
la source

C'est plutôt cool.

J Atkin

Hmm ... Chaque numéro est le numéro de colonne, indexé par 0. : - /

ev3commander

@JAtkin Je pense aussi. ^ _ ^ Explication ajoutée.

DLosc

Très bien, prenez un +1;)

J Atkin

4

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+$/)

Poignée de porte
la source

fissuré

kennytm

@ Kennytm Wow, je suis impressionné. Vous avez même réussi à en faire un caractère plus court que mon code original!

Poignée de porte

4

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!

DankMemes
la source

Cracked

lirtosiast

Qu'est-ce que "REIS"?

mbomb007

@ mbomb007 mrob.com/pub/ries

DankMemes

4

MATLAB, fissuré par Tom Carpenter

Plage <= 16

ans =

        5760       22320
       13920       53940

Stewie Griffin
la source

Grr, 17 est le plus proche que je peux obtenir!

Tom Carpenter

8

En fait, j'ai trouvé jusqu'à présent 8 façons de le faire sur 17 octets!

Tom Carpenter

2

Cracked: codegolf.stackexchange.com/a/60436/42295

Tom Carpenter

2

C'était un défi amusant!

Tom Carpenter

4

Mathematica, fissuré par Sp3000

Plage: <= 32

808017424794512875886459904961710757005754368000000000

Alephalpha
la source

Cracked

Sp3000

4

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

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

C'est 2016 5s; au fait.

poivré
la source

fissuré

histocrat

4

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.

jimmy23013
la source

4

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

Xnor
la source

1

S'agit-il d'un REPL ou d'un programme complet?

lirtosiast

@ThomasKwa Programme complet.

xnor

Utilisé dir(complex)pour voir quels ops sont définis pour les nombres complexes. Je ne savais pas que tu pouvais utiliser un module. Notez que cela ne sera probablement pas utile, mais peut-être ...

mbomb007

3

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

Conor O'Brien
la source

Still safe :3

Conor O'Brien

1

J'ai apprécié ça. Cracked

SLuck49

@ SLuck49 j'ai posté le code.

Conor O'Brien

3

TI-BASIC (fissuré par Thomas Kwa)

Plage: <= 2

Chaîne: -10

Code: Xmin

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

un spaghetto
la source

Vous ne l'avez pas déjà craqué, n'est-ce pas?

un spaghetto

1

Je serais sérieusement triste si vous le faisiez, c'est assez malin.

un spaghetto

En Python, c'est ~9(inversion de bits)

utilisateur193661

Bien sûr, mais vous devez y répondre dans TI-BASIC. En tout cas, cela n'a pas vraiment d'importance; Thomas l'a déjà fait craquer. Je pense qu'il attend juste pour être gentil (?).

un spaghetto

Cracked

lirtosiast

3

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)

Addison Crump
la source

a=ou a- 1=ou 1-ou? Je ne sais pas =)

flawr

Nan. Ceux-ci jetteront à STDERR comme erreur # -2741.

Addison Crump

osascript -e 'say "Cracked."'

ossifrage

1

@squeamishossifrage Vous pouvez raccourcir cela d'un octet à l'aide say"Cracked.", et, si cela ne vous dérange pas de la grammaire, d'un octet supplémentaire avec say"Cracked". c:

Addison Crump

3

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

Longueur <= 8

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

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

randomra
la source

Cracked

Sp3000

3

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.

Dennis
la source

L'imprimante à cordes mystère (Cops)

Votre challenge

Restrictions

Notation

Les soumissions

Réponses:

Pyth, sûr, plage ≤ 8

VBA, [Safe]

Solution

Code

A expliqué

Mathematica, sûr, plage ≤ 64

ngn APL (safe)

Solution

Comment ça fonctionne

Pyth, fissuré par Sp3000

> <> (Coffre-fort)

Explication:

Bonhomme de neige 1.0.2

Matlab, ≤16. Fissuré par Wauzl

Perl (sûr)

Solution

Comment ça fonctionne

Python, <= 16 ( fissuré par kennytm )

> <> , ≤ 8 [ fissuré ]

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

CJam, ≤ 8 [sûr]

Solution

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

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

CJam ( fissuré par Dennis)

Lua, ≤ 4 ( fissuré par le feersum)

Pip , <= 16 (sûr)

Ruby, fissuré par Kenny

TI-BASIC ( fissuré par Thomas Kwa )

MATLAB, fissuré par Tom Carpenter

Mathematica, fissuré par Sp3000

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

CJam, ≤8 (sûr)

Python 2 (coffre 16)

JavaScript ES6, ≤128 octets - fissuré

TI-BASIC (fissuré par Thomas Kwa)

AppleScript, ≤ 2 octets fissuré

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

GolfScript (safe)

Solution

Comment ça fonctionne