Einführung

Eine Codepage ordnet Ganzzahlwerte einem bestimmten Zeichen zu. Wir können eine Codepage wie diese visualisieren:

+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - + --- + --- + --- + --- +
| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - + --- + --- + --- + --- +
| 0 | q | w | e | r | t | z | u | ich | 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 | Ich | O | P | A | S | D | F | G | H | J | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - + --- + --- + --- + --- +

Die Zeilen geben die erste Ziffer und die Spalten die zweite Ziffer der Hex-Zahl an.

Die Herausforderung

Geben Sie bei einer Zeichenfolge mit 16 bis 255 eindeutigen Zeichen die entsprechende Codepage aus, wobei Sie den auf Null basierenden Index jedes Zeichens in der Zeichenfolge als Wert verwenden. Die Eingabe würde qwertzuiopasdfghjklyxcvbnmQWERTZUIOPASDFGHJzum Beispiel die obige Tabelle ergeben.

• Die Ausgabe muss genau das gleiche Format haben wie in der obigen Tabelle. Nur ein abschließender Zeilenumbruch ist optional.
• Wenn die Eingabelänge kein Vielfaches von 16 ist, müssen Sie eine neue Zeile für die verbleibenden Zeichen beginnen und die nicht verwendeten Zellen leer lassen (= mit 3 Leerzeichen gefüllt).
• Jedes Zeichen wird genau in der Mitte einer Zelle platziert und links und rechts um ein Leerzeichen aufgefüllt.
• Die Werte in der ersten Zeile und Spalte werden durch Hexadezimalzahlen mit den Ziffern angegeben 0123456789ABCDEF. Diese sind links und rechts mit einem Leerzeichen aufgefüllt. Sie können auch hexadezimale Kleinbuchstaben verwenden, müssen sich jedoch an eine halten.
• Die einzigen in der Ausgabe vorhandenen Zeichen sind Bindestriche -, Pluszeichen +, Pipes |, Leerzeichen , die Ziffern für Hexadezimalzahlen und die Zeichen aus der Eingabe.
• Alle eingebauten Elemente, die sich auf ASCII-Tabellen beziehen oder das Problem in irgendeiner Weise trivialisieren, sind verboten.
• Sie können davon ausgehen, dass die Eingabe nur aus Zeichen einer bestimmten Codierung besteht. Bitte geben Sie an, ob dies der Fall ist.
• Wenn Ihre Sprache nur ASCII-Eingaben verarbeiten kann, können Sie nur ASCII-Eingaben und wiederholte Zeichen annehmen.

Regeln

• Funktion oder Vollprogramm erlaubt.
• Standardregeln für die Eingabe / Ausgabe.
• Es gelten Standardlücken .
• Dies ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl. Tiebreaker ist eine frühere Vorlage.

Viel Spaß beim Codieren!

Pyth, 60 Bytes

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

Der führende Zeilenumbruch ist signifikant.

Probieren Sie es hier aus.

Python 3.5, 326 355 Bytes:

( +29 Bytes, da, wenn die Länge der letzten Zeile kein Vielfaches von 16 ist, nicht verwendete Zellen leer bleiben sollten (obwohl es meiner Meinung nach viel besser aussieht, wenn diese leeren Zellen einfach nicht einmal angezeigt werden) )

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

Klappt wunderbar!

Beispieleingänge und -ausgänge:

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

Ich hoffe das ist okay.

Auch hier ist eine andere Version , die ich für diese Herausforderung geschaffen, die, obwohl sie ein ungültiges Kandidat , da es sich nicht zusätzliche leere Zellen für die letzte Zeile ausdrucken, wenn seine Länge nicht ein Vielfaches 16 ist, meiner Meinung nach gibt ein viel besser aussehende Seite als die von OP geforderte, vor allem, weil sie keine leeren Zellen anzeigt, wenn die letzte Zeile kein Vielfaches von 16 ist, sondern nur gefüllte Zellen anzeigt, und das wars:

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

Hier ist ein Beispiel für die Eingabe und Ausgabe des oben nicht zutreffenden Codes:

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

Code:

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

Probieren Sie es online! . Verwendet die CP-1252- Codierung.

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

Das ist ' 0123456789ABCDEF'vorhanden, um die erste Spalte zu füllen, es deckt jedoch auch die erste Zeile ab. Die Eingabezeichenfolge wird dann mit Leerzeichen aufgefüllt, damit sie in Teilzeichenfolgen der Länge 16 aufgeteilt werden kann, wobei (?|^)verhindert wird, dass das führende Leerzeichen übereinstimmt. Der Rest fügt nur die Teile zusammen.

Excel VBA, 157 Bytes (Betrug?)

Anonyme VBE-Direktfensterfunktion, die zerstörerisch Eingaben aus dem Bereich [A1]und Ausgaben in das VBE-Direktfenster aufnimmtActiveSheet Objekt .

Golf gespielt

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

Formatiert

[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

Gegeben:

[A1]="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJ"

Die generierte Ausgabe ist