Cheela (จากหนังสือของมังกรไข่โดยโรเบิร์ตแอล Forward) เป็นสิ่งมีชีวิตที่อาศัยอยู่บนพื้นผิวของดาวนิวตรอน ร่างกายของพวกเขาแบนและเป็นวงกลมโดยมีดวงตาทั้งสิบสองตาที่บริเวณรอบนอกดังนั้นพวกเขาจึงใช้ระบบเลขฐาน 12

ในหมู่ Cheela การดูแลลูกฟักและการศึกษาของเด็กเป็นงานที่ทำโดย Old Ones เนื่องจาก Cheela หนุ่มต้องได้รับการสอนวิธีการคูณ Ones Old สามารถใช้ตารางสูตรคูณ

งานของคุณคือการสร้างตารางการคูณ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

เอาต์พุต shoud จะถูกพิมพ์บนหน้าจอ รูปแบบควรเป็นดังนี้:

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โดยมีรูปแบบข้างต้น

อินพุตอาจมาจากแป้นพิมพ์หรือเป็นอาร์กิวเมนต์ของฟังก์ชัน โปรแกรมหรือฟังก์ชั่นควรจะทำงานสำหรับ2≤ N≤ 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}*pCo1d1*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 ไบต์ขอบคุณคำแนะนำของ Tim Pederick! :)

CJam, 38 33 32 38 * (.8) = 30.4 ไบต์

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

ลองที่นี่

(ดูคล้ายกับ Martin ตอนนี้)

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

(นี่เป็นวิธีที่ฉันจะเขียนแม้ว่าฉันจะไม่พยายามทำให้สั้นที่สุดเท่าที่จะทำได้)

การใช้งาน:

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

หมายเหตุ

• มันน่าเสียดายที่ jTString ผลิตอักษรตัวพิมพ์เล็ก
• alert ไม่ใช่วิธีที่ดีที่สุดในการแสดงผลตาราง แต่มันสั้นกว่าเนื่องจากมีการร้องขออย่างชัดเจนที่จะ "แสดงบนหน้าจอ"
• เพียงแค่คืนค่าจะสั้นลงสองสามไบต์

น้อย golfed

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 เอาต์พุตเป็นอาร์เรย์ถ่านที่มีการนำ 0-s

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¨: express ในฐาน element แต่ละองค์ประกอบของตารางสูตรคูณ
• ⊃∘(⎕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 

Ruby, 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 (radix ที่ใหญ่ที่สุดที่รองรับโดย 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