En este desafío, debe imprimir tablas de multiplicación por entrada. Aquí hay algunos ejemplos:

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

Reglas

1. El código más corto en bytes gana.

2. Este desafío es un código de golf, sigue las reglas generales del código de golf ( código de golf )

3. Si, solo si, su código no puede imprimir el número, puede usar letras. Aquí hay un ejemplo:

   Entrada: B

   Salida: BDFHJLNPRT

4. Puede elegir comenzar desde 0 o su número (como 20). Puedes elegir si poner espacios o no. El desafío es gratis, solo tome una entrada e imprima tablas de multiplicar.

5. Su salida debe enumerar los primeros 10 miembros de la tabla de tiempos para el número dado. Puede omitir 0 * n.

MATL , 4 bytes

10:*

Descompostura:

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

Pruébalo en línea

C #, 105 96 67 56 bytes

Ahora que sé cómo funciona lambda en C #, aquí hay una actualización de mi primera respuesta:

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

Ahorra 11 bytes.

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

Sin golf:

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

Gracias Jonathan Allan, no puedo agregar comentarios todavía. Y gracias Kevin Cruijssen. Supuse que siempre tenía que incluir todo el programa a menos que la pregunta especificara que se permitían fragmentos. ¿También podría dejar de lado el sistema? ¿Llamar para imprimir a la consola en este caso, o están utilizando / importaciones requeridas entonces?

Jalea , 3 bytes

⁵R×

Pruébelo en TryItOnline
o en los primeros 256 casos, bien alineados, también en TryItOnline

¿Cómo?

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

Clojure, 70 80 bytes

Esta es mi primera publicación en CG, espero que la entrada esté bien:

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

El programa leerá un número como argumento estándar y mostrará el resultado:

Salida

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

05AB1E , 3 bytes

TL*

Explicación

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

Pruébalo en línea!

Perl, 19 bytes

Incluye +1 para -n

Ejecutar con la entrada en STDIN:

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

table.pl:

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

Haskell, 16 bytes

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

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

Pointfree versión de: f n = map (n*) [1..10].

Medusa , 8 bytes

p*r11
 i

Pruébalo en línea!

Muy simple: r11da la lista [0, 1, ..., 9, 10], ilee la entrada, las *multiplica e pimprime la lista resultante.

R, 11 bytes

scan()*0:10

30 char.

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

Este es el intervalo de 0al 9incluido ( i.10) unido ( &ingenio) la función de multiplicación ( *). Esto comienza en cero.

Casos de prueba

   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}

Ejecución de muestra:
(Esta es la forma interactiva de ejecutarla, 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 guardados gracias a @manatwork

Formatear la salida es visiblemente innecesario

Mata, 15 29 bytes

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

Mata es el lenguaje de programación matricial en el paquete de estadísticas comerciales de Stata. El código crea una matriz, se multiplica por la entrada (2 en este caso) y las salidas de la nueva matriz

Salida

        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]

La entrada se toma como un parámetro de línea de comandos.

Stata, 46 bytes

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

Salida

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 |

Cheddar , 20 bytes

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

Yay para funcional \ o /

No creo que esto necesite explicación, pero si me gustaría agregar una, solo pregunte :)

Java 7, 61 57 bytes

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

Sin golf y casos de prueba:

Pruébalo aquí.

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

Salida:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 bytes

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

Es una solución recursiva.

T-SQL 61 bytes

Reemplace n con el número para el que se debe completar la tabla. Manifestación

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

spt_value es una tabla no documentada en SQL Server, puede leer más sobre esta tabla en

• Propósito y significado de la tabla spt_values
• ¿Qué significa Spt_value?

Espero que alguien presente una mejor solución de TSQL.

Scala, 24 bytes

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

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

Brachylog , 12 bytes

,10y:[?]z:*a

Pruébalo en línea!

Necesito implementar eso I * [A, B, C] = [I*A, I*B, I*C]...

Explicación

,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 la entrada como un solo byte (ya que BF solo puede operar en números hasta 255) y devuelve los resultados como bytes individuales. Algunos valores pueden parecer ASCII, pero no deben tratarse como tales; mira la representación decimal de los bytes devueltos.

Pruébalo en línea!

JavaScript, 42 bytes

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

MATLAB, 12 bytes

@(x)x*[1:10]

Realmente no mucho. Una función anónima que toma xcomo entrada y la multiplica por el vector [1:10]. Se muestra comoans = 2 4 6 .. . También funciona en Octave.

Pruébalo en línea .

PowerShell v2 +, 23 bytes

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

Toma datos a través del argumento de la línea de comandos, recorre el rango 1en 10, cada bucle coloca ese número *$nen la tubería. La salida implícita Write-Outputal final de la ejecución del programa da como resultado valores separados por nueva línea.

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

Sin golf:

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

Compilar y ejecutar con (entrada 4)

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

Salida

40 36 32 28 24 20 16 12 8 4 

Pruébalo

Demo

Pyke, 5 bytes

TSQm*

Pruébalo aquí!

O TQm*si se le permite hacer números en 0-9lugar de1-10

O TL*si nos estamos volviendo no 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)}

Guardado 3 bytes gracias a grizzly.

Cubix , 24 bytes

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

Cubix es un esolang bidimensional basado en pila. Cubix es diferente de otros idiomas 2D en que el código fuente se envuelve alrededor del exterior de un cubo.

¡Pruébalo en línea!Nota: tendrá que copiar y pegar el código, y hay un retraso de 50 ms entre iteraciones.

Explicación

Lo primero que hace el intérprete es averiguar el cubo más pequeño en el que se ajustará el código. En este caso, la longitud del borde es 1. Luego, el código se rellena sin operaciones .hasta que se llenen los seis lados. El espacio en blanco se elimina antes del procesamiento, por lo que este código es idéntico al anterior:

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