18

我最近向一位从事工作经验的学生介绍了一篇关于将乘法表转储到控制台的文章。它使用嵌套的 for 循环并将每个循环的步长值相乘。

这看起来像是一种 .NET 2.0 方法。我想知道，使用 Linq 和扩展方法，例如，需要多少行代码才能达到相同的结果。

stackoverflow 社区能应对挑战吗？

挑战：在控制台应用程序中，编写代码以生成如下示例所示的表：

01 02 03 04 05 06 07 08 09
02 04 06 08 10 12 14 16 18
03 06 09 12 15 18 21 24 27
04 08 12 16 20 24 28 32 36
05 10 15 20 25 30 35 40 45
06 12 18 24 30 36 42 48 54
07 14 21 28 35 42 49 56 63
08 16 24 32 40 48 56 64 72
09 18 27 36 45 54 63 72 81

由于这变成了与语言无关的代码高尔夫之战，我将与社区一起决定哪个是公认答案的最佳解决方案。

有很多关于表格应该采用的规范和格式的讨论，我故意添加了 00 格式但双换行符最初只是在那里，因为我在创建帖子时不知道如何格式化文本！

4

40 回答 40

41

J - 8 个字符 - 24 个字符用于正确格式

*/~1+i.9

给出：

1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81

@earl 找到的这个解决方案：

'r(0)q( )3.'8!:2*/~1+i.9

给出：

01 02 03 04 05 06 07 08 09
02 04 06 08 10 12 14 16 18
03 06 09 12 15 18 21 24 27
04 08 12 16 20 24 28 32 36
05 10 15 20 25 30 35 40 45
06 12 18 24 30 36 42 48 54
07 14 21 28 35 42 49 56 63
08 16 24 32 40 48 56 64 72
09 18 27 36 45 54 63 72 81
于 2010-08-05T16:25:16.253 回答
16

MATLAB - 10 个字符

a=1:9;a'*a

... 或 33 个字符以获得更严格的输出格式

a=1:9;disp(num2str(a'*a,'%.2d '))
于 2010-08-06T01:27:42.740 回答
15

Brainf**k - 185 个字符

>---------[++++++++++>---------[+<[-<+>>+++++++++[->+>>---------[>-<++++++++++<]<[>]>>+<<<<]>[-<+>]<---------<]<[->+<]>>>>++++[-<++++>]<[->++>+++>+++<<<]>>>[.[-]<]<]++++++++++.[-<->]<+]
于 2010-08-05T18:22:39.773 回答
14

猫 - 252 个字符

01 02 03 04 05 06 07 08 09

02 04 06 08 10 12 14 16 18

03 06 09 12 15 18 21 24 27

04 08 12 16 20 24 28 32 36

05 10 15 20 25 30 35 40 45

06 12 18 24 30 36 42 48 54

07 14 21 28 35 42 49 56 63

08 16 24 32 40 48 56 64 72

09 18 27 36 45 54 63 72 81

假设需要尾随换行符；否则，251 个字符。

*运行*

于 2010-08-07T18:52:05.640 回答
8

Python - 61 个字符

r=range(1,10)
for y in r:print"%02d "*9%tuple(y*x for x in r)
于 2010-08-05T11:35:56.630 回答
7

C＃

这只有2行。它使用 lambdas 而不是扩展方法

 var nums = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 nums.ForEach(n => { nums.ForEach(n2 => Console.Write((n * n2).ToString("00 "))); Console.WriteLine(); });

当然，它可以在一条长长的不可读的行中完成

 new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 }.ForEach(n => { new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 }.ForEach(n2 => Console.Write((n * n2).ToString("00 "))); Console.WriteLine(); });

所有这一切都是假设您考虑使用labmda 单线？

于 2010-08-05T08:27:13.387 回答
6

K - 12 个字符

让我们认真对待罗塞塔石化问题，并将 Kdb+ 的 K4 与规范 J 解 ( */~1+i.9) 进行比较：

  a*/:\:a:1+!9
1 2  3  4  5  6  7  8  9 
2 4  6  8  10 12 14 16 18
3 6  9  12 15 18 21 24 27
4 8  12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81

J 的“表”运算符 ( /) 等于 K“左右两边” ( /:\:) 习语。我们在 K 中没有 J 非常方便的“反身”运算符 ( ~)，因此我们必须同时a作为左参数和右参数传递。

于 2010-08-05T22:24:13.260 回答
6

Fortran95 - 40 个字符（比 perl 快 4 个字符！）

此解决方案确实根据规范打印前导零。

print"(9(i3.2))",((i*j,i=1,9),j=1,9);end
于 2010-08-05T21:36:29.707 回答
5

C# - 117、113、99、96、95 89 个字符

根据NickLarsen 的想法更新

for(int x=0,y;++x<10;)
    for(y=x;y<x*10;y+=x)
        Console.Write(y.ToString(y<x*9?"00 ":"00 \n"));

99, 85, 82 81 个字符 ...如果您不关心前导零并允许制表符对齐。 

for(int x=0,y;++x<10;)
{
    var w="";
    for(y=1;++y<10;)
        w+=x*y+"    ";
    Console.WriteLine(w);
}
于 2010-08-05T20:39:20.113 回答
5

Oracle SQL，103 个字符：

select n, n*2, n*3, n*4, n*5, n*6, n*7, n*8, n*9 from (select rownum n from dual CONNECT BY LEVEL < 10)
于 2010-08-05T16:19:59.187 回答
4

COBOL - 218 个字符 -> 216 个字符

PROGRAM-ID.P.DATA DIVISION.WORKING-STORAGE SECTION.
1 I PIC 9.
1 N PIC 99.
PROCEDURE DIVISION.PERFORM 9 TIMES
ADD 1 TO I
SET N TO I
PERFORM 9 TIMES
DISPLAY N' 'NO ADVANCING
ADD I TO N
END-PERFORM
DISPLAY''
END-PERFORM.

编辑

216 个字符（可能是不同的编译器）

PROGRAM-ID.P.DATA DIVISION.WORKING-STORAGE SECTION.
1 I PIC 9.
1 N PIC 99.
PROCEDURE DIVISION.

  PERFORM B 9 TIMES
  STOP RUN.

B.
 ADD 1 TO I
 set N to I
 PERFORM C 9 TIMES
 DISPLAY''.

C.
 DISPLAY N" "NO ADVANCING
 Add I TO N.
于 2010-08-05T22:13:53.810 回答
3

Ruby - 42 个字符（包括一个换行符，仅限交互式命令行）

这种方法是两行输入，并且只适用于irb（因为 irb 给了我们_），但是将前面的方法缩短了 2 个字符。

1..9
_.map{|y|puts"%02d "*9%_.map{|x|x*y}}

Ruby - 44 个字符（与 perl 相关）

(a=1..9).map{|y|puts"%02d "*9%a.map{|x|x*y}}

红宝石 - 46 个字符

9.times{|y|puts"%02d "*9%(1..9).map{|x|x*y+x}}

红宝石 - 47 个字符

回到双循环

(1..9).map{|y|puts"%02d "*9%(1..9).map{|x|x*y}}

Ruby - 54 个字符！

使用单个循环可以节省几个字符！

(9..89).map{|n|print"%02d "%(n/9*(x=n%9+1))+"\n"*(x/9)}

红宝石 - 56 个字符

9.times{|x|puts (1..9).map{|y|"%.2d"%(y+x*y)}.join(" ")}
于 2010-08-06T03:27:40.047 回答
3

不是真正的单线，而是我能想到的最短的 linq：

var r = Enumerable.Range(1, 9);
foreach (var z in r.Select(n => r.Select(m => n * m)).Select(a => a.Select(b => b.ToString("00 "))))
{
    foreach (var q in z)
        Console.Write(q);
    Console.WriteLine();
}

为了回应结合这个和SRuly的回答

Enumberable.Range(1,9).ToList.ForEach(n => Enumberable.Range(1,9).ToList.ForEach(n2 => Console.Write((n * n2).ToString("00 "))); Console.WriteLine(); });

于 2010-08-05T08:27:09.473 回答
3

哈斯克尔——85 8479 个字符

r=[1..9]
s x=['0'|x<=9]++show x
main=mapM putStrLn[unwords[s$x*y|x<-r]|y<-r]

如果需要双倍间距（8981 个字符），

r=[1..9]
s x=['0'|x<=9]++show x
main=mapM putStrLn['\n':unwords[s$x*y|x<-r]|y<-r]
于 2010-08-05T17:28:05.160 回答
2

c# - 125 , 123 个字符（2 行）：

var r=Enumerable.Range(1,9).ToList();
r.ForEach(n=>{var s="";r.ForEach(m=>s+=(n*m).ToString("00 "));Console.WriteLine(s);});
于 2010-08-05T17:32:24.023 回答
2

PHP，71 个字符

for($x=0;++$x<10;print"\n"){for($y=0;++$y<10;){printf("%02d ",$x*$y);}}

输出：

$ php -r 'for($x=0;++$x<10;print"\n"){for($y=0;++$y<10;){printf("%02d ",$x*$y);}}'
01 02 03 04 05 06 07 08 09 
02 04 06 08 10 12 14 16 18 
03 06 09 12 15 18 21 24 27 
04 08 12 16 20 24 28 32 36 
05 10 15 20 25 30 35 40 45 
06 12 18 24 30 36 42 48 54 
07 14 21 28 35 42 49 56 63 
08 16 24 32 40 48 56 64 72 
09 18 27 36 45 54 63 72 81
于 2010-08-06T19:10:50.643 回答
2

C - 97 79 个字符

#define f(i){int i=0;while(i++<9)
main()f(x)f(y)printf("%.2d ",x*y);puts("");}}
于 2010-08-05T21:20:53.077 回答
2

F# - 61 个字符：

for y=1 to 9 do(for x=1 to 9 do printf"%02d "(x*y));printfn""

如果您更喜欢更适用/LINQ-y 的解决方案，那么在 72 个字符中：

[1..9]|>Seq.iter(fun y->[1..9]|>Seq.iter((*)y>>printf"%02d ");printfn"")
于 2010-08-05T16:55:44.680 回答
2

R（非常类似于这个级别的 Matlab）：12 个字符。

> 1:9%*%t(1:9)
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
[1,]    1    2    3    4    5    6    7    8    9
[2,]    2    4    6    8   10   12   14   16   18
[3,]    3    6    9   12   15   18   21   24   27
[4,]    4    8   12   16   20   24   28   32   36
[5,]    5   10   15   20   25   30   35   40   45
[6,]    6   12   18   24   30   36   42   48   54
[7,]    7   14   21   28   35   42   49   56   63
[8,]    8   16   24   32   40   48   56   64   72
[9,]    9   18   27   36   45   54   63   72   81
于 2010-08-06T18:55:34.243 回答
2

Perl，44 个字符

（没有希望接近 J，但是具有矩阵运算的语言在这里属于自己的一类......）

for$n(1..9){printf"%3d"x9 .$/,map$n*$_,1..9}
于 2010-08-06T07:26:05.830 回答
1

Java - 155 137 个字符

  • 更新 1：通过直接打印替换了字符串构建。节省了 18 个字符。
class M{public static void main(String[]a){for(int x,y=0,z=10;++y<z;System.out.println())for(x=0;++x<z;System.out.printf("%02d ",x*y));}}

更易读的格式：

class M{
 public static void main(String[]a){
  for(int x,y=0,z=10;++y<z;System.out.println())
   for(x=0;++x<z;System.out.printf("%02d ",x*y));
 }
}
于 2010-08-19T19:33:47.637 回答
1

斯卡拉 - 77 59 58 个字符

print(1 to 9 map(p=>1 to 9 map(q=>"%02d "format(p*q))mkString)mkString("\n"))

抱歉，我不得不这样做，Malax 的 Scala 解决方案太易读了……

[编辑] 对于理解似乎是更好的选择：

for(p<-1 to 9;q<-{println;1 to 9})print("%02d "format p*q)

[编辑] 一个更长的解决方案，但没有乘法，而且更加模糊：

val s=(1 to 9).toSeq
(s:\s){(p,q)=>println(q.map("%02d "format _)mkString)
q zip(s)map(t=>t._1+t._2)}
于 2010-08-06T19:29:02.330 回答
1

C - 66 个字符

这解决了对 main 的第二个参数的抱怨 :)

main(x){for(x=8;x++<89;)printf("%.2d%c",x/9*(x%9+1),x%9<8?32:10);}

C - 77 个字符

基于 dreamlax 的 97 char 答案。他现在的回答有点像现在这个:)

使用 gcc 编译正常，main(x,y)我认为对高尔夫来说是公平的游戏

#define f(i){for(i=0;i++<9;)
main(x,y)f(x)f(y)printf("%.2d ",x*y);puts("");}}
于 2010-08-05T21:54:06.253 回答
1

C#, 135 chars, nice and clean:

var rg = Enumerable.Range(1, 9);
foreach (var rc in from r in rg 
                   from c in rg 
                   select (r * c).ToString("D2") + (c == 9 ? "\n\n" : " "))
    Console.Write(rc);
于 2010-08-06T01:34:52.923 回答
1

Ruby - 56 chars :D

9.times{|a|9.times{|b|print"%02d "%((a+1)*(b+1))};puts;}
于 2010-08-06T03:47:52.050 回答
1

PHP，62 个字符

for(;$x++<9;print"\n",$y=0)while($y++<9)printf("%02d ",$x*$y);
于 2010-08-19T18:27:54.737 回答
1

XQuery 1.0（96 字节）

string-join(for$x in 1 to 9 return(for$y in 1 to 9 return concat(0[$x*$y<10],$x*$y,' '),'

'),'')

运行（使用XQSharp）：

xquery table.xq !method=text
于 2010-08-09T17:10:18.017 回答
1

PostgreSQL：81 74 个字符

select array(select generate_series(1,9)*x)from generate_series(1,9)as x;
于 2010-08-06T02:13:18.247 回答
0

重击 53

for((i=1;i<10;i++));do seq -s' ' $i $i $((9*i));done
于 2010-08-16T06:37:36.467 回答
0

导入后的 Haskell（不是列表理解）71

遗憾的是，haskell 的 prelude 库中没有 printf，但在导入 ghci 71 字符后，另一个 haskell 程序正在使用列表推导：

Prelude> :module Text.Printf
Prelude Text.Printf> let r=[1..9]
Prelude Text.Printf> mapM_(\y->(mapM_(\x->printf"%02d "(x*y))r)>>(putStrLn ""))r
01 02 03 04 05 06 07 08 09
02 04 06 08 10 12 14 16 18
03 06 09 12 15 18 21 24 27
04 08 12 16 20 24 28 32 36
05 10 15 20 25 30 35 40 45
06 12 18 24 30 36 42 48 54
07 14 21 28 35 42 49 56 63
08 16 24 32 40 48 56 64 72
09 18 27 36 45 54 63 72 81
于 2010-08-19T20:19:39.303 回答
0

Ruby, 49 chars

1.upto(9){|n|puts"%02d "*9%(n..81).step(n).to_a}

PS. With Wolfram Alpha it's 23 characters DS.

于 2010-08-06T12:25:01.933 回答
0

Common Lisp，79 个字符（包括空格）：

(dotimes (i 9) (dotimes (j 9) (format t "~2,'0d " (* (1+ i) (1+ j)))) (terpri))

使用更传统的格式：

(dotimes (i 9) 
  (dotimes (j 9) 
    (format t "~2,'0d " (* (1+ i) (1+ j)))) 
  (terpri))

然后是一个 106 个字符的版本，展示了格式化程序的强大功能：

(format t "~{~{~2,'0d~^ ~}~%~}"
        (loop for i from 1 to 9 
           collect (loop for j from 1 to 9 
                      collect (* i j))))
于 2010-08-07T18:34:03.190 回答
0

PHP，67 个字符

while(++$x<10){$y=0;while(++$y<10)printf("%02d ",$x*$y);print"\n";}
于 2010-08-07T18:45:45.523 回答
0

Repent, 11 , 10 个字符

↓1⇄.⇄^↓↻*;

这是使用我自己的基于玩具语言堆栈的语言 Repent（一旦达到标准，我将很快发布）。看到 J 击败它我很难过，因为我设计它只是为了在代码高尔夫中击败 J、Perl 和 Golfscript。

V_1v.v^↓↻*;

口译员（阿尔法）

语言参考（阿尔法）

于 2010-08-07T21:04:45.100 回答
0

C# 使用聚合，118 个字符

var r=Enumerable.Range(1,9).ToList();
r.ForEach(i=>Console.WriteLine(r.Aggregate("",(a,b)=>a+=(i*b).ToString("00 "))));
于 2010-08-08T14:06:15.320 回答
0

将 C#/Linq 与 GroupJoin 一起使用的另一次尝试：

Console.Write(
    String.Join(
        Environment.NewLine,
        Enumerable.Range(1, 9)
            .GroupJoin(Enumerable.Range(1, 9), y => 0, x => 0, (y, xx) => String.Join(" ", xx.Select(x => x * y)))
            .ToArray()));
于 2010-08-06T06:49:44.200 回答
0

JavaScript - 带控制台 - 65 个字符

for(i=0,a='';++i<10;a+='\n')for(j=0;++j<10;a+=i*j);console.log(a)

JavaScript - 带有 html - 68 个字符

for(i=0,a='';++i<10;a+='\n')for(j=0;++j<10;a+=i*j);document.write(a)
于 2010-08-19T20:41:54.110 回答
0

红宝石- 47 个字符

puts (a=1..9).map{|i|a.map{|j|"%2d"%(j*i)}*" "}

输出

 1  2  3  4  5  6  7  8  9
 2  4  6  8 10 12 14 16 18
 3  6  9 12 15 18 21 24 27
 4  8 12 16 20 24 28 32 36
 5 10 15 20 25 30 35 40 45
 6 12 18 24 30 36 42 48 54
 7 14 21 28 35 42 49 56 63
 8 16 24 32 40 48 56 64 72
 9 18 27 36 45 54 63 72 81

（如果我们忽略间距，它会变成 39：puts (a=1..9).map{|i|a.map{|j|j*i}*" "} 无论如何，我觉得罗嗦的map东西还有一点改进的空间。）

于 2010-08-06T07:54:15.913 回答
0

重击，59 个字符

for i in `seq 9`;do seq -w $i $i 99|sed 9q;done|column -c80
01  02  03  04  05  06  07  08  09
02  04  06  08  10  12  14  16  18
03  06  09  12  15  18  21  24  27
04  08  12  16  20  24  28  32  36
05  10  15  20  25  30  35  40  45
06  12  18  24  30  36  42  48  54
07  14  21  28  35  42  49  56  63
08  16  24  32  40  48  56  64  72
09  18  27  36  45  54  63  72  81
于 2010-08-13T18:09:29.683 回答
0

C++ 排名第 99999 位（76 个字符） 

for(int i=1;i<=9;++i){cout<<i<<" "<<i+1<<i+2<<i+3<<i+4<<i+5<<i+6<<i+7<<i+8;}
于 2012-04-12T17:05:29.440 回答