Die Cheela (aus dem Buch Dragon's Egg von Robert L. Forward) sind Wesen, die auf der Oberfläche eines Neutronensterns leben. Ihr Körper ist flach und kreisförmig mit zwölf Augen am Umfang, weshalb sie natürlich ein Basis-12-Nummerierungssystem verwenden.

Bei den Cheela sind die Betreuung der Jungtiere und die Erziehung der Jungen Aufgaben der Alten. Da der junge Cheela das Multiplizieren beibringen muss, könnten die Alten eine Multiplikationstabelle verwenden.

Ihre Aufgabe ist es, eine 12x- 12Multiplikationstabelle 12wie die folgende in base zu erstellen . Großbuchstaben Aund Bsind für die Ziffern entsprechend dezimal verwendet 10 und 11jeweils.

  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

Die Ausgabe sollte auf dem Bildschirm gedruckt werden. Das Format sollte wie folgt sein:

1. Zahlen sollten in jeder Spalte nach rechts ausgerichtet werden.
2. Führende Leerzeichen vor der ersten Spalte, nachfolgende Leerzeichen nach der letzten Spalte oder eine nachfolgende neue Zeile nach der letzten Zeile sind zulässig.

3. Die Trennung zwischen den Spalten kann ein Leerzeichen (wie oben gezeigt) oder mehr als ein Leerzeichen sein, die Anzahl der Leerzeichen sollte jedoch zwischen den Spalten übereinstimmen. Berücksichtigen Sie zum Messen des Spaltenabstands, dass die angezeigten Zahlen alle führenden Leerzeichen enthalten, die zur Erfüllung von Anforderung 1 erforderlich waren (daher belegt jede Zahl drei Zeichen, von denen das erste Leerzeichen sein kann). Die Tabelle mit der Trennung von zwei Leerzeichen sieht beispielsweise folgendermaßen aus:

     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
   

Computerspeicher auf einem Neutronenstern ist sehr teuer, daher sollte Ihr Code so wenig Byte wie möglich enthalten.

Erweiterte Herausforderung und Bonus

Idealerweise sollte Ihr Code in anderen Teilen des Universums wiederverwendet werden, wo möglicherweise andere Nummerierungssysteme verwendet werden. Zu diesem Zweck wird die Abfrage optional wie folgt erweitert: Ihr Code akzeptiert eine Zahl Nals Eingabe und generiert eine Nx- NMultiplikationstabelle in der Basis Nmit dem obigen Format.

Die Eingabe kann über die Tastatur oder als Funktionsargument erfolgen. Das Programm oder die Funktion sollte funktionieren für 2≤ N≤ 36, als Ziffern unter Verwendung der ersten NZeichen der Folge 0, 1, ..., 9, A, B, ..., Z(Großbuchstaben)

Diese erweiterte Herausforderung ist optional. Wenn Sie dieser Route folgen, reduzieren Sie Ihre Byteanzahl um 20% (es ist nicht erforderlich, auf eine Ganzzahl zu runden).

Pyth, 27 · 0,8 = 21,6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

Probieren Sie es online aus: Demonstration

Erläuterung:

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*

Teste es hier.

Dies verwendet die minimal erforderliche Trennung.

Erläuterung

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.

Tabelle für die Eingabe 22(die größte, die ohne horizontale Bildlaufleiste in den Beitrag passt):

   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

Haftungsausschluss

Da der Ersteller der Sprache und der Autor der Herausforderung identisch sind, ist diese Antwort nicht gewinnberechtigt .

Eine Diskussion darüber, ob diese Einschränkung erforderlich ist oder nicht, finden Sie in dieser Meta-Frage .

Code

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

Dies verwendet den minimalen Abstand.

Beispiel

Oktal-Multiplikationstabelle

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

Erläuterung

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

Bearbeiten: Probieren Sie es online!

Um im Online-Compiler (Stand: 19. Februar 2016) ausgeführt zu werden, wechseln Sie Y)zu X:und entfernen Sie []. Dies dient der Anpassung an Änderungen, die an der Sprache vorgenommen wurden, seit diese Herausforderung veröffentlicht wurde.

Bash + BSD-Dienstprogramme, 36

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

Funktioniert rssofort unter OS X. Möglicherweise muss es auf Linux-Systemen installiert werden.

• Bash erweitert Co{1..12}d{1..12}*pum Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p.
• Dies ist ein dcAusdruck, der die erforderlichen Begriffe generiert. CoSetzt die Ausgabebasis auf 12. dWird anstelle eines Leerzeichens als Trennzeichen zwischen Zahlen verwendet, sodass in der geschweiften Klammer kein Escape erforderlich ist. ddupliziert tatsächlich die Oberseite des Stapels, dies wird jedoch effektiv ignoriert und verworfen.
• Die Ausgabe von dcist eine einzelne durch Leerzeichen getrennte Zeile. rsFormt dies in ein 12x12-Array um. -jrechtfertigt jeden Begriff.

Pyth, 36 Bytes

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

Probieren Sie es hier aus.

Python, 153 147 132 Bytes * 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)),

Bis zu 132 Bytes dank dem Rat von Tim Pederick! :)

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

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

Probieren Sie es hier aus.

(Sieht Martin jetzt ziemlich ähnlich.)

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 Bytes -20% = 48 Bytes

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

(Das ist fast genau so, wie ich es schreiben würde, selbst wenn ich nicht versuchen würde, es so kurz wie möglich zu machen.)

Verwendung:

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

Der naheliegende Weg, um damit zu beginnen.

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

Anmerkungen

• Es ist schade, dass js toString Kleinbuchstaben erzeugt
• alert ist nicht der beste Weg, die Tabelle auszugeben, aber der kürzere, da explizit eine Aufforderung zur "Anzeige auf dem Bildschirm" vorliegt
• Nur die Rückgabe des Wertes würde ein paar Bytes kürzer sein.

Weniger golfen

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 Bytes

Die äußere Funktion tist diejenige, die die Multiplikationstabelle tatsächlich druckt. Die innere Funktion iführt die Umwandlung einer Zahl in eine Basis von 2 bis 36 durch.

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

Hutspitze zu Boomerang für ihre Lösung und für eine Golfspitze. Ich habe es vermieden, irgendetwas aus Boomerangs Lösung zu kopieren, aber ich habe mir erlaubt, einen Blick darauf zu werfen, um zu sehen, wo ich mehr herausschneiden könnte. Und schon vorher stellte ich fest, dass je mehr ich Golf spielte, desto mehr meins aussah wie das von Boomerang!

Javascript (ES6) 96,8 93,6 Bytes (20% von 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)}

Erläuterung

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 Bytes dank @ edc65 gespart

MATLAB, 111 × 0,8 = 88,8 110 × 0,8 = 88 Bytes

Mein Debüt hier:

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

Erläuterung:

[1:N]'*[1:N] Multiplikationstabelle in Basis 10 erstellen

dec2base([1:N]'*[1:N],N) konvertiere zu Basis 12. Die Ausgabe ist ein Zeichen-Array mit führenden 0-s

strjoin(cellstr(dec2base(___))) In Zelle und zurück in Zeichen konvertieren, um Zeichenfolgen mit Leerzeichen zu verbinden, was eine Zeichenfolge von 1x575 ergibt

[' ',strjoin(___)] Füge Raum hinzu, um 576 Elemente zu haben

strrep(___,' 0',' ')entfernen Sie eine führende Null. Wir machen das zweimal, weil wir Strings mit zwei führenden Nullen haben

reshape(___,4*N,N)' Konvertieren Sie ein 1x576-Zeichen-Array in ein 48x12-Zeichen-Array

disp(___) das ergebnis ohne anzeigen ans =

Ausgabe:

 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 

Wenn wir keine Anweisung zählen N=12;, werden 5*.8=4Bytes gespeichert. Wenn die ans =Ausgabe toleriert wird, können wir das disp()Speichern weiterer 6*0.8=4.8Bytes entfernen . Natürlich kann es auch andere Möglichkeiten geben, um Bytes zu speichern :)

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

Ich weiß, dass es den vorhandenen Python-Antworten unterlegen ist, aber ich habe mir vorgenommen, es zu versuchen. Es ist mein erstes Mal, dass ich etwas auf dieser Seite poste ...

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 Bytes

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

In origin 0. Auf Englisch:

• ∘.×⍨1+⍳⍵: Multiplikationstabelle
• ⍵⊥⍣¯1¨: drücke in base ⍵ jedes Element der Multiplikationstabelle aus
• ⊃∘(⎕D,⎕A)¨¨: Wandelt die Vektortabelle von Zahlen in eine Vektortabelle von Zeichen um
• ¯4↑¨: Richten Sie jedes Element des Ergebnisses auf Länge 4 aus

Die Standard-APL-Druckroutine macht das Richtige.

      {¯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 Zeichen - 20% = 52,8

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

Probelauf:

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 Bytes

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

Dies sollte bis zur Basis 64 funktionieren (die größte von ksh unterstützte Basis). Beispiele:

 $ 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 Bytes * 0,8 = 11,2 Bytes, nicht konkurrenzfähig

QhD]UA*MbQMl2P

Probieren Sie es hier aus!

Erläuterung:

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

Oder 12 Bytes ohne den Bonus

13D]UA*Mb12P