L'évêque ivre

42

Dans la cryptographie à clé publique, une empreinte de clé publique est une courte séquence d'octets utilisée pour identifier une clé publique plus longue.

Dans SSH en particulier, ils peuvent être utilisés pour vérifier qu'un serveur est bien le serveur avec lequel je m'attends à communiquer et que je ne suis pas ciblé par une attaque de type "man-in-the-middle".

Ils sont généralement représentés par une chaîne de chiffres hexadécimaux. Il peut donc être fastidieux et fastidieux de la comparer à l’empreinte digitale que j’attendrais:

37:e4:6a:2d:48:38:1a:0a:f3:72:6d:d9:17:6b:bd:5e

Pour faciliter les choses, OpenSSH a introduit une méthode de visualisation des empreintes digitales en tant qu’art ASCII, qui se présenterait ainsi:

+-----------------+
|                 |
|                 |
|          .      |
|     .   o       |
|o . o . S +      |
|.+ + = . B .     |
|o + + o B o E    |
| o .   + . o     |
|         .o      |
+-----------------+

Avec cela, je pourrais essayer de me rappeler la forme approximative de la technique ASCII et je la reconnaisrais (théoriquement) lorsque l’empreinte du serveur serait modifiée et que l’image serait différente.

Comment ça marche

Tiré de Dirk Loss, Tobias Limmer et Alexander von Gernler. 2009. L'évêque saoul: Analyse de l'algorithme de visualisation d'empreintes digitales OpenSSH .

La grille a une largeur de 17 caractères et une hauteur de 9 caractères. "L'évêque" commence à la ligne 4 / colonne 8 (le centre). Chaque position peut être notée [x, y], c'est-à-dire [8,4] pour la position de départ de l'évêque.

            1111111
  01234567890123456
 +-----------------+
0|                 |
1|                 |
2|                 |
3|                 |
4|        S        |
5|                 |
6|                 |
7|                 |
8|                 |
 +-----------------+

L'évêque utilise l'empreinte digitale pour se déplacer. Il le lit par octets de gauche à droite et du bit le moins significatif au bit le plus significatif:

Fingerprint      37      :       e4      :       6a      :  ...  :       5e
Bits        00 11 01 11  :  11 10 01 00  :  01 10 10 10  :  ...  :  01 01 11 10
             |  |  |  |      |  |  |  |      |  |  |  |              |  |  |  |
Step         4  3  2  1      8  7  6  5     12 11 10  9             64 63 62 61

L'évêque agira selon le plan suivant:

Bits   Direction
-----------------
00     Up/Left
01     Up/Right
10     Down/Left
11     Down/Right

Cas spéciaux:

  • Si l'évêque est dans un coin et bougerait de nouveau dans le coin, il ne bougera pas du tout. C'est-à-dire que l'évêque est à [0,0]et sa prochaine étape serait 00. Il reste à[0,0]
  • Si l'évêque se trouve dans un coin ou contre un mur et se déplace dans l'un des murs, il se déplace uniquement horizontalement ou verticalement. C'est-à-dire que l'évêque est à [0,5]et sa prochaine étape serait 01. Il ne peut pas aller à gauche, alors il monte simplement [0,4].

Chaque position a une valeur de combien de fois l'évêque a visité ce champ:

Value      | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14| 15| 16|
Character  |   | . | o | + | = | * | B | O | X | @ | % | & | # | / | ^ | S | E |

Les valeurs 15 (S) et 16 (E) ont ceci de particulier qu'elles marquent respectivement la position de départ et d'arrivée de l'évêque et écrasent la valeur réelle de la position de respect.

Objectif

Créez un programme qui prend une empreinte alphanumérique en entrée et produit sa représentation graphique ASCII comme indiqué dans les exemples.

Exemples

Input:
16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48

Output:
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+

Input:
b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b

Output:
+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

Input:
05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47

Output:
+-----------------+
|       o=.       |
|    o  o++E      |
|   + . Ooo.      |
|    + O B..      |
|     = *S.       |
|      o          |
|                 |
|                 |
|                 |
+-----------------+

Règles

  • C'est du . Le code dans le moins d'octets gagne.
  • Vous ne pouvez pas utiliser une bibliothèque existante qui produit l'image.
  • Utilisez la langue que vous préférez!
  • Votre soumission doit être un programme complet
Padarom
la source
3
Peut-on supposer qu'aucune cellule ne sera visitée plus de 14 fois?
Martin Ender
2
Il existe quelques cas de couverture minimale qui auraient pour conséquence que quelques champs soient visités plus de 14 fois. 33:33:33:...:33, cc:cc:cc:...:ccserait des exemples pour cela. L’empreinte digitale est généralement un hachage MD5, il est donc très peu probable que vous obteniez un tel résultat. Je n'ai trouvé aucune source fiable sur la manière de traiter ces problèmes, alors pour le moment, je dirais: supposons qu'aucune cellule ne sera visitée plus de 14 fois.
Padarom

Réponses:

2

Pyth, 125 octets

Jj*17\-"++"JVc9XXsm@"^ .o+=*BOX@%&#/"hdrS+*U9U17K.u.e@S[0b*8hk)1.b+tNyYNYsm_c4.[08jxsM^.HM16 2d2cz\:,4 8 8ieK17\E76\SjN"||")J

Essayez-le en ligne: démonstration ou test-suite

J'ai écrit il y a quelques jours, mais je ne l'ai pas posté car je n'étais pas vraiment content.

Explication:

L'idée principale est la suivante. Je commence par la paire (4, 8). Dans chaque mouvement, (m1,m2)je vais du (x, y)au (x-1+2*m1, y-1+2*m2). Pour vous assurer que ces coordonnées ne vont pas en dehors des frontières, je vais faire des listes, les trier et retourner l'élément central: (sorted(0,8,newx)[1], sorted(0,16,newy)[1]).

Je garde une trace de toutes les positions. À cette liste de positions, j'ajoute une liste de toutes les positions possibles, les trie et les code longueur-exécution. Ce qui me donne un numéro pour chaque position. Avec ce numéro, je peux choisir le caractère coorect et, à la fin, écraser les caractères des positions de début et de fin.

Jakube
la source
9

Dyalog APL (178)

{⎕ML←3⋄F←9 17⍴0⋄5 9{(⍺⌷F)+←1⋄×⍴⍵:(1 1⌈9 17⌊⍺-1 1-2×↑⍵)∇1↓⍵⋄(⍺⌷F)←16⋄F[5;9]←15⋄K⍪(M,' .o+=*BOX@%&#/^SE'[1+F],M←'|')⍪K←'+','+',⍨17⍴'-'}⊃,/{↓⊖4 2⍴⍉(4/2)⊤¯1+⍵⍳⍨⎕D,'abcdef'}¨⍵⊂⍨':'≠⍵}

C'est une fonction qui prend la chaîne comme argument correct et renvoie une matrice de caractères contenant la représentation artistique ASCII, par exemple:

      F←{⎕ML←3⋄F←9 17⍴0⋄5 9{(⍺⌷F)+←1⋄×⍴⍵:(1 1⌈9 17⌊⍺-1 1-2×↑⍵)∇1↓⍵⋄(⍺⌷F)←16⋄F[5;9]←15⋄K⍪(M,' .o+=*BOX@%&#/^SE'[1+F],M←'|')⍪K←'+','+',⍨17⍴'-'}⊃,/{↓⊖4 2⍴⍉(4/2)⊤¯1+⍵⍳⍨⎕D,'abcdef'}¨⍵⊂⍨':'≠⍵}


      F '16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48'
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+
      F 'b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b'
+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

Explication:

  • ⎕ML←3: réglé ⎕MLsur 3. Cela rend plus utile pour fractionner des chaînes.

  • F←9 17⍴0: faire une matrice de 17 x 9 de zéros. Freprésente combien de fois chaque poste a été visité.

  • ⍵⊂⍨':'≠⍵: divisé en :caractères.

  • {... : pour chaque groupe:
    • ¯1+⍵⍳⍨⎕D,'abcdef': trouve l'index de chaque caractère dans la chaîne '01234567890abcdef'. Soustrayez 1, car APL est 1-indexé par défaut.
    • (4/2)⊤: convertit les valeurs en représentations 4 bits (il devrait maintenant y avoir une matrice 2-sur-4).
    • ↓⊖4 2⍴⍉: faites pivoter la matrice, utilisez les éléments pour remplir une matrice 2 sur 4 à la place, reproduisez-la horizontalement, puis obtenez chaque ligne séparément. Cela nous donne les 4 valeurs à 2 bits dont nous avons besoin.
  • ⊃,/: joindre les listes résultantes ensemble, en donnant une liste d’étapes de 2 bits.
  • 5 9{... }: étant donné la liste des étapes et commençant à la position [9,5]:
    • (⍺⌷F)+←1: incrémente la position actuelle dans F.
    • ×⍴⍵:: si la liste des étapes n'est pas vide:
      • ↑⍵: faites le premier pas dans la liste
      • ⍺-1 1-2×: récupère le delta de cette étape et le soustrait de la position actuelle
      • 1 1⌈9 17⌊: restreindre le mouvement à l'intérieur du champ
      • (... )∇1↓⍵: continue avec la nouvelle position et le reste des étapes
    • Si elle est vide:
      • (⍺⌷F)←16: mis Fà 16 en position finale
      • F[5;9]←15: réglé Fà 15 à la position de départ
      • ' .o+=*BOX@%&#/^SE'[1+F]: associe chaque position au caractère correspondant
      • K⍪(M,... ,M←'|')⍪K←'+','+',⍨17⍴'-': encapsule le résultat en lignes
marinus
la source
8

Perl, 300 + 1 (-n) = 301 octets

perl -ne 'sub b{$b=$_[0]+$_[1];$_[0]=$b<0?0:$b>$_[2]?$_[2]:$b}$v=pack"(H2)*",/\w\w/g;($x,$y)=(8,4);$a[b($y,($_&2)-1,8)*17+b($x,($_&1)*2-1,16)]++for map{vec$v,$_,2}0..63;@a[76,$y*17+$x]=(15,16);$c=" .o+=*BOX@%&#/^SE";print$d="+".("-"x17)."+\n",(map{+"|",(map{substr$c,$_,1}@a[$_*17..($_+1)*17-1]),"|\n"}0..8),$d'

Cette réponse est dégoûtante, mais c'est aussi la première de ce casse-tête, donc ça ira pour le moment.

-nprendre une ligne d’entrée sur STDIN et remplir $_.

# b($v, -1 or 1, max) modifies $v within 0..max
sub b{$b=$_[0]+$_[1];$_[0]=$b<0?0:$b>$_[2]?$_[2]:$b}

# turn $_ into a binary string
$v=pack"(H2)*",/\w\w/g;

# initialize cursor
($x,$y)=(8,4);

# find an element of single-dimensional buffer @a
$a[
    # y += (bitpair & 2) - 1, within 8
    b($y,($_&2)-1,8) * 17
    # x += (bitpair & 1) * 2 - 1, within 17
  + b($x,($_&1)*2-1,16)
# and increment it
]++
# for each bit pair (in the right order!)
  for map{vec$v,$_,2}0..63;

# overwrite the starting and ending positions
@a[76,$y*17+$x]=(15,16);

# ascii art lookup table
$c=" .o+=*BOX@%&#/^SE";

# output
print
  # the top row, saving it for later
  $d="+".("-"x17)."+\n",
  # each of the eight middle rows
  (map{+
    # converting each character in @a in this row as appropriate
    "|",(map{substr$c,$_,1}@a[$_*17..($_+1)*17-1]),"|\n"
  }0..8),
  # the bottom row
  $d
Eric Wastl
la source
7

R, 465 459 410 393 382 357 octets

f=function(a){s=strsplit;C=matrix(as.integer(sapply(strtoi(el(s(a,":")),16),intToBits)[1:8,]),2);C[!C]=-1;n=c(17,9);R=array(0,n);w=c(9,5);for(i in 1:64){w=w+C[,i];w[w<1]=1;w[w>n]=n[w>n];x=w[1];y=w[2];R[x,y]=R[x,y]+1};R[]=el(s(" .o+=*BOX@%&#/^",""))[R+1];R[9,5]="S";R[x,y]="E";z="+-----------------+\n";cat(z);for(i in 1:9)cat("|",R[,i],"|\n",sep="");cat(z)}

Avec indentations et nouvelles lignes:

f=function(a){
    s=strsplit
    C=matrix(as.integer(sapply(strtoi(el(s(a,":")),16),intToBits)[1:8,]),2)
    C[!C]=-1
    n=c(17,9)
    R=array(0,n)
    w=c(9,5)
    for(i in 1:64){
        w=w+C[,i]
        w[w<1]=1
        w[w>n]=n[w>n]
        x=w[1]
        y=w[2]
        R[x,y]=R[x,y]+1
    }
    R[]=el(s(" .o+=*BOX@%&#/^",""))[R+1]
    R[9,5]="S"
    R[x,y]="E"
    z="+-----------------+\n"
    cat(z)
    for(i in 1:9)cat("|",R[,i],"|\n",sep="")
    cat(z)
}

Usage:

> f("16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48")
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+
> f("37:e4:6a:2d:48:38:1a:0a:f3:72:6d:d9:17:6b:bd:5e")
+-----------------+
|                 |
|                 |
|          .      |
|     .   o       |
|o . o . S +      |
|.+ + = . B .     |
|o + + o B o E    |
| o .   + . o     |
|         .o      |
+-----------------+
planificateur
la source
Vous ne pouvez pas jouer au golf avec la fonction "matrice" en la définissant une fois comme "m"? Pareil pour 'fonction'?
CousinCocaine
Je pense que vous n'avez pas besoin de 'sep =' dans la fonction 'chat'
CousinCocaine
la valeur par défaut pour sep est un espace, je dois donc le remplacer, mais je pourrais aussi alias matrix.
plannapus
De plus, autant que je sache, vous ne pouvez pas alias function.
Plannapus
5

Octave, 277

d=reshape(rot90(dec2bin(hex2dec(strsplit(input('','s'),':'))))>'0',2,[])*2-1;p=[9;5];for m=1:64 p=[max(min(p(:,1)+d(:,m),[17;9]),1) p];end;A=' .o+=*BOX@%&#/^SE';F=A(sparse(p(2,:),p(1,:),1,9,17)+1);F(5,9)='S';F(p(2,1),p(1,1))='E';[a='+-----------------+';b=['|||||||||']' F b;a]

Explication:

%// convert the input to binary and rearrange it to be
%//   an array of vectors: [x_displacement; y_displacement]
d=reshape(rot90(dec2bin(hex2dec(strsplit(input('','s'),':'))))>'0',2,[])*2-1;

%// start position array with vector for the start position
p=[9;5];
%// for each move, add displacement, clamping to valid values
for m=1:64 p=[max(min(p(:,1)+d(:,m),[17;9]),1) p];end;

%// alphabet for our fingerprint
A=' .o+=*BOX@%&#/^SE';

%// create a sparse matrix, accumulating values for duplicate
%// positions, and replace counts with symbols
F=A(sparse(p(2,:),p(1,:),1,9,17)+1);

%// correct the start and end symbols and construct the final output
F(5,9)='S';F(p(2,1),p(1,1))='E';
[a='+-----------------+';b=['|||||||||']' F b;a]

Échantillon échantillon:

>> bish
b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b
ans =

+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+
gobelet
la source
3

Pyth, 145 143 140

Jm*17]09A,4K8FYcz\:V4AmhtS[0^2d+@,HGdtyv@+_.BiY16*7\0+-4dyN),3 4 X@JGHh@@JGH; X@J4K15 X@JGH16
=Y++\+*17\-\+VJ++\|s@L" .o+=*BOX@%&#/^SE"N\|)Y

Essayez-le en ligne.

Pyth n'est pas vraiment bon pour les défis avec itération. J'attends de CJam qu'il batte facilement.

PurkkaKoodari
la source
3

JavaScript (ES6) 249 208

Modifier la bordure manquante ajoutée

Testez l'exécution de l'extrait de code ci-dessous dans tout navigateur compatible EcmaScript 6.

B=f=>f.replace(/\w+/g,b=>{for(b=`0x1${b}`;b-1;b>>=2)++g[p=(q=(p=(q=p+~-(b&2)*18)>0&q<162?q:p)+b%2*2-1)%18?q:p]},p=81,z=`+${'-'.repeat(17)}+`,g=Array(162).fill(0))&&g.map((v,q)=>q?q-81?q-p?q%18?' .o+=*BOX@%&#/^'[v]:`|
|`:'E':'S':z+`
|`).join``+`|
`+z

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;['37:e4:6a:2d:48:38:1a:0a:f3:72:6d:d9:17:6b:bd:5e'
,'16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48'
,'b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b'
,'05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47'  
].forEach(t=>console.log(t+'\n'+B(t)+'\n'))


// Less golfed

BB=f=>(
  p = 81,
  g = Array(162).fill(0),
  f.replace(/\w+/g, b => {
    for(b = `0x1${b}`;b != 1; b >>= 2)
      q = p+~-(b&2)*18,
      p = q>0&q<162?q:p,
      p = (q=p+b%2*2-1)%18?q:p,
      ++g[p]
  }),
  g.map((v,q) => q-81?q-p?q%18?' .o+=*BOX@%&#/^'[v]:'\n':'E':'S')
  .join``
)
pre { font-family: menlo,consolas; font-size:13px }
<pre id=O></pre>

edc65
la source
Votre code de golf doit lui-même être capable d'imprimer les frontières. Actuellement, seul votre scénario de test imprime les bordures supérieure et inférieure forEach, les bordures verticales sont toujours manquantes.
Padarom
@Padarom J'ai mal compris votre commentaire "soyez raisonnable", pensant que la frontière n'était pas demandée
edc65
Je voulais dire être raisonnable quant à la méthode d’entrée et de sortie que vous utilisez. Toutes mes excuses si cela était trompeur, je vais le
réviser
3

Python, 381 328

-51 grâce à @JonathanFrech

def h(f):
 s=[f'{int(o,16)>>s&3:02b}'for o in f.split(':')for s in(0,2,4,6)];r=[0]*153;p=76;w=17
 for d in s:r[p]+=1;p+=(-(p%w!=0),p%w!=16)[int(d[1])]+(-w*(p//w!=0),w*(p//w!=8))[int(d[0])]
 r[76]=15;r[p]=16;b='+'+'-'*w+'+';print(b);i=0
 while i<153:print(f"|{''.join(' .o+=*BOX@%&#/^SE'[c]for c in r[i:i+w])}|");i+=w
 print(b)

Légèrement non golfé pour des raisons d'explication:

def h_(f):
 #Alias 17 because it gets used enough times for this to save bytes
 w=17

 #Input parsing
 s=[f'{int(o,16)>>s&3:02b}'for o in f.split(':')for s in(0,2,4,6)]

 #Room setup
 r=[0]*153
 p=76

 #Apply movements
 for d in s:
  r[p]+=1
  p+=(-(p%w!=0),p%w!=16)[int(d[1])]+(-w*(p//w!=0),w*(p//w!=8))[int(d[0])]
 r[76]=15 #Set start position
 r[p]=16 #Set end position

 #Display result
 b='+'+'-'*w+'+'
 print(b)
 i=0
 while i<153:
  print(f"|{''.join(' .o+=*BOX@%&#/^SE'[c]for c in r[i:i+w])}|")
  i+=w
 print(b)

Ce bordel d'une ligne:

r[p]+=1;p+=(-(p%w!=0),p%w!=16)[int(d[1])]+(-w*(p//w!=0),w*(p//w!=8))[int(d[0])]

Est fonctionnellement équivalent à ceci:

if int(d[0]): #Down, Y+
  if p//17!=8:
    p+=17
else: #Up, Y-
  if p//17!=0:
    p-=17
​
if int(d[1]): #Right, X+
  if p%17!=16:
    p+=1
else: #Left, X-
  if p%17!=0:
    p-=1

mais niche tous les conditionnels dans ce style de raccourci de golf: (false_value,true_value)[condition] Espérons que le reste est assez explicite

Des tests

h('16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48')
+-----------------+
|        .        |
|       + .       |
|      . B .      |
|     o * +       |
|    X * S        |
|   + O o . .     |
|    .   E . o    |
|       . . o     |
|        . .      |
+-----------------+

h("b6:dd:b7:1f:bc:25:31:d3:12:f4:92:1c:0b:93:5f:4b")
+-----------------+
|            o.o  |
|            .= E.|
|             .B.o|
|              .= |
|        S     = .|
|       . o .  .= |
|        . . . oo.|
|             . o+|
|              .o.|
+-----------------+

h("05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47")
+-----------------+
|       o=.       |
|    o  o++E      |
|   + . Ooo.      |
|    + O B..      |
|     = *S.       |
|      o          |
|                 |
|                 |
|                 |
+-----------------+
```
senox13
la source
Bonjour et bienvenue sur PPCG. Vous pouvez utiliser votre nom de code en utilisant des noms de variable d'une lettre et en mettant une ligne pour boucle dans une ligne. (1,0)[p%17==16]est +(p%17!=16), ou peut-être même p%17!=16.
Jonathan Frech
De plus, il y a un espace superflu dans ] for.
Jonathan Frech
Je pense fpdevrait être f.
Jonathan Frech le
330 octets .
Jonathan Frech
2
Pourquoi ai-je utilisé ~16? Un peu d'obfuscation ne peut jamais nuire à votre golf!
Jonathan Frech
2

Ruby 288

->k{w=17
r=[z=?++?-*w+?+]
(0...w*9).each_slice(w).map{|o|r<<?|+o.map{|x|c=76
q=0
k.split(?:).flat_map{|b|(0..7).map{|i|b.to_i(16)[i]}}.each_slice(2){|h,v|v<1?(c>w&&c-=w):c<w*8&&c+=w
c+=h<1?c%w>0?-1:0:c%w<16?1:0
c==x&&q+=1}
x==76?'S':c==x ?'E':' .o+=*BOX@%&#/^'[q]}.join+?|}
(r+[z]).join'
'}

Essayez-le en ligne: http://ideone.com/QOHAnM

La version lisible (celle à partir de laquelle j'ai commencé le golf) est ici: http://ideone.com/XR64km

Cristian Lupascu
la source
2

C - 488

Il doit y avoir un moyen de réduire cette taille ....

#include<stdio.h>
#define H ++p;h[i]|=(*p-(*p>58?87:48))<<
#define B ((h[j]>>n*2)&3)
#define L puts("+-----------------+")
#define F(m,s)for(m=0;m<s;m++)
int h[16],m[17][9],i,j,n,x=8,y=4;main(w,v)char**v;{char*p=v[1]-1,c[17]={32,46,111,43,61,42,66,79,88,64,37,38,35,47,94,83,69};for(;*p;p++,i++){H 4;H 0;}F(j,16)F(n,4){if(B&1)x+=!(x==16);else x-=!(x==0);if(B&2)y+=!(y==8);else y-=!(y==0);m[x][y]++;}m[8][4]=15;m[x][y]=16;L;F(i,9){printf("|");F(j,17)printf("%c",c[m[j][i]]);puts("|");}L;}
Jerry Jeremiah
la source
0

Rouille - 509 octets

fn b(s:&str)->String{let(mut v,mut b)=([[0;11];20],[9,5]);v[19]=[19;11];for i in 0..16{let mut c=usize::from_str_radix(&s[i*3..i*3+2],16).unwrap();for k in 0..4{for j in 0..2{v[j*18][i%9+1]=18;v[i+k][j*10]=[17,3][(i+k+17)%18/17];b[j]=match(if c&(j+1)==j+1{b[j]+1}else{b[j]-1},j,){(0,_)=>1,(18,0)=>17,(10,1)=>9,x@_=>x.0 as usize,}}v[b[0]][b[1]]+=1;c>>=2;}}v[9][5]=15;v[b[0]][b[1]]=16;(0..220).fold("\n".to_string(),|s,i|{format!("{}{}",s," .o+=*BOX@%&#/^SE-|\n".chars().nth(v[i%20][i/20] as usize).unwrap())})}

Large mais ... presque proche de C. Comme d'habitude, de nombreux octets ont été utilisés du fait que Rust ne transtype pas automatiquement les types les uns dans les autres. Mais il y a probablement aussi place à amélioration ... pourrait probablement utiliser certaines idées d'autres solutions.

la version ungolfed est sur le Rust Playground en ligne

don lumineux
la source