Cheela (책에서 드래곤의 알 로버트 L. 전달에 의한)는 중성자 별의 표면에 살고있는 생물이다. 그들의 몸은 둘레에 12 개의 눈을 가진 평평하고 원형이므로, 자연스럽게 12 진법을 사용합니다.

Cheela 중, 부화를 돌보고 젊은이들을 교육하는 것은 Old Ones가 수행하는 작업입니다. 어린 Cheela는 곱하는 법을 배워야하므로 Old One은 곱셈표를 사용할 수 있습니다.

당신의 임무는 다음과 같이 base에 12x 12곱셈 테이블 을 생성하는 12것입니다. 대문자 A와 B10 진수 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을 충족하는 데 필요할 수있는 선행 공백이 포함된다는 점을 고려하십시오 (따라서 각 숫자는 세 문자를 차지하며 첫 문자는 공백 일 수 있음). 예를 들어, 공백이 2 개인 테이블은 다음과 같습니다.

     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를 입력으로 받아들이고 위의 형식으로 base에 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!

이것은 최소 분리를 사용합니다.

예

8 진수 곱셈표

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

편집 : 온라인으로 사용해보십시오!

변경 (2 월 (19), 2016) 온라인 컴파일러에서 실행하기 Y)에 X:, 및 제거 []. 이것은이 도전이 게시 된 이후에 변경된 언어에 적응하는 것입니다.

배쉬 + 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

여기에서 시도하십시오.

파이썬 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)),

Tim Pederick의 조언 덕분에 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

자바 스크립트 (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)
}

파이썬 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))

그들의 솔루션 과 골프 팁을위한 부메랑의 모자 팁 . Boomerang의 솔루션에서 아무것도 복사하지 않았지만 더 잘 볼 수있는 곳을 직접 볼 수있었습니다. 그리고 그 전에도 골프를 많이할수록 부메랑처럼 보이기 시작했습니다!

자바 스크립트 (ES6) 96.8 93.6 바이트 (117의 20 %)

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
}

- @ edc65 덕분에 4 바이트 절약

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을 선행하는 char 배열입니다.

strjoin(cellstr(dec2base(___))) 1x575 문자열을 생성하는 셀로 변환하고 다시 문자 결합 문자열로 변환

[' ',strjoin(___)] 576 개의 요소가있는 공간 추가

strrep(___,' 0',' ')하나의 선행 0을 제거하십시오. 두 개의 선행 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바이트 저장 을 제거 할 수 있습니다 . 물론 바이트를 저장하는 다른 방법이있을 수 있습니다. :)

파이썬 3 166 161 152 - 20 % = 121.6 바이트

나는 기존의 파이썬 답변보다 열등하다는 것을 알고 있지만 그것을 쐈다. 이 사이트에 처음 게시하는 것은…

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