In questa sfida devi stampare le tabelline per input, Ecco alcuni esempi:

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

Regole

1. Vince il codice più breve in byte.

2. Questa sfida è un code-golf, segue le regole generali del code-golf ( code-golf )

3. Se, solo se, il tuo codice non è in grado di stampare il numero, puoi usare le lettere, ecco un esempio:

   Ingresso: B

   Uscita: BDFHJLNPRT

4. Puoi scegliere di iniziare da 0 o dal tuo numero (come 20). Puoi scegliere se inserire spazi o no. La sfida è gratuita, basta inserire un input e stampare tabelle di moltiplicazione.

5. L'output deve elencare i primi 10 membri della tabella dei tempi per il numero specificato. Puoi tralasciare 0 * n.

MATL , 4 byte

10:*

Abbattersi:

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

Provalo online

C #, 105 96 67 56 byte

Ora che so come funziona lambda in C #, ecco un aggiornamento alla mia prima risposta:

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

Salva 11 byte.

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

Grazie Jonathan Allan, non posso ancora aggiungere commenti. E grazie Kevin Cruijssen. Supponevo di dover includere sempre l'intero programma a meno che la domanda non specificasse che erano consentiti frammenti. Potrei anche tralasciare il sistema. chiamare per stampare su console in questo caso, oppure sono richiesti / importati allora?

Gelatina , 3 byte

⁵R×

Provalo su TryItOnline
O sui primi 256 casi, ben allineati, anche su TryItOnline

Come?

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

Clojure, 70 80 byte

Questo è il mio primo post su CG, spero che l'input sia OK:

70 byte

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

80 byte

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

Il programma leggerà un numero come argomento stdin e visualizzerà il risultato:

Produzione

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

05AB1E , 3 byte

TL*

Spiegazione

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

Provalo online!

Perl, 19 byte

Include +1 per -n

Esegui con l'input su STDIN:

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

table.pl:

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

Haskell, 16 byte

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

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

Versione Pointfree di: f n = map (n*) [1..10].

Meduse , 8 byte

p*r11
 i

Provalo online!

Abbastanza semplice: r11dà l'elenco [0, 1, ..., 9, 10], ilegge l'input, *li moltiplica e pstampa l'elenco risultante.

R, 11 byte

scan()*0:10

30 caratteri

PHP, 34 byte

(34 byte)

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

(34 byte)

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

(34 byte)

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

(35 byte)

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

( 41 40 byte)

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

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

(44 byte)

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

J, 8 byte

(i.10)&*

Questo è l'intervallo da 0a 9compreso ( i.10) bonded ( &) con la funzione di moltiplicazione ( *). Questo inizia da zero.

Casi test

   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 caratteri

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

Esempio di esecuzione:
(Questo è il modo interattivo per eseguirlo, 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 byte

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

3 byte salvati grazie a @manatwork

La formattazione dell'output è visibilmente non necessaria

Mata, 15 29 byte

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

Mata è il linguaggio di programmazione matriciale nel pacchetto di statistiche commerciali di Stata. Il codice crea una matrice, si moltiplica per l'input (2 in questo caso) e genera la nuova matrice

Produzione

        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]

L'input viene considerato come parametro della riga di comando.

Stata, 46 byte

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

Produzione

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

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

Sì per funzionale \ o /

Non credo che questo abbia bisogno di spiegazioni, ma se vuoi aggiungerne uno, basta chiedere :)

Java 7, 61 57 byte

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

Casi non testati e test:

Provalo qui.

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

Produzione:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 byte

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

È una soluzione ricorsiva.

T-SQL 61 byte

Sostituisci n con il numero per il quale è necessario popolare la tabella. dimostrazione

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

spt_value è una tabella non documentata in SQL Server, puoi leggere ulteriori informazioni su questa tabella in

• Scopo e significato della tabella spt_values
• Cosa significa Spt_value

Spero che qualcuno troverà una soluzione TSQL migliore.

Scala, 24 byte

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

Spiegazione:

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

,10y:[?]z:*a

Provalo online!

Devo implementare quel I * [A, B, C] = [I*A, I*B, I*C]...

Spiegazione

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

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

Prevede l'input come singolo byte (poiché BF può operare solo su numeri fino a 255) e restituisce i risultati come singoli byte. Alcuni valori possono apparire come ASCII, ma non dovrebbero essere trattati come tali; guarda la rappresentazione decimale dei byte restituiti.

Provalo online!

JavaScript, 42 byte

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

MATLAB, 12 byte

@(x)x*[1:10]

Non molto. Una funzione anonima che accetta xcome input e la moltiplica per il vettore [1:10]. Visualizza come ans = 2 4 6 ... Funziona anche in Octave.

Provalo online .

PowerShell v2 +, 23 byte

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

Prende ingresso tramite argomento della riga di comando, loop nell'intervallo 1da 10, ogni ciclo ponendo quel numero *$nsulla tubazione. L'output tramite implicito Write-Outputalla fine dell'esecuzione del programma produce valori separati da nuova riga.

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 byte

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

Compila ed esegui con (input 4)

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

Produzione

40 36 32 28 24 20 16 12 8 4 

Provalo

Demo

Pyke, 5 byte

TSQm*

Provalo qui!

O TQm*se è permesso fare numeri 0-9anziché1-10

O TL*se stiamo diventando non competitivi.

Javascript (ES6), 34 31 byte

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

Salvato 3 byte grazie a grizzly.

Cubix , 24 byte

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

Cubix è un esolang bidimensionale basato su stack. Cubix è diverso dalle altre lingue 2D in quanto il codice sorgente è racchiuso all'esterno di un cubo.

Provalo online! Nota: dovrai copiare e incollare il codice e c'è un ritardo di 50 ms tra le iterazioni.

Spiegazione

La prima cosa che fa l'interprete è capire il cubo più piccolo su cui si adatterà il codice. In questo caso, la lunghezza del bordo è 1. Quindi il codice viene riempito con nessuna operazione .fino a quando tutti e sei i lati sono riempiti. Lo spazio bianco viene rimosso prima dell'elaborazione, quindi questo codice è identico al precedente:

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