Các Cheela (từ cuốn sách Dragon Egg bởi Robert L. Forward) là những sinh vật sống trên bề mặt của một ngôi sao neutron. Cơ thể của chúng phẳng và tròn với mười hai mắt trên chu vi, vì vậy chúng tự nhiên sử dụng hệ thống đánh số cơ sở 12.

Trong số các Cheela, chăm sóc chim con và giáo dục trẻ là những nhiệm vụ được thực hiện bởi Người già. Vì Cheela trẻ cần được dạy cách nhân lên, Người già có thể sử dụng bảng nhân.

Nhiệm vụ của bạn là tạo ra một bảng nhân 12x 12trong cơ sở 12, như sau. Chữ in hoa Avà Bđược sử dụng cho các chữ số tương ứng với số thập phân 10 và 11tương ứng.

  1   2   3   4   5   6   7   8   9   A   B  10 
  2   4   6   8   A  10  12  14  16  18  1A  20 
  3   6   9  10  13  16  19  20  23  26  29  30 
  4   8  10  14  18  20  24  28  30  34  38  40 
  5   A  13  18  21  26  2B  34  39  42  47  50 
  6  10  16  20  26  30  36  40  46  50  56  60 
  7  12  19  24  2B  36  41  48  53  5A  65  70 
  8  14  20  28  34  40  48  54  60  68  74  80 
  9  16  23  30  39  46  53  60  69  76  83  90 
  A  18  26  34  42  50  5A  68  76  84  92  A0 
  B  1A  29  38  47  56  65  74  83  92  A1  B0 
 10  20  30  40  50  60  70  80  90  A0  B0 100

Shoud đầu ra được in trên màn hình. Các định dạng nên như sau:

1. Các số phải được căn bên phải trong mỗi cột.
2. Không gian hàng đầu trước cột đầu tiên, dấu cách sau cột cuối cùng hoặc một dòng mới sau hàng cuối cùng được cho phép.

3. Tách giữa các cột có thể là một khoảng trắng (như được hiển thị ở trên) hoặc nhiều hơn một khoảng trắng, nhưng số lượng khoảng trắng phải nhất quán giữa các cột. Để đo tách cột, hãy xem xét rằng các số được hiển thị bao gồm bất kỳ khoảng trắng hàng đầu nào có thể cần thiết để thực hiện yêu cầu 1 (vì vậy mỗi số chiếm ba ký tự, đầu tiên có thể là khoảng trắng). Ví dụ: bảng có phân tách hai không gian sẽ như sau:

     1    2    3    4    5    6    7    8    9    A    B   10 
     2    4    6    8    A   10   12   14   16   18   1A   20 
     3    6    9   10   13   16   19   20   23   26   29   30 
     4    8   10   14   18   20   24   28   30   34   38   40 
     5    A   13   18   21   26   2B   34   39   42   47   50 
     6   10   16   20   26   30   36   40   46   50   56   60 
     7   12   19   24   2B   36   41   48   53   5A   65   70 
     8   14   20   28   34   40   48   54   60   68   74   80 
     9   16   23   30   39   46   53   60   69   76   83   90 
     A   18   26   34   42   50   5A   68   76   84   92   A0 
     B   1A   29   38   47   56   65   74   83   92   A1   B0 
    10   20   30   40   50   60   70   80   90   A0   B0  100
   

Lưu trữ máy tính trên một ngôi sao neutron thực sự tốn kém, vì vậy mã của bạn nên sử dụng càng ít byte càng tốt.

Thử thách mở rộng và tiền thưởng

Lý tưởng nhất là mã của bạn nên được sử dụng lại trong các phần khác của vũ trụ, nơi các hệ thống đánh số khác có thể được sử dụng. Cuối cùng, thách thức được mở rộng tùy chọn như sau: Mã của bạn chấp nhận một số Nlàm đầu vào và tạo bảng nhân Nx Ntrong cơ sở N, với định dạng trên.

Đầu vào có thể từ bàn phím hoặc như là một đối số chức năng. Chương trình hoặc chức năng nên làm việc cho 2≤ N≤ 36, sử dụng như chữ số đầu tiên Nnhân vật của dãy 0, 1, ..., 9, A, B, ..., Z(viết hoa chữ cái)

Thử thách mở rộng này là tùy chọn. Nếu bạn theo lộ trình này, hãy giảm 20% số byte của bạn (không cần làm tròn đến số nguyên).

Bình, 27 * 0,8 = 21,6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

Dùng thử trực tuyến: Trình diễn

Giải trình:

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 byte

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

Kiểm tra nó ở đây.

Điều này sử dụng sự tách biệt tối thiểu cần thiết.

Giải trình

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.

Bảng cho đầu vào 22(lớn nhất phù hợp với bài đăng mà không có thanh cuộn ngang):

   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

Khước từ

Vì người tạo ra ngôn ngữ và tác giả của thử thách là như nhau, câu trả lời này không đủ điều kiện để chiến thắng .

Để thảo luận về việc hạn chế này có cần thiết hay không, hãy xem câu hỏi meta này .

Mã

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

Điều này sử dụng sự tách biệt tối thiểu.

Thí dụ

Bảng nhân

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

Giải trình

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

Chỉnh sửa: Hãy thử trực tuyến!

Để chạy trong trình biên dịch trực tuyến (tính đến ngày 19 Tháng 2 năm 2016), thay đổi Y)đến X:, và loại bỏ []. Điều này là để thích ứng với những thay đổi đã được thực hiện đối với ngôn ngữ kể từ khi thử thách này được đăng.

Tiện ích Bash + BSD, 36

echo Co{1..12}d{1..12}*p|dc|rs -j 12

Hoạt động ngoài luồng trên OS X. rscó thể cần phải được cài đặt trên các hệ thống Linux.

• Bash mở rộng Co{1..12}d{1..12}*pđến Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p.
• Đây là một dcbiểu thức tạo ra các điều khoản cần thiết. Cođặt cơ sở đầu ra thành 12. dđược sử dụng làm dấu phân cách giữa các số thay vì khoảng trắng, do đó không cần thoát trong mở rộng dấu ngoặc. dthực sự trùng lặp đỉnh của ngăn xếp, nhưng điều này thực sự bị bỏ qua và loại bỏ.
• Đầu ra từ dclà một dòng tách biệt không gian. rsđịnh hình lại điều này thành một mảng 12x12. -jquyền biện minh cho mỗi thuật ngữ.

Bình thường, 36 byte

Km+1dUJ12rjbmjkm.[\ 4j""m.Hbj*dkJKK1

Hãy thử nó ở đây.

Python, 153 147 132 byte * 0.8 = 105.6

def p(b):
 f=lambda n:(n>=b and f(n/b)or'')+chr((48,55)[n%b>9]+n%b)
 for i in range(b*b):print'%4s\n'[:3+(~i%b<1)]%f(~(i%b)*~(i/b)),

Xuống tới 132 byte nhờ lời khuyên của Tim Pederick! :)

CJam, 38 33 32 38 * (.8) = 30,4 byte

qi:D,:):L{Lf*{Db{_9>{55+c}&}%4Se[}%N}%

Hãy thử nó ở đây.

(Trông khá giống với Martin bây giờ.)

qi:D,:):L          e# Generate list of [1...input]
{Lf*               e# Take each number in that list and multiply it by the same list ([[1,2,3,..,input][2,4,6,...,input],...})
{Db{_9>{55+c}&}%   e# Convert each product to base input. If a digit value is >= 10 add 55 and convert to char, to make it a letter.
4Se[}%N}%          e# Pad each number with spaces to length 4. Put a newline after each row.

Perl 6 , 60 byte -20% = 48 byte

{.put for (1..$_ X*1..$_)».base($_)».fmt('%3s').rotor($_)} # 60-20% = 48
#          ^-----------^ produce a list of two cross multiplied lists
#                        ^--------^ convert each to base N
#          format each to 3 spaces ^----------^
#         split the list into N element chunks ^--------^
#^-------^ print each of those on their own line with spaces between elements

(Đây gần như chính xác là cách tôi sẽ viết nó ngay cả khi tôi không cố gắng viết nó ngắn nhất có thể)

Sử dụng:

{...}(2)
  1  10
 10 100

my &code = {...}
code 2;
  1  10
 10 100

{...}(12);
  1   2   3   4   5   6   7   8   9   A   B  10
  2   4   6   8   A  10  12  14  16  18  1A  20
  3   6   9  10  13  16  19  20  23  26  29  30
  4   8  10  14  18  20  24  28  30  34  38  40
  5   A  13  18  21  26  2B  34  39  42  47  50
  6  10  16  20  26  30  36  40  46  50  56  60
  7  12  19  24  2B  36  41  48  53  5A  65  70
  8  14  20  28  34  40  48  54  60  68  74  80
  9  16  23  30  39  46  53  60  69  76  83  90
  A  18  26  34  42  50  5A  68  76  84  92  A0
  B  1A  29  38  47  56  65  74  83  92  A1  B0
 10  20  30  40  50  60  70  80  90  A0  B0 100

{...}(18);
  1   2   3   4   5   6   7   8   9   A   B   C   D   E   F   G   H  10
  2   4   6   8   A   C   E   G  10  12  14  16  18  1A  1C  1E  1G  20
  3   6   9   C   F  10  13  16  19  1C  1F  20  23  26  29  2C  2F  30
  4   8   C   G  12  16  1A  1E  20  24  28  2C  2G  32  36  3A  3E  40
  5   A   F  12  17  1C  1H  24  29  2E  31  36  3B  3G  43  48  4D  50
  6   C  10  16  1C  20  26  2C  30  36  3C  40  46  4C  50  56  5C  60
  7   E  13  1A  1H  26  2D  32  39  3G  45  4C  51  58  5F  64  6B  70
  8   G  16  1E  24  2C  32  3A  40  48  4G  56  5E  64  6C  72  7A  80
  9  10  19  20  29  30  39  40  49  50  59  60  69  70  79  80  89  90
  A  12  1C  24  2E  36  3G  48  50  5A  62  6C  74  7E  86  8G  98  A0
  B  14  1F  28  31  3C  45  4G  59  62  6D  76  7H  8A  93  9E  A7  B0
  C  16  20  2C  36  40  4C  56  60  6C  76  80  8C  96  A0  AC  B6  C0
  D  18  23  2G  3B  46  51  5E  69  74  7H  8C  97  A2  AF  BA  C5  D0
  E  1A  26  32  3G  4C  58  64  70  7E  8A  96  A2  AG  BC  C8  D4  E0
  F  1C  29  36  43  50  5F  6C  79  86  93  A0  AF  BC  C9  D6  E3  F0
  G  1E  2C  3A  48  56  64  72  80  8G  9E  AC  BA  C8  D6  E4  F2  G0
  H  1G  2F  3E  4D  5C  6B  7A  89  98  A7  B6  C5  D4  E3  F2  G1  H0
 10  20  30  40  50  60  70  80  90  A0  B0  C0  D0  E0  F0  G0  H0 100

JavaScript (ES6) 84 (105-20%)

Cách rõ ràng, để bắt đầu với.

n=>{for(o=i=``;i++<n;o+=`
`)for(j=0;j++<n;)o+=(`   `+(i*j).toString(n)).slice(-4).toUpperCase();alert(o)}

Ghi chú

• Thật đáng tiếc js toString tạo ra các chữ cái viết thường
• alert không phải là cách tốt nhất để xuất bảng, nhưng nó ngắn hơn, vì có một yêu cầu rõ ràng là "hiển thị trên màn hình"
• Chỉ cần trả về giá trị sẽ là một vài byte ngắn hơn.

Ít chơi gôn

n=>{
  for(o='', i=0; i++<n; o+='\n')
    for(j=0;j++<n;)
       o+=('   '+(i*j).toString(n)).slice(-4).toUpperCase()
  alert(o)
}

Python 3, 126 - 20% = 100,8 byte

Hàm ngoài t, là hàm thực sự in bảng nhân. Hàm bên trong i, thực hiện chuyển đổi một số thành cơ sở từ 2 đến 36.

def t(b):
 i=lambda n:(n>=b and i(n//b)or'')+chr(n%b+[48,55][n%b>9]);R=range(b)
 for r in R:print(*('%3s'%i(~r*~c)for c in R))

Hat tip cho Boomerang cho giải pháp của họ , và cho một mẹo chơi golf. Tôi tránh sao chép bất cứ thứ gì từ giải pháp của Boomerang, nhưng tôi đã cho phép mình liếc nhìn nó để xem nơi tôi có thể cắt tỉa nhiều hơn. Và thậm chí trước đó, tôi thấy rằng tôi càng chơi golf, tôi càng bắt đầu giống Boomerang!

Javascript (ES6) 96,8 93,6 byte (20% của 117)

n=>{b='';for(i=0;i++<n;b+=`\n`)for(j=0;j++<n;)a=(i*j).toString(n).toUpperCase(),b+=' '.repeat(4-a.length)+a;alert(b)}

Giải trình

n=>
    {                                     
      b='';                                    //clear table var at each run
      for(i=0;i++<n;b+=`\n`)                   //iterate through rows
        for(j=0;j++<n;)                        //iterate through cols
          a=(i*j).toString(n).toUpperCase(),   //get desired number
          b+=' '.repeat(4-a.length)+a";        //pad to right
    alert(b)                                   //display result
}

- đã lưu 4 byte nhờ @ edc65

MATLAB, 111 * 0.8 = 88.8 110 * 0.8 = 88 byte

Ra mắt của tôi ở đây:

@(N)disp(reshape(strrep(strrep([' ',strjoin(cellstr(dec2base([1:N]'*[1:N],N)))],' 0','  '),' 0','  '),4*N,N)')

Giải trình:

[1:N]'*[1:N] lập bảng nhân trong cơ sở 10

dec2base([1:N]'*[1:N],N) chuyển đổi sang cơ sở 12. Đầu ra là mảng char với 0-s hàng đầu

strjoin(cellstr(dec2base(___))) chuyển đổi thành ô và quay lại chuỗi kết nối char với chuỗi 1x575 không gian

[' ',strjoin(___)] nối thêm không gian để có 576 phần tử

strrep(___,' 0',' ')loại bỏ một số không hàng đầu. Chúng tôi làm điều đó hai lần vì chúng tôi có các chuỗi có hai số 0 đứng đầu

reshape(___,4*N,N)' chuyển đổi mảng char 1x576 thành mảng char 48x12

disp(___) hiển thị kết quả mà không ans =

Đầu ra:

 1   2   3   4   5   6   7   8   9   A   B  10
 2   4   6   8   A  10  12  14  16  18  1A  20
 3   6   9  10  13  16  19  20  23  26  29  30
 4   8  10  14  18  20  24  28  30  34  38  40
 5   A  13  18  21  26  2B  34  39  42  47  50
 6  10  16  20  26  30  36  40  46  50  56  60
 7  12  19  24  2B  36  41  48  53  5A  65  70
 8  14  20  28  34  40  48  54  60  68  74  80
 9  16  23  30  39  46  53  60  69  76  83  90
 A  18  26  34  42  50  5A  68  76  84  92  A0
 B  1A  29  38  47  56  65  74  83  92  A1  B0
10  20  30  40  50  60  70  80  90  A0  B0 100 

Nếu chúng ta không đếm câu lệnh N=12;, 5*.8=4byte sẽ được lưu. Ngoài ra, nếu ans =đầu ra được dung thứ, thì chúng ta có thể loại bỏ việc disp()lưu các 6*0.8=4.8byte khác . Tất nhiên, có thể có các cách khác để lưu byte :)

Python 3: 166 161 152 - 20% = 121,6 byte

Tôi biết nó kém hơn các câu trả lời Python hiện có nhưng tôi đã tìm cách cho nó một shot. Đây là lần đầu tiên tôi đăng bài trên trang này

def t(b):
 r=range(1,b+1);f=lambda x:x and f(x//b)+chr((55,48)[x%b>9]+x%b)or''
 print('\n'.join(''.join(B)for B in(('%4s'%f(i*j)for j in r)for i in r)))

APL, 32 31 × 0,8 = 24,8 byte

{¯4↑¨⊃∘(⎕D,⎕A)¨¨⍵⊥⍣¯1¨∘.×⍨1+⍳⍵}

Trong nguồn gốc 0. Trong tiếng Anh:

• ∘.×⍨1+⍳⍵: bảng cửu chương
• ⍵⊥⍣¯1¨: thể hiện trong cơ sở ⍵ mỗi phần tử của bảng nhân
• ⊃∘(⎕D,⎕A)¨¨: chuyển đổi bảng vectơ số thành bảng vectơ ký tự
• ¯4↑¨: canh lề phải với độ dài 4 mỗi phần tử của kết quả

Thói quen in APL mặc định thực hiện đúng.

      {¯4↑¨(⍵⊥⍣¯1¨∘.×⍨1+⍳⍵)⊃¨¨⊂⊂⎕D,⎕A}13
    1     2     3     4     5     6     7     8     9     A     B     C    10 
    2     4     6     8     A     C    11    13    15    17    19    1B    20 
    3     6     9     C    12    15    18    1B    21    24    27    2A    30 
    4     8     C    13    17    1B    22    26    2A    31    35    39    40 
    5     A    12    17    1C    24    29    31    36    3B    43    48    50 
    6     C    15    1B    24    2A    33    39    42    48    51    57    60 
    7    11    18    22    29    33    3A    44    4B    55    5C    66    70 
    8    13    1B    26    31    39    44    4C    57    62    6A    75    80 
    9    15    21    2A    36    42    4B    57    63    6C    78    84    90 
    A    17    24    31    3B    48    55    62    6C    79    86    93    A0 
    B    19    27    35    43    51    5C    6A    78    86    94    A2    B0 
    C    1B    2A    39    48    57    66    75    84    93    A2    B1    C0 
   10    20    30    40    50    60    70    80    90    A0    B0    C0   100 

Ruby, 69 66 ký tự - 20% = 52,8

->n{(r=1..n).map{|a|puts r.map{|b|"%4s"%(a*b).to_s(n).upcase}*''}}

Chạy mẫu:

2.1.5 :001 > ->n{(r=1..n).map{|a|puts r.map{|b|"%4s"%(a*b).to_s(n).upcase}*''}}[4]
   1   2   3  10
   2  10  12  20
   3  12  21  30
  10  20  30 100

ksh93, 51 * 0.8 == 40.8 byte

eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'

Điều này sẽ hoạt động đến cơ sở 64 (cơ số lớn nhất được hỗ trợ bởi ksh). Ví dụ:

 $ n= ksh -s 12 <<\EOF
eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'
EOF


   1   2   3   4   5   6   7   8   9   a   b  10
   2   4   6   8   a  10  12  14  16  18  1a  20
   3   6   9  10  13  16  19  20  23  26  29  30
   4   8  10  14  18  20  24  28  30  34  38  40
   5   a  13  18  21  26  2b  34  39  42  47  50
   6  10  16  20  26  30  36  40  46  50  56  60
   7  12  19  24  2b  36  41  48  53  5a  65  70
   8  14  20  28  34  40  48  54  60  68  74  80
   9  16  23  30  39  46  53  60  69  76  83  90
   a  18  26  34  42  50  5a  68  76  84  92  a0
   b  1a  29  38  47  56  65  74  83  92  a1  b0
  10  20  30  40  50  60  70  80  90  a0  b0 100

 $ n= ksh -s 22 <<\EOF
eval echo "'
' {"{1..$1}'..$((++n*$1))..$n%3..$1d}'
EOF


   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

Pyke, 14 byte * 0.8 = 11.2 byte, không cạnh tranh

QhD]UA*MbQMl2P

Hãy thử nó ở đây!

Giải trình:

            - autoassign Q = eval_or_not_input()
QhD]        - [Q+1, Q+1]
    U       - nd_range(^)
     A*     - apply(*, ^)
       MbQ  - map(base(Q), ^)
          Ml2 - map(lower, ^)
          P - print_grid(^)

Hoặc 12 byte mà không có tiền thưởng

13D]UA*Mb12P