Bu meydan okumada, çarpım tablolarını girdiye göre yazdırmanız gerekir, İşte bazı örnekler:

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

kurallar

1. Bayt cinsinden en kısa kod kazanır.

2. Bu zorluk bir kod golf, kod-golf genel kurallara uyar ( kod-golf )

3. Kodunuz sayı yazdıramıyorsa, harfleri kullanabilirsiniz, İşte bir örnek:

   Giriş: B

   Çıktı: BDFHJLNPRT

4. 0'dan veya numaranızdan başlamayı seçebilirsiniz (20 gibi). Boşluk koyup koymamayı seçebilirsiniz. Zorluk ücretsizdir, sadece bir girdi alın ve çarpım tablolarını yazdırın.

5. Çıktınız, verilen sayı için zaman tablosunun ilk 10 üyesini listelemelidir. 0 * n dışında bırakabilirsiniz.

MATL , 4 bayt

10:*

Yıkmak:

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

Çevrimiçi deneyin

C #, 105 96 67 56 bayt

Şimdi lambda'nın C # 'daki çalışmasını bildiğime göre, işte ilk cevabım için bir güncelleme:

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

11 bayt tasarruf sağlar.

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

Teşekkür ederim Jonathan Allan, henüz yorum ekleyemiyorum. Ve teşekkürler Kevin Cruijssen. Parçacıklara izin verildiğini belirtmedikçe, her zaman tüm programı dahil etmem gerektiğini varsaydım. Sistemden ayrılabilir miyim? Bu durumda konsola yazdırmak için çağrı mı yapıyorsunuz, yoksa / import kullanılıyor mu?

Jöle , 3 bayt

⁵R×

En Test edin TryItOnline
Veya ilk 256 olguda, güzel de ayrıca, hizalanmış TryItOnline

Nasıl?

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

Clojure, 70 80 bayt

Bu CG benim ilk yazı, umarım giriş iyi:

70 bayt

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

80 bayt

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

Program bir sayıyı stdin argümanı olarak okuyacak ve sonucu gösterecektir:

Çıktı

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

05AB1E , 3 bayt

TL*

açıklama

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

Çevrimiçi deneyin!

Perl, 19 bayt

İçin +1 içerir -n

STDIN üzerindeki giriş ile çalıştırın:

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

table.pl:

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

Haskell, 16 bayt

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

Kullanım örneği: (<$>[1..10]).(*) $ 4-> [4,8,12,16,20,24,28,32,36,40].

Ait Pointfree versiyonu: f n = map (n*) [1..10].

Denizanası , 8 bayt

p*r11
 i

Çevrimiçi deneyin!

Oldukça basit: r11listesini verir [0, 1, ..., 9, 10], igiriş okur, *çarpar onları ve psonuçtaki listeyi yazdırır.

R, 11 bayt

scan()*0:10

30 karakter

PHP, 34 bayt

(34 bayt)

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

(34 bayt)

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

(34 bayt)

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

(35 bayt)

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

( 41 40 bayt)

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

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

(44 bayt)

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

J, 8 bayt

(i.10)&*

Bu aralıktır 0için 9dahil ( i.10) bağlanmış ( &çarpma fonksiyonu) wit ( *). Bu sıfırdan başlar.

Test senaryoları

   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 karakter

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

Örnek çalışma:
(Bu, çalıştırmanın etkileşimli yoludur. İle eşdeğerdir 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 bayt

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

@Manatwork sayesinde 3 byte tasarruf edildi

Çıktıyı biçimlendirmek görsel olarak gerekli değildir

Mata, 15 29 Bayt

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

Mata, Stata ticari istatistik paketindeki matris programlama dilidir. Kod bir matris oluşturur, girişle (bu durumda 2) çarpar ve yeni matrisi çıkarır

Çıktı

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

Saf Bash, 18

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

Giriş bir komut satırı parametresi olarak alınır.

Stata, 46 bayt

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

Çıktı

İ = 15 için

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

Çedar , 20 bayt

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

Fonksiyonel için Yay \ o /

Bunun bir açıklamaya ihtiyacı olduğunu sanmıyorum ama bana eklemek isterseniz sormanız yeterli :)

Java 7, 61 57 bayt

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

Test edilmemiş ve test durumları:

Burada deneyin.

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

Çıktı:

2468101214161820
20406080100120140160180200

JavaScript (ES6), 33 31 bayt

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

Bu özyinelemeli bir çözüm.

T-SQL 61 bayt

N yerine tablonun doldurulması gereken numarayı yazın. gösteri

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

spt_value SQL Server'da belgelenmemiş bir tablodur, bu tablo hakkında daha fazla bilgi için

• Spt_values ​​tablosunun amacı ve anlamı
• Spt_value anlamı ne

Umarım birisi daha iyi TSQL çözümü bulur.

Scala, 24 bayt

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

Açıklama:

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

,10y:[?]z:*a

Çevrimiçi deneyin!

Bunu uygulamam gerek I * [A, B, C] = [I*A, I*B, I*C]…

açıklama

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

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

Girişi tek bir bayt olarak bekler (BF yalnızca 255'e kadar olan numaralarda çalışabileceğinden) ve sonuçları tek bayt olarak döndürür. Bazı değerler ASCII'ye benzeyebilir, ancak bu şekilde ele alınmamalıdır; Döndürülen baytların ondalık gösterimine bakın.

Çevrimiçi deneyin!

JavaScript, 42 bayt

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

MATLAB, 12 bayt

@(x)x*[1:10]

O kadar da değil. xGirdi olarak alan ve vektörle çarpan anonim bir işlev [1:10]. Olarak görüntülenir ans = 2 4 6 ... Octave'da da çalışır.

Çevrimiçi deneyin .

PowerShell v2 +, 23 bayt

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

Komut satırı bağımsız ile girişi alır aralığında döngü 1için 10bu sayı yerleştirilmesi, her döngü, *$nboru hattı üzerinde. Write-OutputProgram yürütme sonunda örtük yoluyla çıktı yeni satırla ayrılmış değerlerle sonuçlanır.

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 bayt

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

Derleyin ve çalıştırın (giriş 4)

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

Çıktı

40 36 32 28 24 20 16 12 8 4 

Dene

Demo

Pyke, 5 bayt

TSQm*

Burada deneyin!

Veya TQm*sayı 0-9yerine numara yapmasına izin verilirse1-10

Ya TL*da rekabetçi olmayacaksak.

Javascript (ES6), 34 31 bayt

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

Grizzly sayesinde 3 bayt kaydedildi.

Cubix , 24 bayt

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

Cubix 2 boyutlu, yığın tabanlı bir esolang. Cubix, kaynak kodun bir küpün dışına sarılması bakımından diğer 2D şeritlerden farklıdır.

Çevrimiçi test edin! Not: kodu kopyalayıp yapıştırmanız gerekir ve yinelemeler arasında 50 ms gecikme olur.

açıklama

Yorumlayıcının yaptığı ilk şey, kodun sığacağı en küçük küpü bulmaktır. Bu durumda kenar uzunluğu 1'dir. Daha sonra kod, .altı tarafın tümü dolana kadar ops ile doldurulur. Boşluk işlemeden önce kaldırılır, bu nedenle bu kod yukarıdakilerle aynıdır:

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