Cheela (з книги Яйце дракона Роберт Л. вперед) істотиякі живуть на поверхні нейтронної зірки. Їх тіло плоске та кругле з дванадцятьма очима по периметру, тому вони, природно, використовують базову систему нумерації 12.

Серед чеелів догляд за люками та виховання молодих людей - це завдання, що виконуються Старими. Оскільки молодого Чеела потрібно навчити розмножуватися, Старі можуть використовувати таблицю множення.

Ваше завдання - створити таблицю множення 12x 12у базі 12, як описано нижче. Заголовні букви Aі Bвикористовуються для цифр , відповідних десятковим 10 і 11відповідно.

  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

Вихід повинен бути надрукований на екрані. Формат повинен бути наступним:

1. Числа повинні бути вирівняні праворуч у межах кожного стовпця.
2. Доступні провідні пробіли перед першим стовпцем, пробіли після останнього стовпця або останній рядок після останнього рядка.

3. Поділ між стовпцями може містити один пробіл (як показано вище) або більше одного простору, але кількість пробілів має відповідати між стовпцями. Для вимірювання поділу стовпців врахуйте, що відображені числа включають будь-які провідні пробіли, які, можливо, були необхідні для виконання вимоги 1 (тому кожне число займає три символи, перший з яких може бути пробілами). Наприклад, таблиця з роздільним простором буде такою:

     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в якості вхідного даних і створює таблицю множення Nx Nу базіN з вищевказаним форматом.

Введення даних може бути з клавіатури або як аргумент функції. Програма або функція повинна працювати & 2le ; & Nle ; 36, використовуючи в якості цифр перших Nсимволів послідовності 0, 1, ..., 9, A, B, ...,Z (великі літери)

Це розширене завдання не є обов'язковим. Якщо ви слідуєте за цим маршрутом, зніміть 20% від кількості байтів (не потрібно округляти до цілого числа).

Піт, 27 * 0,8 = 21,6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

Спробуйте в Інтернеті: Демонстрація

Пояснення:

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 байт

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

Перевірте це тут.

При цьому використовується мінімально необхідний поділ.

Пояснення

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.

Таблиця для введення даних 22(найбільша, що вміщується в публікації без горизонтальної смуги прокрутки):

   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

Відмова від відповідальності

Оскільки творець мови та автор виклику однакові, ця відповідь не підходить для виграшу .

Для обговорення того, чи потрібно це обмеження чи ні, див. Це мета-питання .

Код

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

При цьому використовується мінімальний поділ.

Приклад

Таблиця множення восьмигранних

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

Пояснення

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

Редагувати: Спробуйте в Інтернеті!

Щоб запустити онлайн-компілятор (станом на 19 лютого 2016 року), перейдіть Y)на X:та видаліть []. Це необхідно для адаптації до змін, які відбулися в мові з моменту опублікування цього виклику.

Bash + BSD утиліти, 36

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

Працює нестандартно в ОС X. rsМожливо, потрібно буде встановити в системах Linux.

• Bash розширюється Co{1..12}d{1..12}*pдоCo1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p .
• Це dcвираз, що генерує необхідні терміни. CoВстановлює вихідну базу на 12. dвикористовується як роздільник між числами, а не пробілом, тому в розгортанні дужки не потрібно виконувати жодний вихід. dнасправді дублює верхню частину стека, але це фактично ігнорується та відкидається.
• Вихід з dc- це одна окрема пробіл лінія. rsпереробляє це на масив 12x12. -jправильно-обґрунтовує кожен термін.

Pyth, 36 байт

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

Спробуйте тут.

Python, 153 147 132 байт * 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)),

Внизу до 132 байтів завдяки пораді Тіма Педеріка! :)

CJam, 38 33 32 38 * (.8) = 30,4 байт

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

Спробуйте тут.

(Виглядає досить схоже на Мартіна зараз.)

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.

Перл 6 , 60 байт -20% = 48 байт

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

(Це майже точно так, як я б написав це, навіть якби я не намагався отримати його якомога коротше)

Використання:

{...}(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%)

Очевидний спосіб, для початку.

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

Примітки

• Шкода, що SString створює малі літери
• alert не найкращий спосіб вивести таблицю, але це коротший, оскільки є явний запит на "відображення на екрані"
• Просто повернення значення буде на пару байт коротше.

Менше гольфу

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 байт

Зовнішня функція, t- це та, яка насправді друкує таблицю множення. Внутрішня функція, iперетворює число в базу від 2 до 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))

Наконечник капелюха до Бумерангу для їх вирішення , і для наконечника для гольфу. Я уникав копіювати що-небудь з рішення Бумеранга, але я дозволив собі поглянути на це, щоб побачити, де я міг би обрізати більше. І навіть до цього я виявив, що чим більше я займався гольфом, тим більше міна починала виглядати як бумеранг!

Javascript (ES6) 96,8 93,6 байт (20% від 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)}

Пояснення

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
}

- збережено 4 байти завдяки @ edc65

MATLAB, 111 * 0,8 = 88,8 110 * 0,8 = 88 байт

Мій дебют тут:

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

Пояснення:

[1:N]'*[1:N] скласти таблицю множення в базі 10

dec2base([1:N]'*[1:N],N) перетворити в базу 12. Вихід - це масив char із провідними 0-с

strjoin(cellstr(dec2base(___))) перетворити в клітинку і назад в рядки, що з'єднуються з пробілом, що дає 1x575 рядок

[' ',strjoin(___)] додайте простір, щоб було 576 елементів

strrep(___,' 0',' ')видаліть один провідний нуль. Ми робимо це двічі, тому що у нас є рядки з двома провідними нулями

reshape(___,4*N,N)' перетворити масив 1x576 char у масив 48x12 char

disp(___) відобразити результат без ans =

Вихід:

 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=12;, 5*.8=4байти зберігаються. Крім того, якщо ans =вихід переноситься, ми можемо видалити disp()збереження іншого 6*0.8=4.8байта. Звичайно, можуть бути й інші способи збереження байтів :)

Пітон 3: 166 161 152 - 20% = 121,6 байт

Я знаю, що вона поступається наявним відповідям Python, але я зрозумів, що це дасть змогу. Це вперше публікація на цьому сайті ...

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 байт

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

За походженням 0. Англійською мовою:

• ∘.×⍨1+⍳⍵: таблиця множення
• ⍵⊥⍣¯1¨: виразити в базі ⍵ кожен елемент таблиці множення
• ⊃∘(⎕D,⎕A)¨¨: перетворимо таблицю векторів чисел у таблицю векторів символів
• ¯4↑¨: право вирівняти по довжині 4 кожен елемент результату

Процедура друку APL за замовчуванням робить правильно.

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

Рубі, 69 66 символів - 20% = 52,8

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

Проба зразка:

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

кш93, 51 * 0,8 == 40,8 байт

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

Це має працювати до бази 64 (найбільший радіакс, підтримуваний ksh). Приклади:

 $ 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 байт * 0,8 = 11,2 байт, неконкурентоспроможний

QhD]UA*MbQMl2P

Спробуйте тут!

Пояснення:

            - 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(^)

Або 12 байт без бонусу

13D]UA*Mb12P