O Bispo Bêbado


42

Na criptografia de chave pública, uma impressão digital de chave pública é uma sequência curta de bytes usada para identificar uma chave pública mais longa.

No SSH, em particular, eles podem ser usados ​​para verificar se um servidor é de fato o servidor com o qual estou esperando me comunicar e não sou alvo de um ataque do tipo intermediário.

Eles geralmente são representados como uma sequência de dígitos hexadecimais, portanto, pode ser bastante chato e tedioso compará-lo com a impressão digital que eu esperaria:

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

Para facilitar um pouco, o OpenSSH introduziu um método para visualizar impressões digitais como arte ASCII, com a seguinte aparência:

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

Com isso, eu poderia tentar lembrar a forma grosseira da arte ASCII e então (teoricamente) a reconheceria quando a impressão digital do servidor mudasse e a imagem parecesse diferente.

Como funciona

Tomado de Dirk Loss, Tobias Limmer, Alexander von Gernler. 2009. O bispo bêbado: Uma análise do algoritmo de visualização de impressão digital OpenSSH .

A grade tem uma largura de 17 caracteres e uma altura de 9 caracteres. O "bispo" começa na linha 4 / coluna 8 (o centro). Cada posição pode ser indicada como [x, y], ou seja, [8,4] para a posição inicial do bispo.

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

O bispo usa a impressão digital para se movimentar. Ele lê em bytes da esquerda para a direita e do bit menos significativo para o bit mais significativo:

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

O bispo adotará o seguinte plano:

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

Casos especiais:

  • Se o bispo está em um canto e se move novamente para o canto, ele não se move. ou seja: o bispo está [0,0]e seu próximo passo seria 00. Ele permanece em[0,0]
  • Se o bispo estiver em um canto ou em uma parede e se mover para uma das paredes, ele se moverá horizontal ou verticalmente. ou seja: o bispo está [0,5]e seu próximo passo seria 01. Ele não pode ir para a esquerda, então ele apenas sobe, para [0,4].

Cada posição possui um valor de quantas vezes o bispo visitou esse campo:

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 |

Os valores 15 (S) e 16 (E) são especiais, pois marcam a posição inicial e final do bispo, respectivamente, e substituem o valor real da posição correspondente.

Objetivo

Crie um programa que use uma impressão digital alfanumérica como entrada e produz sua representação artística ASCII, conforme mostrado nos exemplos.

Exemplos

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

Regras

  • Isso é . O código no menor número de bytes vence.
  • Você não pode usar uma biblioteca existente que produz a imagem.
  • Use o idioma que você preferir!
  • Sua inscrição deve ser um programa completo

3
Podemos supor que nenhuma célula será visitada mais de 14 vezes?
Martin Ender

2
Existem alguns casos de cobertura mínima que resultariam em alguns campos sendo visitados mais de 14 vezes. 33:33:33:...:33, cc:cc:cc:...:ccseriam exemplos para isso. A impressão digital é geralmente um hash MD5, por isso é altamente improvável que você obtenha esse resultado. Não encontrei nenhuma fonte confiável sobre como lidar com isso, então, por enquanto, eu diria: Suponha que nenhuma célula será visitada mais de 14 vezes.
Padarom

Respostas:


2

Pitão, 125 bytes

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

Experimente online: demonstração ou suíte de testes

Escrevi há alguns dias, mas não a publiquei, porque não estava realmente feliz com isso.

Explicação:

A ideia básica é a seguinte. Eu começo com o par (4, 8). Em cada movimento (m1,m2)eu vou do (x, y)para (x-1+2*m1, y-1+2*m2). Para certificar-se, que estas coordenadas não ir para fora das fronteiras, vou fazer algumas listas, classificá-los e devolver o elemento do meio: (sorted(0,8,newx)[1], sorted(0,16,newy)[1]).

Eu acompanho todas as posições. A esta lista de posições, adiciono uma lista de todas as posições possíveis, classificá-las e codificá-las no comprimento da execução. O que me dá um número para cada posição. Com esse número, posso escolher o caractere co-correto e, no final, substituir os caracteres da posição inicial e final.


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'}¨⍵⊂⍨':'≠⍵}

Esta é uma função que usa a string como argumento correto e retorna uma matriz de caracteres contendo a representação artística ASCII, por exemplo:

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

Explicação:

  • ⎕ML←3: definido ⎕MLcomo 3. Isso torna mais útil para dividir seqüências de caracteres.

  • F←9 17⍴0: faça uma matriz de zeros de 17 por 9. Frepresenta quantas vezes cada posição foi visitada.

  • ⍵⊂⍨':'≠⍵: dividir em :caracteres.

  • {... : para cada grupo:
    • ¯1+⍵⍳⍨⎕D,'abcdef': encontre o índice de cada caractere na string '01234567890abcdef'. Subtraia 1, porque a APL é indexada 1 por padrão.
    • (4/2)⊤: converta os valores em suas representações de 4 bits (agora deve haver uma matriz de 2 por 4).
    • ↓⊖4 2⍴⍉: gire a matriz, use os elementos para preencher uma matriz 2 por 4, espelhe essa matriz horizontalmente e, em seguida, obtenha cada linha separadamente. Isso nos fornece os 4 valores de 2 bits necessários.
  • ⊃,/: junte as listas resultantes, fornecendo uma lista de etapas de 2 bits.
  • 5 9{... }: dada a lista de etapas e iniciando na posição [9,5]:
    • (⍺⌷F)+←1: incrementa a posição atual em F.
    • ×⍴⍵:: se a lista de etapas não estiver vazia:
      • ↑⍵: dê o primeiro passo da lista
      • ⍺-1 1-2×: obtenha o delta para essa etapa e subtraia-o da posição atual
      • 1 1⌈9 17⌊: restringir o movimento para dentro do campo
      • (... )∇1↓⍵: continue com a nova posição e o restante das etapas
    • Se estiver vazio:
      • (⍺⌷F)←16: definido Fcomo 16 na posição final
      • F[5;9]←15: definido Fcomo 15 na posição inicial
      • ' .o+=*BOX@%&#/^SE'[1+F]: mapeia cada posição para o caractere correspondente
      • K⍪(M,... ,M←'|')⍪K←'+','+',⍨17⍴'-': agrupar o resultado em linhas

8

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

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'

Essa resposta é nojenta, mas também é a primeira para esse quebra-cabeça, então será o suficiente por enquanto.

-npara pegar uma linha de entrada no STDIN e preencher $_.

# 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

7

R, 465 459 410 393 382 357 bytes

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

Com recuos e novas linhas:

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

Uso:

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

Você não pode jogar a função 'matriz' definindo-a uma vez como 'm'? O mesmo para 'função'?
CousinCocaine

Eu acho que você não precisa 'setembro =' na função 'gato'
CousinCocaine

o padrão para sep é um espaço, então eu preciso substituí-lo, mas na verdade eu poderia alias matrix.
plannapus

Além disso, até onde eu sei, você não pode usar o pseudônimo function.
plannapus

5

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

Explicação:

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

Exemplo de execução:

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

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

Experimente online.

Pyth não é realmente bom em desafios com iteração. Estou esperando que o CJam o derrote facilmente.


3

JavaScript (ES6) 249 208

Editar Borda ausente adicionada

Teste a execução do snippet abaixo em qualquer navegador compatível com 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>


Seu próprio código de golfe também deve ser capaz de imprimir as bordas. Atualmente, apenas o seu caso de teste imprime as bordas superior e inferior na forEach, as bordas verticais ainda estão ausentes.
Padarom 9/10/2015

@Padarom eu não entendi o seu "ser razoável" comentário, pensando que a fronteira não foi solicitado
edc65

Eu quis dizer ser razoável quanto ao método de entrada e saída que você usa. Minhas desculpas se isso era enganador, eu vou editá-lo para fora
Padarom

3

Python, 381 328

-51 graças a @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)

Ligeiramente não-destruído por uma questão de explicação:

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)

Essa bagunça de uma linha:

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

É funcionalmente equivalente a isso:

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

mas aninha todos os condicionais nesse estilo de atalho de golfe: (false_value,true_value)[condition] Espero que o resto seja bastante auto-explicativo

Testes

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

Olá e bem-vindo ao PPCG. Você pode jogar seu código usando nomes de variáveis ​​de uma letra e colocando um loop de linha única em uma linha. (1,0)[p%17==16]é +(p%17!=16), ou possivelmente até p%17!=16.
Jonathan Frech

Além disso, há um espaço supérfluo em ] for.
Jonathan Frech

Eu acho que fpdeveria ser f.
Jonathan Frech


2
Por que eu usei ~16? Um pouco de ofuscação nunca pode prejudicar o seu golfe!
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'
'}

Experimente online: http://ideone.com/QOHAnM

A versão legível (da qual comecei a jogar golfe) está aqui: http://ideone.com/XR64km


2

C - 488

Deve haver uma maneira de tornar isso menor ....

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

0

Ferrugem - 509 bytes

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())})}

Grande, mas ... quase próximo de C. Como de costume, há muitos bytes usados ​​devido à maneira como o Rust não lança automaticamente tipos um no outro. Mas provavelmente também há espaço para melhorias ... provavelmente poderia usar algumas idéias de outras soluções.

versão ungolfed está no Rust Playground on-line

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.