Cheela (z książki Dragon Egg przez Roberta L. przodu) to istoty, które żyją na powierzchni gwiazdy neutronowej. Ich ciało jest płaskie i okrągłe z dwunastoma oczami na obwodzie, więc naturalnie używają systemu numeracji base-12.

Opieka nad pisklętami i wychowanie młodych wśród Cheeli to zadania realizowane przez Starych. Ponieważ młodą Cheelę trzeba nauczyć, jak się rozmnażać, Starzy mogą korzystać z tablicy mnożenia.

Twoim zadaniem jest stworzenie w bazie 12tabliczki 12mnożenia x 12, jak poniżej. Wielkie litery Ai Bsą używane dla cyfr odpowiadających odpowiednio liczbom dziesiętnym 10 i 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

Wyjście powinno zostać wydrukowane na ekranie. Format powinien wyglądać następująco:

1. Liczby powinny być wyrównane do prawej w każdej kolumnie.
2. Dopuszczalne są spacje wiodące przed pierwszą kolumną, spacje końcowe za ostatnią kolumną lub nowa linia końcowa po ostatnim wierszu.

3. Separacja między kolumnami może być jedną spacją (jak pokazano powyżej) lub więcej niż jedną spacją, ale liczba spacji powinna być spójna między kolumnami. Aby zmierzyć separację kolumn, należy wziąć pod uwagę, że wyświetlane liczby obejmują spacje wiodące, które mogły być konieczne do spełnienia wymagania 1 (więc każda liczba zajmuje trzy znaki, z których pierwszą mogą być spacje). Na przykład tabela z separacją dwóch spacji wygląda następująco:

     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
   

Przechowywanie komputera na gwiazdy neutronowej jest naprawdę drogie, więc kod powinien zajmować jak najmniej bajtów.

Rozszerzone wyzwanie i bonus

Najlepiej byłoby, gdyby kod był ponownie wykorzystywany w innych częściach wszechświata, gdzie mogą być używane inne systemy numeracji. W tym celu wyzwanie jest opcjonalnie rozszerzane w następujący sposób: Twój kod przyjmuje liczbę Njako dane wejściowe i generuje tablicę mnożenia Nxw Nbazie N, w powyższym formacie.

Dane wejściowe mogą pochodzić z klawiatury lub jako argument funkcji. Program lub funkcja powinna działać dla 2≤ N≤ 36, używając cyfr jako pierwsze Nznaki sekwencji 0, 1, ..., 9, A, B, ..., Z(wielkimi literami)

To rozszerzone wyzwanie jest opcjonalne. Jeśli podążysz tą drogą, zmniejsz o 20% liczbę bajtów (nie musisz zaokrąglać do liczby całkowitej).

Pyth, 27 * 0,8 = 21,6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

Wypróbuj online: demonstracja

Wyjaśnienie:

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 bajtów

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

Sprawdź to tutaj.

Wykorzystuje to minimalną wymaganą separację.

Wyjaśnienie

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.

Tabela wprowadzania danych 22(największa, która mieści się we wpisie bez poziomego paska przewijania):

   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

Zrzeczenie się

Ponieważ twórca języka i autor wyzwania są tacy sami, ta odpowiedź nie kwalifikuje się do wygrania .

W celu dyskusji, czy to ograniczenie jest konieczne, czy nie, zobacz to meta pytanie .

Kod

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

Wykorzystuje to minimalną separację.

Przykład

Ośmiokrotna tabliczka mnożenia

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

Wyjaśnienie

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

Edycja: Wypróbuj online!

Aby uruchomić w kompilator online (na dzień 19 lutego 2016), zmiany Y)do X:i wyjąć []. Ma to na celu dostosowanie się do zmian dokonanych w języku od czasu opublikowania tego wyzwania.

Narzędzia Bash + BSD, 36

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

Działa od razu rspo instalacji w systemie OS X. Może być konieczne zainstalowanie go w systemach Linux.

• Bash rozwija się Co{1..12}d{1..12}*pdo Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p.
• To dcwyrażenie generuje wymagane terminy. Coustawia wyjściową podstawę na 12. djest używany jako separator między liczbami zamiast spacji, więc nie jest wymagane ucieczka w rozwinięciu nawiasu. dfaktycznie duplikuje górę stosu, ale jest to skutecznie ignorowane i odrzucane.
• Dane wyjściowe dcto pojedyncza linia oddzielona spacjami. rsprzekształca to w tablicę 12x12. -juzasadnia każdy termin.

Pyth, 36 bajtów

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

Wypróbuj tutaj.

Python, 153 147 132 bajtów * 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)),

Do 132 bajtów dzięki radom Tima Pedericka! :)

CJam, 38 33 32 38 * (.8) = 30,4 bajtów

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

Wypróbuj tutaj.

(Wygląda teraz bardzo podobnie do Martina).

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 bajtów -20% = 48 bajtów

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

(Jest to prawie dokładnie tak, jak bym to napisał, nawet gdybym nie starał się, żeby było tak krótko, jak tylko mogłem)

Stosowanie:

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

Na początek oczywisty sposób.

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

Uwagi

• Szkoda, że ​​JS produkuje małe litery
• alert nie jest najlepszym sposobem na wyświetlenie tabeli, ale jest krótszy, ponieważ istnieje wyraźne żądanie „wyświetlenia na ekranie”
• Zwrócenie wartości byłoby o kilka bajtów krótsze.

Mniej golfa

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 bajtów

Funkcja zewnętrzna t, to ta, która faktycznie drukuje tabliczkę mnożenia. Funkcja wewnętrzna i, dokonuje konwersji liczby na bazę z 2 do 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))

Czapka dla Boomeranga za ich rozwiązanie i wskazówkę golfową. Unikałem kopiowania czegokolwiek z rozwiązania Boomeranga, ale pozwoliłem sobie spojrzeć na to, aby zobaczyć, gdzie mogę wyciąć więcej. I nawet wcześniej odkryłem, że im bardziej grałem w golfa, tym bardziej mój wyglądał jak Boomerang!

JavaScript (ES6) 96,8 93,6 Bajty (20% z 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)}

Wyjaśnienie

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
}

- zapisane 4 bajty dzięki @ edc65

MATLAB, 111 * 0,8 = 88,8 110 * 0,8 = 88 bajtów

Mój debiut tutaj:

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

Wyjaśnienie:

[1:N]'*[1:N] stwórz tabliczkę mnożenia w bazie 10

dec2base([1:N]'*[1:N],N) przekonwertować na bazę 12. Wyjściem jest tablica char z wiodącymi 0-s

strjoin(cellstr(dec2base(___))) konwertuj na komórkę i z powrotem na znak łączący ciągi z odstępem dającym ciąg 1x575

[' ',strjoin(___)] dodaj miejsce, aby mieć 576 elementów

strrep(___,' 0',' ')usuń jedno wiodące zero. Robimy to dwa razy, ponieważ mamy ciągi znaków z dwoma zerami wiodącymi

reshape(___,4*N,N)' konwertuj tablicę znaków 1x576 na tablicę znaków 48x12

disp(___) wyświetl wynik bez ans =

Wydajność:

 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 

Jeśli nie liczymy instrukcji N=12;, 5*.8=4bajty są zapisywane. Ponadto, jeśli ans =wyjście jest tolerowane, możemy usunąć disp()zapisywanie kolejnych 6*0.8=4.8bajtów. Oczywiście mogą istnieć inne sposoby zapisywania bajtów :)

Python 3: 166 161 152 - 20% = 121,6 bajtów

Wiem, że jest gorszy od istniejących odpowiedzi w języku Python, ale postanowiłem spróbować. To mój pierwszy post na tej stronie…

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 bajtów

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

Pochodzenie 0. W języku angielskim:

• ∘.×⍨1+⍳⍵: tabliczka mnożenia
• ⍵⊥⍣¯1¨: wyraż w bazie ⍵ każdy element tablicy mnożenia
• ⊃∘(⎕D,⎕A)¨¨: przekształca tabelę wektorową liczb w tabelę wektorów znaków
• ¯4↑¨: wyrównaj do prawej 4 długości każdego elementu wyniku

Domyślna procedura drukowania APL działa poprawnie.

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

Rubinowy, 69 66 znaków - 20% = 52,8

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

Przykładowy przebieg:

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 bajtów

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

Powinno to działać do podstawy 64 (największa podstawa obsługiwana przez ksh). Przykłady:

 $ 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 bajtów * 0,8 = 11,2 bajtów, niekonkurencyjny

QhD]UA*MbQMl2P

Wypróbuj tutaj!

Wyjaśnienie:

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

Lub 12 bajtów bez premii

13D]UA*Mb12P