Code a code page

Question

Introduction

A code page maps integer values to a specific character. We can visualize a code page like this:

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

The rows specify the first digit and the columns the second digit of the hex-number.

The Challenge

Given a string of 16-255 unique characters, output the corresponding code page using the zero-based index of each character in the string as it's value. The input qwertzuiopasdfgjklyxcvbnmQWERTZUIOPASDFGHJ for example would yield the table above.

• The output has to be in the exact same format as the table above. Only a trailing newline is optional.
• If the input length is not a multiple of 16, you need to start a new row for the remaining characters and leave the unused cells empty (=filled with 3 spaces).
• Each character is placed exactly in the middle of a cell, padded by one space to the left and right.
• The values in the first row and column are given by hex-numbers with the digits 0123456789ABCDEF. Those are padded with one space to the left and right as well. You may choose to use lowercase hex-digits but you need to stick to one.
• The only characters present in the output are hyphens -, pluses +, pipes |, spaces , the digits for hexadecimal numbers and the characters from the input.
• Any builtins that are related to ASCII-art tables or trivialize the problem in any way are forbidden.
• You may assume that the input consists only of characters of a specific encoding. Please specify if that is the case.
• If your language can only handle ASCII input, you may assume ASCII-only input and repeated characters.

Rules

• Function or full program allowed.
• Default rules for input/output.
• Standard loopholes apply.
• This is code-golf, so lowest byte-count wins. Tiebreaker is earlier submission.

Happy Coding!

• Doorknob: Can we use lowercase hex digits?
• Denker: @Doorknob Yes, clarified it in the challenge.
• Luis Mendo: Can we assume the input is ASCII (with possibly repeated characters)?
• Luis Mendo: @DenkerAffe That would conflict with the word "unique" or with "255" in Given a string of 16-255 unique characters, though...
• Denker: @LuisMendo Hmm yea, thats true. Gonna allow that for languages that can only handle ASCII.

Answer 1

Pyth, 60 bytes

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

The leading newline is significant.

Try it here.

• CalculatorFeline: Can you show the transpiled code?
• Denker: @CatsAreFluffy Just enable the debug mode in the online interpreter.
• Leaky Nun: What does the newline do?
• Doorknob: @Adnan Whoops, that was an oversight on my part. Fixed, thanks.
• Doorknob: @KennyLau It prints the first +---+---+---[...]. In Pyth, the newline function prints and returns its argument.

Answer 2

Python 3.5, (削除) 326 (削除ここまで) 355 bytes:

(+29 bytes since if the length of the last row is not a multiple of 16, unused cells should be left empty (although, in my opinion, it looks much better if those empty cells are just not even shown))

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

Works like a charm!

Sample Inputs and Outputs:

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

I hope this is okay.

Also, here is another version I created for this challenge, which, although is an invalid candidate since it does not print out extra empty cells for the last row if its length is not a multiple 16, in my opinion outputs a much better looking page than the one required by OP, mainly because it does not even show empty cells if the last row is not a multiple of 16, but instead just shows filled cells, and that's it:

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

Here is a sample input and output for the inapplicable code above:

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

• Leaky Nun: "If the input length is not a multiple of 16, you need to start a new row for the remaining characters and leave the unused cells empty (=filled with 3 spaces)."
• R. Kap: @KennyLau Ah, yes. I did not see that. Dang...edit now in progress. Honestly though, this looks much better than the one OP shows, don't you think?
• R. Kap: Why the down vote?
• cat: @R.Kap I couldn't quite tell you, but here, have an upvote

Answer 3

Excel VBA, _{(削除) 157 (削除ここまで)} 146 Bytes (Cheating?)

Anonymous VBE Immediate Window function that destructively takes input from range [A1] and outputs to the ActiveSheet object.

Golfed

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

Formatted

[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

Given:

[A1]="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJ"

the generated output is

Table thingy

• Frames Catherine White: probs not valid, but cool anyway. To make it more similar (but still invalid?) you should turn on the appropriate cell boarders.

Answer 4

Excel (Version 1911), 247

A1 =DEC2HEX(COLUMN(A1:P1)-1)
A2 'Input String
A3 =2+LEN(A2)/16
A4 =CONCAT(" ",C2#)
A5 =TEXTJOIN("
"&REPT("+---",17)&"+
",0,,"| "&MID(A4,B2#+1,1)&" | "&MID(TEXTJOIN(" | ",0,A1#,MID(A2&REPT(" ",16),HEX2DEC(C2#&A1#)+1,1)),B2#*64+1,61)&" |",) ' Output
B2 =SEQUENCE(A3)-1
C2 =DEC2HEX(SEQUENCE(A3-1)-1)

Sample Test

Sample test

Excel (Joke answer), 88 Bytes

Not a valid solution, but fun

B2 'Input
C4 =DEC2HEX(SEQUENCE(,16,0))
B5 =DEC2HEX(SEQUENCE(1+LEN(B2)/16)-1)
C5 =MID(B2,HEX2DEC(B5#&C4#)+1,1)

Output

enter image description here

Answer 5

05AB1E, (削除) 65 (削除ここまで) 63 bytes

Code:

×ばつ'+J©,žhAu61ドルJ16÷)v„| ?N>iðëN&l×ばつðñvy„ |ðJ?}¶?®,

Try it online!. Uses CP-1252 encoding.

Answer 6

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

The ' 0123456789ABCDEF' exists to populate the first column, but conveniently also covers the first row. The input string is then padded with spaces to allow it to be split into substrings of length 16, with the (?!^) preventing the leading space from being matched. The rest is just joining up the pieces.

Answer 7

PowerShell, (削除) 127 (削除ここまで) (削除) 126 (削除ここまで) 121 bytes

($d='+---'*17+'+')
($n="0123456789ABCDEF$args"+' '*16)|sls '.{16}'-a|% m*|% v*|%{"$($n[$i++-1]+$_|% t*y|%{"| $_"}) |"
$d}

Try it online!

Answer 8

Perl 5 -pF, (削除) 134 (削除ここまで) (削除) 109 (削除ここまで) 106 bytes

@F=(@a=($",0..9,A..F),@F);shift@F;printf+($_="+---"x@a.'+
')."|%2s "x@a."|
",$a[$i++],splice@F,0,16while@F

Try it online!

Answer 9

Perl 5 -pl, (削除) 127 (削除ここまで) 120 bytes

@.=($",0..9,A..F);$\='+---'x@..'+
';$_=join'',@.,s;.{1,16};$.[$.++].sprintf'%-16s',$&;gre;s;.;| $& ;g;s;.{1,68};$\$&|
;g

Try it online!

Previous version:

@.=($",0..9,A..F);$~='+'.'---+'x@.;$_=join'',@.,s;.{1,16};$.[$.++].sprintf'%-16s',$&;gre;s;.;| $& ;g;s;.{1,68};$~
$&|
;g;$_.=$~

Try it online!

Answer 10

05AB1E, (削除) 47 (削除ここまで) 45 bytes

Thanks to Kevin Cruijssen for -2 bytes!

16ôí16jí15ÝhJš¬ðìsøv"+---"69∍=yS3j€ÀõšĆ'|ý,},

Try it online!

Commented:

16ô # split the input into groups of (up to) 16
 í16jí # right-pad the groups to 16 with reverse, left-pad, reverse
 15Ý # push [0, 1, ..., 15]
 hJ # convert each number to hexadecimal and join into string
 # => "0123456789ABCDEF"
 š # prepend this string to the list
 ¬ # get the string back from the list
 ðìs # prepend a space
 ø # zip the list and the string
v } # iterate over the list
 "+---" # push the string "+---"
 69∍ # extend it to length 69
 = # print it without removing the string from the stack
 y # push the current entry
 S # split into a list of characters
 3j # left-pad each to 3 chars with spaces
 €À # rotate each string left
 õšĆ # prepend and append the empty string
 '|ý # join by "|"
 , # print the string
, # after the loop: print "+---"69∍, which is still on the stack

Try the first part with step-by-step output
Try one loop-iteration with step-by-step output

• Kevin Cruijssen: DŠšs can be š¬ for -2
• Kevin Cruijssen: PS: It doesn't save bytes here, but just in case you're unaware of it, there is a builtin "surround with" .ø. The 3j€Àõš could alternatively have been ðδ.øõ.ø.
• ovs: @KevinCruijssen That does look a little cleaner, I did not know about this builtin. I had õšĆ... | ý¦¨ as a same-length alternative and I guess ðì€ĆõšĆ works too.