Introdução

Uma página de código mapeia valores inteiros para um caractere específico. Podemos visualizar uma página de código como esta:

+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - - + --- + --- + --- + --- +
| | 0 1 | 2 3 4 5 6 7 8 9 A B C D E F
+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - - + --- + --- + --- + --- +
| 0 q w e r | t z você eu o | p a | s d f g j
+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - - + --- + --- + --- + --- +
| 1 | k eu y x c v b n | m Q W E R T Z U
+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - - + --- + --- + --- + --- +
| 2 Eu O P A S D F G H J | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - - + --- + --- + --- + --- +

As linhas especificam o primeiro dígito e as colunas o segundo dígito do número hexadecimal.

O desafio

Dada uma cadeia de 16 a 255 caracteres únicos, produza a página de código correspondente usando o índice baseado em zero de cada caractere na cadeia como valor. A entrada, qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJpor exemplo, renderia a tabela acima.

• A saída deve estar exatamente no mesmo formato da tabela acima. Somente uma nova linha à direita é opcional.
• Se o comprimento da entrada não for múltiplo de 16, será necessário iniciar uma nova linha para os caracteres restantes e deixar as células não utilizadas vazias (= preenchidas com 3 espaços).
• Cada caractere é colocado exatamente no meio de uma célula, preenchido por um espaço à esquerda e à direita.
• Os valores na primeira linha e coluna são dados por números hexadecimais com os dígitos 0123456789ABCDEF. Aqueles são preenchidos com um espaço à esquerda e à direita também. Você pode optar por usar dígitos hexadecimais em minúsculas, mas precisa se ater a um.
• Os únicos caracteres presentes na saída são hífens -, vantagens +, tubos |, espaços , os dígitos dos números hexadecimais e os caracteres da entrada.
• São proibidos quaisquer componentes internos relacionados a tabelas de arte ASCII ou banalizarem o problema.
• Você pode assumir que a entrada consiste apenas em caracteres de uma codificação específica. Especifique se for esse o caso.
• Se o seu idioma puder lidar apenas com entrada ASCII, você poderá assumir a entrada somente ASCII e caracteres repetidos.

Regras

• Função ou programa completo permitido.
• Regras padrão para entrada / saída.
• Aplicam-se brechas padrão .
• Isso é código-golfe , e a menor contagem de bytes vence. O desempatador é uma inscrição anterior.

Feliz codificação!

Pitão, 60 bytes

K+*"+---"hJ16\+Vm++"| "j" | "d" |"+]+]d.HMJ.e+.Hk.[bdJczJNK

A nova linha líder é significativa.

Experimente aqui.

Python 3.5, 326 355 bytes:

( +29 bytes, pois se o comprimento da última linha não for múltiplo de 16, as células não utilizadas devem ser deixadas em branco (embora, na minha opinião, pareça muito melhor se essas células vazias não forem mostradas) )

def f(r):o=' 0123456789ABCDEF';r=[r[0+i:16+i]for i in range(0,len(r),16)];print('+---'*17+'+\n|',end='');[print(' {} |'.format(h),end='')for h in o];print(''.join([str(e+' | ')if e.isdigit()or e.isalpha()else str(e)for e in''.join([str('\n'+'+---'*17+'+\n| '+x[0]+x[1])for x in zip(o[1::1],r)])]),end='');print('  |'+'   |'*(15-len(r[-1]))+'\n'+'+---'*17+'+')

Funciona como um encanto!

Entradas e saídas de amostra:

Input: 'hopper'

Output:

    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    |   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    | 0 | h | o | p | p | e | r |   |   |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Input: 'honkhonkhonkhonkhonk'

Output:

    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    |   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    | 0 | h | o | n | k | h | o | n | k | h | o | n | k | h | o | n | k | 
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    | 1 | h | o | n | k |   |   |   |   |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Input: 'hi'

Output: 

    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    |   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    | 0 | h | i |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Espero que isso esteja bem.

Além disso, aqui está outra versão que eu criei para esse desafio, que, embora seja um candidato inválido, pois não imprime células vazias extras para a última linha, se o comprimento não for múltiplo 16, na minha opinião gera uma página muito mais bonita do que o exigido pelo OP, principalmente porque ele nem mostra células vazias se a última linha não é um múltiplo de 16, mas apenas mostra células preenchidas, e é isso:

def f2(r):o=' 0123456789ABCDEF';r=[r[0+i:16+i]for i in range(0,len(r),16)];print('+---'*17+'+\n|',end='');[print(' {} |'.format(h),end='')for h in o];print(''.join([str(e+' | ')if e.isdigit()or e.isalpha()else str(e)for e in''.join([str('\n'+'+---'*17+'+\n| '+x[0]+x[1])for x in zip(o[1::1],r)])]));print('+---'*(len(r[-1])+1)+'+')

Aqui está uma amostra de entrada e saída para o código inaplicável acima:

Input: 'ggreuuobgugoubgoubguorgoruguor'

Output:

    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    |   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    | 0 | g | g | r | e | u | u | o | b | g | u | g | o | u | b | g | o | 
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    | 1 | u | b | g | u | o | r | g | o | r | u | g | u | o | r | 
    +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

    (As you can see, there are no empty cells shown in the entire table. This looks much better to me.)

05AB1E , 65 63 bytes

Código:

"+---"17×'+J©,žhAu6£¹J16÷)v„| ?N>iðëN<16B}y«ð17×ðñvy„ |ðJ?}¶?®,

Experimente online! . Usa a codificação CP-1252 .

JavaScript (ES6), 148 bytes

s=>(s=' 0123456789ABCDEF'+s+' '.repeat(15)).match(/(?!^).{16}/g).map((t,i)=>d+`+
| `+[s[i],...t].join` | `,d=`+---`.repeat(17)).join` |
`+` |
${d}+`

A ' 0123456789ABCDEF'existe para preencher a primeira coluna, mas convenientemente também cobre a primeira linha. A sequência de entrada é então preenchida com espaços para permitir que ela seja dividida em substrings de comprimento 16, (?|^)impedindo que o espaço à esquerda seja correspondido. O resto é apenas juntar as peças.

Excel VBA, 157 bytes (trapaça?)

Função de janela imediata VBE anônima que destrutivamente leva a entrada do intervalo [A1]e as saídas para o ActiveSheetobjeto.

Golfe

[B1:Q1]="=Dec2Hex(Column(B1)-2)":L=[Len(A1)]:For i=0To l:Cells(Int(i/16)+2,i Mod 16+2)=Mid([A1],i+1,1):Next:For i=1To Int(l/16)+1:Cells(i+1,1)=i:Next:[A1]=""

Formatado

[B1:Q1]="=Dec2Hex(Column(B1)-2)"
L=[Len(A1)]
For i=0To l:Cells(Int(i/16)+2,i Mod 16+2)=Mid([A1],i+1,1):Next
For i=1To Int(l/16)+1:Cells(i+1,1)=i:Next
[A1]=""

Entrada / Saída

Dado:

[A1]="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJ"

a saída gerada é