Introducción

Una página de códigos asigna valores enteros a un carácter específico. Podemos visualizar una página de códigos como esta:

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

Las filas especifican el primer dígito y las columnas el segundo dígito del número hexadecimal.

El reto

Dada una cadena de 16-255 caracteres únicos, muestre la página de códigos correspondiente utilizando el índice basado en cero de cada carácter en la cadena como su valor. La entrada, qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJpor ejemplo, arrojaría la tabla de arriba.

• La salida debe estar exactamente en el mismo formato que la tabla anterior. Solo una nueva línea final es opcional.
• Si la longitud de entrada no es un múltiplo de 16, debe comenzar una nueva fila para los caracteres restantes y dejar vacías las celdas no utilizadas (= llenas de 3 espacios).
• Cada personaje se coloca exactamente en el medio de una celda, rellenado por un espacio a la izquierda y a la derecha.
• Los valores en la primera fila y columna están dados por números hexadecimales con los dígitos 0123456789ABCDEF. Esos están rellenados con un espacio a la izquierda y a la derecha también. Puede optar por usar dígitos hexadecimales en minúsculas, pero debe atenerse a uno.
• Los únicos caracteres presentes en la salida son guiones -, más +, tuberías |, espacios , los dígitos para números hexadecimales y los caracteres de la entrada.
• Se prohíbe cualquier construcción que esté relacionada con tablas de arte ASCII o que trivialice el problema de alguna manera.
• Puede suponer que la entrada consta solo de caracteres de una codificación específica. Por favor, especifique si ese es el caso.
• Si su idioma solo puede manejar la entrada ASCII, puede asumir una entrada solo ASCII y caracteres repetidos.

Reglas

• Función o programa completo permitido.
• Reglas predeterminadas para entrada / salida.
• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana la cuenta de bytes más baja. Tiebreaker es una presentación anterior.

¡Feliz codificación!

Pyth, 60 bytes

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

La nueva línea principal es significativa.

Pruébalo aquí.

Python 3.5, 326355 bytes:

( +29 bytes ya que si la longitud de la última fila no es múltiplo de 16, las celdas no utilizadas deben dejarse vacías (aunque, en mi opinión, se ve mucho mejor si esas celdas vacías ni siquiera se muestran) )

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 de maravilla!

Entradas y salidas de muestra:

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 esté bien.

Además, aquí hay otra versión que creé para este desafío, que, aunque es un candidato no válido, ya que no imprime celdas vacías adicionales para la última fila si su longitud no es un 16 múltiple, en mi opinión, genera una página mucho mejor que el requerido por OP, principalmente porque ni siquiera muestra celdas vacías si la última fila no es múltiplo de 16, sino que solo muestra celdas llenas, y eso es todo:

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

Aquí hay una entrada y salida de muestra para el código inaplicable anterior:

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?}¶?®,

Pruébalo en línea! . Utiliza la codificación 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}+`

El ' 0123456789ABCDEF'existe para rellenar la primera columna, pero convenientemente también cubre la primera fila. La cadena de entrada se rellena con espacios para permitir que se divida en subcadenas de longitud 16, (?|^)evitando que el espacio inicial coincida. El resto es solo unir las piezas.

Excel VBA, 157 Bytes (¿Hacer trampa?)

Función de ventana inmediata anónima de VBE que toma de manera destructiva la entrada del rango [A1]y las salidas al ActiveSheetobjeto.

Golfed

[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]=""

Formateado

[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]=""

De entrada y salida

Dado:

[A1]="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJ"

la salida generada es