다음 곱셈표를 인쇄하는 가장 짧은 코드를 작성하십시오.

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

엑셀, 92 91 바이트

VBA 편집기의 즉시 창에서 다음 명령을 실행하십시오 Range("A1:I9").Formula="=IF(ROW()<COLUMN(),"""",COLUMN()&""×""&ROW()&""=""&COLUMN()*ROW())" . 출력은 활성 워크 시트에 직접 있습니다.

if변경 순서를 로 바꾸어 여분의 바이트를 골프로 바꿨 >=습니다 <. 스크린 샷을 업데이트하지 않았지만 출력이 아닌 맨 위에있는 수식에만 영향을 미칩니다.

파이썬 (75)

r=range(1,10)
for i in r:print''.join('%sx%s=%-3s'%(j,i,i*j)for j in r[:i])

다른 두 파이썬 버전보다 약간 더 나은 골프.

C ++, 106 98 바이트

두 개의 루프와 몇 가지 트릭을 사용했습니다.

#import <cstdio>
main(){for(int i,j;i++-9;j=0)while(j++-i)printf("%dx%d=%d%c",j,i,i*j,j<i?32:10);}

J : 57 51 자

([:;"2*\#"2(":@],'x',":@[,'=',":@*,' '"_)"0/~)>:i.9

루프가 없습니다.

APL (37)

∆∘.{⊃(⍺≥⍵)/,/(⍕⍺)'×'(⍕⍵)'=',⍕⍺×⍵}∆←⍳9

그리고 그것은 단지 두 개의 for-loops가 아닙니다. APL에서 다음 구성은 다음과 같습니다.

x ∘.F y

여기서 x및 y목록이며, F함수가 적용 F항목의 각 쌍 x과y 당신에게 매트릭스를 제공한다.

: 그래서, ∆∘.×∆←⍳9위의 기능은 각각의 쌍에 필요한 문자열 9로 1에서 곱셈 테이블을 생성 도착, 즉 (⍕⍺), 다음의 첫 번째 숫자의 문자열 표시 ×한 후, (⍕⍵)이어서, 두 번째 숫자의 스트링 표현은 =,이어서 ⍕⍺×⍵만큼 ⍺≥⍵.

루비 : 60 59 자

1.upto(9){|i|puts (1..i).map{|j|"%dx%d=%-3d"%[j,i,i*j]}*""}

샘플 실행 :

bash-4.2$ ruby -e '1.upto(9){|i|puts (1..i).map{|j|"%dx%d=%-3d"%[j,i,i*j]}*""}'
1x1=1 
1x2=2  2x2=4 
1x3=3  2x3=6  3x3=9 
1x4=4  2x4=8  3x4=12 4x4=16
1x5=5  2x5=10 3x5=15 4x5=20 5x5=25
1x6=6  2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7  2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8  2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9  2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

펄, 54 자

printf"%dx$?=%-3d"x$?.$/,map{$_,$_*$?}1..$?while$?++<9

APL (Dyalog), 28

↑{⍵{⍕⍵,'×',⍺,'=',⍺×⍵}¨⍳⍵}¨⍳9

다른 언어의 이중 루프와 유사

{⍵{...}¨⍳⍵}¨⍳9이중 루프
⍕⍵,'×',⍺,'=',⍺×⍵를 설정하여 각 쌍의 문자열을 만듭니다.
↑ 배열을 스팅 행렬로 변환

산출

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

매스 매 티카 , 45

꽤 지루하지만 구문 비교 역할을한다고 생각합니다.

Grid@Table[Row@{a, "x", b, "=", a b}, {a, 9}, {b, a}]

D, 75 자

foreach(i,1..10){foreach(j,1..i+1){writef("%dx%d=%d ",i,j,i*j);}writeln();}

방금 코드가 작동하지 않거나 전체 프로그램이 아닙니다

VBScript (133); 루프없이.

g=""
sub m(x,y)
    g=x&"x"&y&"="&x*y&vbTab&g
    if x>1 then 
        m x-1,y
    elseif y>1 then 
        g=vbLf&g 
        m y-1,y-1
    end if
end sub
m 9,9
wscript.echo g

챌린저 요청시 : 루프 없음. 이 코드는 재귀 서브 루틴 호출을 사용합니다.

메이플, 64

seq(printf(seq(printf("%ax%a=%a ",j,i,i*j),j=1..i),"\n"),i=1..9)

x86_64 머신 코드 (리눅스), 175 99 76 바이트

0000000000400080 <_start>:
  400080:   66 bf 09 00             mov    $0x9,%di

0000000000400084 <_table.L2>:
  400084:   6a 0a                   pushq  $0xa
  400086:   89 fe                   mov    %edi,%esi

0000000000400088 <_table.L3>:
  400088:   89 f0                   mov    %esi,%eax
  40008a:   f7 e7                   mul    %edi

000000000040008c <_printInteger>:
  40008c:   6a 20                   pushq  $0x20
  40008e:   3c 0a                   cmp    $0xa,%al
  400090:   7d 02                   jge    400094 <_printInteger.L1>
  400092:   6a 20                   pushq  $0x20

0000000000400094 <_printInteger.L1>:
  400094:   66 31 d2                xor    %dx,%dx
  400097:   b3 0a                   mov    $0xa,%bl
  400099:   66 f7 f3                div    %bx
  40009c:   83 c2 30                add    $0x30,%edx
  40009f:   52                      push   %rdx
  4000a0:   66 85 c0                test   %ax,%ax
  4000a3:   75 ef                   jne    400094 <_printInteger.L1>
  4000a5:   6a 3d                   pushq  $0x3d
  4000a7:   66 57                   push   %di
  4000a9:   80 04 24 30             addb   $0x30,(%rsp)
  4000ad:   6a 78                   pushq  $0x78
  4000af:   66 56                   push   %si
  4000b1:   80 04 24 30             addb   $0x30,(%rsp)
  4000b5:   ff ce                   dec    %esi
  4000b7:   75 cf                   jne    400088 <_table.L3>
  4000b9:   ff cf                   dec    %edi
  4000bb:   75 c7                   jne    400084 <_table.L2>

00000000004000bd <_printChars>:
  4000bd:   66 ba 00 08             mov    $0x800,%dx
  4000c1:   b0 01                   mov    $0x1,%al
  4000c3:   66 bf 01 00             mov    $0x1,%di
  4000c7:   48 89 e6                mov    %rsp,%rsi
  4000ca:   0f 05                   syscall

이것은 이진 파일의 덤프이며이 모두는 175 바이트입니다. 기본적으로 모든 답변과 동일한 두 가지 루프를 수행하지만 콘솔에 인쇄하는 것은 약간 어렵고 기본적으로 문자를 스택에 인쇄하여 역으로 인쇄 한 다음 (Linux 관련) syscall을 작성하여 실제로 해당 문자를 넣습니다 stdout에.

이제는 1 번의 쓰기 작업 만 수행하고 (빠른!) 마법의 숫자 (wow!)를 가지며 syscall을 만들기 전에 전체 결과를 스택으로 뒤로 밀면되도록 이것을 최적화했습니다. 누가 적절한 종료 코드가 필요하기 때문에 종료 루틴을 수행 했습니까?

여기 제에 대한 링크의 첫 번째 와 두 은 원래 nasm 구문의 시도 시도에 입니다.

개선 방법에 대한 다른 제안이있는 사람을 환영합니다. 궁금한 점이 있으면 논리를 더 자세히 설명 할 수도 있습니다.

(또한 모든 열을 정렬하기 위해 여분의 공간을 인쇄하지는 않지만 필요한 경우 논리를 몇 바이트 더 넣을 수 있습니다).

편집 : 이제 여분의 공간을 인쇄하고 훨씬 더 골프 다운됩니다! 레지스터로 꽤 미친 짓을하고 있으며이 프로그램을 확장하면 불안정 할 것입니다.

자바 스크립트, 190 바이트

늦게 파티에 갔지만 @jdstankosky의 의견에 시달리고 다른 접근 방식을 결정했습니다. 다음은 템플릿을 방해하고 그 자체로 사라지는 Javascript 항목입니다.

t="a*b=c ";u="";r=u;for(i=1;i<10;i++){a=0;u=u+t;r+=u.split(' ').map(x=>x.replace('a',++a).replace('b',i)).map(x=>x.replace('*','x').replace('c',eval(x.substr(0,3)))).join(' ')+'\n'}alert(r);

골프화되지 않은 버전 (함수가 스크립트를 경고하는 대신 테이블을 반환하지만 약간의 동일한 원칙이 적용되는 이전 버전) :

function f()
{
    t="a*b=c "; // template for our multiplication table
    u="";r="";  // tmp- and return values
    for(i=1;i<10;i++)
    {
        a=0;    // is auto-incremented in MAP
        u=u+t;// extend the template once per iteration
        v=u.split(' '); // Smash the template to pieces
        w=v.map(x=>x.replace('a', ++a).replace('b', i)) // MAP replaces the A and B's with the correct numbers
        w=w.map(x=>x.replace('*', 'x').replace('c', eval(x.substring(0,3)))).join(' '); // second map evals that and replaces c with the answer, makes the asteriks into an X
        r=r+w+'\n'  // results get concatenated
    }
    return r;
}

파스칼, 128 바이트

하나의 재귀 절차가 모든 것을 처리합니다. 로 전화하십시오 m(9,9).

procedure m(i,j:integer);begin if i<1then Exit;if i=j then begin m(i-1,j-1);writeln;end;m(i-1,j);write(i,'x',j,'=',i*j,' ');end;

언 골프 드 :

procedure mul(i, j: integer);
begin
  if i<1 then
    Exit;
  if i=j then
  begin
    mul(i-1, j-1);
    writeln;
  end;
  mul(i-1, j);
  write(i,'x',j,'=',i*j,' ');
end;

푸리에, 756 632 바이트

124 바이트의 @BetaDecay에게 감사합니다!

1o120~Ea1o61a1o10~Na1oEa2o61a2o32~Saa2oEa2o61a4oNa1oEa3o61a3oSaa2oEa3o61a6oSaa3oEa3o61a9o^a1oEa4o61a4oSaa2oEa4o61a8oSaa3oEa4o61a12oSa4oEa4o61a16oNa1oEa5o61a5oSaa2oEa5o61aNoSa3oEa5o61a15oSa4oEa5o61a20oSa5oEa5o61a25oNa1oEa6o61a6oSaa2oEa6o61a12oSa3oEa6o61a18oSa4oEa6o61a24oSa5oEa6o61a30oSa6oEa6o61a36oNa1oEa7o61a7oSaa2oEa7o61a14oSa3oEa7o61a21oSa4oEa7o61a28oSa5oEa7o61a35oSa6oEa7o61a42oSa7oEa7o61a49oNa1oEa8o61a8oSaa2oEa8o61a16oSa3oEa8o61a24oSa4oEa8o61aSoa5oEa8o61a40oSa6oEa8o61a48oSa7oEa8o61a56oSa8oEa8o61a64oNa1oEa9o61a9oSaa2oEa9o61a18oSa3oEa9o61a27oSa4oEa9o61a36oSa5oEa9o61a45oSa6oEa9o61a54oSa7oEa9o61a63oSa8oEa9o61a72oSa9oEa9o61a81o

VBA 55

(즉시 창)

for f=1 to 9:for j=1 to f:?f;"x";j;"=";f*j,:next:?:next

참고-GWBasic에는 2 개의 추가 문자 만 필요합니다.

1 for f=1 to 9:for j=1 to f:?f;"x";j;"=";f*j,:next:?:next

자바 스크립트, 75

for(s="",a=b=1;a<10;b=a==b?(a++,alert(s),s="",1):b+1)s+=b+"x"+a+"="+a*b+" "

루프에 대해 두 개보다 더 나은 것이 결합되어 있는지 궁금합니다.

배쉬 /로 coreutils : 147 136 135

for i in {1..9}; do
  yes $'\n' | head -n $[i-1] > $i
  paste -dx= <(yes $i) <(seq $i 9) <(seq $[i*i] $i $[9*i]) |head -n$[10-i] >> $i
done
paste {1..9}

명시적인 줄 바꿈을 사용하고 더 이상 사용되지 않는 헤드 옵션을 사용하여 골프를 쳤습니다 (manatwork 덕분에).

for i in {1..9};do yes '
'|head -$[i-1]>$i;paste -dx= <(yes $i) <(seq $i 9) <(seq $[i*i] $i $[9*i])| head -$[10-i]>>$i;done;paste {1..9}

산출:

1x1=1                               
1x2=2   2x2=4                           
1x3=3   2x3=6   3x3=9                       
1x4=4   2x4=8   3x4=12  4x4=16                  
1x5=5   2x5=10  3x5=15  4x5=20  5x5=25              
1x6=6   2x6=12  3x6=18  4x6=24  5x6=30  6x6=36          
1x7=7   2x7=14  3x7=21  4x7=28  5x7=35  6x7=42  7x7=49      
1x8=8   2x8=16  3x8=24  4x8=32  5x8=40  6x8=48  7x8=56  8x8=64  
1x9=9   2x9=18  3x9=27  4x9=36  5x9=45  6x9=54  7x9=63  8x9=72  9x9=81

LOLCODE, 202 바이트

IM IN YR o UPPIN YR b TIL BOTH SAEM b AN 10
c R ""
IM IN YR i UPPIN YR a TIL BOTH SAEM a AN SUM OF b AN 1
c R SMOOSH c SMOOSH a "x" b "=" PRODUKT OF a AN b " " MKAY
IM OUTTA YR i
VISIBLE c
IM OUTTA YR o

언 골프 드 :

HAI 1.3 BTW Unnecessary in current implementations
IM IN YR outer UPPIN YR multiplicand TIL BOTH SAEM multiplicand AN 10
    I HAS A output ITZ ""
    IM IN YR inner UPPIN YR multiplier TIL BOTH SAEM multiplier AN SUM OF multiplicand AN 1
        output R SMOOSH output AN SMOOSH multiplier AN "x" AN multiplicand AN "=" AN PRODUCKT OF multiplicand AN multiplier AN " " MKAY MKAY BTW AN is optional to separate arguments, a linebreak is an implicit MKAY.
    IM OUTTA YR inner
    VISIBLE output
IM OUTTA YR outer
KTHXBYE BTW Unnecessary in current implementations

비연 사자를위한 Pythonated :

for multiplicand in range(1, 10):
    output = ""
    for multiplier in range(1, multiplicand + 1):
        output = output + (multiplier + "x" + multiplicand + "=" + str(multiplicand * multiplier) + " ")
    print(output)

C #, 142 바이트

Enumerable.Range(1,9).ToList().ForEach(i =>Enumerable.Range(1,i).ToList().ForEach(j=>Console.Write("{0}x{1}={2}{3}",j,i,j*i,j==i?"\n":"\t")));

그리고 눈에 보이지 않는 ...

> <> , 50 바이트

1v
 1
?\::n"x"o{::n"="o}*n" "o1+:{:})
 \~1+:a=?;ao

온라인 통역사 에서 사용해 볼 수 있습니다 .

각 줄에 후행 공백이있어 잘못 될 수 있습니다 (이 답변에서이 시점에서 OP는 언급되지 않았습니다).

/// , 268 바이트

/_/\/\///x/×_N/x9=_E/x8=_V/x7=_S/x6=_F/x5=_R/x4=_O/
1_t/  2_h/ 3/1x1=1Ox2=2tx2=4Ox3=3tx3=6 hx3=9OR4tR8 hR12 4R16OF5tF10hF15 4F20 5F25OS6tS12hS18 4S24 5S30 6S36OV7tV14hV21 4V28 5V35 6V42 7V49OE8tE16hE24 4E32 5E40 6E48 7E56 8E64ON9tN18hN27 4N36 5N45 6N54 7N63 8N72 9N81

자바, 103 94 92 90 바이트

Java 9 SDK에서 JShell을 사용하면 많은 공간을 절약 할 수 있습니다

for(int i=0,j;i++<9;)for(j=1;j<=i;)System.out.print(i+"*"+j+"="+i*j+"\t"+(j++<i?"":"\n"))

Kevin의 제안에 따라 솔루션을 2 바이트 줄였습니다.

cliffroot 덕분에 1 바이트 더 줄일 수있었습니다.

C 79 바이트

i=1,j=1;f(){printf("%dx%d=%d ",j,i,i*j);++i>j?++j,i=1,j<=9?puts(""),f():0:f();}

메인

main(){f();}

탁자

1x1=1 
2x1=2 2x2=4 
3x1=3 3x2=6 3x3=9 
4x1=4 4x2=8 4x3=12 4x4=16 
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81 

TCL 98 자

while {[incr a]<10} {set b 0;while {[incr b]<=$a} {puts -nonewline "$a×$b=[expr $a*$b] "};puts ""}

자바 스크립트 : 82 자

o="";for(a=1;a<10;a++){for(b=1;b<=a;b++){o+=a+"x"+b+"="+(a*b)+" "}o+="\n"}alert(o)

파이썬 : 87

다른 사람들이 게시 한 솔루션을 주목하고 있으며 대부분 간격이 정확하지 않은 것으로 보입니다.

for i in range(1,10):print''.join(('%s×%s=%s'%(j,i,i*j)).ljust(7)for j in range(1,i+1))

파이썬 (79)

또는 ( 77 ) range(10)처음에 빈 줄을 생성하는 것을 제외하고 사용 하면

for i in range(1,10):print' '.join('%dx%d=%-2d'%(j,i,j*i)for j in range(1,i+1))

1x1=1 
1x2=2  2x2=4 
1x3=3  2x3=6  3x3=9 
1x4=4  2x4=8  3x4=12 4x4=16
1x5=5  2x5=10 3x5=15 4x5=20 5x5=25
1x6=6  2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7  2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8  2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9  2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

펄 : 65 , 62 자

map{map{printf"%dx%d=%2d ",$_,$i,$_*$i}1..($i=$_);print$/}1..9