Trong thử thách này, bạn đã in các bảng nhân theo đầu vào, Dưới đây là một số ví dụ:

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

Quy tắc

1. Mã ngắn nhất tính bằng byte thắng.

2. Thách thức này là một môn đánh gôn, Nó tuân theo các quy tắc chung về môn đánh gôn ( môn đánh gôn )

3. Nếu, chỉ khi, mã của bạn không thể in số, bạn có thể sử dụng các chữ cái, Dưới đây là một ví dụ:

   Đầu vào: B

   Đầu ra: BDFHJLNPRT

4. Bạn có thể chọn bắt đầu từ 0 hoặc số của bạn (như 20). Bạn có thể chọn nếu đặt dấu cách hoặc không. Thử thách là miễn phí, chỉ cần lấy một đầu vào và in các bảng nhân.

5. Đầu ra của bạn phải liệt kê 10 thành viên đầu tiên của bảng lần cho số đã cho. Bạn có thể bỏ qua 0 * n.

MATL , 4 byte

10:*

Phá vỡ:

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

Dùng thử trực tuyến

C #, 105 96 67 56 byte

Bây giờ tôi đã biết cách lambda hoạt động trong C #, đây là bản cập nhật cho câu trả lời đầu tiên của tôi:

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

Lưu 11 byte.

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

Ung dung:

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

Cảm ơn Jonathan Allan, chưa thể thêm ý kiến. Và cảm ơn Kevin Cruijssen. Tôi giả sử tôi phải luôn bao gồm toàn bộ chương trình trừ khi câu hỏi được chỉ định rằng đoạn trích được cho phép. Tôi cũng có thể rời khỏi Hệ thống. gọi để in ra bàn điều khiển trong trường hợp này, hoặc đang sử dụng / nhập khẩu sau đó?

Thạch , 3 byte

⁵R×

Kiểm tra nó tại TryItOnline
Hoặc 256 trường hợp đầu tiên, được căn chỉnh độc đáo, cũng tại TryItOnline

Làm sao?

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

Clojure, 70 80 byte

Đây là bài viết đầu tiên của tôi trên CG, tôi hy vọng đầu vào là 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)))))

Chương trình sẽ đọc một số dưới dạng đối số stdin và hiển thị kết quả:

Đầu ra

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

05AB1E , 3 byte

TL*

Giải trình

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

Hãy thử trực tuyến!

Perl, 19 byte

Bao gồm +1 cho -n

Chạy với đầu vào trên STDIN:

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

table.pl:

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

Haskell, 16 byte

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

Ví dụ sử dụng: (<$>[1..10]).(*) $ 4-> [4,8,12,16,20,24,28,32,36,40].

Phiên bản miễn phí của : f n = map (n*) [1..10].

Sứa , 8 byte

p*r11
 i

Hãy thử trực tuyến!

Khá đơn giản: r11đưa ra danh sách [0, 1, ..., 9, 10], iđọc đầu vào, *nhân chúng và pin danh sách kết quả.

R, 11 byte

scan()*0:10

30 char

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

Đây là phạm vi từ 0đến 9bao gồm ( i.10) ngoại quan ( &) với hàm nhân ( *). Điều này bắt đầu từ số không.

Các trường hợp thử nghiệm

   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 ký tự

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

Chạy mẫu:
(Đây là cách tương tác để chạy nó, tương đương với 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 được lưu nhờ @manatwork

Định dạng đầu ra rõ ràng là không cần thiết

Mata, 15 29 byte

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

Mata là ngôn ngữ lập trình ma trận trong gói thống kê thương mại Stata. Mã tạo một ma trận, nhân với đầu vào (2 trong trường hợp này) và đầu ra ma trận mới

Đầu ra

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

Bash thuần khiết, 18

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

Đầu vào được lấy dưới dạng tham số dòng lệnh.

Stata, 46 byte

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

Đầu ra

Cho tô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&(*))

Yay cho chức năng \ o /

Tôi không nghĩ rằng điều này cần giải thích nhưng nếu bạn muốn tôi thêm một câu hỏi :)

Java 7, 61 57 byte

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

Các trường hợp bất khả kháng & thử nghiệm:

Hãy thử nó ở đây.

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

Đầu ra:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 byte

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

Đó là một giải pháp đệ quy.

T-SQL 61 byte

Thay n bằng số mà bảng cần được điền. Bản giới thiệu

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

spt_value là một bảng không có giấy tờ trong SQL Server, bạn có thể đọc thêm về bảng này trong

• Mục đích và ý nghĩa của bảng spt_values
• Spt_value có nghĩa là gì

Tôi hy vọng ai đó sẽ đưa ra giải pháp TSQL tốt hơn.

Scala, 24 byte

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

Giải trình:

(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

Hãy thử trực tuyến!

Tôi cần phải thực hiện điều đó I * [A, B, C] = [I*A, I*B, I*C] ...

Giải trình

,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

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

Yêu cầu đầu vào dưới dạng một byte đơn (vì BF chỉ có thể hoạt động trên các số lên tới 255) và trả về kết quả dưới dạng byte đơn. Một số giá trị có thể trông giống như ASCII, nhưng chúng không nên được xử lý như vậy; nhìn vào biểu diễn thập phân của các byte được trả về.

Hãy thử trực tuyến!

JavaScript, 42 byte

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

MATLAB, 12 byte

@(x)x*[1:10]

Không thực sự nhiều cho nó. Một hàm ẩn danh lấy xđầu vào và nhân nó với vectơ [1:10]. Hiển thị như ans = 2 4 6 ... Cũng hoạt động trong Octave.

Hãy thử trực tuyến .

PowerShell v2 +, 23 byte

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

Đưa đầu vào thông qua đối số dòng lệnh, các vòng lặp trong phạm vi 1tới 10, mỗi vòng lặp đặt số đó *$ntrên đường ống. Đầu ra thông qua ẩn Write-Outputở cuối kết quả thực hiện chương trình trong các giá trị phân tách dòng mới.

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

Ung dung:

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

Biên dịch và chạy với (đầu vào 4)

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

Đầu ra

40 36 32 28 24 20 16 12 8 4 

Kiểm tra nó

Demo

Pyke, 5 byte

TSQm*

Hãy thử nó ở đây!

Hoặc TQm*nếu được phép làm số 0-9chứ không phải1-10

Hoặc TL*nếu chúng ta sẽ không cạnh tranh.

Javascript (ES6), 34 31 byte

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

Đã lưu 3 byte nhờ Grizzly.

Khối , 24 byte

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

Cubix là một esolang 2 chiều, dựa trên ngăn xếp. Cubix khác với các lang 2D khác ở chỗ mã nguồn được bao bọc bên ngoài khối lập phương.

Kiểm tra nó trực tuyến! Lưu ý: bạn sẽ phải sao chép-dán mã và có độ trễ 50 ms giữa các lần lặp.

Giải trình

Điều đầu tiên trình thông dịch làm là tìm ra khối lập phương nhỏ nhất mà mã sẽ phù hợp. Trong trường hợp này, độ dài cạnh là 1. Sau đó, mã được đệm bằng no-op .cho đến khi tất cả sáu mặt được lấp đầy. Khoảng trắng được xóa trước khi xử lý, vì vậy mã này giống hệt như trên:

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