I Cheela (dal libro Dragon's Egg di Robert L. Forward) sono creature che vivono sulla superficie di una stella di neutroni. Il loro corpo è piatto e circolare con dodici occhi sul perimetro, quindi usano naturalmente un sistema di numerazione base-12.

Tra i Cheela, la cura dei cuccioli e l'educazione dei giovani sono compiti svolti dagli Antichi. Poiché alla giovane Cheela deve essere insegnato come moltiplicare, gli Antichi potrebbero usare una tabella di moltiplicazione.

Il tuo compito è produrre una tabella di moltiplicazione 12x 12in base 12, come il seguente. Lettere maiuscole Ae Bvengono utilizzate per le cifre corrispondenti al decimale 10 e 11rispettivamente.

  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'output deve essere stampato sullo schermo. Il formato dovrebbe essere il seguente:

1. I numeri devono essere allineati a destra all'interno di ogni colonna.
2. Sono consentiti spazi iniziali prima della prima colonna, spazi finali dopo l'ultima colonna o una nuova riga finale dopo l'ultima riga.

3. La separazione tra le colonne può essere uno spazio (come mostrato sopra) o più di uno spazio, ma il numero di spazi deve essere coerente tra le colonne. Per misurare la separazione delle colonne, considerare che i numeri visualizzati includono tutti gli spazi iniziali che potrebbero essere stati necessari per soddisfare il requisito 1 (quindi ogni numero occupa tre caratteri, il primo dei quali può essere spazi). Ad esempio, la tabella con separazione di due spazi sarebbe la seguente:

     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
   

La memoria del computer su una stella di neutroni è molto costosa, quindi il tuo codice dovrebbe usare il minor numero di byte possibile.

Sfida estesa e bonus

Idealmente, il codice dovrebbe essere riutilizzato in altre parti dell'universo, dove potrebbero essere in uso altri sistemi di numerazione. A tal fine, la sfida è facoltativamente estesa come segue: Il codice accetta un numero Ncome input e genera una tabella di moltiplicazione Nx Nin base N, con il formato sopra.

L'input può provenire dalla tastiera o come argomento di funzione. Il programma o funzione dovrebbe funzionare per 2≤ N≤ 36, utilizzando come cifre i primi Ncaratteri della sequenza 0, 1, ..., 9, A, B, ..., Z(maiuscolo lettere)

Questa sfida estesa è facoltativa. Se segui questo percorso, risparmia il 20% sul conteggio dei byte (non è necessario arrotondare a un numero intero).

Pyth, 27 * 0.8 = 21.6

VSQsm.[\ 4jkXj*dNQrT99rG1SQ

Provalo online: dimostrazione

Spiegazione:

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*

Provalo qui.

Questo utilizza la separazione minima richiesta.

Spiegazione

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.

Tabella per input 22(il più grande che si adatta al post senza barra di scorrimento orizzontale):

   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

disconoscimento

Poiché il creatore della lingua e l'autore della sfida sono gli stessi, questa risposta non è idonea a vincere .

Per una discussione sulla necessità o meno di questa restrizione, vedere questa meta domanda .

Codice

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

Questo utilizza la separazione minima.

Esempio

Tabella di moltiplicazione ottale

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

Spiegazione

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

Modifica: provalo online!

Per eseguire nel compilatore on-line (a partire dal 19 febbraio 2016), il cambiamento Y)a X:, e rimuovere []. Questo per adattarsi alle modifiche apportate alla lingua da quando è stata pubblicata questa sfida.

Utilità Bash + BSD, 36

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

Funziona immediatamente su OS X. rspotrebbe essere necessario installarlo su sistemi Linux.

• Bash si espande Co{1..12}d{1..12}*pa Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p.
• Questa è dcun'espressione che genera i termini richiesti. Coimposta l'output base su 12. dviene utilizzato come separatore tra i numeri anziché uno spazio, quindi non è necessario scappare nell'espansione del controvento. din realtà duplica la parte superiore dello stack, ma questo viene effettivamente ignorato e scartato.
• L'output da dcè una singola linea separata da spazio. rsrimodella questo in un array 12x12. -jgiustifica ogni termine.

Pyth, 36 byte

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

Provalo qui.

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

Fino a 132 byte grazie al consiglio di Tim Pederick! :)

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

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

Provalo qui.

(Sembra abbastanza simile a quello di Martin ora.)

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

(Questo è quasi esattamente come lo scriverei anche se non stessi cercando di farlo il più corto possibile)

Uso:

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

Il modo ovvio, per cominciare.

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

Gli appunti

• È un peccato che JsString produca lettere minuscole
• alert non è il modo migliore per generare la tabella, ma è il più breve, in quanto esiste una richiesta esplicita di "visualizzare sullo schermo"
• Restituire il valore sarebbe un paio di byte in meno.

Meno golf

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

La funzione esterna t, è quella che stampa effettivamente la tabella di moltiplicazione. La funzione interna i, fa la conversione di un numero in una base da 2 a 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))

Punta del cappello a Boomerang per la loro soluzione e per un consiglio di golf. Ho evitato di copiare qualsiasi cosa dalla soluzione di Boomerang, ma mi sono lasciato dare un'occhiata per vedere dove avrei potuto tagliare di più. E anche prima, ho scoperto che più ci giocavo, più il mio ha iniziato ad assomigliare a Boomerang!

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

Spiegazione

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
}

- salvato 4 byte grazie a @ edc65

MATLAB, 111 * 0,8 = 88,8 110 * 0,8 = 88 byte

Il mio debutto qui:

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

Spiegazione:

[1:N]'*[1:N] crea una tabella di moltiplicazione nella base 10

dec2base([1:N]'*[1:N],N) converti in base 12. L'output è un array di caratteri con 0-s iniziali

strjoin(cellstr(dec2base(___))) converti in cella e torna a char unendo le stringhe con spazio che produce una stringa 1x575

[' ',strjoin(___)] aggiungi spazio per avere 576 elementi

strrep(___,' 0',' ')rimuove uno zero iniziale. Lo facciamo due volte perché abbiamo stringhe con due zeri iniziali

reshape(___,4*N,N)' converti array di caratteri 1x576 in array di caratteri 48x12

disp(___) visualizza il risultato senza ans =

Produzione:

 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 

Se non contiamo l'istruzione N=12;, i 5*.8=4byte vengono salvati. Inoltre, se l' ans =output è tollerato, è possibile rimuovere il disp()salvataggio di altri 6*0.8=4.8byte. Naturalmente, potrebbero esserci altri modi per salvare byte :)

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

So che è inferiore alle risposte esistenti di Python, ma ho pensato di provarlo. È la prima volta che invio post su questo sito ...

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+⍳⍵}

In origine 0. In inglese:

• ∘.×⍨1+⍳⍵: tabellina
• ⍵⊥⍣¯1¨: esprime in base ⍵ ogni elemento della tabella di moltiplicazione
• ⊃∘(⎕D,⎕A)¨¨: converti la tabella del vettore di numeri in una tabella di vettori di caratteri
• ¯4↑¨: allineare a destra alla lunghezza 4 di ogni elemento del risultato

La routine di stampa APL predefinita fa la cosa giusta.

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

Rubino, 69 66 caratteri - 20% = 52,8

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

Esecuzione di esempio:

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

Questo dovrebbe funzionare fino alla base 64 (il più grande radix supportato da ksh). Esempi:

 $ 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, non competitivo

QhD]UA*MbQMl2P

Provalo qui!

Spiegazione:

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

O 12 byte senza il bonus

13D]UA*Mb12P