Le fil des flics se trouve ici: The Mystery String Printer (Cops)

Votre défi

• Choisissez une soumission dans le fil de la police et imprimez la chaîne à partir d'une réponse dans ce fil.
• La soumission que vous choisissez ne doit pas être sécurisée (elle doit être postérieure à 7 jours).

• Votre programme, fonction ou script REPL doit suivre les mêmes règles que le thread des flics. Pour récapituler:

  • Votre programme doit contenir ≤128 caractères (si la soumission d'un policier est dans une plage de longueurs de programme plus petite, votre programme doit également être dans cette plage de longueur. Par exemple, si le programme d'un policier est ≤32 octets, votre programme doit être ≤32 octets ).
  • Le programme doit produire la même sortie à chaque exécution.
  • Pas de fonctions cryptographiques.
  • Le programme ne doit pas accepter d'entrée.
  • Pas de failles standard.
• Toutes les nouvelles soumissions doivent utiliser la même langue. Les soumissions d'avant cette règle ont été faites, même si elles ne le sont pas.

Notation

La notation fonctionne de manière similaire pour les voleurs, mais elle est légèrement différente:

• La fissuration de tout programme de ≤8 octets donne 1 point.
• La fissuration d'un programme ≤16 octets donne 2 points. ≤32 octets donne 4 points, et ainsi de suite.
• Chaque soumission supplémentaire, quelle que soit sa longueur, rapporte +5 points
• La soumission de chaque flic ne peut être piratée qu'une seule fois - seule la première personne à casser chaque soumission obtient les points.

Soumissions

Chaque réponse doit inclure

• Un lien vers la soumission du flic.
• Votre programme et votre langage de programmation.
• Ayez également la longueur du programme du flic (comme une puissance de 2) comme dernier numéro de votre en-tête.

De plus, veuillez commenter la soumission du policier avec un lien vers votre réponse.

Voici un extrait de pile pour générer des classements. Veuillez laisser un commentaire en cas de problème avec l'extrait. Si vous souhaitez voir toutes les soumissions ouvertes de flics, consultez l'extrait du défi des flics.

/* Configuration */

var QUESTION_ID = 60329; // 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";

/* 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 POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\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;

    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);

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

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints

      });
    }
  });

  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++;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });

  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });

  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });

}

body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  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>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

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

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

Ce concours est maintenant terminé.

Vainqueur général: kennytm

La plupart des soumissions: Sp3000

(Notez que le nombre de soumissions ne se traduit pas exactement en points, car la longueur du programme piraté est comptée lors du calcul du score).

Pyth, Dennis, ≤ 8

V./Tp*FN

Merde, c'était amusant - la partie la plus difficile était de trouver comment le faire assez court en Pyth.

Une analyse

Au 1234début, il s'agit probablement d'une liste de chiffres, imprimée sans séparateur. Essayons de diviser les chiffres d'une manière logique:

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

Il y a quelques indices que nous sommes sur la bonne voie:

• Tous les nombres ont des facteurs premiers inférieurs à 10
• Beaucoup de nombres sont assez proches de leur index dans la liste

Cependant, il y a quelques particularités. Le nombre à l'index 23 est 24 et est le seul cas où le nombre à l'index est supérieur à l'index lui-même. Cependant, l'indice le plus important est que certains nombres sont clairement plus petits que leurs voisins, en particulier le 7 à l'indice 15, le 8 à l'indice 22 et le 9 à l'indice 30.

Notant que cela forme un modèle 7-8-9, nous pouvons également voir que le dernier nombre est un 10 à l'index 42. Étant donné la question récente de @Dennis sur les groupes abéliens , une vérification rapide sur OEIS révèle qu'il 15, 22, 30, 42s'agit d'une sous-séquence de la partition chiffres . Pyth a une fonction intégrée pour les partitions, qui nous donne deux des huit caractères:./

Mais notez que le dernier nombre est 10, ce qui est suspect car 10 est une variable préinitialisée en Pyth, comme T. ./Tdonne une liste complète des 42 partitions du numéro 10, ce qui pourrait être utile.

Maintenant, l'impression se fait sans séparateur, donc cela suggère une utilisation de p. Peut-être que nous parcourons chaque partition, y faisons quelque chose, puis imprimons avec p? Cela nous donne le modèle suivant:

V./Tp??N

où Vest une boucle for qui boucle sur un itérable, stockant chaque élément dans la variable N.

Un coup d'œil à l'avant-dernière partition (5, 5)devrait montrer clairement que nous voulons prendre un produit. La manière naïve de réduire une liste par multiplication est

u*GHd1

où dest la liste en question. Cependant, c'est beaucoup trop long.

Malheureusement, c'est là que j'ai dû retirer un forceur brutal. Je n'ai pas suivi Pyth depuis un moment, donc je ne connaissais pas beaucoup des nouvelles fonctionnalités. Il ne restait que deux personnages, ce qui semblait tout à fait faisable.

Le forceur brutal est alors revenu:

V./Tp*FN

où *Fest plié par *(multiplication). Pas étonnant que je ne l'ai pas trouvé dans ma recherche - je cherchais le mot-clé "réduire" plutôt que "plier"!

Mathematica, alphalpha, ≤ 32

GroupOrder[MonsterGroupM[]]

Je déteste dire ça, mais je viens de reconnaître le nombre sur place.

> <>, VTCAKAVSMoACE, ≤ 64

'9?':?!;1-$:'@'+o'3'*'='%$30.

Ironiquement, non seulement cette limite de portée est beaucoup plus basse, mais elle est également portable et fonctionne avec l' interpréteur en ligne .

Une analyse

Commençons par la chaîne cible:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <> pousse les caractères vers la pile avec 'ou "en mode chaîne, mais avec 63 caractères à imprimer et seulement 64 octets avec lesquels travailler, la présence de majuscules (instructions invalides dans> <>, pour l'astuce de bouclage standard) permet l'impression directe impossible. Par conséquent, nous devons faire quelque chose avec les points de code.

La conversion en points de code donne (j'utilise Python ici):

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

Notez que les trois derniers chiffres sont les mêmes que les trois premiers. Cela suggère une boucle modulo possible en cours.

Jetons un coup d'œil au nombre d'éléments différents que nous avons:

>>> len(set(L))
60

Nous avons 63 éléments L, dont les trois premiers coïncident avec les trois derniers. Cela signifie que, à part cette collision, tous les autres éléments sont uniques. Maintenant, cela suggère quelque chose comme prendre des pouvoirs modulo un nombre premier. En effet, 60 + 1 = 61est premier, ce qui est un bon signe.

Essayons de trouver le plus petit élément

>>> min(L)
65

et l'utiliser pour réduire tous les éléments afin que l'élément min soit 1:

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

Notez comment l'élément après 1est 51. S'il y a une sorte de pouvoir / multiplication, c'est une bonne supposition pour notre multiplicateur.

Essayons-le:

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

Bingo! Nous pouvons maintenant revenir en arrière, en donnant le code suivant:

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

qui a ensuite été traduit en> <>

Pyth, Maltysen, ≤4

C.ZG

La force brutale a pris tellement de temps que je l'ai fait plus rapidement manuellement.

Une analyse

C(convertir la chaîne en base 256 int) est le moyen le plus simple de générer un grand nombre en Pyth, c'est donc probablement le premier caractère. Si nous convertissons à partir de la base 256, nous obtenons:

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

Hmm ... pas très éclairant.

Maintenant, Gc'est la chaîne de l'alphabet "abc...z", qui semble pouvoir être une source pour une longue chaîne à alimenter C. En parcourant les documents que je trouve:

.Z    Compresses or decompresses a string.

Si nous avons affaire à la compression ici, il ne serait pas surprenant d'obtenir toutes sortes de caractères ASCII étendus. Essayer a C.ZGensuite donné la réponse.

Fourier, désintégration bêta, ≤ 32

2~x1~y20(xoy~z*x~yz~xq^~q)

Ou bien, dans CJam:

X0I{_2$+}*]2\f#

Une analyse

Au début, nous pouvons voir beaucoup de pouvoirs de 2:

2
1
2
2
4
8
32
256
8192
2097152
...

Si nous prenons le log base 2 de ces nombres, nous obtenons:

1 0 1 1 2 3 5 8 13 21 ...

qui est la série Fibonacci, à partir de 1, 0.

Escargots, feersum, ≤2 octets

z

Il s'agit en fait de 2 octets; le caractère zsuivi d'une nouvelle ligne \n.

Je n'ai aucune idée de comment cela fonctionne ou de ce qu'il fait, mais après avoir testé toutes les entrées possibles en dehors de ~+et ~,, ce fut le seul programme à 2 octets qui a produit 8en sortie.

Et il a fallu des années pour obtenir ce résultat. Pas étonnant que ça s'appelle "Escargots" :-D

^{Remarque à vous-même: la prochaine fois que vous testez un logiciel inconnu, faites-le à l'intérieur d'une machine virtuelle.}

Rouille, Liam Noronha, ≤128 octets

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

La simple impression de la chaîne textuellement est de 120 octets ...

Macaroni 0.0.2, poignée de porte, ≤64

set x "................................."print x print x print x

Python 2, question claire avec des exemples, <= 64

Une solution possible:

print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])

( 9**2139, 27**1426et 729**713donnent également le même résultat)

CoffeeScript, user2428118, ≤64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

(fonctionne uniquement sur Chrome 46.0.2490.71 comme décrit par la Cop.)

La sortie est évidemment une concaténation de courtes chaînes encodées en base64 en raison de tous les "=". Après les avoir décodés, nous trouvons une liste de chaînes de 2 caractères comme

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

ce qui ne semble pas avoir de sens. Mais j'y trouve des objets étranges, comme nXet tY. Après les avoir filtrés, nous obtenons

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

Ces X et Y semblent indiquer les propriétés de position utilisées par le code source d'origine comme offsetX/Y. Un nZélément particulièrement intéressant est l' article. Pour vérifier mon hypothèse, j'ai recherché toutes les propriétés se terminant par "Z":

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

qui montre des tonnes de CSSStyleDeclaration, "webkitTransformOriginZ". De cela, nous avons une forte indication que la liste est constituée par les 2 derniers caractères de toutes les clés d'un styleobjet, ce que le test ci-dessus montre en effet est correct.

Lua <= 4, Egor Skriptunoff

Beaucoup d'utilisateurs s'inquiétaient de cette réponse dans le chat, donc je dois les soulager de leur misère. Je ne connais pas Lua et je n'ai pas pu le tester, mais je serais très surpris si cela ne fonctionnait pas.

4^~9

Ce serait assez évident, mais probablement personne ne l'a obtenu car les opérateurs au niveau du bit n'ont été ajoutés que dans la version 5.3; ideone.com n'a que la version 5.2.

Python 2, histocrate, ≤16

[[[51002**3/6]]] 

Le plus gros indice est la promesse que cela ne fonctionnera pas dans Python 3. Qu'est-ce qui a changé dans Python 3 ? Le plus gros suspect est que l'opérateur de division renvoie un floaten Python 3.

Je suppose donc que la solution est de la forme ⌊α ^β / n⌋ = c = 22111101102001, car l'exponentiation est le seul moyen court de créer des nombres énormes.

Si {α, β, n} forme effectivement une solution, alors (cn) ^{1 / β} ≈ α devrait être très proche d'un entier. Par conséquent, j'utilise ce qui suit pour essayer de forcer brutalement les {α, β} pour chaque n:

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

Le résultat réel sort rapidement lorsque n = 6.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Tirages:

ans =
        5760       22320
       13920       53940

Matlab, Luis Mendo, ≤16

Je l'ai trouvé, ouais!

fix(peaks(9).^2)

Je ne savais pas qu'Octave pouvait faire ça aussi.

Mathematica, LegionMammal978, ≤64

Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]

Python, spacemanjosh, ≤ 64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

Glorieuse calculatrice symbolique inverse. Pas bien joué au golf, mais bon ça va.

Edit: je l'ai joué au golf.

print([10/(100-n*n)**.5for n in range(10)])

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 octets

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

Je doute que ce soit exact, car je n'avais pas besoin de près de 128 octets, mais trouver une séquence répétitive était un défi amusant.

Thue, poivre, <= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

Décompose 2016 en ses principaux facteurs, essentiellement. 62 caractères, donc je suppose que c'est similaire à ce que vous recherchiez.

Python, DLosc, ≤32

(Cette solution utilise Python 2)

a=97
while a<4e31:a^=a*2;print a

> <>, Sp3000, <= 8

'l(?; o>

Le pointeur d'instructions s'enroule et les étapes suivantes se produisent:

• 'l(?; o>'pousse les valeurs ASCII de l(?; o>la pile
• l pousse la taille de la pile sur la pile
• (comparer les deux premiers éléments de la pile: size of stacketord('>')
• ?; arrête le programme si la taille de la pile était plus grande
• oafficher l'élément supérieur de la pile en tant que caractère (ce sera toujours o)
• > définit la direction IP, ici c'est no-op
• nous revenons à la première étape

La sortie est oooooooooooo.

Nous pouvons obtenir beaucoup de sorties différentes en changeant [space]en quelque chose qui pousse ou saute sur la pile et en utilisant un autre caractère valide à la place de >, qui peut également pousser ou sauter.

JavaScript, commande ev3, ≤ 32

console.log(0.1411200080598672)

OK, c'était facile.

CJam, Reto Koradi, ≤ 4

HJK#

Pousse 17 , puis 19 ²⁰ = 37589973457545958193355601 .

Essayez-le en ligne.

Il n'y a que tant de choses que vous pouvez faire en quatre octets. Un entier de cette taille devait impliquer des pouvoirs ou des factoriels d'une manière ou d'une autre, et un factoriel aurait des zéros à la fin.

Pyth <= 4, Dennis

ljyG

C'est la durée de la jointure sur les nouvelles lignes de tous les sous-ensembles de l'alphabet.

Essai:

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

J'ai compris que le nombre était 2^27 * 7 - 1un indice fort sur lequel il se base yG, qui est 2^26long. J'ai alors deviné qu'il devait être converti en chaîne et sa longueur imprimée. Cependant, la seule façon de le faire à laquelle j'ai pu penser pendant un certain temps était ``, repr. Ensuite, j'ai pensé à jce qui convient parfaitement.

C, tucuxi, ≤64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

Les sorties sont toutes 0 et 1, mais C ne peut pas imprimer directement en binaire, il est donc très probable que ce soient des résultats booléens.

Il y a plus de 1 que de 0, j'ai donc enregistré les positions de 0 ( 3, 9, 13, 19, …), ce qui s'avère être OEIS A075318 . Ce n'est pas utile cependant, il n'y a pas de formule simple pour déterminer où se trouve un nombre dans cette séquence.

Mais nous notons qu'il y a tous des nombres impairs, nous (x-1)/2 = {1, 4, 6, 9, 12, …}avons donc peut- être des informations plus utiles. Et c'est A003622 .

A003622 peut être défini comme "positions de 1 dans A003849 ", ce qui est exactement ce que nous devons craquer ici. Et A003849 est défini comme " A003714 mod 2", où A003714 sont simplement tous les entiers qui x & (2*x) == 0. Nous avons donc la solution.

OEIS rox.

Dyalog APL, Dennis, ≤4

*⍨⍟8

Calcule ln (8) ^ ln (8). Est-ce que StackExchange arrêterait de convertir mes réponses? Je vais taper un tas de trucs ici pour que ça ne devienne pas un commentaire.

Coincé, @quartata, ≤8

Le programme Pyth suivant :

^33 9

produit la sortie souhaitée

46411484401953

Méthode de craquage: recherche du numéro sur Google.

Pyth, xnor, ≤ 4

C`CG

CG(convertir la chaîne "abc...z"de l'alphabet à partir de la base 256) est le moyen Pyth typique de générer un très grand nombre. Après cela, il suffit de stringifier et de convertir à nouveau à partir de la base.

Python 3, Mego, ≤128

(Utilisation de Python 3.5.0, non testé sur les versions précédentes. 105 98 octets.)

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])

Rubis, poignée de porte, ≤64

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

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

En utilisant la même idée que la réponse de Tom Carpenter

(Si cela n'a pas fonctionné, essayez ceci :)

[50;51;52]*'567'