cat - 252个字符

Question

我最近指出一名学生正在做一篇关于将乘法表转储到控制台的文章。它使用嵌套的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格式，但是双重换行最初只是因为我不知道在创建时如何格式化文本帖子！

Answer 1

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

Answer 2

MATLAB - 10个字符

a=1:9;a'*a

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

a=1:9;disp(num2str(a'*a,'%.2d '))

Answer 3

Brainf ** k - 185个字符

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

Answer 4

cat - 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个字符。

*运行*

Answer 5

Python - 61个字符

r=range(1,10)
for y in r:print"%02d "*9%tuple(y*x for x in r)

Answer 6

<强> 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一行？

Answer 7

Fortran95 - 40个字符（以4个字符击败perl！）

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

print"(9(i3.2))",((i*j,i=1,9),j=1,9);end

Answer 8

K - 12个字符

让我们认真对待rosetta-stoning，并将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作为左右参数传递。

Answer 9

C＃ - ~~117,113,99,96,95~~ 89个字符

根据NickLarsen's想法

进行了更新

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

Answer 10

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)

Answer 11

COBOL - 218 chars - ＆gt; 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.

Answer 12

Haskell - 85 84 79个字符

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

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

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

Answer 13

不是真正的单线，但我能想到的最短的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(); });

Answer 14

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

此方法是两行输入，仅适用于irb（因为irb为我们提供_），但是通过少量2个字符缩短了之前的方法。

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

Ruby - 44 Chars（与perl并列）

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

Ruby - 46 Chars

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

Ruby - 47 Chars

回到双循环

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

Ruby - 56个字符

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

Answer 15

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

Answer 16

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

Answer 17

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

Answer 18

Perl，44个字符

（没有希望到J附近的任何地方，但是带有矩阵运算的语言在这里属于他们自己的类......）

for$n(1..9){printf"%3d"x9 .$/,map$n*$_,1..9}

Answer 19

C - 97 79个字符

#define f(i){int i=0;while(i++<9)
main()f(x)f(y)printf("%.2d ",x*y);puts("");}}

Answer 20

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

Answer 21

Java - 155 137 chars

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

Answer 22

Scala - 77 59 58 chars

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

Answer 23

PHP，62个字符

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

Answer 24

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

Answer 25

Ruby - 56个字符：D

9.times{|a|9.times{|b|print"%02d "%((a+1)*(b+1))};puts;}

Answer 26

PostgreSQL： 81 74个字符

select array(select generate_series(1,9)*x)from generate_series(1,9)as x;

Answer 27

C＃，135个字符，干净整洁：

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

Answer 28

C - 66 Chars

这解决了关于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个字母答案。他现在的答案现在有点类似于这个：）

使用gcc编译好，main(x,y)是高尔夫的公平游戏，我估计

#define f(i){for(i=0;i++<9;)
main(x,y)f(x)f(y)printf("%.2d ",x*y);puts("");}}

Answer 29

导入后

Haskell（非列表推导）71

令人遗憾的是，haskell在其前奏库中没有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

Answer 30

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)

Answer 31

BASH 53

for((i=1;i<10;i++));do seq -s' ' $i $i $((9*i));done

Answer 32

Bash，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

Answer 33

C ++在99999TH PLACE排名（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;}

Answer 34

C＃使用聚合，118个字符

var r=Enumerable.Range(1,9).ToList();
r.ForEach(i=>Console.WriteLine(r.Aggregate("",(a,b)=>a+=(i*b).ToString("00 "))));

Answer 35

忏悔，<罢工> 11 ，10个字符

↓1⇄.⇄^↓↻*;

这是使用我自己的基于玩具语言堆栈的语言忏悔（我将很快发布，一旦达到临近）。我很遗憾地看到Ĵ击败它，因为我设计它只是在代码高尔夫击败Ĵ，Perl和Golfscript。

V_1v.v^↓↻*;

Interpreter (Alpha)

Language Reference (Alpha)

Answer 36

PHP，67个字符

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

Answer 37

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

Answer 38

Ruby，49个字符

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

PS。使用Wolfram Alpha，它是23个字符DS。

Answer 39

Ruby - 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的东西还有一些改进空间。）

Answer 40

使用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()));

Code-golf：输出乘法表到控制台

40 个答案:

J - 8个字符 - 24个字符，格式正确

MATLAB - 10个字符

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

Brainf ** k - 185个字符

cat - 252个字符

Python - 61个字符

Fortran95 - 40个字符（以4个字符击败perl！）

K - 12个字符

COBOL - 218 chars - ＆gt; 216个字符

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

Haskell - 85 84 79个字符

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

Ruby - 44 Chars（与perl并列）

c＃ - 125 ，123个字符（2行）：

PHP，71个字符

Perl，44个字符

C - 97 79个字符

F＃ - 61个字符：

Java - 155 137 chars

Scala - 77 59 58 chars

PHP，62个字符

Ruby - 56个字符：D

PostgreSQL： 81 74个字符

C - 66 Chars

Bash，59个字符

C＃使用聚合，118个字符

忏悔，<罢工> 11 ，10个字符

PHP，67个字符

Ruby，49个字符

Ruby - 47个字符