Cheela (из книги Яйцо дракона Роберт Л. вперед) существа , которые живут на поверхности нейтронной звезды. Их тело плоское и круглое с двенадцатью глазами по периметру, поэтому они, естественно, используют систему нумерации Base-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% (нет необходимости округлять до целого числа).

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

Работает "из коробки" на OS X. rsВозможно, потребуется установить на системы Linux.

• Баш расширяется 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.

Perl 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)}

Заметки

• Жаль, что JS toString производят строчные буквы
• 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 в массив символов 48x12

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байтов. Конечно, могут быть и другие способы сохранения байтов :)

Python 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

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

Пайк, 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