Neste desafio, você deve imprimir tabelas de multiplicação por entrada. Aqui estão alguns exemplos:

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

Regras

1. O código mais curto em bytes vence.

2. Este desafio é um código de golfe, segue as regras gerais do código de golfe ( código de golfe )

3. Se, apenas se, seu código não puder imprimir o número, você poderá usar letras. Aqui está um exemplo:

   Entrada: B

   Saída: BDFHJLNPRT

4. Você pode optar por começar do 0 ou do seu número (como 20). Você pode escolher se coloca espaços ou não. O desafio é gratuito, basta dar uma entrada e imprimir tabelas de multiplicação.

5. Sua saída deve listar os 10 primeiros membros da tabela de tempos para o número fornecido. Você pode deixar de fora 0 * n.

MATL , 4 bytes

10:*

Demolir:

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

Experimente online

C #, 105 96 67 56 bytes

Agora que eu sei como o lambda funciona em C #, aqui está uma atualização para minha primeira resposta:

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

Salva 11 bytes.

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+" ");
    }
}

Obrigado Jonathan Allan, ainda não pode adicionar comentários. E obrigado Kevin Cruijssen. Presumi que sempre deveria incluir o programa inteiro, a menos que a pergunta especificava que snippets eram permitidos. Eu também seria capaz de deixar de fora o sistema. ligue para imprimir para o console nesse caso, ou são necessárias / importações então?

Geléia , 3 bytes

⁵R×

Teste no TryItOnline
Ou nos primeiros 256 casos, bem alinhados, também no TryItOnline

Quão?

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

Clojure, 70 80 bytes

Este é o meu primeiro post no CG, espero que a entrada esteja OK:

70 bytes

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

80 bytes

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

O programa lerá um número como argumento stdin e exibirá o resultado:

Resultado

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

05AB1E , 3 bytes

TL*

Explicação

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

Experimente online!

Perl, 19 bytes

Inclui +1 para -n

Execute com a entrada em STDIN:

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

table.pl:

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

Haskell, 16 bytes

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

Exemplo de uso: (<$>[1..10]).(*) $ 4-> [4,8,12,16,20,24,28,32,36,40].

Versão pointfree de: f n = map (n*) [1..10].

Água-viva , 8 bytes

p*r11
 i

Experimente online!

Muito simples: r11fornece a lista [0, 1, ..., 9, 10], ilê a entrada, *multiplica-os e pimprime a lista resultante.

R, 11 bytes

scan()*0:10

30 caracteres.

PHP, 34 bytes

(34 bytes)

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

(34 bytes)

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

(34 bytes)

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

(35 bytes)

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

( 41 40 bytes)

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

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

(44 bytes)

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

J, 8 bytes

(i.10)&*

Esse é o intervalo de 0até 9inclusivo ( i.10) ligado ( &) com a função de multiplicação ( *). Isso começa em zero.

Casos de teste

   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

Zsh, 19 caracteres

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

Exemplo de execução:
(Esta é a maneira interativa de executá-lo, equivalente a 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 bytes

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

3 bytes salvos graças a @manatwork

Formatar a saída visivelmente não é necessário

Mata, 15 29 bytes

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

Mata é a linguagem de programação matricial no pacote de estatísticas comerciais Stata. O código cria uma matriz, multiplica pela entrada (2 neste caso) e gera a nova matriz

Resultado

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

Pure Bash, 18

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

A entrada é tomada como um parâmetro da linha de comandos.

Estado, 46 ​​bytes

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

Resultado

Para i = 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 |

Queijo Cheddar , 20 bytes

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

Yay para \ o / funcional

Eu não acho que isso precise de explicação, mas se você quiser adicionar uma, basta perguntar :)

Java 7, 61 57 bytes

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

Casos não testados e de teste:

Experimente aqui.

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

Resultado:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 bytes

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

É uma solução recursiva.

T-SQL 61 bytes

Substitua n pelo número para o qual a tabela precisa ser preenchida. Demo

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

spt_value é uma tabela não documentada no SQL Server, você pode ler mais sobre esta tabela em

• Finalidade e significado da tabela spt_values
• O que significa Spt_value

Espero que alguém venha com a melhor solução TSQL.

Scala, 24 bytes

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

Explicação:

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

Braquilog , 12 bytes

,10y:[?]z:*a

Experimente online!

Eu preciso implementar isso I * [A, B, C] = [I*A, I*B, I*C]...

Explicação

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

brainf *** , 84 bytes

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

Espera a entrada como um byte único (como o BF pode operar apenas em números de até 255) e retorna os resultados como bytes únicos. Alguns valores podem parecer ASCII, mas não devem ser tratados como tal; observe a representação decimal dos bytes retornados.

Experimente online!

JavaScript, 42 bytes

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

MATLAB, 12 bytes

@(x)x*[1:10]

Não é muito para isso. Uma função anônima que recebe xcomo entrada e a multiplica pelo vetor [1:10]. Exibe como ans = 2 4 6 ... Também funciona em oitava.

Experimente online .

PowerShell v2 +, 23 bytes

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

Recebe a entrada por meio do argumento da linha de comando, passa pelo intervalo 1para 10, cada loop colocando esse número *$nno pipeline. A saída via implícita Write-Outputno final da execução do programa resulta em valores separados por nova linha.

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 bytes

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

Compilar e executar com (entrada 4)

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

Resultado

40 36 32 28 24 20 16 12 8 4 

Teste-o

Demo

Pyke, 5 bytes

TSQm*

Experimente aqui!

Ou, TQm*se for permitido fazer números em 0-9vez de1-10

Ou TL*se não formos competitivos.

Javascript (ES6), 34 31 bytes

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

Economizou 3 bytes graças ao grizzly.

Cubix , 24 bytes

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

Cubix é um esolang bidimensional baseado em pilha. O Cubix é diferente de outros idiomas 2D, pois o código-fonte está envolvido na parte externa de um cubo.

Teste online! Nota: você precisará copiar e colar o código e haverá um atraso de 50 ms entre as iterações.

Explicação

A primeira coisa que o intérprete faz é descobrir o menor cubo no qual o código se ajustará. Nesse caso, o comprimento da borda é 1. Em seguida, o código é preenchido com no-ops .até que todos os seis lados sejam preenchidos. O espaço em branco é removido antes do processamento, portanto, esse código é idêntico ao acima:

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