Python - 61 символ

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

Еще одна попытка использования 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()));

C#

Это всего 2 строки. Он использует лямбды, а не методы расширения

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

все это при условии, что вы считаете лямбду одной строкой?

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)

K - 12 символов

Давайте серьезно отнесемся к розетте и сравним K4 Kdb + с каноническим решением 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 "каждый-слева, каждый-направо" ( /: \: ). У нас нет чрезвычайно удобного «рефлексивного» оператора J ( ~ ) в K, поэтому мы должны передать a как левый и правый аргумент.

Brainf ** k - 185 символов

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

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.

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]

C - 97 79 символов

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

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

Ruby - 46 символов

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

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

Не совсем однострочный, но самый короткий 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 ();});

MATLAB - 10 символов

a=1:9;a'*a

... или 33 символа для более строгого формата вывода

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

Ruby - 56 символов: D

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

C # - 117, 113, 99, 96, 95 89 символов

обновлено на основе ] Идея Ника Ларсена

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

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 

Scala - 77 59 58 символов

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

Извините, мне пришлось это сделать, решение Scala от Малакса было слишком читабельным ...

[Edit] Для понимания кажется лучшим выбором:

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

[Edit] Намного более длинное решение, но без умножения и гораздо более запутанное:

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

Fortran95 - 40 символов (победа над perl на 4 символа!)

Это решение делает печать ведущих нулей согласно спецификации.

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

c# - 125, 123 chars (2 lines):

var r=Enumerable.Range(1,9).ToList();
r.ForEach(n=>{var s="";r.ForEach(m=>s+=(n*m).ToString("00 "));Console.WriteLine(s);});

Perl, 44 символа

(Нет никакой надежды приблизиться к J, но языки с матричными операциями здесь находятся в отдельном классе ...)

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

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 символов. Его текущий ответ несколько напоминает этот:)

Компилируется нормально с gcc, а main (x, y) - справедливая игра для гольфа, я считаю

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

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

PostgreSQL: 81 74 символа

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

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

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

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 символ.

* работает *

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

Ruby - 47 символов

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

Output

 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 вещей.)

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

PHP, 62 символа

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