# A multiplication table for the Cheela

## Pyth, 27 * 0.8 = 21.6

``````VSQsm.[ 4jkXj*dNQrT99rG1SQ
``````

Try it online: Demonstration

### Explanation:

``````VSQsm.[ 4jkXj*dNQrT99rG1SQ   implicit: Q = input number
VSQ                           for N in [1, 2, ..., Q]:
m                    SQ      map each number d in [1, 2, ..., Q] to:
*dN                   N * d
j   Q                  in base Q
X     rT99rG1           replace the numbers [10, 11, ..., 98] with "A...Z"
jk                        join to a string
.[ 4                          prepend spaces, so that the string has a length of 4
s                             join all strings and print
``````

### CJam, 33 * 0.8 = 26.4 bytes

``````ri:C,:)_ff{*Cb{_9>{'7+}&}%4Se[}N*
``````

Test it here.

This uses the minimum required separation.

### Explanation

``````ri:C        e# Read input, convert to integer, store in C.
,:)         e# Get range [1 2 ... C].
_ff{        e# 2D-map over all repeated pairs from that range...
*Cb       e#   Multiply, convert to base C.
{         e#   Map over the digits...
_9>     e#     Check if the digit is greater than 9.
{'7+}&  e#     If so, add the digit to the character "7", to get "A" to "Z".
}%
4Se[      e#   Pad the digits with spaces from the left, to 4 elements.
}
N*          e# Join with linefeeds.
``````

Table for input `22` (the largest that fits in the post without a horizontal scrollbar):

``````   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F   G   H   I   J   K   L  10
2   4   6   8   A   C   E   G   I   K  10  12  14  16  18  1A  1C  1E  1G  1I  1K  20
3   6   9   C   F   I   L  12  15  18  1B  1E  1H  1K  21  24  27  2A  2D  2G  2J  30
4   8   C   G   K  12  16  1A  1E  1I  20  24  28  2C  2G  2K  32  36  3A  3E  3I  40
5   A   F   K  13  18  1D  1I  21  26  2B  2G  2L  34  39  3E  3J  42  47  4C  4H  50
6   C   I  12  18  1E  1K  24  2A  2G  30  36  3C  3I  42  48  4E  4K  54  5A  5G  60
7   E   L  16  1D  1K  25  2C  2J  34  3B  3I  43  4A  4H  52  59  5G  61  68  6F  70
8   G  12  1A  1I  24  2C  2K  36  3E  40  48  4G  52  5A  5I  64  6C  6K  76  7E  80
9   I  15  1E  21  2A  2J  36  3F  42  4B  4K  57  5G  63  6C  6L  78  7H  84  8D  90
A   K  18  1I  26  2G  34  3E  42  4C  50  5A  5K  68  6I  76  7G  84  8E  92  9C  A0
B  10  1B  20  2B  30  3B  40  4B  50  5B  60  6B  70  7B  80  8B  90  9B  A0  AB  B0
C  12  1E  24  2G  36  3I  48  4K  5A  60  6C  72  7E  84  8G  96  9I  A8  AK  BA  C0
D  14  1H  28  2L  3C  43  4G  57  5K  6B  72  7F  86  8J  9A  A1  AE  B5  BI  C9  D0
E  16  1K  2C  34  3I  4A  52  5G  68  70  7E  86  8K  9C  A4  AI  BA  C2  CG  D8  E0
F  18  21  2G  39  42  4H  5A  63  6I  7B  84  8J  9C  A5  AK  BD  C6  CL  DE  E7  F0
G  1A  24  2K  3E  48  52  5I  6C  76  80  8G  9A  A4  AK  BE  C8  D2  DI  EC  F6  G0
H  1C  27  32  3J  4E  59  64  6L  7G  8B  96  A1  AI  BD  C8  D3  DK  EF  FA  G5  H0
I  1E  2A  36  42  4K  5G  6C  78  84  90  9I  AE  BA  C6  D2  DK  EG  FC  G8  H4  I0
J  1G  2D  3A  47  54  61  6K  7H  8E  9B  A8  B5  C2  CL  DI  EF  FC  G9  H6  I3  J0
K  1I  2G  3E  4C  5A  68  76  84  92  A0  AK  BI  CG  DE  EC  FA  G8  H6  I4  J2  K0
L  1K  2J  3I  4H  5G  6F  7E  8D  9C  AB  BA  C9  D8  E7  F6  G5  H4  I3  J2  K1  L0
10  20  30  40  50  60  70  80  90  A0  B0  C0  D0  E0  F0  G0  H0  I0  J0  K0  L0 100
``````

## MATL, 42*.8 = 33.6

### Disclaimer

Since the creator of the language and the author of the challenge are the same, this answer is not eligible for winning.

For a discussion on whether this restriction is necessary or not, see this meta question.

### Code

``````iXK:t!*Y)KYAZ{'(?<=^0*)0'32cYXZc32hK4*[]e!
``````

This uses the minimum separation.

### Example

Octal multiplication table

``````>> matl
> iXK:t!*Y)KYAZ{'(?<=^0*)0'32cYXZc32chK4*[]e!
>
> 8
1   2   3   4   5   6   7  10
2   4   6  10  12  14  16  20
3   6  11  14  17  22  25  30
4  10  14  20  24  30  34  40
5  12  17  24  31  36  43  50
6  14  22  30  36  44  52  60
7  16  25  34  43  52  61  70
10  20  30  40  50  60  70 100
``````

### Explanation

``````i              % input number, say n
XK             % copy to clipboard K
:              % vector 1, 2, ... n
t!*            % generate table: duplicate, transpose and multiply with broadcasting
Y)             % linearize into column array
KYA            % paste n from clipboard K. Convert to that base
Z{             % cell array of rows from array
'(?<=^0*)0'    % string literal for regexp replacement: find leading zeros
32c            % space character (for regexp replacement)
YX             % regexp replacement
Zc             % join cell array of strings into single string
32             % code for space character. Conversion to char happens automatically
h              % concatenate horizontally
K4*[]e!        % paste n and multiply by 4. Reshape into 2D char array with 4*n columns
``````

### Edit: Try it online!

To run in the online compiler (as of February 19, 2016), change `Y)` to `X:`, and remove `[]`. This is to adapt to changes that have been made to the language since this challenge was posted.