Таблица умножения для Cheela

26

Cheela (из книги Яйцо дракона Роберт Л. вперед) существа , которые живут на поверхности нейтронной звезды. Их тело плоское и круглое с двенадцатью глазами по периметру, поэтому они, естественно, используют систему нумерации Base-12.

Среди чил, забота о детенышах и воспитание молодёжи - это задачи, выполняемые древними. Поскольку молодого Чилу нужно научить умножать, Древние могли использовать таблицу умножения.

Ваша задача - создать в базе 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

Вывод должен быть напечатан на экране. Формат должен быть следующим:

  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с указанным выше форматом.

Ввод может быть с клавиатуры или в качестве аргумента функции. Программа или функция должна работать & 2le ; & Nle ; 36, используя в качестве цифр первых Nсимволов последовательности 0, 1, ..., 9, A, B, ..., Z(прописные буквы)

Этот расширенный вызов не является обязательным. Если вы следуете по этому маршруту, снимите с байта 20% (нет необходимости округлять до целого числа).

Луис Мендо
источник
Хороший Луис! =) Хотелось бы, чтобы у меня было время придумать решение MATLAB, но я занят измерением размеров рождественских подарков ...
Стьюи Гриффин
6
Удачи с этими сферическими шляпами! :-P
Луис Мендо
5
Because they have twelve eyes, they naturally use a base-12 numbering system.Ну естественно. Вот почему мы используем двоичный файл, в конце концов ... ;-)
Тим Педерик
2
@TimPederick Хорошая мысль :-D Чтобы уточнить: тело Чилы круглое, они могут изменять форму конечностей по мере необходимости ... двенадцать глаз численно являются наиболее отличительной чертой их тел. Я обновил вопрос, спасибо!
Луис Мендо
1
@LuisMendo очень хороший роман, который вы цитируете. Старквейк тоже неплох.
Истефано

Ответы:

14

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
Jakube
источник
11

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
Мартин Эндер
источник
8

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:и удалите []. Это делается для того, чтобы адаптироваться к изменениям, которые были внесены в язык с момента публикации этого запроса.

Луис Мендо
источник
«Поскольку создатель языка и автор задания одинаковы, этот ответ не имеет права на победу». Я не знал об этом ограничении. Это само навязывается или вы нашли соответствующий мета-консенсус?
Алекс А.
1
@AlexA. Я сам навязал это. Я подозревал, что, вероятно, было какое-то соглашение по этому поводу. Из твоего сообщения я вижу, что там нет? Моя точка зрения такова: если вы разрабатываете язык, а затем отправляете вызов, вы, вероятно, находитесь в выгодном положении. Что обычно делается с этим? Никаких ограничений?
Луис Мендо
Я бы подумал, что вы не обязательно получаете преимущество, если не планируете задачу именно как вариант использования встроенного в ваш язык. Я не знаю ни о каком таком консенсусе, поэтому я рекомендую спросить о мета.
Алекс А.
@AlexA. Отличная идея! Готово
Луис Мендо
@AlexA. Если вы хотите сделать это, возможно, добавьте свое предложение в качестве ответа там?
Луис Мендо
5

Утилиты 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}*pдо Co1d1*p Co1d2*p Co1d3*p ... Co1d12*p ... Co12d12*p.
  • Это dcвыражение, которое генерирует необходимые термины. Coустанавливает выходное основание равным 12. dИспользуется в качестве разделителя между числами вместо пробела, поэтому в расширении фигурных скобок не требуется экранирования. dфактически дублирует вершину стека, но это фактически игнорируется и отбрасывается.
  • Выходные данные dc- это одна строка, разделенная пробелом. rsизменяет это в массив 12x12. -jоправдывает каждый термин.
Цифровая травма
источник
4

Pyth, 36 байт

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

Попробуй это здесь.

синий
источник
Вы можете заменить Km+1dUJ12на KSJ12. Sсоздает диапазон [1, 2, ..., 12]. Вы можете заменить как j""и jkс s, так как ваши соединительные строки. И еще один байт: изменить rjbm...K1на jmr...1K. С этими изменениями вы получите 28 байтов:KSJ12jmrsm.[\ 4sm.Hbj*dkJK1K
Jakube
4

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 байтов благодаря совету Тима Педерика! :)

Базиль-генри
источник
Проголосовал, потому что чем больше я играю в гольф мой ответ , тем больше он начинает выглядеть как твой!
Тим Педерик
Некоторые возможные улучшения: Используйте% -форматирование вместо rjust( '%4s'%f(...)). Посмотрите, короче ли печать каждого значения с помощью print ...,(а затем одного printдля новой строки) join. Если это так, попробуйте свернуть петли .
Тим Педерик
Спасибо Тим, я попытался свернуть петли (я не знал этого трюка). Я не уверен, что это заставляет меня набирать много байтов, если таковые имеются, но это довольно круто :)
basile-henry
Я вижу, вы переключились на троичную форму (условие andA orB) внутри функции f, используя n>=b. Я делал это до тех пор, пока не понял, что он не короче того, что у меня было раньше n//b... но вы используете Python 2! Вы можете сохранить байт с помощью n/b.
Тим Педерик
Да, именно поэтому я использовал эту часть вашего кода, используя Python 2, чтобы сохранить еще один байт :)
basile-henry
4

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.
geokavel
источник
3

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
Брэд Гилберт b2gills
источник
Не эксперт, но является ли пробел между «для» и «(» обязательным? Нужно обрезать пробелы, где это возможно.
J_F_B_M
@J_F_B_M Я всегда сначала пытаюсь удалить пробелы. Так что, если есть место, это требуется. Если бы я удалил пробел, он наверняка не скомпилировался бы, так как он стал бы for(началом вызова подпрограммы с именем forвместо конструкции цикла модификатора for. Что может привести к ошибке компиляции.
Брэд Гилберт b2gills
Узнал что-то. Спасибо.
J_F_B_M
3

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

Заметки

  • Жаль, что 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)
}
edc65
источник
3

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

Шляпный наконечник Бумерангу за их решение и за наконечник для игры в гольф. Я избегал копировать что-либо из решения Бумеранга, но позволил себе взглянуть на него, чтобы увидеть, где я мог бы урезать больше. И даже до этого я обнаружил, что чем больше я играю в гольф, тем больше мое становится похожим на бумеранг!

Тим Педерик
источник
Отличное решение! :) И вы получите лучший результат, чем я! Мне нравится> 9 вместо моего <10. Я не слишком знаком с python3 и помеченными звездами выражениями (я должен был это найти). Мне нравится твой трюк, я должен начать использовать это!
Базили-Генри
Я немного протестировал ваше решение, и похоже, что я не возвращаю больше двух базовых n цифр. Например, если вы делаете print(i(15,12),i(120,12),i(144,12),i(150,12))ваш код возвращается 13 A0 00 06вместо 13 A0 100 106. К сожалению, задача требует распечатать одно трехзначное основание номер n (100). Это не должно быть слишком сложно исправить, но это может добавить несколько байтов ...
basile-henry
@Boomerang: <царапины головы> Я думаю , что я , должно быть , что- то нарушил, то ... потому что это было работать раньше! Кажется, проблема в том, что это не даст 1 ... о, подожди, я знаю, в чем проблема. Должно быть n>=b, нет n>b.
Тим Педерик
Я нашел еще одну хитрость, чтобы сделать код меньше: определите i в t (b), чтобы вы могли удалить второй аргумент в i! Примерно так: 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))я хотел бы сделать это в своем решении, но теперь оба наших решения довольно близки, с таким же успехом можно улучшить и лучший ^^
basile-henry
@Boomerang: Эй, твой был первым, и я думаю, что Python 2 предлагает достаточно быстрых клавиш, чтобы ты мог меня обогнать. Но спасибо за помощь!
Тим Педерик
3

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

Aᴄʜᴇʀᴏɴғᴀɪʟ
источник
1
Просто используя {} и alert(b)без eval- короче. И, по крайней мере, избегайте переменных a, это бесполезноb+=' '.repeat(4-a.length)+(i*j).toString(n).toUpperCase()
edc65
Спасибо 😊 Я не видел необходимости отображать его, поэтому для меня eval () изначально был короче, чем возвращаемое значение. @ edc65 однако, если я избегу, aкак ты тогда вычисляешь ...repeat(4-a.length)...?
Aᴄʜᴇʀᴏɴғᴀɪʟ
Тьфу жаль, что ты прав насчет +1 как есть
edc65
2

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. Выходные данные - массив char с начальными 0-с

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байтов. Конечно, могут быть и другие способы сохранения байтов :)

brainkz
источник
В общем случае ansвывод допускается, если вывод является аргументом функции. Но в этом случае задание говорит: «вывод должен быть напечатан на экране», поэтому ansне допускается. Кроме того, Nследует принять за вход в расширенный вызов. Вы можете решить это, используя анонимную функцию:, @(n)disp(reshape(strrep(strrep([' ',strjoin(cellstr(dec2base([1:N]'*[1:N],N)))],' 0',' '),' 0',' '),4*N,N)')которую вы бы назвали, используяans(12)
Луис Мендо
1
Ох и добро пожаловать на сайт! :-)
Луис Мендо
@ LuisMendo спасибо! Я отредактирую свой ответ с помощью @ (N) нотации
brainkz
2

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)))
Теему Пииппо
источник
Есть 3 закрывающие скобки и 2 числовых литерала, за которыми следуют пробелы. Эти места не нужны. В противном случае приятно сначала попробовать. Кстати, Советы по игре в гольф на Python - приятное чтение.
manatwork
Добро пожаловать в PPCG.SE, даже если он не превосходит другой ответ Python, если он другой (не тот же алгоритм / идея), вы можете опубликовать его :).
Катенкё
@manatwork Спасибо! Я получил еще 9 байтов с этим.
Теему Пийппо
2

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 
lstefano
источник
-1:{¯4↑¨⊃∘(⎕D,⎕A)¨¨⍵⊥⍣¯1¨∘.×⍨1+⍳⍵}
Адам
Вместо «chars» вы должны использовать «bytes» со ссылкой на meta.codegolf.stackexchange.com/a/9429/43319 .
Адам
1

Рубин, 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
manatwork
источник
1

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
ormaaj
источник
0

Пайк, 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
синий
источник
Задача определяет заглавные буквы
Луис Мендо