15
\$\begingroup\$

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

Happy Coding!

\$\endgroup\$
  • \$\begingroup\$ Can we use lowercase hex digits? \$\endgroup\$ – Doorknob Apr 1 '16 at 23:59
  • \$\begingroup\$ @Doorknob Yes, clarified it in the challenge. \$\endgroup\$ – Denker Apr 2 '16 at 0:00
  • 1
    \$\begingroup\$ Can we assume the input is ASCII (with possibly repeated characters)? \$\endgroup\$ – Luis Mendo Apr 2 '16 at 0:05
  • \$\begingroup\$ @DenkerAffe That would conflict with the word "unique" or with "255" in Given a string of 16-255 unique characters, though... \$\endgroup\$ – Luis Mendo Apr 2 '16 at 0:07
  • 1
    \$\begingroup\$ @LuisMendo Hmm yea, thats true. Gonna allow that for languages that can only handle ASCII. \$\endgroup\$ – Denker Apr 2 '16 at 0:14
7
\$\begingroup\$

Pyth, 60 bytes


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

The leading newline is significant.

Try it here.

\$\endgroup\$
  • \$\begingroup\$ Can you show the transpiled code? \$\endgroup\$ – CalculatorFeline Apr 2 '16 at 0:27
  • \$\begingroup\$ @CatsAreFluffy Just enable the debug mode in the online interpreter. \$\endgroup\$ – Denker Apr 2 '16 at 0:42
  • \$\begingroup\$ What does the newline do? \$\endgroup\$ – Leaky Nun Apr 2 '16 at 10:56
  • \$\begingroup\$ @Adnan Whoops, that was an oversight on my part. Fixed, thanks. \$\endgroup\$ – Doorknob Apr 3 '16 at 14:48
  • \$\begingroup\$ @KennyLau It prints the first +---+---+---[...]. In Pyth, the newline function prints and returns its argument. \$\endgroup\$ – Doorknob Apr 3 '16 at 14:48
5
\$\begingroup\$

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.)
\$\endgroup\$
  • \$\begingroup\$ "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)." \$\endgroup\$ – Leaky Nun Apr 3 '16 at 7:24
  • \$\begingroup\$ @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? \$\endgroup\$ – R. Kap Apr 3 '16 at 7:25
  • \$\begingroup\$ Why the down vote? \$\endgroup\$ – R. Kap Apr 5 '16 at 19:06
  • \$\begingroup\$ @R.Kap I couldn't quite tell you, but here, have an upvote \$\endgroup\$ – cat Apr 16 '16 at 15:22
2
\$\begingroup\$

05AB1E, 65 63 bytes

Code:

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

Try it online!. Uses CP-1252 encoding.

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

Excel VBA, 157 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(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]=""

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

\$\endgroup\$
  • \$\begingroup\$ probs not valid, but cool anyway. To make it more similar (but still invalid?) you should turn on the appropriate cell boarders. \$\endgroup\$ – Lyndon White Jan 21 '18 at 14:43

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.