Dans ce défi, vous devez imprimer des tables de multiplication par entrée, voici quelques exemples:

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

Règles

1. Le code le plus court en octets gagne.

2. Ce défi est un code-golf, il suit les règles générales du code-golf ( code-golf )

3. Si, juste si, votre code ne peut pas imprimer de nombre, vous pouvez utiliser des lettres, voici un exemple:

   Entrée: B

   Sortie: BDFHJLNPRT

4. Vous pouvez choisir de partir de 0 ou de votre numéro (comme 20). Vous pouvez choisir de mettre des espaces ou non. Le défi est gratuit, il suffit de prendre une entrée et d'imprimer des tables de multiplication.

5. Votre sortie doit répertorier les 10 premiers membres de la table des temps pour le nombre donné. Vous pouvez laisser de côté 0 * n.

MATL , 4 octets

10:*

Panne:

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

Essayez-le en ligne

C #, 105 96 67 56 octets

Maintenant que je sais comment fonctionne lambda en C #, voici une mise à jour de ma première réponse:

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

Enregistre 11 octets.

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

Non golfé:

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

Merci Jonathan Allan, je ne peux pas encore ajouter de commentaires. Et merci Kevin Cruijssen. J'ai supposé que je devais toujours inclure l'intégralité du programme, sauf si la question spécifiait que les extraits étaient autorisés. Serais-je également en mesure de laisser de côté le système. appelez pour imprimer sur la console dans ce cas, ou utilisez-vous / imports alors?

Gelée , 3 octets

⁵R×

Testez-le sur TryItOnline
Ou 256 premiers cas, bien alignés, également sur TryItOnline

Comment?

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

Clojure, 70 80 octets

Ceci est mon premier post sur CG, j'espère que l'entrée est OK:

70 octets

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

80 octets

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

Le programme lira un nombre comme argument stdin et affichera le résultat:

Production

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

05AB1E , 3 octets

TL*

Explication

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

Essayez-le en ligne!

Perl, 19 octets

Comprend +1 pour -n

Exécutez avec l'entrée sur STDIN:

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

table.pl:

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

Haskell, 16 octets

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

Exemple d'utilisation: (<$>[1..10]).(*) $ 4-> [4,8,12,16,20,24,28,32,36,40].

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

Méduse , 8 octets

p*r11
 i

Essayez-le en ligne!

Assez simple: r11donne la liste [0, 1, ..., 9, 10], ilit les entrées, les *multiplie et pimprime la liste résultante.

R, 11 octets

scan()*0:10

30 car.

PHP, 34 octets

(34 octets)

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

(34 octets)

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

(34 octets)

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

(35 octets)

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

( 41 40 octets)

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

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

(44 octets)

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

J, 8 octets

(i.10)&*

Il s'agit de la plage de 0à 9inclusive ( i.10) bonded ( &) avec la fonction de multiplication (* ). Cela commence à zéro.

Cas de 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 caractères

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

Exemple d'exécution:
(C'est la façon interactive de l'exécuter, équivalente à 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 octets

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

3 octets économisés grâce à @manatwork

Le formatage de la sortie n'est visiblement pas nécessaire

Mata, 15 29 octets

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

Mata est le langage de programmation matriciel du progiciel de statistiques commerciales Stata. Le code crée une matrice, multiplie par l'entrée (2 dans ce cas) et sort la nouvelle matrice

Production

        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'entrée est considérée comme un paramètre de ligne de commande.

Stata, 46 octets

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

Production

Pour 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 octets

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

Ouais pour fonctionnel \ o /

Je ne pense pas que cela nécessite une explication, mais si vous souhaitez en ajouter un, demandez simplement :)

Java 7, 61 57 octets

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

Cas non testés et testés:

Essayez-le ici.

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

Production:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 octets

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

C'est une solution récursive.

T-SQL 61 octets

Remplacez n par le numéro pour lequel la table doit être remplie. Démo

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

spt_value est une table non documentée dans SQL Server, vous pouvez en savoir plus sur cette table dans

• Objectif et signification de la table spt_values
• Que signifie Spt_value

J'espère que quelqu'un trouvera une meilleure solution TSQL.

Scala, 24 octets

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

Explication:

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

,10y:[?]z:*a

Essayez-le en ligne!

J'ai besoin de mettre cela en œuvre I * [A, B, C] = [I*A, I*B, I*C] …

Explication

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

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

Attend l'entrée comme un seul octet (car BF ne peut fonctionner que sur des nombres jusqu'à 255) et renvoie les résultats sous forme d'un seul octet. Certaines valeurs peuvent ressembler à ASCII, mais elles ne doivent pas être traitées comme telles; regardez la représentation décimale des octets retournés.

Essayez-le en ligne!

JavaScript, 42 octets

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

MATLAB, 12 octets

@(x)x*[1:10]

Pas vraiment grand-chose. Une fonction anonyme qui prend xen entrée et la multiplie par le vecteur [1:10]. S'affiche comme ans = 2 4 6 ... Fonctionne également dans Octave.

Essayez-le en ligne .

PowerShell v2 +, 23 octets

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

Prend l'entrée via l'argument de ligne de commande, boucle sur la plage 1jusqu'à 10, chaque boucle plaçant ce nombre *$nsur le pipeline. La sortie via implicite Write-Outputà la fin de l'exécution du programme entraîne des valeurs séparées par des sauts de ligne.

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 octets

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

Non golfé:

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

Compiler et exécuter avec (entrée 4)

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

Production

40 36 32 28 24 20 16 12 8 4 

Essaye-le

Demo

Pyke, 5 octets

TSQm*

Essayez-le ici!

Ou TQm*s'il est autorisé à faire des chiffres 0-9plutôt que1-10

Ou TL*si nous devenons non compétitifs.

Javascript (ES6), 34 31 octets

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

Enregistré 3 octets grâce à grizzly.

Cubix , 24 octets

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

Cubix est un esolang bidimensionnel basé sur la pile. Cubix est différent des autres langages 2D en ce que le code source est enroulé autour de l'extérieur d'un cube.

Testez-le en ligne!Remarque: vous devrez copier-coller le code et il y a un délai de 50 ms entre les itérations.

Explication

La première chose que fait l'interpréteur est de trouver le plus petit cube sur lequel le code s'adaptera. Dans ce cas, la longueur du bord est 1. Ensuite, le code est .rempli de non-opérations jusqu'à ce que les six côtés soient remplis. L'espace est supprimé avant le traitement, donc ce code est identique à celui ci-dessus:

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