introduzione

Una tabella codici associa valori interi a un carattere specifico. Possiamo visualizzare una tabella codici come questa:

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

Le righe specificano la prima cifra e le colonne la seconda cifra del numero esadecimale.

La sfida

Data una stringa di 16-255 caratteri univoci, genera la tabella codici corrispondente utilizzando l'indice in base zero di ciascun carattere della stringa come valore. L'input, qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJad esempio, produrrebbe la tabella sopra.

• L'output deve essere nello stesso identico formato della tabella sopra. Solo una nuova riga finale è facoltativa.
• Se la lunghezza di input non è un multiplo di 16, è necessario iniziare una nuova riga per i caratteri rimanenti e lasciare vuote le celle non utilizzate (= riempite con 3 spazi).
• Ogni personaggio è posizionato esattamente nel mezzo di una cella, imbottito di uno spazio a sinistra e a destra.
• I valori nella prima riga e colonna sono dati da numeri esadecimali con le cifre 0123456789ABCDEF. Quelli sono imbottiti con uno spazio anche a sinistra e a destra. È possibile scegliere di utilizzare cifre esadecimali minuscole ma è necessario attenersi a una.
• Gli unici caratteri presenti nell'output sono trattini -, vantaggi +, pipe |, spazi , cifre per numeri esadecimali e caratteri dall'input.
• È vietato qualsiasi builtin correlato a tabelle di arte ASCII o banalizzare il problema.
• Si può presumere che l'input sia costituito solo da caratteri di una codifica specifica. Si prega di specificare se è così.
• Se la tua lingua può gestire solo input ASCII, puoi assumere solo caratteri ASCII e caratteri ripetuti.

Regole

• Funzione o programma completo consentiti.
• Regole predefinite per input / output.
• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince il conteggio dei byte più basso. Tiebreaker è una presentazione precedente.

Buona programmazione!

Pyth, 60 byte

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

La nuova linea principale è significativa.

Provalo qui.

Python 3.5, 326 355 byte:

( +29 byte poiché se la lunghezza dell'ultima riga non è un multiplo di 16, le celle inutilizzate dovrebbero essere lasciate vuote (anche se, a mio avviso, sembra molto meglio se quelle celle vuote non vengono nemmeno mostrate) )

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

Funziona come un fascino!

Ingressi e uscite di esempio:

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

Spero che vada bene.

Inoltre, ecco un'altra versione che ho creato per questa sfida, che, sebbene sia un candidato non valido poiché non stampa celle vuote extra per l'ultima riga se la sua lunghezza non è un multiplo 16, a mio avviso produce una pagina molto più bella di quello richiesto da OP, principalmente perché non mostra nemmeno celle vuote se l'ultima riga non è un multiplo di 16, ma mostra solo celle riempite, e basta:

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

Ecco un esempio di input e output per il codice inapplicabile sopra:

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 byte

Codice:

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

Provalo online! . Utilizza la codifica CP-1252 .

JavaScript (ES6), 148 byte

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

Il ' 0123456789ABCDEF'esiste per popolare la prima colonna, ma convenientemente copre anche la prima riga. La stringa di input viene quindi riempita con spazi per consentirne la divisione in sottostringhe di lunghezza 16, (?|^)impedendo che lo spazio iniziale venga adattato. Il resto sta solo unendo i pezzi.

Excel VBA, 157 byte (barare?)

Anonimo VBE Funzione finestra immediata che accetta in modo distruttivo l'input dall'intervallo [A1]e l'output ActiveSheetsull'oggetto.

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

formattato

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

Input Output

Dato:

[A1]="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJ"

l'output generato è