Подтвердить что ты не робот

Code-golf: таблица умножения вывода на консоль

Недавно я указал студенту, работающему с опытом работы, на статью о том, как сбрасывать таблицу умножения на консоль. Он использовал вложенный цикл и умножал значение шага каждого.

Это выглядело как подход .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, но двойная новая строка изначально была только там, потому что я не знал, как отформатировать текст при создании пост!

4b9b3361

ОТВЕТЫ

Ответ 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

Ответ 2

MATLAB - 10 символов

a=1:9;a'*a

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

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

Ответ 3

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

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

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

* работает *

Ответ 5

Python - 61 символ

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

Ответ 6

С#

Это всего 2 строки. Он использует методы lambdas not extension

 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 одной линией?

Ответ 7

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

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

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

Ответ 8

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

Ответ 9

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)

Ответ 10

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

Ответ 11

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.

Ответ 12

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

Ответ 13

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]

Ответ 14

Ruby - 42 Chars (включая один linebreak, только интерактивная командная строка)

Этот метод является двумя строками ввода и работает только в irb (потому что irb дает нам _), но сокращает предыдущий метод с помощью scent 2 charcters.

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

Ответ 15

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

Ответ 16

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

Ответ 17

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

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

Ответ 18

Perl, 44 символа

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

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

Ответ 19

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

Ответ 20

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

Ответ 21

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

Ответ 22

С#, 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);

Ответ 23

PostgreSQL: 81 74 символа

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

Ответ 24

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

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

Ответ 25

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

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

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

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

Ответ 26

XQuery 1.0 (96 bytes)

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

Ответ 27

PHP, 62 символа

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

Ответ 28

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

Ответ 29

Другая попытка использования С#/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()));

Ответ 30

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