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

Input: 2 

Output: 
0 2  4 6 8  10  12  14  16  18  20

Input: 20

Output: 20 40 60 80 100 120 140 160 180 200

правила

1. Самый короткий код в байтах побеждает.

2. Эта задача представляет собой код-гольф, она следует общим правилам код-гольфа ( код-гольф )

3. Если, если ваш код не может напечатать номер, вы можете использовать буквы, вот пример:

   Вход: B

   Выход: BDFHJLNPRT

4. Вы можете начать с 0 или вашего номера (например, 20). Вы можете выбрать, ставить пробелы или нет. Задача бесплатна, просто возьмите вход и напечатайте таблицы умножения.

5. Ваш вывод должен перечислить первые 10 членов таблицы времен для данного числа. Вы можете пропустить 0 * n.

MATL , 4 байта

10:*

Сломать:

        % Implicit input
10:     % Create a list from 1 2 ... 10
   *    % Multiply list by input
        % Implicit output

Попробуйте онлайн

C #, 105 96 67 56 байт

Теперь, когда я знаю, как работает лямбда в C #, вот обновление моего первого ответа:

n=>{for(int i=0;i++<10;)System.Console.Write(i*n+" ");};

Сохраняет 11 байтов.

void c(int n){for(int i=0;i++<10;){System.Console.Write(i*n+" ");}}

Ungolfed:

void c(int n)
{
    for (int i = 0; i++ < 10 ; )
    {
        System.Console.Write(i*n+" ");
    }
}

Спасибо Джонатан Аллан, пока не могу добавлять комментарии. И спасибо Кевину Круйссену. Я предполагал, что мне всегда нужно включать всю программу, если только в вопросе не указано, что фрагменты разрешены. Смогу ли я также опустить Систему. в этом случае вызовите команду print на консоль, или тогда требуется использование / import?

Желе , 3 байта

⁵R×

Протестируйте это в TryItOnline
Или первые 256 случаев, хорошо выровненных, также в TryItOnline

Как?

⁵R× - main link takes one argument, n
⁵   - literal 10
 R  - range [1,2,...,10]
  × - multiply by input (implicit vectorization)

Clojure, 70 80 байт

Это мой первый пост на CG, я надеюсь, что ввод в порядке:

70 байт

(defn -main[& a](println(map #(* %(read-string(first a)))(range 10))))

80 байт

(defn -main[& a](let[n(read-string(first a))](println(map #(* % n)(range 10)))))

Программа прочитает число в качестве аргумента стандартного ввода и отобразит результат:

Выход

lein run 10
(0 10 20 30 40 50 60 70 80 90)

05AB1E , 3 байта

TL*

объяснение

T    # literal predefined  as 10
 L   # 1-based range: [1,2,3,4,5,6,7,8,9,10]
  *  # multiply with input

Попробуйте онлайн!

Perl, 19 байт

Включает +1 для -n

Запустите с помощью ввода на STDIN:

perl -M5.1010 -n table.pl <<< 8

table.pl:

say$_*$`for/$/..10

Haskell, 16 байт

(<$>[1..10]).(*)

Пример использования: (<$>[1..10]).(*) $ 4-> [4,8,12,16,20,24,28,32,36,40].

Pointfree версия: f n = map (n*) [1..10].

Медуза , 8 байт

p*r11
 i

Попробуйте онлайн!

Все очень просто: r11выдает список [0, 1, ..., 9, 10], iчитает входные данные, *умножает их и pпечатает полученный список.

R 11 байт

scan()*0:10

30 символов

PHP, 34 байта

(34 байта)

for(;$i++<10;)echo$i*$argv[1].' ';

(34 байта)

for(;++$i%11;)echo$i*$argv[1].' ';

(34 байта)

while($i++<10)echo$i*$argv[1].' ';

(35 байт)

for(;$i++<10;)echo' '.$a+=$argv[1];

( 41 40 байт)

<?=join(' ',range(0,10*$a=$argv[1],$a));

<?=join(' ',range($a=$argv[1],10*$a,$a));

(44 байта)

foreach(range(1,10)as$i)echo$i*$argv[1].' ';

J, 8 байт

(i.10)&*

Это диапазон от 0до 9включенного ( i.10) bonded ( &) с функцией умножения ( *). Это начинается с нуля.

Контрольные примеры

   k =: (i.10)&*
   k 2
0 2 4 6 8 10 12 14 16 18
   k 10
0 10 20 30 40 50 60 70 80 90
   k"0 i.10
0 0  0  0  0  0  0  0  0  0
0 1  2  3  4  5  6  7  8  9
0 2  4  6  8 10 12 14 16 18
0 3  6  9 12 15 18 21 24 27
0 4  8 12 16 20 24 28 32 36
0 5 10 15 20 25 30 35 40 45
0 6 12 18 24 30 36 42 48 54
0 7 14 21 28 35 42 49 56 63
0 8 16 24 32 40 48 56 64 72
0 9 18 27 36 45 54 63 72 81

Зш, 19 знаков

echo {0..${1}0..$1}

Пример запуска:
(Это интерактивный способ запуска, эквивалентный zsh scriptfile.sh 20.)

~ % set -- 20          

~ % echo {0..${1}0..$1}
0 20 40 60 80 100 120 140 160 180 200

Python 3, 52 33 30 байт

lambda n:list(range(0,11*n,n))

3 байта сохранены благодаря @manatwork

Форматирование вывода явно не требуется

Мата, 15 29 байт

args i
mata
A=1..10
B=`i'*A
B

Mata - это язык программирования матриц в пакете коммерческой статистики Stata. Код создает матрицу, умножает на вход (в нашем случае 2) и выводит новую матрицу

Выход

        1    2    3    4    5    6    7    8    9   10
    +---------------------------------------------------+
  1 |   2    4    6    8   10   12   14   16   18   20  |
    +---------------------------------------------------+

Чистый Баш, 18

echo $[{0..10}*$1]

Ввод принимается в качестве параметра командной строки.

Стата, 46 байт

args i
set obs `i'
gen x=_n
gen y=x*`i'
list y

Выход

Для я = 15

    +-----+
    |   y |
    |-----|
 1. |  15 |
 2. |  30 |
 3. |  45 |
 4. |  60 |
 5. |  75 |
    |-----|
 6. |  90 |
 7. | 105 |
 8. | 120 |
 9. | 135 |
 10.| 150 |
    |-----|
 11.| 165 |
 12.| 180 |
 13.| 195 |
 14.| 210 |
 15.| 225 |

Чеддер , 20 байтов

n->(|>11).map(n&(*))

Яй для функционала \ о /

Я не думаю, что это нуждается в объяснении, но если вы хотите, чтобы я добавил, просто спросите :)

Java 7, 61 57 байт

void c(int n){for(int i=0;i++<10;)System.out.print(i*n);}

Ungolfed и тестовые случаи:

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

class M{
  static void c(int n){
    for(int i = 0; i++ < 10; ){
      System.out.print(i*n);
    }
  }

  public static void main(String[] a){
    c(2);
    System.out.println();
    c(20);
  }
}

Выход:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 байт

f=(x,i=11)=>--i&&f(x,i)+" "+x*i

Это рекурсивное решение.

T-SQL 61 байт

Замените n номером, для которого необходимо заполнить таблицу. демонстрация

SELECT TOP 11 number*n FROM master..spt_values WHERE type='P'

spt_value - недокументированная таблица в SQL Server, вы можете узнать больше об этой таблице в

• Назначение и значение таблицы spt_values
• Что означает Spt_value

Я надеюсь, что кто-то придумает лучшее решение TSQL.

Скала, 24 байта

(n:Int)=>0 to 10 map(n*)

Объяснение:

(n:Int)=> //define an anonymous function
  0 to 10 //create a range from 0 to 10
  map(n*) //multiply each element by the input

Брахилог , 12 байт

,10y:[?]z:*a

Попробуйте онлайн!

Мне нужно реализовать это I * [A, B, C] = [I*A, I*B, I*C]...

объяснение

,10y            The range [0, 1, …, 10]
    :[?]z       The list [[0, Input], [1, Input], …, [10, Input]]
         :*a    The list [0*Input, 1*Input, …, 10*Input]

брейнф *** , 84 байта

,[>+>++>+++>++++>+++++>++++++>+++++++>++++++++>+++++++++>++++++++++<<<<<<<<<<-]>[.>]

Ожидает ввод в виде одного байта (поскольку BF может работать только с числами до 255) и возвращает результаты в виде одного байта. Некоторые значения могут выглядеть как ASCII, но они не должны рассматриваться как таковые; посмотрите на десятичное представление возвращаемых байтов.

Попробуйте онлайн!

JavaScript, 42 байта

function f(a){for(i=0;i<11;i++)alert(i*a)}

MATLAB, 12 байт

@(x)x*[1:10]

Не очень много для этого. Анонимная функция, которая принимает в xкачестве входных данных и умножает ее на вектор [1:10]. Отображается как ans = 2 4 6 ... Также работает в Октаве.

Попробуйте онлайн .

PowerShell v2 +, 23 байта

param($n)1..10|%{$_*$n}

Принимает входной сигнал с помощью аргумента командной строки, петли в диапазоне 1до 10, каждой петли размещения этого числа *$nна трубопроводе. Вывод через неявный Write-Outputконец программы приводит к значениям, разделенным символом новой строки.

PS C:\Tools\Scripts\golfing> .\multiplication-table.ps1 2
2
4
6
8
10
12
14
16
18
20

PS C:\Tools\Scripts\golfing> .\multiplication-table.ps1 20
20
40
60
80
100
120
140
160
180
200

C89, 44 байта

k;main(n){for(k=n*11;k-=n;)printf("%d ",k);}

Ungolfed:

k;
main(n)
{
    for (k=n*11 ; k-=n ;)
        printf("%d ", k);
}

Скомпилируйте и запустите с (вход 4)

gcc -ansi main.c && ./a.out 2 3 4

Выход

40 36 32 28 24 20 16 12 8 4 

Попробуй это

Demo

Пайк, 5 байт

TSQm*

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

Или TQm*если разрешено делать цифры, 0-9а не1-10

Или TL*если мы идем неконкурентоспособны.

Javascript (ES6), 34 31 байт

a=>{for(i=0;i<11;)alert(++i*a)}
(a)=>{for(i=0;i<11;++i)alert(i*a)}

Сохранено 3 байта благодаря гризли.

Cubix , 24 байта

;;..I1.N-?W.;;)W@/So..*O

Cubix - это двумерный esolang на основе стека. Cubix отличается от других 2D-языков тем, что исходный код обернут снаружи куба.

Проверьте это онлайн! Примечание: вам придется скопировать и вставить код, и между итерациями будет задержка в 50 мс.

объяснение

Первое, что делает интерпретатор, это вычисляет наименьший куб, на который поместится код. В этом случае длина ребра равна 1. Затем код дополняется без операций, .пока все шесть сторон не будут заполнены. Пробелы удаляются перед обработкой, поэтому этот код идентичен приведенному выше:

    ; ;
    . .
I 1 . N - ? W .
; ; ) W @ / S o
    . .
    * O