Bei dieser Herausforderung müssen Sie Multiplikationstabellen nach Eingabe drucken. Hier einige Beispiele:

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

Regeln

1. Der kürzeste Code in Bytes gewinnt.

2. Diese Herausforderung ist ein Code-Golf. Sie folgt den allgemeinen Regeln des Code-Golfs ( Code-Golf ).

3. Wenn Ihr Code keine Zahlen drucken kann, können Sie Buchstaben verwenden. Hier ein Beispiel:

   Eingabe: B.

   Ausgabe: BDFHJLNPRT

4. Sie können wählen, ob Sie bei 0 oder bei Ihrer Nummer (z. B. 20) beginnen möchten. Sie können wählen, ob Leerzeichen eingefügt werden sollen oder nicht. Die Herausforderung ist kostenlos, nehmen Sie einfach eine Eingabe und drucken Sie Multiplikationstabellen.

5. Ihre Ausgabe muss die ersten 10 Mitglieder der Zeittabelle für die angegebene Nummer auflisten. Sie können 0 * n weglassen.

MATL , 4 Bytes

10:*

Nervenzusammenbruch:

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

Probieren Sie es online aus

C #, 105 96 67 56 Bytes

Jetzt, da ich weiß, wie Lambda in C # funktioniert, ist hier ein Update meiner ersten Antwort:

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

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

Vielen Dank Jonathan Allan, kann noch keine Kommentare hinzufügen. Und danke Kevin Cruijssen. Ich nahm an, dass ich immer das gesamte Programm einschließen musste, es sei denn, die Frage spezifizierte, dass Snippets erlaubt waren. Würde ich auch das System weglassen können. Rufen Sie in diesem Fall an, um auf der Konsole zu drucken, oder sind dann / imports erforderlich?

Gelee , 3 Bytes

⁵R×

Testen Sie es bei TryItOnline
oder bei den ersten 256 Fällen, die gut aufeinander abgestimmt sind , auch bei TryItOnline

Wie?

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

Clojure, 70 80 Bytes

Dies ist mein erster Beitrag zu CG. Ich hoffe, die Eingabe ist in Ordnung:

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

Das Programm liest eine Zahl als Standardargument und zeigt das Ergebnis an:

Ausgabe

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

05AB1E , 3 Bytes

TL*

Erläuterung

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

Probieren Sie es online aus!

Perl, 19 Bytes

Beinhaltet +1 für -n

Mit der Eingabe auf STDIN ausführen:

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

table.pl::

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

Haskell, 16 Bytes

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

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

Punktfreie Version von : f n = map (n*) [1..10].

Qualle , 8 Bytes

p*r11
 i

Probieren Sie es online aus!

Ganz einfach: r11Gibt die Liste an [0, 1, ..., 9, 10], iliest die Eingabe, *multipliziert sie und pdruckt die resultierende Liste.

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

Dies ist der Bereich von 0bis 9einschließlich ( i.10) gebunden ( &) mit der Multiplikationsfunktion ( *). Dies beginnt bei Null.

Testfälle

   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 Zeichen

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

Probelauf:
(Dies ist die interaktive Methode zum Ausführen, entsprechend 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 dank @manatwork gespeichert

Das Formatieren der Ausgabe ist sichtbar nicht erforderlich

Mata, 15 29 Bytes

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

Mata ist die Matrix-Programmiersprache im kommerziellen Statistikpaket von Stata. Code erstellt eine Matrix, multipliziert mit der Eingabe (in diesem Fall 2) und gibt die neue Matrix aus

Ausgabe

        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]

Die Eingabe wird als Befehlszeilenparameter verwendet.

Stata, 46 Bytes

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

Ausgabe

Für 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 für funktionale \ o /

Ich denke nicht, dass dies einer Erklärung bedarf, aber wenn Sie mir eine hinzufügen möchten, fragen Sie einfach :)

Java 7, 61 57 Bytes

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

Ungolfed & Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 Byte

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

Es ist eine rekursive Lösung.

T-SQL 61 Bytes

Ersetzen Sie n durch die Nummer, für die die Tabelle ausgefüllt werden muss. Demo

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

spt_value ist eine undokumentierte Tabelle in SQL Server. Weitere Informationen zu dieser Tabelle finden Sie in

• Zweck und Bedeutung der Tabelle spt_values
• Was bedeutet Spt_value?

Ich hoffe, jemand wird eine bessere TSQL-Lösung finden.

Scala, 24 Bytes

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

Erläuterung:

(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

Probieren Sie es online aus!

Ich muss das umsetzen I * [A, B, C] = [I*A, I*B, I*C]...

Erläuterung

,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

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

Erwartet die Eingabe als einzelnes Byte (da BF nur mit Zahlen bis zu 255 arbeiten kann) und gibt die Ergebnisse als einzelne Bytes zurück. Einige Werte sehen möglicherweise wie ASCII aus, sollten jedoch nicht als solche behandelt werden. Schauen Sie sich die Dezimaldarstellung der zurückgegebenen Bytes an.

Probieren Sie es online aus!

JavaScript, 42 Bytes

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

MATLAB, 12 Bytes

@(x)x*[1:10]

Nicht wirklich viel dazu. Eine anonyme Funktion, die xals Eingabe verwendet und mit dem Vektor multipliziert wird [1:10]. Zeigt an als ans = 2 4 6 ... Funktioniert auch in Octave.

Probieren Sie es online aus .

PowerShell v2 +, 23 Byte

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

Nimmt Eingaben über ein Befehlszeilenargument vor und durchläuft den Bereich 1bis 10, wobei jede Schleife diese Nummer *$nin die Pipeline einfügt. Die implizite Ausgabe Write-Outputam Ende der Programmausführung führt zu durch Zeilenumbrüche getrennten Werten.

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

Kompilieren und ausführen mit (Eingabe 4)

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

Ausgabe

40 36 32 28 24 20 16 12 8 4 

Probier es aus

Demo

Pyke, 5 Bytes

TSQm*

Probieren Sie es hier aus!

Oder TQm*wenn es erlaubt ist, Zahlen zu machen 0-9anstatt1-10

Oder TL*wenn wir nicht wettbewerbsfähig sind.

Javascript (ES6), 34 31 Bytes

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

3 Bytes dank Grizzly gespart.

Cubix , 24 Bytes

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

Cubix ist ein zweidimensionaler, stapelbasierter Esolang. Cubix unterscheidet sich von anderen 2D-langs darin, dass der Quellcode um die Außenseite eines Cubes gewickelt ist.

Testen Sie es online! Hinweis: Sie müssen den Code kopieren und einfügen, und zwischen den Iterationen liegt eine Verzögerung von 50 ms.

Erläuterung

Der Interpreter ermittelt zunächst den kleinsten Cube, auf den der Code passt. In diesem Fall beträgt die Kantenlänge 1. Dann wird der Code mit No-Ops .aufgefüllt, bis alle sechs Seiten gefüllt sind. Leerzeichen werden vor der Verarbeitung entfernt, daher ist dieser Code mit dem oben genannten identisch:

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