Il thread della polizia è disponibile qui: The Mystery String Printer (Cops)

La tua sfida

• Scegli un invio dal thread della polizia e stampa la stringa da una risposta in quel thread.
• L'invio scelto non deve essere sicuro (deve essere più recente di 7 giorni).

• Il tuo programma, funzione o script REPL deve seguire le stesse regole del thread di cops. Per riassumere:

  • Il programma deve contenere ≤128 caratteri (se l'invio di un poliziotto rientra in un intervallo più piccolo di lunghezze di programma, anche il programma deve trovarsi in tale intervallo di lunghezza. Ad esempio, se il programma di un poliziotto è ≤32 byte, il programma deve essere ≤32 byte ).
  • Il programma deve produrre lo stesso output ogni volta che viene eseguito.
  • Nessuna funzione crittografica.
  • Il programma non deve accettare input.
  • Nessuna scappatoia standard.
• Tutti i nuovi invii devono utilizzare la stessa lingua. Le candidature precedenti a questa regola vanno bene, anche se non lo sono.

punteggio

Il punteggio funziona in modo simile per i ladri, ma è leggermente diverso:

• Craccare qualsiasi programma di ≤8 byte dà 1 punto.
• Craccare un programma ≤16 byte dà 2 punti. ≤32 byte fornisce 4 punti e così via.
• Ogni invio aggiuntivo, indipendentemente dalla lunghezza, guadagna +5 punti
• La presentazione di ogni poliziotto può essere decifrata una sola volta: solo la prima persona a decifrare ogni sottomissione ottiene i punti.

Inseriti

Ogni risposta deve includere

• Un link alla presentazione del poliziotto.
• Il tuo programma e linguaggio di programmazione.
• Anche avere la durata del programma del poliziotto (come una potenza di 2) come l'ultimo numero nella tua intestazione.

Inoltre, ti preghiamo di commentare l'invio del poliziotto con un link alla tua risposta.

Ecco uno snippet di stack per generare classifiche. Lascia un commento in caso di problemi con lo snippet. Se desideri vedere tutti gli invii di poliziotti aperti, vedi lo snippet nella sfida dei poliziotti.

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

Questo concorso è chiuso.

Vincitore assoluto: kennytm

Maggior parte degli invii: Sp3000

(Si noti che la quantità di invii non si traduce esattamente in punti, poiché la lunghezza del programma crackato viene conteggiata nel calcolo del punteggio).

Pyth, Dennis, ≤ 8

V./Tp*FN

Accidenti è stato divertente - la parte più difficile è stata capire come farlo abbastanza breve in Pyth.

Analisi

Il 1234presso i suggerimenti iniziali che stiamo probabilmente si occupano di un elenco di numeri, stampati senza un separatore. Proviamo a dividere i numeri in modo sensato:

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

Ci sono alcuni suggerimenti che siamo sulla buona strada:

• Tutti i numeri hanno fattori primi inferiori a 10
• Molti numeri sono abbastanza vicini al loro indice nell'elenco

Tuttavia, ci sono alcune peculiarità. Il numero all'indice 23 è 24 ed è l'unico caso in cui il numero all'indice è maggiore dell'indice stesso. Tuttavia, l'indizio più grande è che alcuni numeri sono chiaramente più piccoli dei loro vicini, in particolare il 7 all'indice 15, l'8 all'indice 22 e il 9 all'indice 30.

Notando che questo forma un modello 7-8-9, possiamo anche vedere che l'ultimo numero è un 10 all'indice 42. Data la recente domanda di @Dennis sui gruppi abeliani , un rapido controllo su OEIS rivela che 15, 22, 30, 42è una sottosequenza della partizione i numeri . Pyth ha un builtin per le partizioni, che ci dà due degli otto personaggi:./

Ma nota che l'ultimo numero è 10, il che è sospetto perché 10 è una variabile preinizializzata in Pyth, come T. ./Tfornisce un elenco completo delle 42 partizioni del numero 10, che sembra utile.

Ora la stampa viene eseguita senza un separatore, quindi questo suggerisce un uso di p. Forse attraversiamo ogni partizione, facciamo qualcosa con essa, quindi stampiamo con p? Questo ci dà il seguente modello:

V./Tp??N

dove Vè un ciclo for che scorre su un iterabile, memorizzando ogni elemento nella variabile N.

Una rapida occhiata alla seconda ultima partizione (5, 5)dovrebbe rendere ovvio che vogliamo prendere un prodotto. Il modo ingenuo di ridurre un elenco per moltiplicazione è

u*GHd1

dov'è dla lista in questione. Tuttavia, questo è troppo lungo.

Sfortunatamente, è qui che ho dovuto estrarre un forcer brutale. Non ho tenuto il passo con Pyth per un po ', quindi non conoscevo molte delle nuove funzionalità. Erano rimasti solo due personaggi, il che sembrava del tutto fattibile.

Il forcer bruto quindi tornò:

V./Tp*FN

dove *Fè fold *(moltiplicazione). Non mi stupisco di non averlo trovato nella mia ricerca: stavo cercando la parola chiave "riduci" anziché "piega"!

Mathematica, alphalpha, ≤ 32

GroupOrder[MonsterGroupM[]]

Odio dirlo, ma ho appena riconosciuto il numero sul posto.

> <>, VTCAKAVSMoACE, ≤ 64

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

Ironia della sorte, non solo è molto più basso del limite di portata, è anche portatile e funziona con l' interprete online .

Analisi

Cominciamo con la stringa di destinazione:

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

> <> spinge i caratteri nello stack con 'o "in modalità stringa, ma con 63 caratteri da stampare e solo 64 byte con cui lavorare, la presenza di lettere maiuscole (istruzioni non valide in> <>, per il trucco standard di looparound) rende la stampa diretta impossibile. Quindi, dobbiamo fare qualcosa con i punti di codice.

La conversione in punti di codice dà (sto usando Python qui):

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

Si noti che gli ultimi tre numeri sono gli stessi dei primi tre. Questo suggerisce un possibile ciclo modulo in corso.

Diamo un'occhiata a quanti diversi elementi abbiamo:

>>> len(set(L))
60

Abbiamo 63 elementi L, i primi tre dei quali coincidono con gli ultimi tre. Ciò significa che, a parte questa collisione, tutti gli altri elementi sono unici. Ora questo suggerisce qualcosa come prendere i poteri modulo un numero primo. Anzi, 60 + 1 = 61è primo, il che è un buon segno.

Proviamo a trovare l'elemento più piccolo

>>> min(L)
65

e usalo per ridimensionare tutti gli elementi in modo che l'elemento min sia 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]

Si noti come l'elemento dopo 1è 51. Se sta succedendo una sorta di potere / moltiplicazione, questa è una buona ipotesi per il nostro moltiplicatore.

Diamo un colpo:

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

Bingo! Ora possiamo tornare indietro, fornendo il seguente codice:

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

che è stato quindi tradotto in> <>

Pyth, Maltysen, ≤4

C.ZG

La forza bruta ha impiegato così tanto tempo che l'ho fatto più velocemente manualmente.

Analisi

C(convertire la stringa in base 256 int) è il modo più semplice per generare un numero elevato in Pyth, quindi è probabilmente il primo carattere. Se convertiamo dalla base 256, otteniamo:

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

Hmm ... non molto illuminante.

Ora Gè la stringa dell'alfabeto "abc...z", che sembra che potrebbe essere una fonte per una lunga stringa da alimentare C. Guardando attraverso i documenti che trovo:

.Z    Compresses or decompresses a string.

Se qui abbiamo a che fare con la compressione, non sarebbe sorprendente ottenere tutti i tipi di caratteri ASCII estesi. Provando C.ZGquindi ha dato la risposta.

Fourier, decadimento beta, ≤ 32

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

O in alternativa, in CJam:

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

Analisi

All'inizio possiamo vedere molti poteri di 2:

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

Se prendiamo la base di registro 2 di questi numeri, otteniamo:

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

che è la serie Fibonacci, a partire da 1, 0.

Lumache, feersum, ≤2 byte

z

Questo è in realtà 2 byte; il personaggio zseguito da una nuova riga \n.

Non ho idea di come funzioni o cosa stia facendo, ma dopo aver testato tutti gli input possibili a parte ~+e ~,, questo è stato l'unico programma a 2 byte prodotto 8come output.

E ci sono voluti anni per ottenere questo risultato. Nessuna meraviglia si chiama "Lumache" MrGreen

^{Nota per sé: la prossima volta che fuzz testare software sconosciuto, fallo all'interno di una VM.}

Ruggine, Liam Noronha, ≤128 byte

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

È sufficiente stampare la stringa alla lettera 120 byte ...

Maccheroni 0.0.2, Maniglia della porta, ≤64

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

Python 2, domanda chiara con esempi, <= 64

Una possibile soluzione:

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

( 9**2139, 27**1426E 729**713anche dare lo stesso risultato)

CoffeeScript, user2428118, ≤64

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

(funziona solo su Chrome 46.0.2490.71 come descritto dal Cop.)

L'output è ovviamente una concatenazione di stringhe codificate in base64 a causa di tutti i "=". Dopo averle decodificate, troviamo un elenco di stringhe di 2 caratteri come

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

che non sembra avere senso. Ma ci trovo alcuni oggetti strani, come nXe tY. Dopo aver filtrato questi, otteniamo

>>> # 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']

Queste X e Y sembrano indicare il codice sorgente originale usato proprietà di posizione come offsetX/Y. Un nZelemento particolarmente interessante è l' articolo. Per verificare la mia ipotesi, ho cercato tutte le proprietà che terminano con "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

che mostra tonnellate di CSSStyleDeclaration, "webkitTransformOriginZ". Da questo abbiamo una forte indicazione che l'elenco è costruito dagli ultimi 2 caratteri di tutte le chiavi di un styleoggetto, che il test sopra mostra in effetti è corretto.

Lua <= 4, Egor Skriptunoff

Molti utenti si sono agitati per questa risposta in chat, quindi devo alleviarli dalla loro miseria. Non conosco Lua e non sono stato in grado di testarlo, ma sarei molto sorpreso se non funzionasse.

4^~9

Ciò sarebbe abbastanza ovvio, ma probabilmente nessuno l'ha capito perché gli operatori bit per bit sono stati aggiunti solo nella versione 5.3; ideone.com ha solo la versione 5.2.

Python 2, istocratico, ≤16

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

Il suggerimento più grande è la promessa che non funzionerà in Python 3. Cosa è cambiato in Python 3 ? Il più grande sospetto è che l'operatore di divisione restituisca a floatin Python 3.

Quindi suppongo che la soluzione sia nella forma ⌊α ^β / n⌋ = c = 22111101102001, poiché l'espiazione è l'unico modo breve per creare numeri enormi.

Se {α, β, n} costituisce effettivamente una soluzione, allora (cn) ^{1 / β} ≈ α dovrebbe essere molto vicino a un numero intero. Quindi uso quanto segue per provare a forzare {α, β} per ogni 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.

*)

Il risultato effettivo viene rapidamente visualizzato quando n = 6.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

stampe:

ans =
        5760       22320
       13920       53940

Matlab, Luis Mendo, ≤16

L'ho trovato, yay!

fix(peaks(9).^2)

Non sapevo che anche Octave potesse fare questo.

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)

Glorioso calcolatore simbolico inverso. Non ben giocato a golf, ma hey si adatta.

Modifica: l' ho giocato a golf.

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

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

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

Dubito che questo sia esattamente giusto dal momento che non avevo bisogno di quasi 128 byte, ma trovare una sequenza ripetuta è stata una sfida divertente.

Giovedì, <= 64

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

Scompone il 2016 nei suoi fattori primi, essenzialmente. 62 personaggi, quindi suppongo sia simile a quello che stavi cercando.

Python, DLosc, ≤32

(Questa soluzione utilizza Python 2)

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

> <>, Sp3000, <= 8

'l(?; o>

Il puntatore dell'istruzione si avvolge e si verificano i seguenti passaggi:

• 'l(?; o>'inserisce i valori ASCII l(?; o>nello stack
• l spinge la dimensione della pila sulla pila
• (confrontare i primi due elementi dello stack: size of stackeord('>')
• ?; arresta il programma se la dimensione dello stack era maggiore
• oemette l'elemento superiore dello stack come carattere (questo sarà sempre o)
• > imposta la direzione IP, qui è no-op
• torniamo al primo passo

L'output è oooooooooooo.

Possiamo ottenere molti output diversi cambiando [space]in qualcosa che spinge o salta in pila e usando un altro carattere valido invece di >, che può anche spingere o pop.

JavaScript, ev3commander, ≤ 32

console.log(0.1411200080598672)

OK, è stato facile.

CJam, Reto Koradi, ≤ 4

HJK#

Spinge 17 , quindi 19 ²⁰ = 37589973457545958193355601 .

Provalo online.

Ci sono solo così tante cose che puoi fare in quattro byte. Un intero così grande doveva coinvolgere in qualche modo poteri o fattoriali e un fattoriale avrebbe zero finali.

Pyth <= 4, Dennis

ljyG

Questa è la lunghezza del join su newline di tutti i sottoinsiemi dell'alfabeto.

Prova:

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

Ho capito che il numero era 2^27 * 7 - 1un forte suggerimento su cui si basa yG, che è 2^26lungo elementi. Ho quindi pensato che doveva essere convertito in una stringa e la sua lunghezza stampata. Tuttavia, l'unico modo di fare ciò a cui potevo pensare per un po 'era ``, repr. Poi ho pensato j, che si adatta perfettamente.

C, tucuxi, ≤64

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

L'output è 0 e 1, ma C non può stampare direttamente il file binario, quindi è molto probabile che si tratti di risultati booleani.

Ci sono più di 1 di 0, quindi ho registrato le posizioni di 0s ( 3, 9, 13, 19, …), che risulta essere OEIS A075318 . Questo non è utile, tuttavia, non esiste una formula semplice per determinare dove si trova un numero in questa sequenza.

Ma notiamo che ci sono tutti i numeri dispari, quindi forse (x-1)/2 = {1, 4, 6, 9, 12, …}hanno informazioni più utili. E questo è A003622 .

A003622 può essere definito come "posizioni di 1 in A003849 ", che è esattamente ciò di cui abbiamo bisogno per decifrare qui. E A003849 è definito come " A003714 mod 2", dove A003714 sono semplicemente tutti numeri interi x & (2*x) == 0. Quindi abbiamo la soluzione.

OEIS rox.

Dyalog APL, Dennis, ≤4

*⍨⍟8

Calcola ln (8) ^ ln (8). StackExchange smetterebbe di convertire le mie risposte? Scriverò un sacco di cose qui in modo che non si trasformi in un commento.

Bloccato, @quartata, ≤8

Il seguente programma Pyth :

^33 9

produce l'output desiderato

46411484401953

Metodo di cracking: cercato Google per il numero.

Pyth, xnor, ≤ 4

C`CG

CG(convertire la stringa alfabetica "abc...z"dalla base 256) è il tipico modo Pyth di generare un numero davvero grande. Dopodiché è solo un stringify e convertire di nuovo dalla base.

Python 3, Mego, ≤128

(Utilizzando Python 3.5.0, non testato su versioni precedenti. 105 98 byte.)

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

Rubino, pomello della porta, ≤64

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

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

Usando la stessa idea della risposta di Tom Carpenter

(Se non ha funzionato, prova questo :)

[50;51;52]*'567'