Multiplication tables: Difference between revisions

← Older edit

Multiplication tables (view source)

Revision as of 14:37, 4 January 2024

185,195 bytes added , 4 months ago

m

→‎{{header|Wren}}: Minor tidy

PureFox

9,482

edits

Revision as of 02:44, 19 December 2011 (view source) rosettacode>Showell (CoffeeScript) ← Older edit		Latest revision as of 14:37, 4 January 2024 (view source) PureFox (talk \| contribs) m (→‎{{header\|Wren}}: Minor tidy)
(315 intermediate revisions by 95 users not shown)
Line 1: {{task\|Arithmetic operations}} [[Category:Simple]] ~~Produce a formatted 12×12 multiplication table of the kind memorised by rote when in primary school.~~ ;Task: Produce a formatted   12×12   multiplication table of the kind memorized by rote when in primary (or elementary) school. Only print the top half triangle of products. <br><br> =={{header\|11l}}== {{trans\|C}} <syntaxhighlight lang="11l">V n = 12 L(j) 1..n print(‘#3’.format(j), end' ‘ ’) print(‘│’) L 1..n print(‘────’, end' ‘’) print(‘┼───’) L(i) 1..n L(j) 1..n print(I j < i {‘ ’} E ‘#3 ’.format(i * j), end' ‘’) print(‘│ ’i)</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 │ ────────────────────────────────────────────────┼─── 1 2 3 4 5 6 7 8 9 10 11 12 │ 1 4 6 8 10 12 14 16 18 20 22 24 │ 2 9 12 15 18 21 24 27 30 33 36 │ 3 16 20 24 28 32 36 40 44 48 │ 4 25 30 35 40 45 50 55 60 │ 5 36 42 48 54 60 66 72 │ 6 49 56 63 70 77 84 │ 7 64 72 80 88 96 │ 8 81 90 99 108 │ 9 100 110 120 │ 10 121 132 │ 11 144 │ 12 </pre> =={{header\|360 Assembly}}== <syntaxhighlight lang="360asm">* 1212 multiplication table 14/08/2015 MULTTABL CSECT USING MULTTABL,R12 LR R12,R15 LA R10,0 buffer pointer LA R3,BUFFER MVC 0(4,R3),=C' \| ' LA R10,4(R10) LA R5,12 LA R4,1 i=1 LOOPN LA R3,BUFFER do i=1 to 12 AR R3,R10 XDECO R4,XDEC i MVC 0(4,R3),XDEC+8 output i LA R10,4(R10) LA R4,1(R4) BCT R5,LOOPN end i XPRNT BUFFER,52 XPRNT PORT,52 border LA R5,12 LA R4,1 i=1 (R4) LOOPI LA R10,0 do i=1 to 12 MVC BUFFER,=CL52' ' LA R3,BUFFER AR R3,R10 XDECO R4,XDEC MVC 0(2,R3),XDEC+10 LA R10,2(R10) LA R3,BUFFER AR R3,R10 MVC 0(2,R3),=C'\| ' LA R10,2(R10) LA R7,12 LA R6,1 j=1 (R6) LOOPJ CR R6,R4 do j=1 to 12 BNL MULT LA R3,BUFFER AR R3,R10 MVC 0(4,R3),=C' ' LA R10,4(R10) B NEXTJ MULT LR R9,R4 i MR R8,R6 ij in R8R9 LA R3,BUFFER AR R3,R10 XDECO R9,XDEC MVC 0(4,R3),XDEC+8 LA R10,4(R10) NEXTJ LA R6,1(R6) BCT R7,LOOPJ end j ELOOPJ XPRNT BUFFER,52 LA R4,1(R4) BCT R5,LOOPI end i ELOOPI XR R15,R15 BR R14 BUFFER DC CL52' ' XDEC DS CL12 PORT DC C'--+-------------------------------------------------' YREGS END MULTTABL</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------- 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|8080 Assembly}}== <syntaxhighlight lang="8080asm"> org 100h lxi h,output ;;; Make the header call skip ; Four spaces, mvi m,'\|' ; separator, inx h lxi d,0C01h ; 12 fields starting at 1 fnum: mov a,e ; Field number call num inr e dcr d ; If not 12 yet, next field number jnz fnum call nl ; Newline mvi a,'-' ; Four dashes, mvi b,4 call bchr mvi m,'+' ; Plus, inx h mvi b,124 ; and 124 more dashes call bchr call nl ; Newline ;;; Write the 12 lines mvi d,1 ; Start at line 1, line: mov a,d ; Add the line number call num mvi m,'\|' ; separator inx h mvi e,1 ; Start at column 1 mvi c,0 ; Cumulative sum at C field: mov a,c ; Add line number giving next column add d mov c,a mov a,e ; If column >= line, we need to print cmp d mov a,c ; the current total cc skip ; skip field if column >= line cnc num ; print field if column < line inr e ; next column mov a,e cpi 13 ; column 13? jnz field ; If not, next field on line call nl ; But if so, add newline inr d ; next line mov a,d cpi 13 ; line 13? jnz line ; If not, next line mvi m,'$' ; Write a CP/M string terminator, mvi c,9 ; And use CP/M to print the string lxi d,output jmp 5 ;;; Add the character in A to the string at HL, B times bchr: mov m,a inx h dcr b jnz bchr ret ;;; Add newline to string at HL nl: mvi m,13 ; CR inx h mvi m,10 ; LF inx h ret ;;; Add four spaces to string at HL (skip field) skip: mvi b,' ' mov m,b inx h mov m,b inx h mov m,b inx h mov m,b inx h ret ;;; Add 3-digit number in A to string at HL num: mvi m,' ' ; Separator space inx h ana a ; Clear carry mvi b,100 ; 100s digit call dspc mvi b,10 ; 10s digit call dspc mvi b,1 ; 1s digit dspc: jc dgt ; If carry, we need a digit cmp b ; >= digit? jnc dgt ; If not, we need a digit mvi m,' ' ; Otherwise, fill with space inx h cmc ; Return with carry off ret dgt: mvi m,'0'-1 ; Calculate digit dloop: inr m ; Increment digit sub b ; while B can be subtracted jnc dloop add b inx h ret output: equ $</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ----+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|AArch64 Assembly}}== {{works with\|as\|Raspberry Pi 3B version Buster 64 bits}} <syntaxhighlight lang="aarch64 assembly"> /* ARM assembly AARCH64 Raspberry PI 3B / / program multtable64.s / /*****************************************/ / Constantes file / /*****************************************/ / for this file see task include a file in language AArch64 assembly/ .include "../includeConstantesARM64.inc" .equ MAXI, 12 /*******************************/ / Initialized data / /******************************/ .data sMessValeur: .fill 11, 1, ' ' // size => 11 szCarriageReturn: .asciz "\n" sBlanc1: .asciz " " sBlanc2: .asciz " " sBlanc3: .asciz " " /******************************/ / UnInitialized data / /******************************/ .bss /******************************/ / code section / /******************************/ .text .global main main: // entry of program ldr x6,qAdrsBlanc1 ldr x7,qAdrsBlanc2 ldr x8,qAdrsBlanc3 // display first line mov x4,#0 1: // begin loop mov x0,x4 ldr x1,qAdrsMessValeur // display value bl conversion10 // call function strb wzr,[x1,x0] // final zéro on display value ldr x0,qAdrsMessValeur bl affichageMess // display message cmp x4,#10 // one or two digit in résult csel x0,x7,x8,ge // display 2 or 3 spaces bl affichageMess // display message add x4,x4,1 // increment counter cmp x4,MAXI ble 1b // loop ldr x0,qAdrszCarriageReturn bl affichageMess // display carriage return mov x5,#1 // line counter 2: // begin loop lines mov x0,x5 // display column 1 with N° line ldr x1,qAdrsMessValeur // display value bl conversion10 // call function strb wzr,[x1,x0] // final zéro ldr x0,qAdrsMessValeur bl affichageMess // display message cmp x5,#10 // one or two digit in N° line csel x0,x7,x8,ge // display 2 or 3 spaces bl affichageMess mov x4,#1 // counter column 3: // begin loop columns mul x0,x4,x5 // multiplication mov x3,x0 // save résult ldr x1,qAdrsMessValeur // display value bl conversion10 // call function strb wzr,[x1,x0] ldr x0,qAdrsMessValeur bl affichageMess // display message cmp x3,100 // 3 digits in résult ? csel x0,x6,x0,ge // display 1 spaces bge 4f cmp x3,10 // 2 digits in result csel x0,x7,x8,ge // display 2 or 3 spaces 4: bl affichageMess // display message add x4,x4,1 // increment counter column cmp x4,x5 // < counter lines ble 3b // loop ldr x0,qAdrszCarriageReturn bl affichageMess // display carriage return add x5,x5,1 // increment line counter cmp x5,MAXI // MAXI ? ble 2b // loop 100: // standard end of the program mov x0,0 // return code mov x8,EXIT // request to exit program svc 0 // perform the system call qAdrsMessValeur: .quad sMessValeur qAdrszCarriageReturn: .quad szCarriageReturn qAdrsBlanc1: .quad sBlanc1 qAdrsBlanc2: .quad sBlanc2 qAdrsBlanc3: .quad sBlanc3 /***************************************************************/ / Converting a register to a decimal unsigned / /****************************************************************/ / x0 contains value and x1 address area / / x0 return size of result (no zero final in area) / / area size => 11 bytes / .equ LGZONECAL, 10 conversion10: stp x1,lr,[sp,-16]! // save registers stp x2,x3,[sp,-16]! // save registers stp x4,x5,[sp,-16]! // save registers mov x3,x1 mov x2,#LGZONECAL mov x4,10 1: // start loop mov x5,x0 udiv x0,x5,x4 msub x1,x0,x4,x5 // x5 <- dividende. quotient ->x0 reste -> x1 add x1,x1,48 // digit strb w1,[x3,x2] // store digit on area cbz x0,2f // stop if quotient = 0 sub x2,x2,1 // else previous position b 1b // and loop // and move digit from left of area 2: mov x4,0 3: ldrb w1,[x3,x2] strb w1,[x3,x4] add x2,x2,1 add x4,x4,1 cmp x2,LGZONECAL ble 3b // and move spaces in end on area mov x0,x4 // result length mov x1,' ' // space 4: strb w1,[x3,x4] // store space in area add x4,x4,1 // next position cmp x4,LGZONECAL ble 4b // loop if x4 <= area size 100: ldp x4,x5,[sp],16 // restaur 2 registers ldp x2,x3,[sp],16 // restaur 2 registers ldp x1,lr,[sp],16 // restaur 2 registers ret // return to address lr x30 /******************************************************/ / File Include fonctions / /******************************************************/ / for this file see task include a file in language AArch64 assembly / .include "../includeARM64.inc" </syntaxhighlight> {{Output}} <pre> 0 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 2 4 3 3 6 9 4 4 8 12 16 5 5 10 15 20 25 6 6 12 18 24 30 36 7 7 14 21 28 35 42 49 8 8 16 24 32 40 48 56 64 9 9 18 27 36 45 54 63 72 81 10 10 20 30 40 50 60 70 80 90 100 11 11 22 33 44 55 66 77 88 99 110 121 12 12 24 36 48 60 72 84 96 108 120 132 144 </pre> =={{header\|Action!}}== <syntaxhighlight lang="action!">PROC PrintRight(BYTE num,size) BYTE i IF num<10 THEN size==-1 ELSEIF num<100 THEN size==-2 ELSE size==-3 FI FOR i=1 TO size DO Put(' ) OD PrintB(num) RETURN PROC Main() BYTE ARRAY colw=[1 1 1 2 2 2 2 2 2 3 3 3] BYTE i,j,x,w ;clear screen Put(125) ;draw frame Position(1,3) FOR i=1 TO 38 DO Put($12) OD FOR j=2 TO 15 DO Position(36,j) Put($7C) OD Position(36,3) Put($13) ;draw numbers FOR j=1 TO 12 DO x=1 FOR i=1 TO 12 DO w=colw(i-1) IF i>=j THEN IF j=1 THEN Position(x,j+1) PrintRight(ij,w) FI IF i=12 THEN Position(37,j+3) PrintRight(j,2) FI Position(x,j+3) PrintRight(ij,w) FI x==+w+1 OD OD RETURN</syntaxhighlight> {{out}} [https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multiplication_tables.png Screenshot from Atari 8-bit computer] <pre> 1 2 3 4 5 6 7 8 9 10 11 12│ ───────────────────────────────────┼── 1 2 3 4 5 6 7 8 9 10 11 12│ 1 4 6 8 10 12 14 16 18 20 22 24│ 2 9 12 15 18 21 24 27 30 33 36│ 3 16 20 24 28 32 36 40 44 48│ 4 25 30 35 40 45 50 55 60│ 5 36 42 48 54 60 66 72│ 6 49 56 63 70 77 84│ 7 64 72 80 88 96│ 8 81 90 99 108│ 9 100 110 120│10 121 132│11 144│12 </pre> =={{header\|ActionScript}}== <syntaxhighlight lang="actionscript"> package { import flash.display.Sprite; import flash.events.Event; import flash.text.TextField; import flash.text.TextFieldAutoSize; import flash.text.TextFormat; [SWF (width = 550, height = 550)] public class MultiplicationTable extends Sprite { public function MultiplicationTable() { if ( stage ) _init(); else addEventListener(Event.ADDED_TO_STAGE, _init); } private function _init(e:Event = null):void { removeEventListener(Event.ADDED_TO_STAGE, _init); var format:TextFormat = new TextFormat(); format.size = 15; var blockSize:uint = 40; var max:uint = 12; var i:uint, j:uint; var tf:TextField; for ( i = 1; i <= max; i++ ) { tf = new TextField(); tf.defaultTextFormat = format; tf.x = blockSize i; tf.y = 0; tf.width = tf.height = blockSize; tf.autoSize = TextFieldAutoSize.CENTER; tf.text = String(i); addChild(tf); tf = new TextField(); tf.defaultTextFormat = format; tf.x = 0; tf.y = blockSize * i; tf.width = tf.height = blockSize; tf.autoSize = TextFieldAutoSize.CENTER; tf.text = String(i); addChild(tf); } var yOffset:Number = tf.textHeight / 2; y += yOffset; graphics.lineStyle(1, 0x000000); graphics.moveTo(blockSize, -yOffset); graphics.lineTo(blockSize, (blockSize * (max + 1)) - yOffset); graphics.moveTo(0, blockSize - yOffset); graphics.lineTo(blockSize * (max + 1), blockSize - yOffset); for ( i = 1; i <= max; i++ ) { for ( j = 1; j <= max; j++ ) { if ( j > i ) continue; tf = new TextField(); tf.defaultTextFormat = format; tf.x = blockSize * i; tf.y = blockSize * j; tf.width = tf.height = blockSize; tf.autoSize = TextFieldAutoSize.CENTER; tf.text = String(i * j); addChild(tf); } } } } } </syntaxhighlight> =={{header\|Ada}}== <syntaxhighlight lang="ada"> ~~<lang Ada>~~ with Ada.Text_IO; use Ada.Text_IO; with Ada.Strings.Fixed; use Ada.Strings.Fixed; Line 31 ⟶ 600: end loop; end Multiplication_Table; </syntaxhighlight> ~~</lang>~~ <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 Line 48 ⟶ 617: 12\| 144 </pre> =={{header\|Agena}}== {{Trans\|ALGOL_W}} <syntaxhighlight lang="agena">scope # print a school style multiplication table # NB: print outputs a newline at the end, write and printf do not write( " " ); for i to 12 do printf( " %3d", i ) od; printf( "\n +" ); for i to 12 do write( "----" ) od; for i to 12 do printf( "\n%3d\|", i ); for j to i - 1 do write( " " ) od; for j from i to 12 do printf( " %3d", i * j ) od; od; print() epocs</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 +------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|ALGOL 68}}== {{works with\|ALGOL 68\|Standard - no extensions to language used}} Line 54 ⟶ 658: <!-- {{does not work with\|ELLA ALGOL 68\|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - missing printf and FORMAT}} --> <~~lang~~syntaxhighlight ~~Algol68~~lang="algol68">main:( INT max = 12; INT width = ENTIER(log(max)2)+1; Line 72 ⟶ 676: OD; printf(($gl$, hr)) )</~~lang~~syntaxhighlight> {{out}} ~~Output:~~ <pre> +---+---+---+---+---+---+---+---+---+---+---+---+---+ Line 92 ⟶ 696: +---+---+---+---+---+---+---+---+---+---+---+---+---+ </pre> =={{header\|ALGOL W}}== <syntaxhighlight lang="algolw">begin % print a school style multiplication table % i_w := 3; s_w := 0; % set output formating % write( " " ); for i := 1 until 12 do writeon( " ", i ); write( " +" ); for i := 1 until 12 do writeon( "----" ); for i := 1 until 12 do begin write( i, "\|" ); for j := 1 until i - 1 do writeon( " " ); for j := i until 12 do writeon( " ", i j ); end; end.</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 +------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|APL}}== A simple table is trivial: <syntaxhighlight lang="apl">(⍳12)∘.×⍳12</syntaxhighlight> But that prints out all the duplicated results across the diagonal: {{Out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 6 9 12 15 18 21 24 27 30 33 36 4 8 12 16 20 24 28 32 36 40 44 48 5 10 15 20 25 30 35 40 45 50 55 60 6 12 18 24 30 36 42 48 54 60 66 72 7 14 21 28 35 42 49 56 63 70 77 84 8 16 24 32 40 48 56 64 72 80 88 96 9 18 27 36 45 54 63 72 81 90 99 108 10 20 30 40 50 60 70 80 90 100 110 120 11 22 33 44 55 66 77 88 99 110 121 132 12 24 36 48 60 72 84 96 108 120 132 144</pre> Getting just the top half, and some labels, requires a bit more work. Text alignment varies with implementation so the numbers will need some tweaking: {{works with\|Dyalog APL}} <syntaxhighlight lang="apl">⎕←(' ×',2↑' '),4 0⍕⍳12⋄{⎕←((4 0⍕⍵),⊂1(4×(⍵-1))⍴' '),4 0⍕(⍵-1)↓(⍵×⍳12)}¨⍳12</syntaxhighlight> {{works with\|GNU APL}} After printing the table, GNU APL will will output the value of the expression that produced it, so in addition to adjusting the header spacing this solution uses <tt>⍬⊣</tt> to throw that value away. <syntaxhighlight lang="apl">⎕←(' ×',4↑' '),4 0⍕⍳12⋄⍬⊣{⎕←((4 0⍕⍵),⊂1(4×(⍵-1))⍴' '),4 0⍕(⍵-1)↓(⍵×⍳12)}¨⍳12</syntaxhighlight> {{Out}} <pre> × 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144</pre> =={{header\|AppleScript}}== ===Iteration=== ~~<lang AppleScript >set n to 12 -- Size of table.~~ <syntaxhighlight lang="applescript ">set n to 12 -- Size of table. repeat with x from 0 to n if x = 0 then set {table, x} to {{return}, -1} repeat with y from 0 to n if y's contents = 0 then if x > 0 then set row to {f(x)} if x = -1 then set {row, x} to {{f("x")}, 1} else if y ≥ x then set end of row to f(x * y) if y < x then set end of row to f("") end if end repeat set end of table to row & return end repeat return table as string Line 111 ⟶ 795: -- Handler/Function for formatting fixed width integer string. on f(x) set text item delimiters to "" return (characters -4 thru -1 of (" " & x)) as string end f</~~lang~~syntaxhighlight>~~Output:~~ {{out}} <pre>" x 1 2 3 4 5 6 7 8 9 10 11 12 Line 129 ⟶ 814: 12 144 "</pre> ===Functional composition=== As an alternative to iteration, we could also write the top level more declaratively, composing a solution from a set of generic functions. {{trans\|JavaScript}} (ES5 functional version) <syntaxhighlight lang="applescript">------------------- MULTIPLICATION TABLE ----------------- -- multiplicationTable :: Int -> Int -> String on multiplicationTable(lower, upper) tell ap(my tableText, my mulTable) \|λ\|(enumFromTo(lower, upper)) end tell end multiplicationTable -- mulTable :: [Int]-> [[Int]] on mulTable(axis) script column on \|λ\|(x) script row on \|λ\|(y) if y < x then {} else {x * y} end if end \|λ\| end script {{x} & map(row, axis)} end \|λ\| end script concatMap(column, axis) end mulTable -- tableText :: [[Int]] -> String on tableText(axis, rows) set colWidth to 1 + (length of (\|last\|(\|last\|(rows)) as string)) set cell to replicate(colWidth, space) script tableLine on \|λ\|(xys) script tableCell on \|λ\|(int) (characters (-colWidth) thru -1 of (cell & int)) as string end \|λ\| end script intercalate(space, map(tableCell, xys)) end \|λ\| end script set legend to {{"x"} & axis} intercalate(linefeed, map(tableLine, legend & {{}} & rows)) end tableText --------------------------- TEST ------------------------- on run multiplicationTable(1, 12) & linefeed & linefeed & ¬ multiplicationTable(30, 40) end run -------------------- GENERIC FUNCTIONS ------------------- -- ap :: (a -> b -> c) -> (a -> b) -> a -> c on ap(f, g) -- The application of f x to g x script go property mf : \|λ\| of mReturn(f) property mg : \|λ\| of mReturn(g) on \|λ\|(x) mf(x, mg(x)) end \|λ\| end script end ap -- concatMap :: (a -> [b]) -> [a] -> [b] on concatMap(f, xs) set lst to {} set lng to length of xs tell mReturn(f) repeat with i from 1 to lng set lst to (lst & \|λ\|(item i of xs, i, xs)) end repeat end tell return lst end concatMap -- enumFromTo :: Int -> Int -> [Int] on enumFromTo(m, n) if m > n then set d to -1 else set d to 1 end if set lst to {} repeat with i from m to n by d set end of lst to i end repeat return lst end enumFromTo -- foldl :: (a -> b -> a) -> a -> [b] -> a on foldl(f, startValue, xs) tell mReturn(f) set v to startValue set lng to length of xs repeat with i from 1 to lng set v to \|λ\|(v, item i of xs, i, xs) end repeat return v end tell end foldl -- intercalate :: Text -> [Text] -> Text on intercalate(strText, lstText) set {dlm, my text item delimiters} to {my text item delimiters, strText} set strJoined to lstText as text set my text item delimiters to dlm return strJoined end intercalate -- justifyRight :: Int -> Char -> Text -> Text on justifyRight(n, cFiller, strText) if n > length of strText then text -n thru -1 of ((replicate(n, cFiller) as text) & strText) else strText end if end justifyRight -- last :: [a] -> a on \|last\|(xs) item -1 of xs end \|last\| -- map :: (a -> b) -> [a] -> [b] on map(f, xs) tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to \|λ\|(item i of xs, i, xs) end repeat return lst end tell end map -- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f) if class of f is script then f else script property \|λ\| : f end script end if end mReturn -- replicate :: Int -> String -> String on replicate(n, s) set out to "" if n < 1 then return out set dbl to s repeat while (n > 1) if (n mod 2) > 0 then set out to out & dbl set n to (n div 2) set dbl to (dbl & dbl) end repeat return out & dbl end replicate</syntaxhighlight> {{Out}} <pre> x 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 x 30 31 32 33 34 35 36 37 38 39 40 30 900 930 960 990 1020 1050 1080 1110 1140 1170 1200 31 961 992 1023 1054 1085 1116 1147 1178 1209 1240 32 1024 1056 1088 1120 1152 1184 1216 1248 1280 33 1089 1122 1155 1188 1221 1254 1287 1320 34 1156 1190 1224 1258 1292 1326 1360 35 1225 1260 1295 1330 1365 1400 36 1296 1332 1368 1404 1440 37 1369 1406 1443 1480 38 1444 1482 1520 39 1521 1560 40 1600</pre> =={{header\|ARM Assembly}}== {{works with\|as\|Raspberry Pi}} <syntaxhighlight lang="arm assembly"> /* ARM assembly Raspberry PI / / program multtable.s / /**********************************/ / Constantes / /*********************************/ .equ STDOUT, 1 @ Linux output console .equ EXIT, 1 @ Linux syscall .equ WRITE, 4 @ Linux syscall .equ MAXI, 12 /******************************/ / Initialized data / /******************************/ .data sMessValeur: .fill 11, 1, ' ' @ size => 11 szCarriageReturn: .asciz "\n" sBlanc1: .asciz " " sBlanc2: .asciz " " sBlanc3: .asciz " " /******************************/ / UnInitialized data / /******************************/ .bss /******************************/ / code section / /******************************/ .text .global main main: @ entry of program push {fp,lr} @ saves 2 registers @ display first line mov r4,#0 1: @ begin loop mov r0,r4 ldr r1,iAdrsMessValeur @ display value bl conversion10 @ call function mov r2,#0 @ final zéro strb r2,[r1,r0] @ on display value ldr r0,iAdrsMessValeur bl affichageMess @ display message cmp r4,#10 @ one or two digit in résult ldrgt r0,iAdrsBlanc2 @ two display two spaces ldrle r0,iAdrsBlanc3 @ one display 3 spaces bl affichageMess @ display message add r4,#1 @ increment counter cmp r4,#MAXI ble 1b @ loop ldr r0,iAdrszCarriageReturn bl affichageMess @ display carriage return mov r5,#1 @ line counter 2: @ begin loop lines mov r0,r5 @ display column 1 with N° line ldr r1,iAdrsMessValeur @ display value bl conversion10 @ call function mov r2,#0 @ final zéro strb r2,[r1,r0] ldr r0,iAdrsMessValeur bl affichageMess @ display message cmp r5,#10 @ one or two digit in N° line ldrge r0,iAdrsBlanc2 ldrlt r0,iAdrsBlanc3 bl affichageMess mov r4,#1 @ counter column 3: @ begin loop columns mul r0,r4,r5 @ multiplication mov r3,r0 @ save résult ldr r1,iAdrsMessValeur @ display value bl conversion10 @ call function mov r2,#0 strb r2,[r1,r0] ldr r0,iAdrsMessValeur bl affichageMess @ display message cmp r3,#100 @ 3 digits in résult ? ldrge r0,iAdrsBlanc1 @ yes, display one space bge 4f cmp r3,#10 @ 2 digits in result ldrge r0,iAdrsBlanc2 @ yes display 2 spaces ldrlt r0,iAdrsBlanc3 @ no display 3 spaces 4: bl affichageMess @ display message add r4,#1 @ increment counter column cmp r4,r5 @ < counter lines ble 3b @ loop ldr r0,iAdrszCarriageReturn bl affichageMess @ display carriage return add r5,#1 @ increment line counter cmp r5,#MAXI @ MAXI ? ble 2b @ loop 100: @ standard end of the program mov r0, #0 @ return code pop {fp,lr} @restaur 2 registers mov r7, #EXIT @ request to exit program svc #0 @ perform the system call iAdrsMessValeur: .int sMessValeur iAdrszCarriageReturn: .int szCarriageReturn iAdrsBlanc1: .int sBlanc1 iAdrsBlanc2: .int sBlanc2 iAdrsBlanc3: .int sBlanc3 /***************************************************************/ / display text with size calculation / /****************************************************************/ / r0 contains the address of the message / affichageMess: push {r0,r1,r2,r7,lr} @ save registres mov r2,#0 @ counter length 1: @ loop length calculation ldrb r1,[r0,r2] @ read octet start position + index cmp r1,#0 @ if 0 its over addne r2,r2,#1 @ else add 1 in the length bne 1b @ and loop @ so here r2 contains the length of the message mov r1,r0 @ address message in r1 mov r0,#STDOUT @ code to write to the standard output Linux mov r7, #WRITE @ code call system "write" svc #0 @ call systeme pop {r0,r1,r2,r7,lr} @ restaur des 2 registres / bx lr @ return /*****************************************************************/ / Converting a register to a decimal unsigned / /****************************************************************/ / r0 contains value and r1 address area / / r0 return size of result (no zero final in area) / / area size => 11 bytes / .equ LGZONECAL, 10 conversion10: push {r1-r4,lr} @ save registers mov r3,r1 mov r2,#LGZONECAL 1: @ start loop bl divisionpar10U @unsigned r0 <- dividende. quotient ->r0 reste -> r1 add r1,#48 @ digit strb r1,[r3,r2] @ store digit on area cmp r0,#0 @ stop if quotient = 0 / subne r2,#1 @ else previous position bne 1b @ and loop @ and move digit from left of area mov r4,#0 2: ldrb r1,[r3,r2] strb r1,[r3,r4] add r2,#1 add r4,#1 cmp r2,#LGZONECAL ble 2b @ and move spaces in end on area mov r0,r4 @ result length mov r1,#' ' @ space 3: strb r1,[r3,r4] @ store space in area add r4,#1 @ next position cmp r4,#LGZONECAL ble 3b @ loop if r4 <= area size 100: pop {r1-r4,lr} @ restaur registres bx lr @return /**************************************************/ / division par 10 unsigned / /*************************************************/ / r0 dividende / / r0 quotient / / r1 remainder / divisionpar10U: push {r2,r3,r4, lr} mov r4,r0 @ save value mov r3,#0xCCCD @ r3 <- magic_number lower movt r3,#0xCCCC @ r3 <- magic_number upper umull r1, r2, r3, r0 @ r1<- Lower32Bits(r1r0) r2<- Upper32Bits(r1r0) mov r0, r2, LSR #3 @ r2 <- r2 >> shift 3 add r2,r0,r0, lsl #2 @ r2 <- r0 5 sub r1,r4,r2, lsl #1 @ r1 <- r4 - (r2 * 2) = r4 - (r0 * 10) pop {r2,r3,r4,lr} bx lr @ leave function </syntaxhighlight> =={{header\|Arturo}}== <syntaxhighlight lang="rebol">mulTable: function [n][ print [" \|"] ++ map 1..n => [pad to :string & 3] print "----+" ++ join map 1..n => "----" loop 1..n 'x [ prints (pad to :string x 3) ++ " \|" if x>1 -> loop 1..x-1 'y [prints " "] loop x..n 'y [prints " " ++ pad to :string xy 3] print "" ] ] mulTable 12</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ----+------------------------------------------------ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144</pre> =={{header\|AutoHotkey}}== <~~lang~~syntaxhighlight lang="autohotkey">Gui, -MinimizeBox Gui, Margin, 0, 0 Gui, Font, s9, Fixedsys Line 166 ⟶ 1,286: } GuiControl,, Edit2, %Table% Return</~~lang~~syntaxhighlight> Message box shows: <pre> x \| 1 2 3 4 5 6 7 8 9 10 11 12 Line 185 ⟶ 1,305: =={{header\|AutoIt}}== <~~lang~~syntaxhighlight ~~AutoIt~~lang="autoit">#AutoIt Version: 3.2.10.0 $tableupto=12 $table="" Line 204 ⟶ 1,324: Next Next msgbox(0,"Multiplication Tables",$table)</~~lang~~syntaxhighlight> =={{header\|AWK}}== <syntaxhighlight lang="awk"> ~~<lang AWK>~~ BEGIN { for(i=1;i<13=12;i++){ for(j=1;j<13=12;j++){ if(j>=i\|\|j==1){printf( "%4d",ij);} else {printf( " ");} } print; } }</syntaxhighlight> } {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 Line 230 ⟶ 1,351: 11 121 132 12 144 </~~lang~~pre> =={{header\|~~BBC BASIC~~Axe}}== Since the standard text output is poorly suited to this kind of formatted data, this example is implemented by writing to the screen buffer using the small font. Also, the limits were adjusted to 10x8 to make the table fit the screen. <syntaxhighlight lang="axe">Fix 5 ClrDraw For(I,1,10) Text(I-19,0,I▶Dec) Text(91,I7+1,I▶Dec) End For(J,1,8) For(I,J,10) Text(I-19,J7+1,IJ▶Dec) End End HLine(7) VLine(89) DispGraph getKeyʳ Fix 4</syntaxhighlight> Approximate output: <pre> 1 2 3 4 5 6 7 8 9 10 \| --------------------------------- 1 2 3 4 5 6 7 8 9 10 \| 1 4 6 8 10 12 14 16 18 20 \| 2 9 12 15 18 21 24 27 30 \| 3 16 20 24 28 32 36 40 \| 4 25 30 35 40 45 50 \| 5 36 42 48 54 60 \| 6 49 56 63 70 \| 7 64 72 80 \| 8 </pre> =={{header\|BASIC}}== ==={{header\|Applesoft BASIC}}=== <syntaxhighlight lang="applesoftbasic">100 M = 12 110 DEF FN T(X) = X 3 + (X < 4) * (4 - X) + (X > 10) * (X - 10) - 1 120 FOR N = -1 TO M 130 IF NOT N THEN PRINT CHR$(13) TAB(5); : FOR J = 5 TO FN T(M + 1) - 2 : PRINT "-"; : NEXT J, N 140 I = ABS(N) 150 IF N > 0 THEN PRINT CHR$(13) MID$(" ", 1, I < 10) I" !"; 160 FOR J = I TO M 170 V$ = STR$(I * J) 180 PRINT TAB(FN T(J)) MID$(" ", 1, 3 - LEN(V$) - (J < 4)) V$; 190 NEXT J, N</syntaxhighlight> ==={{header\|ASIC}}=== {{trans\|Modula-2}} <syntaxhighlight lang="basic"> REM Multiplication tables N = 12 PREDN = N - 1 WDTH = 3 CLS FOR J = 1 TO PREDN INTVAL = J GOSUB PRINTINT: PRINT " "; NEXT J INTVAL = N GOSUB PRINTINT: PRINT FOR J = 0 TO PREDN PRINT "----"; NEXT J PRINT "+" FOR I = 1 TO N WDTH = 3 FOR J = 1 TO N IF J < I THEN PRINT " "; ELSE INTVAL = I * J GOSUB PRINTINT: PRINT " "; ENDIF NEXT J PRINT "\| "; INTVAL = I WDTH = 2 GOSUB PRINTINT: PRINT NEXT I END PRINTINT: REM Writes the value of INTVAL in a field of the given WDTH S2$ = STR$(INTVAL) S2$ = LTRIM$(S2$) SPNUM = LEN(S2$) SPNUM = WDTH - SPNUM S1$ = SPACE$(SPNUM) PRINT S1$; PRINT S2$; RETURN </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> ==={{header\|BASIC256}}=== <syntaxhighlight lang="freebasic">print " X\| 1 2 3 4 5 6 7 8 9 10 11 12" print "---+------------------------------------------------" for i = 1 to 12 nums$ = right(" " + string(i), 3) + "\|" for j = 1 to 12 if i <= j then if j >= 1 then nums$ += left(" ", (4 - length(string(i * j)))) end if nums$ += string(i * j) else nums$ += " " end if next j print nums$ next i</syntaxhighlight> ==={{header\|BBC BASIC}}=== BBC BASIC automatically right-justifies numeric output. <~~lang~~syntaxhighlight lang="bbcbasic"> @% = 5 : REM Set column width FOR row% = 1 TO 12 PRINT row% TAB(row% * @%) ; Line 241 ⟶ 1,497: NEXT col% PRINT NEXT row%</~~lang~~syntaxhighlight> {{out}} ~~Output:~~ <pre> 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 Line 255 ⟶ 1,511: 11 121 132 12 144</pre> ==={{header\|Chipmunk Basic}}=== {{works with\|Chipmunk Basic\|3.6.4}} {{trans\|IS-BASIC}} <syntaxhighlight lang="qbasic">100 cls 110 print tab (4); 120 for i = 1 to 12 130 print using " ###";i; 140 next 150 print 160 print " --+------------------------------------------------" 170 for i = 1 to 12 180 print using " ##\|";i; 190 print tab (i4); 200 for j = i to 12 210 print using " ###";ij; 220 next 230 print 240 next 250 end</syntaxhighlight> ==={{header\|Commodore BASIC}}=== The table consumes every one of the 1000 cells in a 40-column display, and even so has to cheat a little to fit 10x10=100 into the table. It uses the INSERT character (<tt>CHR$(148)</tt>) to push characters over to the right after printing them without triggering a scroll that would push the top line off the screen. <syntaxhighlight lang="gwbasic">100 PRINT CHR$(14);CHR$(147); 110 PRINT " X"; 120 W=2 130 FOR I=1 TO 10 140 : N=I 150 : GOSUB 520 160 : PRINT ":"N$; 170 NEXT I 180 W=3 190 FOR I=11 TO 12 200 : N=I 210 : GOSUB 520 220 : PRINT ":"N$; 230 NEXT 240 FOR I=1 TO 12 250 : PRINT "--"; 260 : FOR J=1 TO 10 270 : PRINT "+--"; 280 : NEXT J 290 : FOR J=11 TO 12 300 : PRINT "+---"; 310 : NEXT J 320 : N=I:W=2:GOSUB 520:PRINT N$; 330 : FOR J=1 TO 10 340 : W=2 350 : IF J<I THEN N$=" ":GOSUB 530:GOTO 370 360 : N=IJ:GOSUB 520 370 : IF LEN(N$)<3 THEN PRINT ":"; 380 : PRINT N$; 390 : NEXT J 400 : FOR J=11 TO 12 410 : W=3 420 : IF J<I THEN N$=" ":GOSUB 530:GOTO 440 430 : N=IJ:GOSUB 520 440 : PRINT N$; 450 : FOR K=1 TO LEN(N$): PRINT CHR$(157);:NEXT K 460 : PRINT CHR$(148);":"; 470 : IF J<12 THEN FOR K=1 TO LEN(N$):PRINT CHR$(29);: NEXT K 480 : NEXT J: IF I<12 THEN PRINT 490 NEXT I 500 GET K$: IF K$="" THEN 500 510 END 520 N$=MID$(STR$(N),2) 530 IF LEN(N$)<W THEN N$=" "+N$:GOTO 530 540 RETURN</syntaxhighlight> {{Out}} <pre> x: 1: 2: 3: 4: 5: 6: 7: 8: 9:10: 11: 12 --+--+--+--+--+--+--+--+--+--+--+---+--- 1: 1: 2: 3: 4: 5: 6: 7: 8: 9:10: 11: 12 --+--+--+--+--+--+--+--+--+--+--+---+--- 2: : 4: 6: 8:10:12:14:16:18:20: 22: 24 --+--+--+--+--+--+--+--+--+--+--+---+--- 3: : : 9:12:15:18:21:24:27:30: 33: 36 --+--+--+--+--+--+--+--+--+--+--+---+--- 4: : : :16:20:24:28:32:36:40: 44: 48 --+--+--+--+--+--+--+--+--+--+--+---+--- 5: : : : :25:30:35:40:45:50: 55: 60 --+--+--+--+--+--+--+--+--+--+--+---+--- 6: : : : : :36:42:48:54:60: 66: 72 --+--+--+--+--+--+--+--+--+--+--+---+--- 7: : : : : : :49:56:63:70: 77: 84 --+--+--+--+--+--+--+--+--+--+--+---+--- 8: : : : : : : :64:72:80: 88: 96 --+--+--+--+--+--+--+--+--+--+--+---+--- 9: : : : : : : : :81:90: 99:108 --+--+--+--+--+--+--+--+--+--+--+---+--- 10: : : : : : : : : 100:110:120 --+--+--+--+--+--+--+--+--+--+--+---+--- 11: : : : : : : : : : :121:132 --+--+--+--+--+--+--+--+--+--+--+---+--- 12: : : : : : : : : : : :144</pre> ==={{header\|FreeBASIC}}=== <syntaxhighlight lang="freebasic"> ' FB 1.05.0 Win64 Print " X\|"; For i As Integer = 1 To 12 Print Using "####"; i; Next Print Print "---+"; String(48, "-") For i As Integer = 1 To 12 Print Using "###"; i; Print"\|"; Spc(4 * (i - 1)); For j As Integer = i To 12 Print Using "####"; i * j; Next j Print Next i Print Print "Press any key to quit" Sleep</syntaxhighlight> {{out}} <pre> X\| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> ==={{header\|FutureBasic}}=== <syntaxhighlight lang="basic"> long i, j window 1, @"Multiplication Table", (0,0,420,220) print " \|"; for i = 1 to 12 print using "####"; i; next print :print "---+"; string$(48, "-") for i = 1 to 12 print using "###"; i; print"\|"; spc(4 * (i - 1)); for j = i to 12 print using "####"; i * j; next print next HandleEvents </syntaxhighlight> {{output}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> ==={{header\|Gambas}}=== '''[https://gambas-playground.proko.eu/?gist=3a3a987766a9a9a383b3e0e8a65d9ea2 Click this link to run this code]''' <syntaxhighlight lang="gambas">'Code 'stolen' from Free Basic and altered to work in Gambas Public Sub Main() Dim i, j As Integer Print " X\|"; For i = 1 To 12 Print Format(i, "####"); Next Print Print "---+"; String(48, "-") For i = 1 To 12 Print Format(i, "###"); Print "\|"; Space(4 * (i - 1)); For j = i To 12 Print Format(i * j, "####"); Next Print Next End</syntaxhighlight> Output: <pre> X\| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> ==={{header\|GW-BASIC}}=== {{trans\|Modula-2}} {{works with\|BASICA}} {{works with\|PC-BASIC\|any}} <syntaxhighlight lang="gwbasic"> 10 ' Multiplication Tables 20 LET N% = 12 30 FOR J% = 1 TO N% - 1 40 PRINT USING "###"; J%; 50 PRINT " "; 60 NEXT J% 70 PRINT USING "###"; N% 80 FOR J% = 0 TO N% - 1 90 PRINT "----"; 100 NEXT J% 110 PRINT "+" 120 FOR I% = 1 TO N% 130 FOR J% = 1 TO N% 140 IF J% < I% THEN PRINT " "; ELSE PRINT USING "###"; I% * J%;: PRINT " "; 150 NEXT J% 160 PRINT "\| "; USING "##"; I% 170 NEXT I% </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> ==={{header\|IS-BASIC}}=== <syntaxhighlight lang="is-basic">100 PROGRAM "Multipli.bas" 110 TEXT 80 120 PRINT TAB(7); 130 FOR I=1 TO 12 140 PRINT USING " ###":I; 150 NEXT 160 PRINT AT 2,5:"----------------------------------------------------" 170 FOR I=1 TO 12 180 PRINT USING "### \|":I;:PRINT TAB(I4+3); 190 FOR J=I TO 12 200 PRINT USING " ###":IJ; 210 NEXT 220 PRINT 230 NEXT</syntaxhighlight> ==={{header\|Liberty BASIC}}=== <syntaxhighlight lang="lb">Print " \| 1 2 3 4 5 6 7 8 9 10 11 12" Print "--+------------------------------------------------------------" For i = 1 To 12 nums$ = Right$(" " + str$(i), 2) + "\|" For ii = 1 To 12 If i <= ii Then If ii >= 1 Then nums$ = nums$ + Left$(" ", (5 - Len(str$(i * ii)))) End If nums$ = nums$ + str$(i * ii) Else nums$ = nums$ + " " End If Next ii Print nums$ Next i</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> ==={{header\|Microsoft Small Basic}}=== {{trans\|Modula-2}} <syntaxhighlight lang="microsoftsmallbasic"> n = 12 For j = 1 To n - 1 TextWindow.CursorLeft = (j - 1) * 4 + (3 - Text.GetLength(j)) TextWindow.Write(j) TextWindow.Write(" ") EndFor TextWindow.CursorLeft = (n - 1) * 4 + (3 - Text.GetLength(n)) TextWindow.Write(n) TextWindow.WriteLine("") For j = 0 To n - 1 TextWindow.Write("----") EndFor TextWindow.WriteLine("+") For i = 1 To n For j = 1 To n If j < i Then TextWindow.Write(" ") Else TextWindow.CursorLeft = (j - 1) * 4 + (3 - Text.GetLength(i * j)) TextWindow.Write(i * j) TextWindow.Write(" ") EndIf EndFor TextWindow.Write("\| ") TextWindow.CursorLeft = n * 4 + (4 - Text.GetLength(i)) TextWindow.Write(i) TextWindow.WriteLine("") EndFor </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> ==={{header\|PureBasic}}=== <syntaxhighlight lang="purebasic">Procedure PrintMultiplicationTable(maxx, maxy) sp = Len(Str(maxxmaxy)) + 1 trenner$ = "+" For l1 = 1 To maxx + 1 For l2 = 1 To sp trenner$ + "-" Next trenner$ + "+" Next header$ = "\|" + RSet("x", sp) + "\|" For a = 1 To maxx header$ + RSet(Str(a), sp) header$ + "\|" Next PrintN(trenner$) PrintN(header$) PrintN(trenner$) For y = 1 To maxy line$ = "\|" + RSet(Str(y), sp) + "\|" For x = 1 To maxx If x >= y line$ + RSet(Str(xy), sp) Else line$ + Space(sp) EndIf line$ + "\|" Next PrintN(line$) Next PrintN(trenner$) EndProcedure OpenConsole() PrintMultiplicationTable(12, 12) Input()</syntaxhighlight> Ouput similar to ALGOL 68 ==={{header\|QBasic}}=== <syntaxhighlight lang="qbasic">CLS 'header row PRINT " "; FOR n = 1 TO 12 'do it this way for alignment purposes o$ = " " MID$(o$, LEN(o$) - LEN(STR$(n)) + 1) = STR$(n) PRINT o$; NEXT PRINT : PRINT " "; STRING$(49, "-"); FOR n = 1 TO 12 PRINT IF n < 10 THEN PRINT " "; PRINT n; "\|"; 'row labels FOR m = 1 TO n - 1 PRINT " "; NEXT FOR m = n TO 12 'alignment again o$ = " " MID$(o$, LEN(o$) - LEN(STR$(m * n)) + 1) = STR$(m * n) PRINT o$; NEXT NEXT</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------- 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> ==={{header\|Run BASIC}}=== <syntaxhighlight lang="runbasic">html "<TABLE border=1 ><TR bgcolor=silver align=center><TD><TD>1<TD>2<TD>3<TD>4<TD>5<TD>6<TD>7<TD>8<TD>9<TD>10<TD>11<TD>12</td></TR>" For i = 1 To 12 html "<TR align=right><TD>";i;"</td>" For ii = 1 To 12 html "<td width=25>" If ii >= i Then html i * ii html "</td>" Next ii next i html "</table>" </syntaxhighlight>Output: <TABLE border=1 ><TR bgcolor=silver align=center><TD><TD>1<TD>2<TD>3<TD>4<TD>5<TD>6<TD>7<TD>8<TD>9<TD>10<TD>11<TD>12</td></TR><TR align=right><TD>1</td><td width=25>1</td><td width=25>2</td><td width=25>3</td><td width=25>4</td><td width=25>5</td><td width=25>6</td><td width=25>7</td><td width=25>8</td><td width=25>9</td><td width=25>10</td><td width=25>11</td><td width=25>12</td><TR align=right><TD>2</td><td width=25></td><td width=25>4</td><td width=25>6</td><td width=25>8</td><td width=25>10</td><td width=25>12</td><td width=25>14</td><td width=25>16</td><td width=25>18</td><td width=25>20</td><td width=25>22</td><td width=25>24</td><TR align=right><TD>3</td><td width=25></td><td width=25></td><td width=25>9</td><td width=25>12</td><td width=25>15</td><td width=25>18</td><td width=25>21</td><td width=25>24</td><td width=25>27</td><td width=25>30</td><td width=25>33</td><td width=25>36</td><TR align=right><TD>4</td><td width=25></td><td width=25></td><td width=25></td><td width=25>16</td><td width=25>20</td><td width=25>24</td><td width=25>28</td><td width=25>32</td><td width=25>36</td><td width=25>40</td><td width=25>44</td><td width=25>48</td><TR align=right><TD>5</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>25</td><td width=25>30</td><td width=25>35</td><td width=25>40</td><td width=25>45</td><td width=25>50</td><td width=25>55</td><td width=25>60</td><TR align=right><TD>6</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>36</td><td width=25>42</td><td width=25>48</td><td width=25>54</td><td width=25>60</td><td width=25>66</td><td width=25>72</td><TR align=right><TD>7</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>49</td><td width=25>56</td><td width=25>63</td><td width=25>70</td><td width=25>77</td><td width=25>84</td><TR align=right><TD>8</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>64</td><td width=25>72</td><td width=25>80</td><td width=25>88</td><td width=25>96</td><TR align=right><TD>9</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>81</td><td width=25>90</td><td width=25>99</td><td width=25>108</td><TR align=right><TD>10</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>100</td><td width=25>110</td><td width=25>120</td><TR align=right><TD>11</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>121</td><td width=25>132</td><TR align=right><TD>12</td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25></td><td width=25>144</td></table> === {{header\|Tiny BASIC}} === {{trans\|Modula-2}} {{works with\|TinyBasic}} <syntaxhighlight lang="basic"> 10 REM MULTIPLICATION TABLES 20 LET N=12 30 REM TO ALIGN NUMBERS TO THE RIGHT 40 REM ASSUME THAT N IS AT MOST TWO-DIGIT. 50 LET J=1 60 PRINT " "; 70 IF J<10 THEN PRINT " "; 80 PRINT J;" "; 90 LET J=J+1 100 IF J=N THEN GOTO 120 110 GOTO 60 120 PRINT " "; 130 IF N<10 THEN PRINT " "; 140 PRINT N 150 LET J=0 160 PRINT "----"; 170 J=J+1 180 IF J=N THEN GOTO 200 190 GOTO 160 200 PRINT "+" 210 LET I=1 220 LET J=1 230 IF J<I THEN GOTO 290 240 LET P=IJ 250 IF P<100 THEN PRINT " "; 260 IF P<10 THEN PRINT " "; 270 PRINT P;" "; 280 GOTO 300 290 PRINT " "; 300 IF J=N THEN GOTO 330 310 LET J=J+1 320 GOTO 230 330 PRINT "! "; 340 IF I<10 THEN PRINT " "; 350 PRINT I 360 IF I=N THEN GOTO 390 370 LET I=I+1 380 GOTO 220 390 END </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 ! 1 4 6 8 10 12 14 16 18 20 22 24 ! 2 9 12 15 18 21 24 27 30 33 36 ! 3 16 20 24 28 32 36 40 44 48 ! 4 25 30 35 40 45 50 55 60 ! 5 36 42 48 54 60 66 72 ! 6 49 56 63 70 77 84 ! 7 64 72 80 88 96 ! 8 81 90 99 108 ! 9 100 110 120 ! 10 121 132 ! 11 144 ! 12 </pre> ==={{header\|True BASIC}}=== <syntaxhighlight lang="qbasic">PRINT " X\| 1 2 3 4 5 6 7 8 9 10 11 12" PRINT "---+------------------------------------------------" FOR i = 1 TO 12 LET nums$ = (" " & STR$(i))[LEN(" " & STR$(i))-3+1:maxnum] & "\|" FOR j = 1 TO 12 IF i <= j THEN IF j >= 1 THEN LET nums$ = nums$ & (" ")[1:(4-LEN(STR$(ij)))] LET nums$ = nums$ & STR$(ij) ELSE LET nums$ = nums$ & " " END IF NEXT j PRINT nums$ NEXT i PRINT END</syntaxhighlight> ==={{header\|uBasic/4tH}}=== {{trans\|BBC BASIC}} <syntaxhighlight lang="basic">For R = 1 To 12 Print R;Tab(R 5); For C = R To 12 Print Using "_____";R * C; Next Print Next</syntaxhighlight> {{out}} <pre>1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 0 OK, 0:105</pre> ==={{header\|VBA}}=== <syntaxhighlight lang="vb"> Option Explicit Sub Multiplication_Tables() Dim strTemp As String, strBuff As String Dim i&, j&, NbDigits As Byte 'You can adapt the following const : Const NB_END As Byte = 12 Select Case NB_END Case Is < 10: NbDigits = 3 Case 10 To 31: NbDigits = 4 Case 31 To 100: NbDigits = 5 Case Else: MsgBox "Number too large": Exit Sub End Select strBuff = String(NbDigits, " ") For i = 1 To NB_END strTemp = Right(strBuff & i, NbDigits) For j = 2 To NB_END If j < i Then strTemp = strTemp & strBuff Else strTemp = strTemp & Right(strBuff & j * i, NbDigits) End If Next j Debug.Print strTemp Next i End Sub </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144</pre> ==={{header\|Visual Basic}}=== {{works with\|Visual Basic\|VB6 Standard}} <syntaxhighlight lang="vb">Sub Main() Const nmax = 12, xx = 3 Const x = xx + 1 Dim i As Integer, j As Integer, s As String s = String(xx, " ") & " \|" For j = 1 To nmax s = s & Right(String(x, " ") & j, x) Next j Debug.Print s s = String(xx, "-") & " +" For j = 1 To nmax s = s & " " & String(xx, "-") Next j Debug.Print s For i = 1 To nmax s = Right(String(xx, " ") & i, xx) & " \|" For j = 1 To nmax If j >= i _ Then s = s & Right(String(x, " ") & i * j, x) _ Else s = s & String(x, " ") Next j Debug.Print s Next i End Sub 'Main</syntaxhighlight> {{Out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --- + --- --- --- --- --- --- --- --- --- --- --- --- 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> ==={{header\|XBasic}}=== {{trans\|Modula-2}} {{works with\|Windows XBasic}} <syntaxhighlight lang="xbasic"> PROGRAM "multiplicationtables" VERSION "0.0001" DECLARE FUNCTION Entry() FUNCTION Entry() $N = 12 FOR j@@ = 1 TO $N - 1 PRINT FORMAT$("### ", j@@); NEXT j@@ PRINT FORMAT$("###", $N) FOR j@@ = 0 TO $N - 1 PRINT "----"; NEXT j@@ PRINT "+" FOR i@@ = 1 TO $N FOR j@@ = 1 TO $N IF j@@ < i@@ THEN PRINT " "; ELSE PRINT FORMAT$("### ", i@@ * j@@); END IF NEXT j@@ PRINT "\|"; FORMAT$(" ##", i@@) NEXT i@@ END FUNCTION END PROGRAM </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> ==={{header\|Yabasic}}=== <syntaxhighlight lang="freebasic">print " X\| 1 2 3 4 5 6 7 8 9 10 11 12" print "---+------------------------------------------------" for i = 1 to 12 nums$ = right$(" " + str$(i), 3) + "\|" for j = 1 to 12 if i <= j then if j >= 1 then nums$ = nums$ + left$(" ", (4 - len(str$(i * j)))) end if nums$ = nums$ + str$(i * j) else nums$ = nums$ + " " end if next j print nums$ next i</syntaxhighlight> =={{header\|Batch File}}== <syntaxhighlight lang="dos">@echo off setlocal enabledelayedexpansion ::The Main Thing... cls set colum=12&set row=12 call :multable echo. pause exit /b 0 ::/The Main Thing. ::The Functions... :multable echo. for /l %%. in (1,1,%colum%) do ( call :numstr %%. set firstline=!firstline!!space!%%. set seconline=!seconline!----- ) echo !firstline! echo !seconline! ::The next lines here until the "goto :EOF" prints the products... for /l %%X in (1,1,%row%) do ( for /l %%Y in (1,1,%colum%) do ( if %%Y lss %%X (set "line%%X=!line%%X! ") else ( set /a ans=%%X%%Y call :numstr !ans! set "line%%X=!line%%X!!space!!ans!" ) ) echo.!line%%X! ^\| %%X ) goto :EOF :numstr ::This function returns the number of whitespaces to be applied on each numbers. set cnt=0&set proc=%1&set space= :loop set currchar=!proc:~%cnt%,1! if not "!currchar!"=="" set /a cnt+=1&goto loop set /a numspaces=5-!cnt! for /l %%A in (1,1,%numspaces%) do set "space=!space! " goto :EOF ::/The Functions.</syntaxhighlight> {{Out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------------------ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 Press any key to continue . . .</pre> =={{header\|Befunge}}== <syntaxhighlight lang="befunge">0>51p0>52p51g52g:51g52g`!\!51g52g++0\3>01p::55+%68+\!28v w^p2<y\|!`+66:+1,+84"\"!:g25$_,#!>#:<$$_^#!:-1g10/+55\-<< "$9"^x>$55+,51g1+:66+`#@_055+68\>\#<1#-#9:#5_$"+---">:#,_$</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+----------------------------------------------- 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|BQN}}== <code>Table</code> formats a multiplication table for any given n. The result is a character array and can be printed with <code>•Out˘</code>. The overall structure is to build a 3-by-3 array of parts, then put them together with a two-dimensional join (<code>∾</code>). <syntaxhighlight lang="bqn">Table ← { m ← •Repr¨ ×⌜˜1+↕𝕩 # The numbers, formatted individually main ← ⟨ # Bottom part: three sections >(-⌈10⋆⁼𝕩)↑¨⊏m # Original numbers 𝕩⥊'\|' # Divider ∾˘(-1+⌈10⋆⁼𝕩×𝕩)↑¨(≤⌜˜↕𝕩)/¨m # Multiplied numbers, padded and joined ⟩ head ← ' '¨⌾⊑ ⊏¨ main # Header: first row but with space left of \| ∾ >⟨head, "-+-"⊣¨¨head, main⟩ # Header, divider, and main } •Out˘ Table 12</syntaxhighlight> {{Out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+----------------------------------------------- 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|Bracmat}}== <syntaxhighlight lang="bracmat"> ( multiplicationTable = high i j row row2 matrix padFnc tmp , celPad leftCelPad padFnc celDashes leftDashes . !arg:?high & ( padFnc = L i w d . @(!arg:? [?L) & 1+(!L:?i):?L & " ":?w & "-":?d & whl ' ( !i+-1:~<0:?i & " " !w:?w & "-" !d:?d ) & str$!w:?w & ( ' ( . @(str$(rev$!arg ()$w):?arg [($L) ?) & rev$!arg ) . str$!d ) ) & padFnc$(!high^2):((=?celPad).?celDashes) & @(!high:?tmp [-2 ?) & padFnc$!tmp:((=?leftCelPad).?leftDashes) & 0:?i & :?row:?row2 & whl ' ( 1+!i:~>!high:?i & !row celPad$!i:?row & !celDashes !row2:?row2 ) & str$(leftCelPad$X "\|" !row \n !leftDashes "+" !row2 \n) : ?matrix & 0:?j & whl ' ( 1+!j:~>!high:?j & 0:?i & :?row & whl ' ( 1+!i:<!j:?i & celPad$() !row:?row ) & leftCelPad$!j "\|" !row:?row & whl ' ( 1+!i:~>!high:?i & !row celPad$(!i!j):?row ) & !matrix str$(!row \n):?matrix ) & str$!matrix ) & out$(multiplicationTable$12) & done;</syntaxhighlight> {{out}} <pre> X\| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|C}}== <syntaxhighlight lang="c">#include <stdio.h> ~~<lang c>int main()~~ int main(void) { int i, j, n = 12; for (j = 1; j <= n; j++) printf("%3d%c", j, j -!= n ? ' ' : '\n'); for (j = 0; j <= n; j++) printf(j -!= n ? "----" : "+\n"); for (i = 1; i <= n; ~~printf("\| %d\n",~~ i++)) { for (j = 1; j <= n; j++) printf(j < i ? " " : "%3d ", i * j); printf("\| %d\n", i); } return 0; }</syntaxhighlight> ~~}</lang>output<lang> 1 2 3 4 5 6 7 8 9 10 11 12~~ {{out}} ~~------------------------------------------------~~ <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 Line 282 ⟶ 2,464: 100 110 120 \| 10 121 132 \| 11 144 \| 12</~~lang~~pre> =={{header\|C sharp}}== <syntaxhighlight lang="csharp">using System; namespace multtbl { class Program { static void Main(string[] args) { Console.Write(" X".PadRight(4)); for (int i = 1; i <= 12; i++) Console.Write(i.ToString("####").PadLeft(4)); Console.WriteLine(); Console.Write(" ___"); for (int i = 1; i <= 12; i++) Console.Write(" ___"); Console.WriteLine(); for (int row = 1; row <= 12; row++) { Console.Write(row.ToString("###").PadLeft(3).PadRight(4)); for (int col = 1; col <= 12; col++) { if (row <= col) Console.Write((row * col).ToString("###").PadLeft(4)); else Console.Write("".PadLeft(4)); } Console.WriteLine(); } Console.WriteLine(); Console.ReadLine(); } } } </syntaxhighlight> {{out}} <pre> X 1 2 3 4 5 6 7 8 9 10 11 12 ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|C++}}== This is a slightly more-generalized version ~~that takes any minimum and maximum table value, and formats the table columns.~~ that takes any minimum and maximum table value, and formats the table columns. <~~lang~~syntaxhighlight lang="cpp">#include <iostream> #include <iomanip> #include <cmath> // for log10() #include <algorithm> // for max() size_t ~~get_table_column_width~~table_column_width(const int min, const int max) { unsigned int abs_max = std::max(maxmax, minmin); Line 299 ⟶ 2,541: // If we take the log10 and add one, we get the string width // of the largest possible absolute value. // Add one more for a little whitespace guarantee. size_t colwidth = 12 + std::log10(abs_max) ~~+ 1~~; // If only one of them is less than 0, then some will // be negative. If some values may be negative, then we need to add some space ~~bool has_negative_result = (min < 0) && (max > 0);~~ ~~// If some values may be negative, then we need to add some space~~ // for a sign indicator (-) if (~~has_negative_result~~min < 0 && max > 0) ++colwidth; ~~colwidth++;~~ return colwidth; } struct Writer_ { decltype(std::setw(1)) fmt_; Writer_(size_t w) : fmt_(std::setw(w)) {} template<class T_> Writer_& operator()(const T_& info) { std::cout << fmt_ << info; return this; } }; void print_table_header(const int min, const int max) { ~~size_t~~Writer_ ~~colwidth = get_table_column_width~~write(table_column_width(min, max)); // table corner write(" "); ~~std::cout << std::setw(colwidth) << " ";~~ for(int col = min; col <= max; ++col) { write(col); ~~std::cout << std::setw(colwidth) << col;~~ } // End header with a newline and blank line. Line 332 ⟶ 2,574: void print_table_row(const int num, const int min, const int max) { ~~size_t~~Writer_ ~~colwidth = get_table_column_width~~write(table_column_width(min, max)); // Header column write(num); ~~std::cout << std::setw(colwidth) << num;~~ // Spacing to ensure only the top half is printed for(int multiplicand = min; multiplicand < num; ++multiplicand) { write(" "); ~~std::cout << std::setw(colwidth) << " ";~~ } // Remaining multiplicands for the row. for(int multiplicand = num; multiplicand <= max; ++multiplicand) write(num multiplicand); { ~~std::cout << std::setw(colwidth) << num * multiplicand;~~ } // End row with a newline and blank line. Line 360 ⟶ 2,598: // Table body for(int row = min; row <= max; ++row) { print_table_row(row, min, max); } } Line 370 ⟶ 2,606: return 0; } </syntaxhighlight> ~~</lang>~~ {{out}} ~~Output:~~ <pre> ~~<pre> 1 2 3 4 5 6 7 8 9 10 11 12~~ 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 Line 399 ⟶ 2,636: 12 144 ~~</pre>~~ ~~=={{header\|C sharp}}==~~ ~~<lang csharp>using System;~~ ~~namespace multtbl~~ { ~~class Program~~ { ~~static void Main(string[] args)~~ { ~~Console.Write(" X".PadRight(4));~~ ~~for (int i = 1; i <= 12; i++)~~ ~~Console.Write(i.ToString("####").PadLeft(4));~~ ~~Console.WriteLine();~~ ~~Console.Write(" ___");~~ ~~for (int i = 1; i <= 12; i++)~~ ~~Console.Write(" ___");~~ ~~Console.WriteLine();~~ ~~for (int row = 1; row <= 12; row++)~~ { ~~Console.Write(row.ToString("###").PadLeft(3).PadRight(4));~~ ~~for (int col = 1; col <= 12; col++)~~ { ~~if (row <= col)~~ ~~Console.Write((row * col).ToString("###").PadLeft(4));~~ ~~else~~ ~~Console.Write("".PadLeft(4));~~ } ~~Console.WriteLine();~~ } ~~Console.WriteLine();~~ ~~Console.ReadLine();~~ } } } ~~</lang>~~ ~~Output:~~ ~~<pre> X 1 2 3 4 5 6 7 8 9 10 11 12~~ ~~___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___~~ ~~1 1 2 3 4 5 6 7 8 9 10 11 12~~ ~~2 4 6 8 10 12 14 16 18 20 22 24~~ ~~3 9 12 15 18 21 24 27 30 33 36~~ ~~4 16 20 24 28 32 36 40 44 48~~ ~~5 25 30 35 40 45 50 55 60~~ ~~6 36 42 48 54 60 66 72~~ ~~7 49 56 63 70 77 84~~ ~~8 64 72 80 88 96~~ ~~9 81 90 99 108~~ ~~10 100 110 120~~ ~~11 121 132~~ ~~12 144~~ </pre> =={{header\|Chef}}== <~~lang~~syntaxhighlight lang="chef">Multigrain Bread. Prints out a multiplication table. Line 524 ⟶ 2,704: Pour contents of the 2nd mixing bowl into the 2nd baking dish. Serves 2.</~~lang~~syntaxhighlight> {{out}} ~~Output:~~ <pre> x 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 Line 543 ⟶ 2,723: =={{header\|Clojure}}== This is more generalized. ~~Any size can be used and the table will be formatted appropriately.~~ Any size can be used and the table will be formatted appropriately. ~~<lang lisp>(let [size 12~~ <syntaxhighlight lang="lisp">(let [size 12 trange (range 1 (inc size)) fmt-width (+ (.length (str (* size size))) 1) Line 557 ⟶ 2,738: (for [j trange] j))))))] (println s))) </syntaxhighlight> ~~</lang>~~ {{out}} ~~Output:~~ <pre> 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 Line 575 ⟶ 2,756: </pre> =={{header\|~~CoffeeScript~~COBOL}}== <syntaxhighlight lang="cobol"> identification division. ~~<lang coffeescript>~~ program-id. multiplication-table. ~~pad = (s, n=4, c=' ') ->~~ ~~s = s.toString()~~ ~~result = ''~~ ~~padding = n - s.length~~ ~~while result.length < padding~~ ~~result += c~~ ~~result + s~~ environment division. configuration section. repository. function all intrinsic. data division. working-storage section. 01 multiplication. 05 rows occurs 12 times. 10 colm occurs 12 times. 15 num pic 999. 77 cand pic 99. 77 ier pic 99. 77 ind pic z9. 77 show pic zz9. procedure division. sample-main. perform varying cand from 1 by 1 until cand greater than 12 after ier from 1 by 1 until ier greater than 12 multiply cand by ier giving num(cand, ier) end-perform perform varying cand from 1 by 1 until cand greater than 12 move cand to ind display "x " ind "\| " with no advancing perform varying ier from 1 by 1 until ier greater than 12 if ier greater than or equal to cand then move num(cand, ier) to show display show with no advancing if ier equal to 12 then display "\|" else display space with no advancing end-if else display " " with no advancing end-if end-perform end-perform goback. end program multiplication-table. </syntaxhighlight> {{out}} <pre>prompt$ cobc -xj multiplication-table.cob x 1\| 1 2 3 4 5 6 7 8 9 10 11 12\| x 2\| 4 6 8 10 12 14 16 18 20 22 24\| x 3\| 9 12 15 18 21 24 27 30 33 36\| x 4\| 16 20 24 28 32 36 40 44 48\| x 5\| 25 30 35 40 45 50 55 60\| x 6\| 36 42 48 54 60 66 72\| x 7\| 49 56 63 70 77 84\| x 8\| 64 72 80 88 96\| x 9\| 81 90 99 108\| x 10\| 100 110 120\| x 11\| 121 132\| x 12\| 144\| </pre> =={{header\|CoffeeScript}}== <syntaxhighlight lang="coffeescript"> print_multiplication_tables = (n) -> width = 4 pad = (s, n=width, c=' ') -> s = s.toString() result = '' padding = n - s.length while result.length < padding result += c result + s s = pad('') + '\|' for i in [1..n] Line 607 ⟶ 2,853: print_multiplication_tables 12 </syntaxhighlight> ~~</lang>~~ ~~output~~ {{out}} ~~<lang>~~ <pre> > coffee multiply.coffee \| 1 2 3 4 5 6 7 8 9 10 11 12 Line 625 ⟶ 2,872: 11\| 121 132 12\| 144 </~~lang~~pre> =={{header\|Common Lisp}}== <~~lang~~syntaxhighlight lang="lisp"> (do ((m 0 (if (= 12 m) 0 (1+ m))) (n 0 (if (= 12 m) (1+ n) n))) Line 646 ⟶ 2,892: (format t "~4,D" (* m n)) (format t " ")))))) </syntaxhighlight> ~~</lang>~~ Output: <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|D}}== {{trans\|PicoLisp}} ~~<lang d>import std.stdio, std.array;~~ <syntaxhighlight lang="d">void main() { import std.stdio, std.array, std.range, std.algorithm; enum n = 12; ~~void main() {~~ writefln(" %(%4d%)\n%s", iota(1, n+1), "-".replicate(4n + 4)); ~~enum int max = 12;~~ ~~write~~foreach ("immutable y; \|1 ".. n + 1); writefln("%4d" ~ " ".replicate(4 * (y - 1)) ~ "%(%4d%)", y, ~~foreach (row; 1 .. max+1)~~ ~~writef~~ iota(~~"%4d"~~y, ~~row~~n + 1).map!(x => x * y)); }</syntaxhighlight> ~~writeln();~~ {{out}} ~~writeln("--+-", "-".replicate(max * 4));~~ <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ~~foreach (row; 1 .. max+1) {~~ ---------------------------------------------------- ~~writef("%2d", row);~~ 1 1 2 3 4 5 6 7 8 9 10 11 12 ~~write("\| ");~~ 2 4 6 8 10 12 14 16 18 20 22 24 ~~foreach (column; 1 .. max+1) {~~ 3 if ~~(column~~ <9 ~~row)~~ 12 15 18 21 24 27 30 33 36 4 ~~write("~~ 16 20 ~~");~~ 24 28 32 36 40 44 48 5 ~~else~~ 25 30 35 40 45 50 55 60 6 ~~writef("%4d",~~ ~~row~~ * ~~column);~~ 36 42 48 54 60 66 72 7 49 56 63 70 77 84 } 8 64 72 80 88 96 ~~writeln();~~ 9 81 90 99 108 } 10 100 110 120 ~~}</lang>~~ 11 121 132 ~~Output:~~ ~~<pre>~~ \|12 1 2 3 4 5 6 7 8 9 10 11 12 144</pre> ~~--+-------------------------------------------------~~ =={{header\|DCL}}== ~~1\| 1 2 3 4 5 6 7 8 9 10 11 12~~ <syntaxhighlight lang="dcl">$ max = 12 ~~2\| 4 6 8 10 12 14 16 18 20 22 24~~ $ h = f$fao( "!4* " ) ~~3\| 9 12 15 18 21 24 27 30 33 36~~ $ r = 0 ~~4\| 16 20 24 28 32 36 40 44 48~~ $ loop1: ~~5\| 25 30 35 40 45 50 55 60~~ $ o = "" ~~6\| 36 42 48 54 60 66 72~~ $ c = 0 ~~7\| 49 56 63 70 77 84~~ $ loop2: ~~8\| 64 72 80 88 96~~ $ if r .eq. 0 then $ h = h + f$fao( "!4SL", c ) ~~9\| 81 90 99 108~~ $ p = r * c ~~10\| 100 110 120~~ $ if c .ge. r ~~11\| 121 132~~ $ then ~~12\| 144</pre>~~ $ o = o + f$fao( "!4SL", p ) $ else $ o = o + f$fao( "!4* " ) $ endif $ c = c + 1 $ if c .le. max then $ goto loop2 $ if r .eq. 0 $ then $ write sys$output h $ n = 4 * ( max + 2 ) $ write sys$output f$fao( "!''n-" ) $ endif $ write sys$output f$fao( "!4SL", r ) + o $ r = r + 1 $ if r .le. max then $ goto loop1</syntaxhighlight> {{out}} <pre>$ @multiplication_tables 0 1 2 3 4 5 6 7 8 9 10 11 12 -------------------------------------------------------- 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Delphi}}== {{trans\|DWScript}} <~~lang~~syntaxhighlight lang="delphi">program MultiplicationTables; {$APPTYPE CONSOLE} Line 717 ⟶ 3,016: Writeln; end; end.</~~lang~~syntaxhighlight> =={{header\|Draco}}== <syntaxhighlight lang="draco">/ Print N-by-N multiplication table / proc nonrec multab(byte n) void: byte i,j; / write header / write(" \|"); for i from 1 upto n do write(i:4) od; writeln(); write("----+"); for i from 1 upto n do write("----") od; writeln(); / write lines / for i from 1 upto n do write(i:4, "\|"); for j from 1 upto n do if i <= j then write(ij:4) else write(" ") fi od; writeln() od corp /* Print 12-by-12 multiplication table / proc nonrec main() void: multab(12) corp</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ----+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|DWScript}}== <~~lang~~syntaxhighlight lang="delphi">const size = 12; var row, col : Integer; Line 739 ⟶ 3,081: PrintLn(''); end; </syntaxhighlight> ~~</lang>~~ =={{header\|E}}== <~~lang~~syntaxhighlight lang="e"> def size := 12 println(`{\|style="border-collapse: collapse; text-align: right;"`) println(`\|`) Line 756 ⟶ 3,098: } } println("\|}")</~~lang~~syntaxhighlight> ~~Targets MediaWiki markup. Output:~~ Targets MediaWiki markup. {{out}} <blockquote> {\|style="border-collapse: collapse; text-align: right;" Line 945 ⟶ 3,287: \|} </blockquote> =={{header\|EasyLang}}== <syntaxhighlight lang="easylang"> n = 12 numfmt 0 4 write " " for i = 1 to n write i . print "" write " " for i = 1 to n write "----" . print "" for i = 1 to n write i write "\|" for j = 1 to n if j < i write " " else write i j . . print "" . </syntaxhighlight> =={{header\|EchoLisp}}== <syntaxhighlight lang="scheme"> (lib 'matrix) (define (mtable i j) (cond ((and (zero? i) (zero? j)) "😅") ((= i 0) j) ((= j 0) i) ((>= j i ) (* i j )) (else " "))) (array-print (build-array 13 13 mtable)) </syntaxhighlight> {{out}} <pre> 😅 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Elixir}}== <syntaxhighlight lang="elixir">defmodule RC do def multiplication_tables(n) do IO.write " X \|" Enum.each(1..n, fn i -> :io.fwrite("~4B", [i]) end) IO.puts "\n---+" <> String.duplicate("----", n) Enum.each(1..n, fn j -> :io.fwrite("~2B \|", [j]) Enum.each(1..n, fn i -> if i<j, do: (IO.write " "), else: :io.fwrite("~4B", [ij]) end) IO.puts "" end) end end RC.multiplication_tables(12)</syntaxhighlight> {{out}} <pre> X \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> =={{header\|EMal}}== {{trans\|TypeScript}} <syntaxhighlight lang="emal"> int NUMBER = 12 for int j = 1; j <= NUMBER; ++j do write((text!j).padStart(3, " ") + " ") end writeLine() writeLine("----" NUMBER + "+") for int i = 1; i <= NUMBER; i++ for int j = 1; j <= NUMBER; ++j write(when(j < i, " ", (text!(i * j)).padStart(3, " ") + " ")) end writeLine("\| " + (text!i).padStart(2, " ")) end </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> =={{header\|Erlang}}== <syntaxhighlight lang="erlang"> -module( multiplication_tables ). -export( [print_upto/1, task/0, upto/1] ). print_upto( N ) -> Upto_tuples = [{X, {Y, Sum}} \|\| {X, Y, Sum} <- upto(N)], io:fwrite( " " ), [io:fwrite( "~5B", [X]) \|\| X <- lists:seq(1, N)], io:nl(), io:nl(), [print_upto(X, proplists:get_all_values(X, Upto_tuples)) \|\| X <- lists:seq(1, N)]. task() -> print_upto( 12 ). upto( N ) -> [{X, Y, XY} \|\| X <- lists:seq(1, N), Y <- lists:seq(1, N), Y >= X]. print_upto( N, Uptos ) -> io:fwrite( "~2B", [N] ), io:fwrite( "~s", [5(N - 1), " "] ), [io:fwrite("~5B", [Sum]) \|\| {_Y, Sum} <- Uptos], io:nl(). </syntaxhighlight> {{out}} <pre> 25> multiplication_tables:task(). 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Euphoria}}== <~~lang~~syntaxhighlight ~~Euphoria~~lang="euphoria">puts(1," x") for i = 1 to 12 do printf(1," %3d",i) Line 964 ⟶ 3,481: end for puts(1,'\n') end for</~~lang~~syntaxhighlight> {{out}} ~~Output:~~ <pre> x 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 Line 980 ⟶ 3,498: 11 121 132 12 144 </pre> =={{header\|Excel}}== ===LAMBDA=== Binding the name FNOVERHALFCARTESIANPRODUCT to the following lambda expression in the Name Manager of the Excel WorkBook: (See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function]) {{Works with\|Office 365 betas 2021}} <syntaxhighlight lang="lisp">FNOVERHALFCARTESIANPRODUCT =LAMBDA(f, LAMBDA(n, LET( ixs, SEQUENCE(n, n, 1, 1), REM, "1-based indices.", x, 1 + MOD(ixs - 1, n), y, 1 + QUOTIENT(ixs - 1, n), IF(x >= y, f(x)(y), "" ) ) ) )</syntaxhighlight> and also assuming the following generic bindings in the Name Manager for the WorkBook: <syntaxhighlight lang="lisp">MUL =LAMBDA(a, LAMBDA(b, a b)) POW =LAMBDA(n, LAMBDA(e, POWER(n, e) ) )</syntaxhighlight> (The single formula in cell '''B2''' below populates the whole 1212 grid) {{Out}} {\| class="wikitable" \|- \|\|\|style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"\|fx ! colspan="13" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"\|=FNOVERHALFCARTESIANPRODUCT( MUL )(12) \|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;" \| \| A \| B \| C \| D \| E \| F \| G \| H \| I \| J \| K \| L \| M \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 1 \| xy \| colspan="12" \| applied over every unique pair in a cartesian product of [1..12] with itself \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 2 \| style="text-align:right; font-weight:bold" \| 1 \| style="text-align:right; background-color:#cbcefb" \| 1 \| style="text-align:right" \| 2 \| style="text-align:right" \| 3 \| style="text-align:right" \| 4 \| style="text-align:right" \| 5 \| style="text-align:right" \| 6 \| style="text-align:right" \| 7 \| style="text-align:right" \| 8 \| style="text-align:right" \| 9 \| style="text-align:right" \| 10 \| style="text-align:right" \| 11 \| style="text-align:right" \| 12 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 3 \| style="text-align:right; font-weight:bold" \| 2 \| \| style="text-align:right" \| 4 \| style="text-align:right" \| 6 \| style="text-align:right" \| 8 \| style="text-align:right" \| 10 \| style="text-align:right" \| 12 \| style="text-align:right" \| 14 \| style="text-align:right" \| 16 \| style="text-align:right" \| 18 \| style="text-align:right" \| 20 \| style="text-align:right" \| 22 \| style="text-align:right" \| 24 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 4 \| style="text-align:right; font-weight:bold" \| 3 \| \| \| style="text-align:right" \| 9 \| style="text-align:right" \| 12 \| style="text-align:right" \| 15 \| style="text-align:right" \| 18 \| style="text-align:right" \| 21 \| style="text-align:right" \| 24 \| style="text-align:right" \| 27 \| style="text-align:right" \| 30 \| style="text-align:right" \| 33 \| style="text-align:right" \| 36 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 5 \| style="text-align:right; font-weight:bold" \| 4 \| \| \| \| style="text-align:right" \| 16 \| style="text-align:right" \| 20 \| style="text-align:right" \| 24 \| style="text-align:right" \| 28 \| style="text-align:right" \| 32 \| style="text-align:right" \| 36 \| style="text-align:right" \| 40 \| style="text-align:right" \| 44 \| style="text-align:right" \| 48 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 6 \| style="text-align:right; font-weight:bold" \| 5 \| \| \| \| \| style="text-align:right" \| 25 \| style="text-align:right" \| 30 \| style="text-align:right" \| 35 \| style="text-align:right" \| 40 \| style="text-align:right" \| 45 \| style="text-align:right" \| 50 \| style="text-align:right" \| 55 \| style="text-align:right" \| 60 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 7 \| style="text-align:right; font-weight:bold" \| 6 \| \| \| \| \| \| style="text-align:right" \| 36 \| style="text-align:right" \| 42 \| style="text-align:right" \| 48 \| style="text-align:right" \| 54 \| style="text-align:right" \| 60 \| style="text-align:right" \| 66 \| style="text-align:right" \| 72 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 8 \| style="text-align:right; font-weight:bold" \| 7 \| \| \| \| \| \| \| style="text-align:right" \| 49 \| style="text-align:right" \| 56 \| style="text-align:right" \| 63 \| style="text-align:right" \| 70 \| style="text-align:right" \| 77 \| style="text-align:right" \| 84 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 9 \| style="text-align:right; font-weight:bold" \| 8 \| \| \| \| \| \| \| \| style="text-align:right" \| 64 \| style="text-align:right" \| 72 \| style="text-align:right" \| 80 \| style="text-align:right" \| 88 \| style="text-align:right" \| 96 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 10 \| style="text-align:right; font-weight:bold" \| 9 \| \| \| \| \| \| \| \| \| style="text-align:right" \| 81 \| style="text-align:right" \| 90 \| style="text-align:right" \| 99 \| style="text-align:right" \| 108 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 11 \| style="text-align:right; font-weight:bold" \| 10 \| \| \| \| \| \| \| \| \| \| style="text-align:right" \| 100 \| style="text-align:right" \| 110 \| style="text-align:right" \| 120 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 12 \| style="text-align:right; font-weight:bold" \| 11 \| \| \| \| \| \| \| \| \| \| \| style="text-align:right" \| 121 \| style="text-align:right" \| 132 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 13 \| style="text-align:right; font-weight:bold" \| 12 \| \| \| \| \| \| \| \| \| \| \| \| style="text-align:right" \| 144 \|} {\| class="wikitable" \|- \|\|\|style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"\|fx ! colspan="13" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"\|=FNOVERHALFCARTESIANPRODUCT( POW )(12) \|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;" \| \| A \| B \| C \| D \| E \| F \| G \| H \| I \| J \| K \| L \| M \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 1 \| x^y \| COLSPAN="12" \| applied over every unique pair in a cartesian product of [1..12] with itself \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 2 \| style="text-align:right; font-weight:bold" \| 1 \| style="text-align:right; background-color:#cbcefb" \| 1 \| style="text-align:right" \| 2 \| style="text-align:right" \| 3 \| style="text-align:right" \| 4 \| style="text-align:right" \| 5 \| style="text-align:right" \| 6 \| style="text-align:right" \| 7 \| style="text-align:right" \| 8 \| style="text-align:right" \| 9 \| style="text-align:right" \| 10 \| style="text-align:right" \| 11 \| style="text-align:right" \| 12 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 3 \| style="text-align:right; font-weight:bold" \| 2 \| \| style="text-align:right" \| 4 \| style="text-align:right" \| 9 \| style="text-align:right" \| 16 \| style="text-align:right" \| 25 \| style="text-align:right" \| 36 \| style="text-align:right" \| 49 \| style="text-align:right" \| 64 \| style="text-align:right" \| 81 \| style="text-align:right" \| 100 \| style="text-align:right" \| 121 \| style="text-align:right" \| 144 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 4 \| style="text-align:right; font-weight:bold" \| 3 \| \| \| style="text-align:right" \| 27 \| style="text-align:right" \| 64 \| style="text-align:right" \| 125 \| style="text-align:right" \| 216 \| style="text-align:right" \| 343 \| style="text-align:right" \| 512 \| style="text-align:right" \| 729 \| style="text-align:right" \| 1000 \| style="text-align:right" \| 1331 \| style="text-align:right" \| 1728 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 5 \| style="text-align:right; font-weight:bold" \| 4 \| \| \| \| style="text-align:right" \| 256 \| style="text-align:right" \| 625 \| style="text-align:right" \| 1296 \| style="text-align:right" \| 2401 \| style="text-align:right" \| 4096 \| style="text-align:right" \| 6561 \| style="text-align:right" \| 10000 \| style="text-align:right" \| 14641 \| style="text-align:right" \| 20736 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 6 \| style="text-align:right; font-weight:bold" \| 5 \| \| \| \| \| style="text-align:right" \| 3125 \| style="text-align:right" \| 7776 \| style="text-align:right" \| 16807 \| style="text-align:right" \| 32768 \| style="text-align:right" \| 59049 \| style="text-align:right" \| 100000 \| style="text-align:right" \| 161051 \| style="text-align:right" \| 248832 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 7 \| style="text-align:right; font-weight:bold" \| 6 \| \| \| \| \| \| style="text-align:right" \| 46656 \| style="text-align:right" \| 117649 \| style="text-align:right" \| 262144 \| style="text-align:right" \| 531441 \| style="text-align:right" \| 1000000 \| style="text-align:right" \| 1771561 \| style="text-align:right" \| 2985984 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 8 \| style="text-align:right; font-weight:bold" \| 7 \| \| \| \| \| \| \| style="text-align:right" \| 823543 \| style="text-align:right" \| 2097152 \| style="text-align:right" \| 4782969 \| style="text-align:right" \| 10000000 \| style="text-align:right" \| 19487171 \| style="text-align:right" \| 35831808 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 9 \| style="text-align:right; font-weight:bold" \| 8 \| \| \| \| \| \| \| \| style="text-align:right" \| 16777216 \| style="text-align:right" \| 43046721 \| style="text-align:right" \| 100000000 \| style="text-align:right" \| 214358881 \| style="text-align:right" \| 429981696 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 10 \| style="text-align:right; font-weight:bold" \| 9 \| \| \| \| \| \| \| \| \| style="text-align:right" \| 387420489 \| style="text-align:right" \| 1000000000 \| style="text-align:right" \| 2357947691 \| style="text-align:right" \| 5159780352 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 11 \| style="text-align:right; font-weight:bold" \| 10 \| \| \| \| \| \| \| \| \| \| style="text-align:right" \| 10000000000 \| style="text-align:right" \| 25937424601 \| style="text-align:right" \| 61917364224 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 12 \| style="text-align:right; font-weight:bold" \| 11 \| \| \| \| \| \| \| \| \| \| \| style="text-align:right" \| 285311670611 \| style="text-align:right" \| 743008370688 \|- \| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" \| 13 \| style="text-align:right; font-weight:bold" \| 12 \| \| \| \| \| \| \| \| \| \| \| \| style="text-align:right" \| 8916100448256 \|} =={{header\|F Sharp\|F#}}== Translation of C# <syntaxhighlight lang="fsharp"> open System let multTable () = Console.Write (" X".PadRight (4)) for i = 1 to 12 do Console.Write ((i.ToString "####").PadLeft 4) Console.Write "\n ___" for i = 1 to 12 do Console.Write " ___" Console.WriteLine () for row = 1 to 12 do Console.Write (row.ToString("###").PadLeft(3).PadRight(4)) for col = 1 to 12 do if row <= col then Console.Write ((row * col).ToString("###").PadLeft(4)) else Console.Write ("".PadLeft 4) Console.WriteLine () Console.WriteLine () Console.ReadKey () \|> ignore multTable () </syntaxhighlight> {{out}} <pre> X 1 2 3 4 5 6 7 8 9 10 11 12 ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Factor}}== <~~lang~~syntaxhighlight lang="factor">USING: io kernel math math.parser math.ranges sequences ; IN: multiplication-table Line 998 ⟶ 4,010: " +" write 12 [ "----" write ] times nl 1 12 [a,b] [ print-row ] each ;</~~lang~~syntaxhighlight> <pre> Line 1,018 ⟶ 4,030: =={{header\|FALSE}}== <~~lang~~syntaxhighlight lang="false">[$100\>[" "]?$10\>[" "]?." "]p: [$p;! m: 2[$m;\>][" "1+]# [$13\>][$m;p;!1+]#%" "]l: 1[$13\>][$l;!1+]#%</~~lang~~syntaxhighlight> =={{header\|Fantom}}== <~~lang~~syntaxhighlight lang="fantom"> class Main { Line 1,047 ⟶ 4,059: } } </syntaxhighlight> ~~</lang>~~ =={{header\|Forth}}== <~~lang~~syntaxhighlight lang="forth"> : multiplication-table cr 2 spaces 13 2 do i 4 u.r loop Line 1,060 ⟶ 4,072: loop loop ; </syntaxhighlight> ~~</lang>~~ =={{header\|Fortran}}== {{works with\|Fortran\|90 and later}} <~~lang~~syntaxhighlight lang="fortran">program multtable implicit none Line 1,082 ⟶ 4,094: end do end program multtable</~~lang~~syntaxhighlight> ===Traditional approach=== The usual style is to write whole lines at a go, traditionally to fast lineprinters. Producing a tabular layout is easy (four characters per field to allow room to print 144 with a space separator), the difficulty lies in having blank parts at the start of the line followed by results. Having results followed by blanks is normal. The simplest way to achieve this would be to have a CHARACTER4 function IFMT4(n) that returns four spaces for n <= 0, otherwise the digits, similar to the above example. But the plan is to write a line of such function calls at a go (with n = 0 for unwanted results), and alas, very few Fortran implementations allow recursive use of the formatted I/O system - here one level would be inside the function to produce the result for N > 0, and the other is the original WRITE statement that invokes the function. So instead, write the table by first writing a line to a CHARACTER variable then blanking out the unwanted part. <syntaxhighlight lang="fortran"> Cast forth a twelve times table, suitable for chanting at school. INTEGER I,J !Steppers. CHARACTER52 ALINE !Scratchpad. WRITE(6,1) (I,I = 1,12) !Present the heading. 1 FORMAT (" ×\|",12I4,/," --+",12("----")) !Alas, can't do overprinting with underlines now. DO 3 I = 1,12 !Step down the lines. WRITE (ALINE,2) I,(IJ, J = 1,12) !Prepare one line. 2 FORMAT (I3,"\|",12I4) !Aligned with the heading. ALINE(5:1 + 4I) = "" !Scrub the unwanted part. 3 WRITE (6,"(A)") ALINE !Print the text. END !"One one is one! One two is two! One three is three!... </syntaxhighlight> Output in the same style as above, with underlining unavailable: those who have used a lineprinter's overprint facility to properly underline find the flabby modern requirement of a second line vexing, but, few output devices support underlining in so easy a way. ×\| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 Going to the trouble of preparing results, and then blanking some might seem a little too crude. An alternative would be to use a different FORMAT statement for each line of output. But, a collection of a dozen output statements hardly represents a programming solution. Instead, create and then use the text of FORMAT statements, as follows. Notice that there are ''no reserved words'' in Fortran. <syntaxhighlight lang="fortran"> Cast forth a twelve times table, suitable for chanting at school. INTEGER I,J !Steppers. CHARACTER16 FORMAT !Scratchpad. WRITE(6,1) (I,I = 1,12) !Present the heading. 1 FORMAT (" ×\|",12I4,/," --+",12("----")) !Alas, can't do overprinting with underlines now. DO 3 I = 1,12 !Step down the lines. WRITE (FORMAT,2) (I - 1)4,13 - I !Spacing for omitted fields, count of wanted fields. 2 FORMAT ("(I3,'\|',",I0,"X,",I0,"I4)") !The format of the FORMAT statement. 3 WRITE (6,FORMAT) I,(IJ, J = I,12) !Use it. END !"One one is one! One two is two! One three is three!... </syntaxhighlight> The output is the same, so instead, here are the generated FORMAT texts: (I3,'\|',0X,12I4) (I3,'\|',4X,11I4) (I3,'\|',8X,10I4) (I3,'\|',12X,9I4) (I3,'\|',16X,8I4) (I3,'\|',20X,7I4) (I3,'\|',24X,6I4) (I3,'\|',28X,5I4) (I3,'\|',32X,4I4) (I3,'\|',36X,3I4) (I3,'\|',40X,2I4) (I3,'\|',44X,1I4) A zero count for spacing (the 0X, due to there being no omitted results on the first line) was possibly a weak point, but if not handled, the fallback position would have been to arrange that instead of 12I4 format, the first would be 1X,I3. Some fortrans offer an extension to FORMAT statements, whereby a variable can appear in place of an integer constant, thus instead of say FORMAT (12I4) there could be FORMAT (<n>I4) for example. Then, during the interpretation of the FORMAT text, the current value of variable ''n'' would be accessed. Note that this is on-the-fly: READ(in,"(I2,<N>I4)") N,(A(I),I = 1,N) would read N as a two-digit integer, and, as the READ statement executes further, use that value of N both in the FORMAT text's interpretation and in the further processing of the READ statement. ===VAX FORTRAN=== <syntaxhighlight lang="fortran"> PROGRAM TABLES IMPLICIT NONE C C Produce a formatted multiplication table of the kind memorised by rote C when in primary school. Only print the top half triangle of products. C C 23 Nov 15 - 0.1 - Adapted from original for VAX FORTRAN - MEJT C INTEGER I,J,K ! Counters. CHARACTER32 S ! Buffer for format specifier. C K=12 C WRITE(S,1) K,K 1 FORMAT(8H(4H0 \|,,I2.2,11HI4,/,4H --+,I2.2,9H(4H----))) WRITE(6,S) (I,I = 1,K) ! Print heading. C DO 3 I=1,K ! Step down the lines. WRITE(S,2) (I-1)4+1,K ! Update format string. 2 FORMAT(12H(1H ,I2,1H\|,,I2.2,5HX,I3,,I2.2,3HI4),8X) ! Format string includes an explicit carridge control character. WRITE(6,S) I,(IJ, J = I,K) ! Use format to print row with leading blanks, unused fields are ignored. 3 CONTINUE C END </syntaxhighlight>Based on the above code but with a slight modification as VAX FORTRAN doesn't allow zero width fields in a format statement. The number of rows and columns can also be altered by modifying the value of K which must be in the range 1 - 25. ===FORTRAN-IV=== <syntaxhighlight lang="fortran"> PROGRAM TABLES C C Produce a formatted multiplication table of the kind memorised by rote C when in primary school. Only print the top half triangle of products. C C 23 Nov 15 - 0.1 - Adapted from original for VAX FORTRAN - MEJT C 24 Nov 15 - 0.2 - FORTRAN IV version adapted from VAX FORTRAN and C compiled using Microsoft FORTRAN-80 - MEJT C DIMENSION K(12) DIMENSION A(6) DIMENSION L(12) C COMMON //A EQUIVALENCE (A(1),L(1)) C DATA A/'(1H ',',I2,','1H\|,','01X,','I3,1','2I4)'/ C WRITE(1,1) (I,I=1,12) 1 FORMAT(4H0 \|,12I4,/,4H --+12(4H----)) C C Overlaying the format specifier with an integer array makes it possibe C to modify the number of blank spaces. The number of blank spaces is C stored as two consecuitive ASCII characters that overlay on the C integer value in L(7) in the ordr low byte, high byte. C DO 3 I=1,12 L(7)=(48+(I4-3)-((I4-3)/10)10)256+48+((I4-3)/10) DO 2 J=1,12 K(J)=IJ 2 CONTINUE WRITE(1,A)I,(K(J), J = I,12) 3 CONTINUE C END</syntaxhighlight>Rather more changes are needed to produce the same result, in particular we cannot modify the format specifier directly and have to rely on overlaying it with an integer array and calculating the ASCII values needed for each byte we need to modify. Nested implicit DO loops are allowed, but not used as it isn't possible to compute K on the fly so we have to calculate (and store) the results for each row before printing it. Note also that the unit numbers for the output devices are different and when using Hollerith strings to define values in a DATA statement the size of each string must match the size of the data type. ===Microsoft FORTRAN-80=== The use of a non standard(?) BYTE data type available in Microsoft FORTRAN-80 makes it easier to understand what is going on. <syntaxhighlight lang="fortran"> PROGRAM TABLES C C Produce a formatted multiplication table of the kind memorised by rote C when in primary school. Only print the top half triangle of products. C C 23 Nov 15 - 0.1 - Adapted from original for VAX FORTRAN - MEJT C 24 Nov 15 - 0.2 - FORTRAN IV version adapted from VAX FORTRAN and C compiled using Microsoft FORTRAN-80 - MEJT C 25 Nov 15 - 0.3 - Microsoft FORTRAN-80 version using a BYTE array C which makes it easier to understand what is going C on. - MEJT C BYTE A DIMENSION A(24) DIMENSION K(12) C DATA A/'(','1','H',' ',',','I','2',',','1','H','\|',',', + '0','1','X',',','I','3',',','1','1','I','4',')'/ C C Print a heading and (try to) underline it. C WRITE(1,1) (I,I=1,12) 1 FORMAT(4H \|,12I4,/,4H --+12(4H----)) DO 3 I=1,12 A(13)=48+((I4-3)/10) A(14)=48+(I4-3)-((I4-3)/10)10 DO 2 J=1,12 K(J)=IJ 2 CONTINUE WRITE(1,A)I,(K(J), J = I,12) 3 CONTINUE C END</syntaxhighlight>Inserting the following two lines before the inner DO loop will print the format specifier used to print each row of the table.<syntaxhighlight lang="fortran"> WRITE(1,4) (A(J), J = 1,24) 4 FORMAT(1x,24A1)</syntaxhighlight>Running the program produces the following output<pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|Frink}}== <syntaxhighlight lang="frink">a = makeArray[[13,13], {\|a,b\| a==0 ? b : (b==0 ? a : (a<=b ? ab : ""))}] formatTable[a,"right"]</syntaxhighlight> {{out}} <pre> 0 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Go}}== <syntaxhighlight lang="go"> ~~<lang go>~~ package main Line 1,112 ⟶ 4,325: fmt.Println("") } </syntaxhighlight> ~~</lang>~~ =={{header\|Groovy}}== Solution: <syntaxhighlight lang="groovy">def printMultTable = { size = 12 -> assert size > 1 // factor1 line print ' \|'; (1..size).each { f1 -> printf('%4d', f1) }; println '' // dividing line print '--+'; (1..size).each { printf('----', it) }; println '' // factor2 result lines (1..size).each { f2 -> printf('%2d\|', f2) (1..<f2).each{ print ' ' } (f2..size).each{ f1 -> printf('%4d', f1f2) } println '' } } printMultTable()</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|Haskell}}== <~~lang~~syntaxhighlight lang="haskell">import ~~Control~~Data.~~Monad~~Maybe (fromMaybe, maybe) ~~import Text.Printf~~ ------------------- MULTIPLICATION TABLE ----------------- ~~main = do~~ ~~putStrLn $ " x" ++ concatMap fmt [1..12]~~ mulTable :: [Int] -> [[Maybe Int]] ~~zipWithM_ f [1..12] $ iterate (" " ++) ""~~ mulTable xs = ~~where f n s = putStrLn $ fmt n ++ s ++ concatMap (fmt . (n)) [n..12]~~ (Nothing : labels) : ~~fmt n = printf "%4d" (n :: Int)</lang>~~ zipWith (:) labels [[upperMul x y \| y <- xs] \| x <- xs] where labels = Just <$> xs upperMul x y \| x > y = Nothing \| otherwise = Just (x y) --------------------------- TEST ------------------------- main :: IO () main = putStrLn . unlines $ showTable . mulTable <$> [ [13 .. 20], [1 .. 12], [95 .. 100] ] ------------------------ FORMATTING ---------------------- showTable :: [[Maybe Int]] -> String showTable xs = unlines $ head rows : [] : tail rows where w = succ $ (length . show) (fromMaybe 0 $ (last . last) xs) gap = replicate w ' ' rows = (maybe gap (rjust w ' ' . show) =<<) <$> xs rjust n c = (drop . length) <> (replicate n c <>)</syntaxhighlight> {{Out}} <pre> 13 14 15 16 17 18 19 20 13 169 182 195 208 221 234 247 260 14 196 210 224 238 252 266 280 15 225 240 255 270 285 300 16 256 272 288 304 320 17 289 306 323 340 18 324 342 360 19 361 380 20 400 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 95 96 97 98 99 100 95 9025 9120 9215 9310 9405 9500 96 9216 9312 9408 9504 9600 97 9409 9506 9603 9700 98 9604 9702 9800 99 9801 9900 100 10000</pre> Or, more roughly and directly: <syntaxhighlight lang="haskell">import Data.List (groupBy) import Data.Function (on) import Control.Monad (join) main :: IO () main = mapM_ print $ fmap (uncurry ()) <$> groupBy (on (==) fst) (filter (uncurry (>=)) $ join ((<>) . fmap (,)) [1 .. 12])</syntaxhighlight> {{Out}} <pre>[1] [2,4] [3,6,9] [4,8,12,16] [5,10,15,20,25] [6,12,18,24,30,36] [7,14,21,28,35,42,49] [8,16,24,32,40,48,56,64] [9,18,27,36,45,54,63,72,81] [10,20,30,40,50,60,70,80,90,100] [11,22,33,44,55,66,77,88,99,110,121] [12,24,36,48,60,72,84,96,108,120,132,144]</pre> =={{header\|hexiscript}}== <syntaxhighlight lang="hexiscript">fun format n l let n tostr n while len n < l; let n (" " + n); endwhile return n endfun print " \|" for let i 1; i <= 12; i++; print format i 4; endfor print "\n --+" for let i 1; i <= 12; i++; print "----"; endfor println "" for let i 1; i <= 12; i++ print format i 3 + "\|" for let j 1; j <= 12; j++ if j < i; print " " else print format (i j) 4; endif endfor println "" endfor</syntaxhighlight> =={{header\|HicEst}}== <~~lang~~syntaxhighlight ~~HicEst~~lang="hicest">WRITE(Row=1) " x 1 2 3 4 5 6 7 8 9 10 11 12" DO line = 1, 12 WRITE(Row=line+2, Format='i2') line Line 1,131 ⟶ 4,493: WRITE(Row=line+2, Column=4col, Format='i3') linecol ENDDO ENDDO</~~lang~~syntaxhighlight> =={{header\|HolyC}}== {{trans\|C}} <syntaxhighlight lang="holyc">U8 i, j, n = 12; for (j = 1; j <= n; j++) if (j != n) Print("%3d%c", j, ' '); else Print("%3d%c", j, '\n'); for (j = 0; j <= n; j++) if (j != n) Print("----"); else Print("+\n"); for (i = 1; i <= n; i++) { for (j = 1; j <= n; j++) if (j < i) Print(" "); else Print("%3d ", i * j); Print("\| %d\n", i); }</syntaxhighlight> =={{header\|Icon}} and {{header\|Unicon}}== <~~lang~~syntaxhighlight ~~Icon~~lang="icon">procedure main() lim := 13 wid := 5 Line 1,140 ⟶ 4,526: every (i := 1 to lim) & writes(right( i\|\|" \|" \| (j := 1 to lim, if j < i then "" else ij) \| "\n",wid)) # table content and triangle end </~~lang~~syntaxhighlight> The above example is a somewhat exaggerated example of contractions. The above example is a somewhat exaggerated example of contractions. In both cases 'every' is used to force all alternatives including row labels, column headings, content, line terminators. The upper triangle is produced by embedding an 'if' expression inside the object of an 'every' (normally an error prone construct which would malfunction if not carefully separated from the generators for 'i' and 'j' - an all too tempting possibility once you get into this mind set.) In both cases 'every' is used to force all alternatives including row labels, column headings, content, line terminators. The upper triangle is produced by embedding an 'if' expression inside the object of an 'every' (normally an error prone construct which would malfunction if not carefully separated from the generators for 'i' and 'j' - an all too tempting possibility once you get into this mind set.) {{out}} ~~Sample output:~~<pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 13 _____________________________________________________________________ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 13 Line 1,160 ⟶ 4,548: 12 \| 144 156 13 \| 169 </pre> =={{Header\|Insitux}}== <syntaxhighlight lang="insitux"> (var pad-num (comp str (pad-left " " 4))) (join "\n" (for y (range 1 13) (... str "x" (pad-num y) (for x (range 1 13) (if (> y x) " " (pad-num (* x y))))))) </syntaxhighlight> {{out}} <pre> x 1 1 2 3 4 5 6 7 8 9 10 11 12 x 2 4 6 8 10 12 14 16 18 20 22 24 x 3 9 12 15 18 21 24 27 30 33 36 x 4 16 20 24 28 32 36 40 44 48 x 5 25 30 35 40 45 50 55 60 x 6 36 42 48 54 60 66 72 x 7 49 56 63 70 77 84 x 8 64 72 80 88 96 x 9 81 90 99 108 x 10 100 110 120 x 11 121 132 x 12 144 </pre> =={{header\|J}}== <~~lang~~syntaxhighlight lang="j"> multtable=: <:/~ * /~ format=: 'b4.0' 8!:2 ] (('' ; ,.) ,. ({. ; ])@format@multtable) >:i.12 Line 1,180 ⟶ 4,596: │11│ 121 132│ │12│ 144│ └──┴────────────────────────────────────────────────┘</~~lang~~syntaxhighlight> That said, note that <code>/~</code> is the core primitive used to construct a multiplication table and this is a general technique so that, for example, <code>+/~</code> would make an addition table. The rest is just to make it look pretty (and to blank out the lower triangle -- we use a less than or equal table (<code><:/~</code>) to control that, and format zeros as spaces to blank them out). =={{header\|Java}}== <syntaxhighlight lang="java">public class MultiplicationTable { ~~<lang Java>~~ public static void main(String[] args) { ~~public class MulTable{~~ for (int i = 1; i <= 12; i++) ~~public static void main(String args[]){~~ ~~int~~ System.out.print("\t" + i,j); ~~for(i=1;i<=12;i++)~~ { ~~System.out.print("\t"+i);~~ } System.out.println(""); for (int i = 0; i < 100; i++) System.out.print("-"); System.out.println(""); for (int i = 1; i <= 12; i++) { System.out.print(~~""+~~i + "\|"); for(int j = 1; j <= 12; j++) { ifSystem.out.print(~~j<i~~"\t"); if (j >= ~~System.out.print("\t"~~i); ~~else~~ System.out.print("\t" + i j); ~~System.out.print("\t"+ij);~~ } System.out.println(""); } } }</syntaxhighlight> } {{out}} ~~</lang>~~ ~~Output:~~ <pre> 1 2 3 4 5 6 7 8 9 10 11 12 Line 1,230 ⟶ 4,640: =={{header\|JavaScript}}== ~~<lang html4strict><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">~~ === Unicode output === The following example works with any (modern) JavaScript runtime: <syntaxhighlight lang="javascript" lines> function timesTable(){ let output = ""; const size = 12; for(let i = 1; i <= size; i++){ output += i.toString().padStart(3); output += i !== size ? " " : "\n"; } for(let i = 0; i <= size; i++) output += i !== size ? "════" : "╕\n"; for(let i = 1; i <= size; i++){ for(let j = 1; j <= size; j++){ output += j < i ? " " : (i j).toString().padStart(3) + " "; } output += `│ ${i}\n`; } return output; } </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ════════════════════════════════════════════════╕ 1 2 3 4 5 6 7 8 9 10 11 12 │ 1 4 6 8 10 12 14 16 18 20 22 24 │ 2 9 12 15 18 21 24 27 30 33 36 │ 3 16 20 24 28 32 36 40 44 48 │ 4 25 30 35 40 45 50 55 60 │ 5 36 42 48 54 60 66 72 │ 6 49 56 63 70 77 84 │ 7 64 72 80 88 96 │ 8 81 90 99 108 │ 9 100 110 120 │ 10 121 132 │ 11 144 │ 12 </pre> === HTML tables === The following examples require a browser or browser-like environment: ====Imperative==== <syntaxhighlight lang="html4strict"><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <head> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" > <title>12 times table</title> <script type='text/javascript'> function multiplication_table(n, target) { var table = document.createElement('table'); Line 1,270 ⟶ 4,728: target.appendChild(table); } </script> <style type='text/css'> Line 1,281 ⟶ 4,738: <div id='target'></div> </body> </html></~~lang~~syntaxhighlight> ~~Outputs~~{{out}} (minus the style): <div><table><tr><th>x</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th><th>7</th><th>8</th><th>9</th><th>10</th><th>11</th><th>12</th></tr><tr><th>1</th><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td><td>11</td><td>12</td></tr><tr><th>2</th><td> </td><td>4</td><td>6</td><td>8</td><td>10</td><td>12</td><td>14</td><td>16</td><td>18</td><td>20</td><td>22</td><td>24</td></tr><tr><th>3</th><td> </td><td> </td><td>9</td><td>12</td><td>15</td><td>18</td><td>21</td><td>24</td><td>27</td><td>30</td><td>33</td><td>36</td></tr><tr><th>4</th><td> </td><td> </td><td> </td><td>16</td><td>20</td><td>24</td><td>28</td><td>32</td><td>36</td><td>40</td><td>44</td><td>48</td></tr><tr><th>5</th><td> </td><td> </td><td> </td><td> </td><td>25</td><td>30</td><td>35</td><td>40</td><td>45</td><td>50</td><td>55</td><td>60</td></tr><tr><th>6</th><td> </td><td> </td><td> </td><td> </td><td> </td><td>36</td><td>42</td><td>48</td><td>54</td><td>60</td><td>66</td><td>72</td></tr><tr><th>7</th><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td>49</td><td>56</td><td>63</td><td>70</td><td>77</td><td>84</td></tr><tr><th>8</th><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td>64</td><td>72</td><td>80</td><td>88</td><td>96</td></tr><tr><th>9</th><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td>81</td><td>90</td><td>99</td><td>108</td></tr><tr><th>10</th><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td>100</td><td>110</td><td>120</td></tr><tr><th>11</th><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td>121</td><td>132</td></tr><tr><th>12</th><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td> </td><td>144</td></tr></table></div> ====Functional==== ~~=={{header\|Liberty BASIC}}==~~ =====ES5===== ~~<lang lb>Print " \| 1 2 3 4 5 6 7 8 9 10 11 12"~~ <syntaxhighlight lang="javascript">(function (m, n) { ~~Print "--+------------------------------------------------------------"~~ // [m..n] function range(m, n) { return Array.apply(null, Array(n - m + 1)).map(function (x, i) { return m + i; }); } // Monadic bind (chain) for lists function mb(xs, f) { return [].concat.apply([], xs.map(f)); } var rng = range(m, n), lstTable = [['x'].concat( rng )] .concat(mb(rng, function (x) { return [[x].concat(mb(rng, function (y) { return y < x ? [''] : [x * y]; // triangle only }))]})); /* FORMATTING OUTPUT / // [[a]] -> bool -> s -> s function wikiTable(lstRows, blnHeaderRow, strStyle) { return '{\| class="wikitable" ' + ( strStyle ? 'style="' + strStyle + '"' : '' ) + lstRows.map(function (lstRow, iRow) { var strDelim = ((blnHeaderRow && !iRow) ? '!' : '\|'); return '\n\|-\n' + strDelim + ' ' + lstRow.map(function (v) { return typeof v === 'undefined' ? ' ' : v; }).join(' ' + strDelim + strDelim + ' '); }).join('') + '\n\|}'; } // Formatted as WikiTable return wikiTable( lstTable, true, 'text-align:center;width:33em;height:33em;table-layout:fixed;' ) + '\n\n' + // or simply stringified as JSON JSON.stringify(lstTable); })(1, 12);</syntaxhighlight> {{out}} {\| class="wikitable" style="text-align:center;width:33em;height:33em;table-layout:fixed;" \|- ! x !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! 11 !! 12 \|- \| 1 \|\| 1 \|\| 2 \|\| 3 \|\| 4 \|\| 5 \|\| 6 \|\| 7 \|\| 8 \|\| 9 \|\| 10 \|\| 11 \|\| 12 \|- \| 2 \|\| \|\| 4 \|\| 6 \|\| 8 \|\| 10 \|\| 12 \|\| 14 \|\| 16 \|\| 18 \|\| 20 \|\| 22 \|\| 24 \|- \| 3 \|\| \|\| \|\| 9 \|\| 12 \|\| 15 \|\| 18 \|\| 21 \|\| 24 \|\| 27 \|\| 30 \|\| 33 \|\| 36 \|- \| 4 \|\| \|\| \|\| \|\| 16 \|\| 20 \|\| 24 \|\| 28 \|\| 32 \|\| 36 \|\| 40 \|\| 44 \|\| 48 \|- \| 5 \|\| \|\| \|\| \|\| \|\| 25 \|\| 30 \|\| 35 \|\| 40 \|\| 45 \|\| 50 \|\| 55 \|\| 60 \|- \| 6 \|\| \|\| \|\| \|\| \|\| \|\| 36 \|\| 42 \|\| 48 \|\| 54 \|\| 60 \|\| 66 \|\| 72 \|- \| 7 \|\| \|\| \|\| \|\| \|\| \|\| \|\| 49 \|\| 56 \|\| 63 \|\| 70 \|\| 77 \|\| 84 \|- \| 8 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 64 \|\| 72 \|\| 80 \|\| 88 \|\| 96 \|- \| 9 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 81 \|\| 90 \|\| 99 \|\| 108 \|- \| 10 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 100 \|\| 110 \|\| 120 \|- \| 11 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 121 \|\| 132 \|- \| 12 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 144 \|} <syntaxhighlight lang="javascript">[["x",1,2,3,4,5,6,7,8,9,10,11,12], [1,1,2,3,4,5,6,7,8,9,10,11,12], [2,"",4,6,8,10,12,14,16,18,20,22,24], [3,"","",9,12,15,18,21,24,27,30,33,36], [4,"","","",16,20,24,28,32,36,40,44,48], [5,"","","","",25,30,35,40,45,50,55,60], [6,"","","","","",36,42,48,54,60,66,72], [7,"","","","","","",49,56,63,70,77,84], [8,"","","","","","","",64,72,80,88,96], [9,"","","","","","","","",81,90,99,108], [10,"","","","","","","","","",100,110,120], [11,"","","","","","","","","","",121,132], [12,"","","","","","","","","","","",144]]</syntaxhighlight> =====ES6===== <syntaxhighlight lang="javascript">(() => { "use strict"; // -------------- MULTIPLICATION TABLE --------------- // multTable :: Int -> Int -> [[String]] const multTable = m => n => { const xs = enumFromTo(m)(n); return [ ["x", ...xs], ...xs.flatMap( x => [ [x, ...xs.flatMap( y => y < x ? ( [""] ) : [`${x y}`] )] ] ) ]; }; // ---------------------- TEST ----------------------- // main :: () -> IO String const main = () => wikiTable({ class: "wikitable", style: [ "text-align:center", "width:33em", "height:33em", "table-layout:fixed" ].join(";") })( multTable(1)(12) ); // ---------------- GENERIC FUNCTIONS ---------------- // enumFromTo :: Int -> Int -> [Int] const enumFromTo = m => n => n >= m ? Array.from({ length: Math.floor(n - m) + 1 }, (_, i) => m + i) : []; // ------------------- FORMATTING -------------------- // wikiTable :: Dict -> [[a]] -> String const wikiTable = opts => rows => { const style = ["class", "style"].reduce( (a, k) => k in opts ? ( `${a}${k}="${opts[k]}" ` ) : a, "" ), body = rows.map((row, i) => { const cells = row.map( x => `${x}` \|\| " " ).join(" \|\| "); return `${i ? "\|" : "!"} ${cells}`; }).join("\n\|-\n"); return `{\| ${style}\n${body}\n\|}`; }; // MAIN --- return main(); })();</syntaxhighlight> {{Out}} {\| class="wikitable" style="text-align:center;width:33em;height:33em;table-layout:fixed" ! x \|\| 1 \|\| 2 \|\| 3 \|\| 4 \|\| 5 \|\| 6 \|\| 7 \|\| 8 \|\| 9 \|\| 10 \|\| 11 \|\| 12 \|- \| 1 \|\| 1 \|\| 2 \|\| 3 \|\| 4 \|\| 5 \|\| 6 \|\| 7 \|\| 8 \|\| 9 \|\| 10 \|\| 11 \|\| 12 \|- \| 2 \|\| \|\| 4 \|\| 6 \|\| 8 \|\| 10 \|\| 12 \|\| 14 \|\| 16 \|\| 18 \|\| 20 \|\| 22 \|\| 24 \|- \| 3 \|\| \|\| \|\| 9 \|\| 12 \|\| 15 \|\| 18 \|\| 21 \|\| 24 \|\| 27 \|\| 30 \|\| 33 \|\| 36 \|- \| 4 \|\| \|\| \|\| \|\| 16 \|\| 20 \|\| 24 \|\| 28 \|\| 32 \|\| 36 \|\| 40 \|\| 44 \|\| 48 \|- \| 5 \|\| \|\| \|\| \|\| \|\| 25 \|\| 30 \|\| 35 \|\| 40 \|\| 45 \|\| 50 \|\| 55 \|\| 60 \|- \| 6 \|\| \|\| \|\| \|\| \|\| \|\| 36 \|\| 42 \|\| 48 \|\| 54 \|\| 60 \|\| 66 \|\| 72 \|- \| 7 \|\| \|\| \|\| \|\| \|\| \|\| \|\| 49 \|\| 56 \|\| 63 \|\| 70 \|\| 77 \|\| 84 \|- \| 8 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 64 \|\| 72 \|\| 80 \|\| 88 \|\| 96 \|- \| 9 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 81 \|\| 90 \|\| 99 \|\| 108 \|- \| 10 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 100 \|\| 110 \|\| 120 \|- \| 11 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 121 \|\| 132 \|- \| 12 \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| \|\| 144 \|} =={{header\|jq}}== <syntaxhighlight lang="jq"> def lpad($len): tostring \| ($len - length) as $l \| (" " * $l)[:$l] + .; def multiplication($n): ($n$n\|tostring\|length) as $len \| ["x", range(0; $n + 1)] \| map(lpad($len)) \| join(" "), (["", range(0; $n + 1)] \| map($len"-") \| join(" ")), ( range(0; $n + 1) as $i \| [$i, range(0; $n + 1) as $j \| if $j>=$i then $i$j else "" end] \| map(lpad($len)) \| join(" ") ) ; multiplication(12) </syntaxhighlight> {{output}} <pre> x 0 1 2 3 4 5 6 7 8 9 10 11 12 --- --- --- --- --- --- --- --- --- --- --- --- --- --- 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Jsish}}== <syntaxhighlight lang="javascript">/ Multiplication tables, is Jsish / var m, n, tableSize = 12; if (console.args.length > 0) tableSize = parseInt(console.args[0]); if (tableSize < 1 \|\| tableSize > 20) tableSize = 12; var width = String(tableSize tableSize).length; var spaces = ' '.repeat(width+1); printf(spaces); for (m = 1; m <= tableSize; m++) printf(' %d', width, m); printf('\n' + ' '.repeat(width) + '+'); printf('-'.repeat((width+1) tableSize)); for (m = 1; m <= tableSize; m++) { printf('\n%d\|', width, m); for (n = m; n < m; n++) printf(spaces); for (n = 1; n <= tableSize; n++) { if (m <= n) printf(' %d', width, m * n); else printf(spaces); } } printf('\n');</syntaxhighlight> {{out}} <pre>prompt$ jsish multiplication-tables.jsi 1 2 3 4 5 6 7 8 9 10 11 12 +------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 prompt$ jsish multiplication-tables.jsi 4 1 2 3 4 +------------ 1\| 1 2 3 4 2\| 4 6 8 3\| 9 12 4\| 16</pre> =={{header\|Julia}}== <syntaxhighlight lang="julia">using Printf println(" X \| 1 2 3 4 5 6 7 8 9 10 11 12") println("---+------------------------------------------------") for i=1:12, j=0:12 if j == 0 @printf("%2d \| ", i) elseif i <= j @printf("%3d%c", i * j, j == 12 ? '\n' : ' ') else print(" ") end end</syntaxhighlight> {{out}} <pre> X \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144</pre> =={{header\|Kotlin}}== <syntaxhighlight lang="scala">// version 1.0.6 fun main(args: Array<String>) { print(" x\|") for (i in 1..12) print("%4d".format(i)) println("\n---+${"-".repeat(48)}") for (i in 1..12) { print("%3d".format(i) +"\|${" ".repeat(4 * i - 4)}") for (j in i..12) print("%4d".format(i * j)) println() } }</syntaxhighlight> {{out}} <pre> x\| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> ==[[header\|Lambdatalk]]== Outputs are visible in http://lambdaway.free.fr/lambdawalks/?view=multiplication_table <syntaxhighlight lang="scheme"> {def format {lambda {:w :c} {@ style="width::wpx; color::c; text-align:right;" }}} -> format {def operation {lambda {:op :i :j} {if {and {= :i 0} {= :j 0}} // left top cell then {format 30 #fff} // is empty else {if {= :i 0} // top row then {format 30 #ff0}:j // is yellow else {if {= :j 0} // left col then {format 30 #0ff}:i // is cyan else {format 30 #ccc} // is lightgrey {if {<= :i :j} then {:op :i :j} else .} // cell [i,j] }}}}} -> operation {def make_table {lambda {:func :row :col} {table {@ style="box-shadow:0 0 8px #000;"} {S.map // apply {{lambda {:func :col :j} // function row {tr {S.map // apply {{lambda {:func :i :j} // function cell {td {:func :i :j}}} :func :j} // apply func on [i,j] {S.serie 0 :col}}}} :func :col} // from 0 to col {S.serie 0 :row} // from 0 to row }}}} -> make_table The following calls: 1) {make_table {operation +} 5 15} 2) {make_table {operation } 12 12} 3) {make_table {operation pow} 6 10} </syntaxhighlight> =={{header\|Lasso}}== <syntaxhighlight lang="lasso">define printTimesTables(max::integer) => { local(result) = `` local(padSize) = string(#max#max)->size + 1 // Print header row #result->append((' ' * #padSize) + '\|') loop(#max) => { #result->append(loop_count->asString(-padding=#padSize)) } #result->append("\n" + (`-` * #padSize) + '+' + (`-` * (#padSize * #max))) with left in 1 to #max do { // left column #result->append("\n" + #left->asString(-padding=#padSize) + '\|') // Table results with right in 1 to #max do { #result->append( #right < #left ? ' ' * #padSize \| (#left * #right)->asString(-padding=#padSize) ) } } return #result } printTimesTables(12)</syntaxhighlight> {{out}} <pre>----+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> ~~For i = 1 To 12~~ ~~nums$ = Right$(" " + str$(i), 2) + "\|"~~ ~~For ii = 1 To 12~~ ~~If i <= ii Then~~ ~~If ii >= 1 Then~~ ~~nums$ = nums$ + Left$(" ", (5 - Len(str$(i * ii))))~~ ~~End If~~ ~~nums$ = nums$ + str$(i * ii)~~ ~~Else~~ ~~nums$ = nums$ + " "~~ ~~End If~~ ~~Next ii~~ ~~Print nums$~~ ~~Next i</lang>~~ =={{header\|Logo}}== {{works with\|UCB Logo}} <~~lang~~syntaxhighlight lang="logo">to mult.table :n type "\| \| for [i 2 :n] [type form :i 4 0] (print) (print) Line 1,320 ⟶ 5,196: mult.table 12 </syntaxhighlight> ~~</lang>~~ =={{header\|Lua}}== <~~lang~~syntaxhighlight lang="lua">io.write( " \|" ) for i = 1, 12 do io.write( string.format( "%#5d", i ) ) Line 1,339 ⟶ 5,216: end io.write( "\n" ) end</~~lang~~syntaxhighlight> <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 ---------------------------------------------------------------- Line 1,355 ⟶ 5,232: 12 \| 144</pre> =={{header\|~~MATLAB~~M2000 Interpreter}}== Using jagged array (arrays of arrays) <syntaxhighlight lang="m2000 interpreter"> Module CheckIt { Dim Base 1, A(12) Mult=lambda (n)-> { Flush ' empty stack For i=1 to n : Data in : Next i =Array([]) ' copy stack in an array, and return a pointer } i=Each(A()) Print " \|"; while i { Print Format$("{0:0:-4}",i^+1); A(i^+1)=Mult(i^+1) } Print Print "--+"+string$("-",412) For i=1 to 12 { Print Format$("{0:0:-2}\|",i); For j=1 to 12 { If len(A(j)())>=i then { Print Format$("{0:0:-4}",A(j)(i-1)); } Else Print " "; } Print } } CheckIt </syntaxhighlight> Final loop can be this, using Each() and r1 as pointer to array. <pre> For i=1 to 12 { j=Each(A()) Print Format$("{0:0:-2}\|",i); While j { r1=A(j^+1) If len(r1)>=i then { Print Format$("{0:0:-4}",Array(r1,i-1)); } Else Print " "; } Print } </pre> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|Maple}}== <syntaxhighlight lang="maple">printf(" "); for i to 12 do printf("%-3d ", i); end do; printf("\n"); for i to 75 do printf("-"); end do; for i to 12 do printf("\n%2d\| ", i); for j to 12 do if j<i then printf(" "); else printf("%-3d ", i * j); end if end do end do</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 --------------------------------------------------------------------------- 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|Mathematica}}/{{header\|Wolfram Language}}== <syntaxhighlight lang="mathematica">Grid[{{Range[12]//Column,Grid[UpperTriangularize[KroneckerProduct[Range[12],Range[12]]]/.{0->""}]}}]</syntaxhighlight> {{out}} <pre>1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144</pre> =={{header\|MATLAB}} / {{header\|Octave}}== timesTable.m: (creates Times Table of N degree) <~~lang~~syntaxhighlight ~~MATLAB~~lang="matlab">function table = timesTable(N) table = [(0:N); (1:N)' triu( kron((1:N),(1:N)') )]; end</~~lang~~syntaxhighlight> A minimally vectorized version of the above code: <~~lang~~syntaxhighlight ~~MATLAB~~lang="matlab">function table = timesTable(N) %Generates a column vector with integers from 1 to N Line 1,381 ⟶ 5,373: table = [columnLabels; rowLabels triu(table)]; end</~~lang~~syntaxhighlight> {{out}} For N=12 ~~the output is~~: <~~lang MATLAB~~pre>timesTable(12) ans = Line 1,402 ⟶ 5,394: 11 0 0 0 0 0 0 0 0 0 0 121 132 12 0 0 0 0 0 0 0 0 0 0 0 144 </~~lang~~pre> =={{header\|Maxima}}== <syntaxhighlight lang="maxima">for i: 1 thru 12 do ( for j: 1 thru 12 do ( if j>=i or j=1 then printf(true, "~4d", ij) else printf(true, " ") ), printf(true, "~%") );</syntaxhighlight> Constructing a function to handle cases like this one [[File:Multiplication table.png\|thumb\|Formatted output using table_form]] <syntaxhighlight lang="maxima"> / Auxiliar function / aux_table(n,k):=append([k],makelist(0,i,1,k-1),makelist(ki,i,k,n))$ /* Function to construct the formatted table / table_mult(n):=block( append([makelist(i,i,0,n)],makelist(aux_table(n,k),k,1,n)), makelist(at(%%[i],0=""),i,2,length(%%)), table_form(%%))$ / Test case / table_mult(12); </syntaxhighlight> =={{header\|МК-61/52}}== <syntaxhighlight lang="text">П0 КИП0 КИП4 КИП5 ИП4 ИП5 С/П ИП5 ИП0 - x=0 03 ИП4 ИП0 - x#0 22 ИП4 П5 БП 02 С/П</syntaxhighlight> ''Input'': 12 С/П ... {{out}} (compiled): <pre> 1 2 3 4 5 6 7 8 9 10 11 12 4 6 8 10 12 14 16 18 20 22 24 9 12 15 18 21 24 27 30 33 36 16 20 24 28 32 36 40 44 48 25 30 35 40 45 50 55 60 36 42 48 54 60 66 72 49 56 63 70 77 84 64 72 80 88 96 81 90 99 108 100 110 120 121 132 144 </pre> =={{header\|Modula-2}}== {{works with\|ADW Modula-2\|any (Compile with the linker option ''Console Application'').}} <syntaxhighlight lang="modula2"> MODULE MultiplicationTables; FROM SWholeIO IMPORT WriteInt; FROM STextIO IMPORT WriteString, WriteLn; CONST N = 12; VAR I, J: INTEGER; BEGIN FOR J := 1 TO N - 1 DO WriteInt(J, 3); WriteString(" "); END; WriteInt(N, 3); WriteLn; FOR J := 0 TO N - 1 DO WriteString("----"); END; WriteString("+"); WriteLn; FOR I := 1 TO N DO FOR J := 1 TO N DO IF J < I THEN WriteString(" "); ELSE WriteInt(I * J, 3); WriteString(" "); END; END; WriteString("\| "); WriteInt(I, 2); WriteLn; END; END MultiplicationTables. </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> =={{header\|MOO}}== This quick example is designed to demonstrate raw MOO. In other words it does not use any of the helper functions available in popular DBs such as LambdaMOO. <syntaxhighlight lang="moo"> @verb me:@tables none none none rxd @program me:@tables player:tell(" \| 1 2 3 4 5 6 7 8 9 10 11 12"); player:tell("-------------------------------------------------------------------"); for i in [1..12] line = ((i < 10) ? " " \| " ") + tostr(i) + " \| "; for j in [1..12] if (j >= i) product = i * j; "calculate spacing for right justification of values"; if (product >= 100) spacer = ""; elseif (product >= 10) spacer = " "; else spacer = " "; endif line = line + " " + spacer + tostr(product); else line = line + " "; endif endfor player:tell(line); endfor . </syntaxhighlight> LambdaMOO string utilities version: <syntaxhighlight lang="moo"> @program me:@tables player:tell(" \| 1 2 3 4 5 6 7 8 9 10 11 12"); player:tell($string_utils:space(67, "-")); for i in [1..12] line = " " + $string_utils:right(i, 2) + " \| "; for j in [1..12] line = line + " " + ((i > j) ? " " \| $string_utils:right(ji, 3)); endfor player:tell(line); endfor . </syntaxhighlight> {{out}} <pre> @tables \| 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------------------------- 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> =={{header\|MUMPS}}== <~~lang~~syntaxhighlight ~~MUMPS~~lang="mumps">MULTTABLE(SIZE) ;Print out a multiplication table ;SIZE is the size of the multiplication table to make Line 1,424 ⟶ 5,589: ..WRITE:((A-1)>=(D-2))&((D-2)>=1) ?((A-1)5),$JUSTIFY((D-2)(A-1),MW) KILL MW,D,A,BAR QUIT</~~lang~~syntaxhighlight> ~~Output:<pre>USER>D MULTTABLE^ROSETTA~~ {{out}} <pre>USER>D MULTTABLE^ROSETTA X\| 1 2 3 4 5 6 7 8 9 10 11 12 Line 1,441 ⟶ 5,608: 11 \| 121 132 12 \| 144</pre> =={{header\|N/t/roff}}== Works with gnu nroff. Please note that the script example contains tab characters which are essential for the correct tabular output. <syntaxhighlight lang="nroff"> .nf .ta T 2mR .nr x 1 1 .nr y 2 1 .nr p 0 .while (\n[x] <= 12) \{\ .if (\n[x]<10) \0\c \n[x]\c .if (\n[x]=1) \c .while (\n[y] <= 12) \{\ .nr p \n[x]\n[y] .ie (\n[y]>=\n[x]) \n[p] \c .el \c .nr y +1 .\} .br .nr x +1 .nr y 1 1 .\} </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Neko}}== <syntaxhighlight lang="actionscript">/** Multiplication table, in Neko Tectonics: nekoc multiplication-table.neko neko multiplication-table / var sprintf = $loader.loadprim("std@sprintf", 2); var i, j; i = 1; $print(" X \|"); while i < 13 { $print(sprintf("%4d", i)); i += 1; } $print("\n"); $print(" ---+"); i = 1; while i < 13 { $print("----"); i += 1; } $print("\n"); j = 1; while j < 13 { $print(sprintf("%3d", j)); $print(" \|"); i = 1; while i < 13 { if j > i { $print(" "); } else { $print(sprintf("%4d", ij)); } i += 1; } $print("\n"); j += 1; }</syntaxhighlight> {{out}} <pre>prompt$ nekoc multiplication-table.neko prompt$ neko multiplication-table X \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> =={{header\|Nim}}== {{trans\|C}} <syntaxhighlight lang="nim">import strfmt const n = 12 for j in 1..n: stdout.write "{:3d}{:s}".fmt(j, if n-j>0: " " else: "\n") for j in 0..n: stdout.write if n-j>0: "----" else: "+\n" for i in 1..n: for j in 1..n: stdout.write if j<i: " " else: "{:3d} ".fmt(ij) echo "\| {:2d}".fmt(i)</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12</pre> =={{header\|OCaml}}== {{trans\|C}} <~~lang~~syntaxhighlight lang="ocaml">let () = let max = 12 in let fmax = float_of_int max in Line 1,463 ⟶ 5,762: print_newline() done; print_newline()</~~lang~~syntaxhighlight> =={{header\|PARI/GP}}== Quick and dirty one-liner: <~~lang~~syntaxhighlight lang="parigp">for(y=1,12,printf("%2Ps\| ",y);for(x=1,12,print1(if(y>x,"",xy)"\t"));print)</~~lang~~syntaxhighlight> =={{header\|Pascal}}== Line 1,473 ⟶ 5,772: =={{header\|Perl}}== <~~lang~~syntaxhighlight lang="perl">our $max = 12; our $width = length($max*2) + 1; Line 1,482 ⟶ 5,781: foreach "$i\|", map { $_ >= $i and $_$i } 1..$max; print "\n"; }</~~lang~~syntaxhighlight> ~~Output:~~ {{out}} <pre> x\| 1 2 3 4 5 6 7 8 9 10 11 12 Line 1,503 ⟶ 5,801: </pre> =={{header\|~~Perl 6~~Phix}}== {{~~trans~~Trans\|~~Perl~~Ada}} <!--<syntaxhighlight lang="phix">(phixonline)--> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" \| "</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">for</span> <span style="color: #000000;">col</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">12</span> <span style="color: #008080;">do</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%4d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">col</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n--+-"</span><span style="color: #0000FF;">&</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'-'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">12</span><span style="color: #0000FF;"></span><span style="color: #000000;">4</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">for</span> <span style="color: #000000;">row</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">12</span> <span style="color: #008080;">do</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n%2d\| "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">row</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">for</span> <span style="color: #000000;">col</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">12</span> <span style="color: #008080;">do</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">col</span><span style="color: #0000FF;"><</span><span style="color: #000000;">row</span><span style="color: #0000FF;">?</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">:</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%4d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">row</span><span style="color: #0000FF;"></span><span style="color: #000000;">col</span><span style="color: #0000FF;">)))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> <!--</syntaxhighlight>--> {{out}} <pre style="font-size: 8px"> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------- 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|Phixmonti}}== ~~{{works with\|Rakudo Star\|2010.08}}~~ <syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/wiki/Multiplication_tables by Galileo, 11/2022 #/ def tab 9 tochar print enddef ~~<lang perl6>my $max = 12;~~ ~~my $width = chars $max*2;~~ ~~my $f = "%{$width}s";~~ tab 12 for print tab endfor nl ~~say 'x'.fmt($f), '┃ ', (1..$max).fmt($f);~~ tab '-' 12 8 repeat print nl ~~say '━' x $width, '╋', '━' x $max$width + $max;~~ 12 for ~~for 1..$max -> $i {~~ dup print tab 8 tochar print "\|" print ~~say $i.fmt($f), '┃ ', (~~ dup for ~~for 1..$max -> $j {~~ over print tab ~~$i <= $j ?? $i$j !! '';~~ endfor } drop nl ~~).fmt($f);~~ endfor</syntaxhighlight> ~~}</lang>~~ {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------------------------------------------------------ 1 \|1 2 \|2 4 3 \|3 6 9 4 \|4 8 12 16 5 \|5 10 15 20 25 6 \|6 12 18 24 30 36 7 \|7 14 21 28 35 42 49 8 \|8 16 24 32 40 48 56 64 9 \|9 18 27 36 45 54 63 72 81 10 \|10 20 30 40 50 60 70 80 90 100 11 \|11 22 33 44 55 66 77 88 99 110 121 12 \|12 24 36 48 60 72 84 96 108 120 132 144 === Press any key to exit ===</pre> ~~Output:~~ =={{header\|Picat}}== ~~<code>~~ <syntaxhighlight lang="picat">go => ~~x┃ 1 2 3 4 5 6 7 8 9 10 11 12~~ N=12, ~~━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━~~ make_table(N), ~~1┃ 1 2 3 4 5 6 7 8 9 10 11 12~~ nl. ~~2┃ 4 6 8 10 12 14 16 18 20 22 24~~ ~~3┃ 9 12 15 18 21 24 27 30 33 36~~ % ~~4┃ 16 20 24 28 32 36 40 44 48~~ % Make a table of size N ~~5┃ 25 30 35 40 45 50 55 60~~ % ~~6┃ 36 42 48 54 60 66 72~~ make_table(N) => ~~7┃ 49 56 63 70 77 84~~ printf(" "), ~~8┃ 64 72 80 88 96~~ foreach(I in 1..N) printf("%4w", I) end, ~~9┃ 81 90 99 108~~ nl, ~~10┃ 100 110 120~~ println(['-' : _ in 1..(N+1)4+1]), ~~11┃ 121 132~~ foreach(I in 1..N) ~~12┃ 144~~ printf("%2d \| ", I), ~~</code>~~ foreach(J in 1..N) if J>=I then printf("%4w", IJ) else printf(" ") end end, nl end, nl.</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ----------------------------------------------------- 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144</pre> =={{header\|PicoLisp}}== <syntaxhighlight lang="picoli/th">sp>(de mulTable (N) (space 4) (for X N (prin (align 4 X)) ) (prinl) (prinl) (for Y N (prin (align 4 Y)) (space ( (dec Y) 4)) (for (X Y (>= N X) (inc X)) (prin (align 4 (* X Y))) ) (prinl) ) ) (mulTable 12)</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144</pre> =={{header\|PL/I}}== <syntaxhighlight lang="pl/i"> ~~<lang PL/I>~~ /* 12 x 12 multiplication table. / Line 1,557 ⟶ 5,957: end multiplication_table; </syntaxhighlight> ~~</lang>~~ Result: <~~lang~~pre> 1 2 3 4 5 6 7 8 9 10 11 12 _________________________________________________ Line 1,576 ⟶ 5,976: 11 \| 121 132 12 \| 144 </~~lang~~pre> =={{header\|~~PicoLisp~~PowerShell}}== <syntaxhighlight lang="powershell"># For clarity ~~<lang PicoLisp>(de mulTable (N)~~ $Tab = "`t" ~~(space 4)~~ ~~(for X N~~ # Create top row ~~(prin (align 4 X)) )~~ $Tab + ( 1..12 -join $Tab ) ~~(prinl)~~ ~~(prinl)~~ # For ~~(for~~each ~~Y N~~row ForEach ( $i in 1..12 ) ~~(prin (align 4 Y))~~ { ~~(space ( (dec Y) 4))~~ $( ~~(for~~# (X YThe ~~(>=~~number Nin X)the ~~(inc~~left ~~X))~~column ~~(prin (align 4 (* X Y))) )~~$i ~~(prinl) ) )~~ # An empty slot for the bottom triangle @( "" ) * ( $i - 1 ) # Calculate the top triangle $i..12 \| ForEach { $i * $_ } # Combine them all together ) -join $Tab }</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144</pre> <b>A more general solution</b> <syntaxhighlight lang="powershell">function Get-TimesTable ( [int]$Size ) { # For clarity $Tab = "`t" # Create top row $Tab + ( 1..$Size -join $Tab ) # For each row ForEach ( $i in 1..$Size ) { $( # The number in the left column $i # An empty slot for the bottom triangle @( "" ) * ( $i - 1 ) # Calculate the top triangle $i..$Size \| ForEach { $i * $_ } # Combine them all together (and send them to the out put stream, which in PowerShell implicityly returns them) ) -join $Tab } } Get-TimesTable 18</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 3 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 4 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 5 25 30 35 40 45 50 55 60 65 70 75 80 85 90 6 36 42 48 54 60 66 72 78 84 90 96 102 108 7 49 56 63 70 77 84 91 98 105 112 119 126 8 64 72 80 88 96 104 112 120 128 136 144 9 81 90 99 108 117 126 135 144 153 162 10 100 110 120 130 140 150 160 170 180 11 121 132 143 154 165 176 187 198 12 144 156 168 180 192 204 216 13 169 182 195 208 221 234 14 196 210 224 238 252 15 225 240 255 270 16 256 272 288 17 289 306 18 324</pre> =={{header\|Prolog}}== ~~(mulTable 12)</lang>~~ <syntaxhighlight lang="prolog">make_table(S,E) :- ~~Output:~~ print_header(S,E), ~~<pre> 1 2 3 4 5 6 7 8 9 10 11 12~~ make_table_rows(S,E), fail. make_table(_,_). print_header(S,E) :- ~~1 1 2 3 4 5 6 7 8 9 10 11 12~~ nl, ~~2 4 6 8 10 12 14 16 18 20 22 24~~ write(' '), ~~3 9 12 15 18 21 24 27 30 33 36~~ forall(between(S,E,X), print_num(X)), ~~4 16 20 24 28 32 36 40 44 48~~ nl, ~~5 25 30 35 40 45 50 55 60~~ Sp is E * 4 + 2, ~~6 36 42 48 54 60 66 72~~ write(' '), ~~7 49 56 63 70 77 84~~ forall(between(1,Sp,_), write('-')). ~~8 64 72 80 88 96~~ ~~9 81 90 99 108~~ make_table_rows(S,E) :- ~~10 100 110 120~~ between(S,E,N), ~~11 121 132~~ nl, ~~12 144</pre>~~ print_num(N), write(': '), between(S,E,N2), X is N * N2, print_row_item(N,N2,X). print_row_item(N, N2, _) :- N2 < N, write(' '). print_row_item(N, N2, X) :- N2 >= N, print_num(X). print_num(X) :- X < 10, format(' ~p', X). print_num(X) :- between(10,99,X), format(' ~p', X). print_num(X) :- X > 99, format(' ~p', X).</syntaxhighlight> {{out}} <pre> ?- make_table(1,12). 1 2 3 4 5 6 7 8 9 10 11 12 ~~=={{header\|PureBasic}}==~~ -------------------------------------------------- ~~<lang PureBasic>Procedure PrintMultiplicationTable(maxx, maxy)~~ 1: 1 2 3 4 5 6 7 8 9 10 11 12 ~~sp = Len(Str(maxxmaxy)) + 1~~ 2: 4 6 8 10 12 14 16 18 20 22 24 ~~trenner$ = "+"~~ 3: 9 12 15 18 21 24 27 30 33 36 ~~For l1 = 1 To maxx + 1~~ 4: 16 20 24 28 32 36 40 44 48 ~~For l2 = 1 To sp~~ 5: 25 30 35 40 45 50 55 60 ~~trenner$ + "-"~~ 6: 36 42 48 54 60 66 72 ~~Next~~ 7: 49 56 63 70 77 84 ~~trenner$ + "+"~~ 8: 64 72 80 88 96 ~~Next~~ 9: 81 90 99 108 ~~header$ = "\|" + RSet("x", sp) + "\|"~~ 10: 100 110 120 ~~For a = 1 To maxx~~ 11: 121 132 ~~header$ + RSet(Str(a), sp)~~ 12: 144 ~~header$ + "\|"~~ true. ~~Next~~ ~~PrintN(trenner$)~~ ~~PrintN(header$)~~ ~~PrintN(trenner$)~~ ~~For y = 1 To maxy~~ ~~line$ = "\|" + RSet(Str(y), sp) + "\|"~~ ~~For x = 1 To maxx~~ ~~If x >= y~~ ~~line$ + RSet(Str(xy), sp)~~ ~~Else~~ ~~line$ + Space(sp)~~ ~~EndIf~~ ~~line$ + "\|"~~ ~~Next~~ ~~PrintN(line$)~~ ~~Next~~ ~~PrintN(trenner$)~~ ~~EndProcedure~~ ?-</pre> ~~OpenConsole()~~ ~~PrintMultiplicationTable(12, 12)~~ ~~Input()</lang>~~ ~~Ouput similar to ALGOL 68~~ =={{header\|Python}}== ===Procedural=== ~~<lang python>>>> size = 12~~ <syntaxhighlight lang="python">>>> size = 12 >>> width = len(str(size*2)) >>> for row in range(-1,size+1): Line 1,677 ⟶ 6,148: 11│ 121 132 12│ 144 >>> </~~lang~~syntaxhighlight> The above works with Python 3.X, which uses Unicode strings by default. <br> Line 1,683 ⟶ 6,154: <small>(As would using ASCII minus, plus, and pipe characters: "-", "+", "\|"; instead of the non-ASCII chars used to draw a frame)</small>. ==~~{{header\|R}}~~=Functional=== ~~An ugly one line solution:~~ ~~<lang r>~~ ~~upper.tri(1:12 %o% 1:12, diag = TRUE) 1:12 %o% 1:12~~ ~~</lang>~~ We can define a multiplication table string first in terms of a '''list comprehension''' (''mulTable'' function), ~~... and a much prettier one:~~ ~~<lang r>~~ and then again, for comparison, as an equivalent '''list monad''' expression (''mulTable2'' function): <syntaxhighlight lang="python">'''Multiplication table 1. by list comprehension (mulTable ), 2. by list monad. (mulTable2)''' from itertools import chain # mulTable :: Int -> String def mulTable(n): '''A multiplication table of dimension n, without redundant entries beneath the diagonal of squares.''' # colWidth :: Int colWidth = len(str(n * n)) # pad :: String -> String def pad(s): return s.rjust(colWidth, ' ') xs = enumFromTo(1)(n) return unlines([ pad(str(y) + ':') + unwords([ pad(str(x * y) if x >= y else '') for x in xs ]) for y in xs ]) # mulTable2 :: Int -> String def mulTable2(n): '''Identical to mulTable above, but the list comprehension is directly desugared to an equivalent list monad expression.''' # colWidth :: Int colWidth = len(str(n * n)) # pad :: String -> String def pad(s): return s.rjust(colWidth, ' ') xs = enumFromTo(1)(n) return unlines( bind(xs)(lambda y: [ pad(str(y) + ':') + unwords( bind(xs)(lambda x: [ pad(str(x * y) if x >= y else '') ]) ) ]) ) # TEST ---------------------------------------------------- # main :: IO () def main(): '''Test''' for s, f in [ ('list comprehension', mulTable), ('list monad', mulTable2) ]: print( 'By ' + s + ' (' + f.__name__ + '):\n\n', f(12).strip() + '\n' ) # GENERIC ------------------------------------------------- # bind (>>=) :: [a] -> (a -> [b]) -> [b] def bind(xs): '''The injection operator for the list monad. Equivalent to concatMap with its arguments flipped.''' return lambda f: list( chain.from_iterable( map(f, xs) ) ) # enumFromTo :: (Int, Int) -> [Int] def enumFromTo(m): '''Integer enumeration from m to n.''' return lambda n: list(range(m, 1 + n)) # unlines :: [String] -> String def unlines(xs): '''A newline-delimited string derived from a list of lines.''' return '\n'.join(xs) # unwords :: [String] -> String def unwords(xs): '''A space-delimited string derived from a list of words.''' return ' '.join(xs) if __name__ == '__main__': main()</syntaxhighlight> {{Out}} <pre>By list comprehension (mulTable): 1: 1 2 3 4 5 6 7 8 9 10 11 12 2: 4 6 8 10 12 14 16 18 20 22 24 3: 9 12 15 18 21 24 27 30 33 36 4: 16 20 24 28 32 36 40 44 48 5: 25 30 35 40 45 50 55 60 6: 36 42 48 54 60 66 72 7: 49 56 63 70 77 84 8: 64 72 80 88 96 9: 81 90 99 108 10: 100 110 120 11: 121 132 12: 144 By list monad (mulTable2): 1: 1 2 3 4 5 6 7 8 9 10 11 12 2: 4 6 8 10 12 14 16 18 20 22 24 3: 9 12 15 18 21 24 27 30 33 36 4: 16 20 24 28 32 36 40 44 48 5: 25 30 35 40 45 50 55 60 6: 36 42 48 54 60 66 72 7: 49 56 63 70 77 84 8: 64 72 80 88 96 9: 81 90 99 108 10: 100 110 120 11: 121 132 12: 144</pre> Or, with a little more abstraction, and a complete separation of model from view: {{Trans\|Haskell}} {{Works with\|Python\|3.7}} <syntaxhighlight lang="python">'''Generalised multiplication tables''' import collections import itertools import inspect # table :: Int -> [[Maybe Int]] def table(xs): '''An option-type model of a multiplication table: a tabulation of Just(x * y) values for all pairings (x, y) of integers in xs where x > y, and Nothing values where y <= x. ''' axis = fmap(Just)(xs) return list(cons( cons(Nothing())(axis) )(zipWith(cons)(axis)([ [ Nothing() if y > x else Just(x * y) for x in xs ] for y in xs ]))) # TEST ---------------------------------------------------- # main :: IO () def main(): '''Test''' print('\n\n'.join( fmap(fmap(fmap(showTable)(table))( liftA2(enumFromTo)(fst)(snd) ))( [(13, 20), (1, 12), (95, 100)] ) )) # DISPLAY ------------------------------------------------- # showTable :: [[Maybe Int]] -> String def showTable(xs): '''A stringification of an abstract model of a multiplication table. ''' w = 1 + len(str(last(last(xs))['Just'])) gap = ' ' * w rows = fmap(fmap(concat)( fmap(maybe(gap)( fmap(justifyRight(w)(' '))(str) )) ))(xs) return unlines([rows[0]] + [''] + rows[1:]) # GENERIC ------------------------------------------------- # Just :: a -> Maybe a def Just(x): '''Constructor for an inhabited Maybe (option type) value.''' return {'type': 'Maybe', 'Nothing': False, 'Just': x} # Nothing :: Maybe a def Nothing(): '''Constructor for an empty Maybe (option type) value.''' return {'type': 'Maybe', 'Nothing': True} # concat :: [[a]] -> [a] # concat :: [String] -> String def concat(xs): '''The concatenation of all the elements in a list or iterable.''' chain = itertools.chain def f(ys): zs = list(chain(ys)) return ''.join(zs) if isinstance(ys[0], str) else zs return ( f(xs) if isinstance(xs, list) else ( chain.from_iterable(xs) ) ) if xs else [] # cons :: a -> [a] -> [a] def cons(x): '''Construction of a list from x as head, and xs as tail.''' chain = itertools.chain return lambda xs: [x] + xs if ( isinstance(xs, list) ) else chain([x], xs) # curry :: ((a, b) -> c) -> a -> b -> c def curry(f): '''A curried function derived from an uncurried function.''' signature = inspect.signature if 1 < len(signature(f).parameters): return lambda x: lambda y: f(x, y) else: return f # enumFromTo :: (Int, Int) -> [Int] def enumFromTo(m): '''Integer enumeration from m to n.''' return lambda n: list(range(m, 1 + n)) # fmap :: Functor f => (a -> b) -> f a -> f b def fmap(f): '''A function f mapped over a functor.''' def go(x): defaultdict = collections.defaultdict return defaultdict(list, [ ('list', fmapList), # ('iter', fmapNext), # ('Either', fmapLR), # ('Maybe', fmapMay), # ('Tree', fmapTree), # ('tuple', fmapTuple), ('function', fmapFn), ('type', fmapFn) ])[ typeName(x) ](f)(x) return lambda v: go(v) # fmapFn :: (a -> b) -> (r -> a) -> r -> b def fmapFn(f): '''fmap over a function. The composition of f and g. ''' return lambda g: lambda x: f(g(x)) # fmapList :: (a -> b) -> [a] -> [b] def fmapList(f): '''fmap over a list. f lifted to a function over a list. ''' return lambda xs: list(map(f, xs)) # fst :: (a, b) -> a def fst(tpl): '''First member of a pair.''' return tpl[0] # justifyRight :: Int -> Char -> String -> String def justifyRight(n): '''A string padded at left to length n, using the padding character c. ''' return lambda c: lambda s: s.rjust(n, c) # last :: [a] -> a def last(xs): '''The last element of a non-empty list.''' return xs[-1] # liftA2 :: (a -> b -> c) -> f a -> f b -> f c def liftA2(f): '''Lift a binary function to the type of a.''' def go(a, b): defaultdict = collections.defaultdict return defaultdict(list, [ # ('list', liftA2List), # ('Either', liftA2LR), # ('Maybe', liftA2May), # ('Tree', liftA2Tree), # ('tuple', liftA2Tuple), ('function', liftA2Fn) ])[ typeName(a) ](f)(a)(b) return lambda a: lambda b: go(a, b) # liftA2Fn :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c def liftA2Fn(op): '''Lift a binary function to a composition over two other functions. liftA2 () (+ 2) (+ 3) 7 == 90 ''' def go(f, g): return lambda x: curry(op)( f(x) )(g(x)) return lambda f: lambda g: go(f, g) # maybe :: b -> (a -> b) -> Maybe a -> b def maybe(v): '''Either the default value v, if m is Nothing, or the application of f to x, where m is Just(x). ''' return lambda f: lambda m: v if m.get('Nothing') else ( f(m.get('Just')) ) # typeName :: a -> String def typeName(x): '''Name string for a built-in or user-defined type. Selector for type-specific instances of polymorphic functions. ''' if isinstance(x, dict): return x.get('type') if 'type' in x else 'dict' else: return 'iter' if hasattr(x, '__next__') else ( type(x).__name__ ) # snd :: (a, b) -> b def snd(tpl): '''Second member of a pair.''' return tpl[1] # uncurry :: (a -> b -> c) -> ((a, b) -> c) def uncurry(f): '''A function over a pair of arguments, derived from a vanilla or curried function. ''' signature = inspect.signature if 1 < len(signature(f).parameters): return lambda xy: f(xy) else: return lambda x, y: f(x)(y) # unlines :: [String] -> String def unlines(xs): '''A single string derived by the intercalation of a list of strings with the newline character. ''' return '\n'.join(xs) # zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] def zipWith(f): '''A list constructed by zipping with a custom function, rather than with the default tuple constructor. ''' return lambda xs: lambda ys: ( map(uncurry(f), xs, ys) ) # MAIN --- if __name__ == '__main__': main()</syntaxhighlight> {{Out}} <pre> 13 14 15 16 17 18 19 20 13 169 182 195 208 221 234 247 260 14 196 210 224 238 252 266 280 15 225 240 255 270 285 300 16 256 272 288 304 320 17 289 306 323 340 18 324 342 360 19 361 380 20 400 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 95 96 97 98 99 100 95 9025 9120 9215 9310 9405 9500 96 9216 9312 9408 9504 9600 97 9409 9506 9603 9700 98 9604 9702 9800 99 9801 9900 100 10000</pre> =={{header\|Quackery}}== <syntaxhighlight lang="quackery"> [ swap number$ tuck size - times sp echo$ ] is echo-rj ( n n --> ) say " \|" 12 times [ i^ 1+ 4 echo-rj ] cr say " ---+" char - 48 of echo$ cr [ 12 times [ i^ 1+ dup 3 echo-rj say " \|" 12 times [ i^ 1+ 2dup > iff [ drop 4 times sp ] else [ dip dup * 4 echo-rj ] ] cr drop ] ]</syntaxhighlight> {{Out}} <pre> * \| 1 2 3 4 5 6 7 8 9 10 11 12 ---+------------------------------------------------ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144</pre> =={{header\|R}}== <syntaxhighlight lang="r"> multiplication_table <- function(n=12) { Line 1,701 ⟶ 6,654: } multiplication_table() </syntaxhighlight> ~~</lang>~~ =={{header\|Racket}}== <syntaxhighlight lang="racket"> #lang racket (define (show-line xs) (for ([x xs]) (display (~a x #:width 4 #:align 'right))) (newline)) (show-line (cons "" (range 1 13))) (for ([y (in-range 1 13)]) (show-line (cons y (for/list ([x (in-range 1 13)]) (if (<= y x) (* x y) ""))))) </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 9 12 15 18 21 24 27 30 33 36 4 16 20 24 28 32 36 40 44 48 5 25 30 35 40 45 50 55 60 6 36 42 48 54 60 66 72 7 49 56 63 70 77 84 8 64 72 80 88 96 9 81 90 99 108 10 100 110 120 11 121 132 12 144 </pre> =={{header\|Raku}}== (formerly Perl 6) <syntaxhighlight lang="raku" line>(my $f = "%{$_}s" given my $width = ($_*2).chars ) given my $max = 12; say '×'.fmt($f) ~ ' ┃ ' ~ (1..$max).fmt($f); say '━' x $width ~ '━╋' ~ '━' x $max × (1+$width); for 1..$max -> $i { say $i.fmt($f) ~ ' ┃ ' ~ ( $i ≤ $_ ?? $i×$_ !! '' for 1..$max ).fmt($f); }</syntaxhighlight> {{out}} <pre> x│ 1 2 3 4 5 6 7 8 9 10 11 12 ───┼──────────────────────────────────────────────── 1│ 1 2 3 4 5 6 7 8 9 10 11 12 2│ 4 6 8 10 12 14 16 18 20 22 24 3│ 9 12 15 18 21 24 27 30 33 36 4│ 16 20 24 28 32 36 40 44 48 5│ 25 30 35 40 45 50 55 60 6│ 36 42 48 54 60 66 72 7│ 49 56 63 70 77 84 8│ 64 72 80 88 96 9│ 81 90 99 108 10│ 100 110 120 11│ 121 132 12│ 144 </pre> =={{header\|REBOL}}== <~~lang~~syntaxhighlight ~~REBOL~~lang="rebol">REBOL [ Title: "12x12 Multiplication Table" ~~Author: oofoe~~ ~~Date: 2009-12-26~~ URL: http://rosettacode.org/wiki/Print_a_Multiplication_Table ] Line 1,738 ⟶ 6,749: print rejoin [ crlf "How about " size: 20 "?" crlf ] -- .row " x " 1 -- repeat y size [.row p3 y y] --</~~lang~~syntaxhighlight> ~~Output (only 12x12 shown):~~ {{out}} (only 12x12 shown): <pre>+---+---+---+---+---+---+---+---+---+---+---+---+---+ \| x \| 1\| 2\| 3\| 4\| 5\| 6\| 7\| 8\| 9\| 10\| 11\| 12\| Line 1,761 ⟶ 6,771: =={{header\|REXX}}== <syntaxhighlight lang="rexx">/REXX program displays a NxN multiplication table (in a boxed grid) to the terminal./ ~~<lang REXX>~~ parse arg sz . /obtain optional argument from the CL./ ~~/REXX program to display a 12x12 multiplication boxed grid table./~~ if sz=='' \| sz=="," then sz= 12 /Not specified? Then use the default./ w= max(3, length(sz2) ); __= copies('─', w) /calculate the width of the table cell/ ___= __'──' /literals used in the subroutines. / do r=1 for sz /calculate & format a row of the table/ if r==1 then call top left('│(x)', w+1) /show title of multiplication table. / $= '│'center(r"x", w)"│" /index for a multiplication table row./ do c=1 for sz; prod= /build a row of multiplication table. / if r<=c then prod= r c /only display when the row ≤ column. / $= $ \|\| right(prod, w+1) '\|' /append product to a cell in the row. / end /k/ say $ /show a row of multiplication table. / if r\==sz then call sep /show a separator except for last row./ end /j/ call bot /show the bottom line of the table. / exit 0 /stick a fork in it, we're all done. / /──────────────────────────────────────────────────────────────────────────────────────/ hdr: $= ?'│'; do i=1 for sz; $=$ \|\| right(i"x\|", w+3); end; say $; call sep; return dap: $= left($, length($) - 1)arg(1); return top: $= '┌'__"┬"copies(___'┬', sz); call dap "┐"; ?= arg(1); say $; call hdr; return sep: $= '├'__"┼"copies(___'┼', sz); call dap "┤"; say $; return bot: $= '└'__"┴"copies(___'┴', sz); call dap "┘"; say $; return</syntaxhighlight> {{out\|output\|text=  when using the default input of:     <tt> 12 </tt>}} <pre> ┌───┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ │(x)│ 1x\| 2x\| 3x\| 4x\| 5x\| 6x\| 7x\| 8x\| 9x\| 10x\| 11x\| 12x\| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │1x │ 1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 8 \| 9 \| 10 \| 11 \| 12 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │2x │ \| 4 \| 6 \| 8 \| 10 \| 12 \| 14 \| 16 \| 18 \| 20 \| 22 \| 24 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │3x │ \| \| 9 \| 12 \| 15 \| 18 \| 21 \| 24 \| 27 \| 30 \| 33 \| 36 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │4x │ \| \| \| 16 \| 20 \| 24 \| 28 \| 32 \| 36 \| 40 \| 44 \| 48 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │5x │ \| \| \| \| 25 \| 30 \| 35 \| 40 \| 45 \| 50 \| 55 \| 60 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │6x │ \| \| \| \| \| 36 \| 42 \| 48 \| 54 \| 60 \| 66 \| 72 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │7x │ \| \| \| \| \| \| 49 \| 56 \| 63 \| 70 \| 77 \| 84 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │8x │ \| \| \| \| \| \| \| 64 \| 72 \| 80 \| 88 \| 96 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │9x │ \| \| \| \| \| \| \| \| 81 \| 90 \| 99 \| 108 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │10x│ \| \| \| \| \| \| \| \| \| 100 \| 110 \| 120 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │11x│ \| \| \| \| \| \| \| \| \| \| 121 \| 132 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │12x│ \| \| \| \| \| \| \| \| \| \| \| 144 \| └───┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ </pre> {{out\|output\|text=  when using the input of:     <tt> 16 </tt>}} ~~/grid will be displayed in "boxing" characters for ASCII or EBCDIC /~~ <pre> ~~/computers. /~~ ┌───┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ ~~parse~~│(x)│ ~~arg~~ ~~high~~ .1x\| 2x\| 3x\| 4x\| 5x\| 6x\| 7x\| 8x\| ~~/get~~ ~~optional~~9x\| ~~grid~~ ~~size.~~10x\| 11x\| /12x\| 13x\| 14x\| 15x\| 16x\| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~if high=='' then high=12 /not specified? Use default/~~ │1x │ 1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 8 \| 9 \| 10 \| 11 \| 12 \| 13 \| 14 \| 15 \| 16 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~ebcdic='f0'==1 /is this an EBCDIC machine? /~~ │2x │ \| 4 \| 6 \| 8 \| 10 \| 12 \| 14 \| 16 \| 18 \| 20 \| 22 \| 24 \| 26 \| 28 \| 30 \| 32 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~if ebcdic then do /----------EBCDIC-----------/~~ │3x │ \| \| 9 ~~bar='fa'x~~\| 12 \| 15 \| 18 \| 21 \| 24 ~~/vertical~~\| ~~bar.~~ 27 \| 30 \| 33 \| 36 \| 39 /\| 42 \| 45 \| 48 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~dash='bf'x /horizontal dash. /~~ │4x │ \| \| bj ~~='cb'x~~\| 16 \| 20 \| 24 \| 28 \| 32 ~~/bottom~~\| ~~junction.~~ 36 \| 40 \| 44 \| 48 /\| 52 \| 56 \| 60 \| 64 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~tj ='cc'x /* top junction. /~~ │5x │ \| \| cj ~~='8f'x~~\| \| 25 \| 30 \| 35 \| ~~/center~~ ~~junction~~40 ~~(cross).~~\| 45 /\| 50 \| 55 \| 60 \| 65 \| 70 \| 75 \| 80 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~lj ='eb'x / left junction. /~~ │6x │ \| \| rj ~~='ec'x~~\| \| \| 36 \| /42 ~~right~~\| ~~junction.~~ 48 \| 54 \| 60 \| 66 /\| 72 \| 78 \| 84 \| 90 \| 96 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~tlc='ac'x /top left corner. /~~ │7x │ \| \| ~~trc='bc'x~~ \| \| \| ~~/top~~ \| 49 ~~right~~\| ~~corner.~~ 56 \| 63 \| /70 \| 77 \| 84 \| 91 \| 98 \| 105 \| 112 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~blc='ab'x /bottom left corner. /~~ │8x │ \| \| ~~brc='bb'x~~ \| \| \| ~~/bottom~~ ~~right~~\| ~~corner.~~ \| 64 /\| 72 \| 80 \| 88 \| 96 \| 104 \| 112 \| 120 \| 128 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~end~~ │9x │ \| ~~else~~ do\| \| \| \| \| ~~/----------ASCII------------/~~ \| \| 81 \| 90 \| 99 \| 108 \| 117 \| 126 \| 135 \| 144 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~bar='b3'x /vertical bar. /~~ │10x│ \| \| ~~dash='c4'x~~\| \| \| ~~/horizontal~~ ~~dash.~~\| \| \| / \| 100 \| 110 \| 120 \| 130 \| 140 \| 150 \| 160 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~bj ='c1'x /bottom junction. /~~ │11x│ \| \| tj\| ~~='c2'x~~ \| \| \| / ~~top~~ ~~junction.~~\| \| \| / \| 121 \| 132 \| 143 \| 154 \| 165 \| 176 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~cj ='c5'x /center junction (cross). /~~ │12x│ \| \| lj\| ~~='c3'x~~ \| \| \| / ~~left~~ ~~junction.~~ \| \| /\| \| \| 144 \| 156 \| 168 \| 180 \| 192 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~rj ='b4'x / right junction. /~~ │13x│ \| \| ~~tlc='da'x~~\| \| \| ~~/top~~\| ~~left~~\| ~~corner.~~ \| / \| \| \| \| 169 \| 182 \| 195 \| 208 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~trc='bf'x /top right corner. /~~ │14x│ \| \| ~~blc='c0'x~~\| \| \| ~~/bottom~~\| ~~left~~ ~~corner.~~ \| /\| \| \| \| \| \| 196 \| 210 \| 224 \| ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~brc='d9'x /bottom right corner. /~~ │15x│ \| \| \| \| \| \| \| \| \| \| \| \| \| \| 225 \| 240 \| ~~end~~ ├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │16x│ \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| 256 \| └───┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ </pre> =={{header\|Ring}}== ~~cell=cj\|\|copies(dash,5) /define the top of the cell./~~ <syntaxhighlight lang="ring"> ~~sep=copies(cell,high+1)rj /build the table seperator. /~~ multiplication_table(12) ~~sepL=length(sep) /length of seperator line. /~~ func multiplication_table n ~~width=length(cell)-1 /width of the table cells. /~~ nSize = 4 See " \| " ~~size=width-1 /width for table numbers. /~~ for t = 1 to n see fsize(t, nSize) next see nl + "----+-" + copy("-", nSizen) + nl for t1 = 1 to n see fsize(t1, nSize) + "\| " for t2 = 1 to n if t2 >= t1 see fsize(t1t2,nSize) else see copy(" ", nSize) ok next see nl next func fsize x,n return string(x) + copy(" ",n-len(string(x))) </syntaxhighlight> Output ~~box.=left('',width) /construct all cells. /~~ <syntaxhighlight lang="ring"> \| 1 2 3 4 5 6 7 8 9 10 11 12 ----+------------------------------------------------- 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </syntaxhighlight> =={{header\|Ruby}}== ~~do j=0 to high /step through zero to H (12)/~~ <syntaxhighlight lang="ruby">def multiplication_table(n) ~~_=right(j,size-1)'x ' /build "label"/border number/~~ puts " \|" + (" %3d" n) % [1..n] ~~box.0.j=_ /build top label cell. /~~ puts "----+" + "----" n ~~box.j.0=_ /build left label cell. /~~ 1.upto(n) do \|x\| print "%3d \|" % x 1.upto(x-1) {\|y\| print " "} x.upto(n) {\|y\| print " %3d" % (xy)} puts end end multiplication_table 12</syntaxhighlight> ~~box.0.0=centre('times',width) /redefine box.0.0 with 'X' /~~ {{out}} ~~do row=1 for high /step through 1 to H (12)./~~ <pre> ~~do col=row to high /step through row to H (12)./~~ \| 1 2 3 4 5 6 7 8 9 10 11 12 ~~box.row.col=right(rowcol,size)' ' /build a multiplication cell/~~ ----+------------------------------------------------ ~~end~~ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 ~~end~~ 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> =={{header\|Rust}}== ~~say /display a blank line. /~~ <syntaxhighlight lang="rust">const LIMIT: i32 = 12; fn main() { ~~do row=0 to high /step through all the lines./~~ for i in 1..LIMIT+1 { ~~asep=sep /allow use of a modified sep/~~ print!("{:3}{}", i, if LIMIT - i == 0 {'\n'} else {' '}) } for i in 0..LIMIT+1 { print!("{}", if LIMIT - i == 0 {"+\n"} else {"----"}); } for i in 1..LIMIT+1 { ~~if row==0 then do~~ for j in 1..LIMIT+1 { ~~asep=overlay(tlc,asep,1) /make a better tlc./~~ if j < i ~~asep=overlay(trc,asep,sepL) /make a better trc./~~{ ~~asep=translate~~print!(~~asep,tj,cj)~~" ~~/make a better tj./~~") } else { ~~end~~ ~~else~~ ~~asep=overlay(lj,asep,1)~~ print!("{:3} ", j /~~make~~ ~~a better lj./~~i) } } println!("\| {}", i); } }</syntaxhighlight> or, in terms of map: ~~say asep /display a table grid line. /~~ ~~if row==0 then call buildLine 00 /display a blank grid line. /~~ ~~call buildLine row /build one line of the grid./~~ ~~if row==0 then call buildLine 00 /display a blank grid line. /~~ ~~end~~ <syntaxhighlight lang="rust">fn main() { ~~asep=sep /allow use of a modified sep/~~ let xs = (1..=12) ~~asep=overlay(blc,asep,1) /make a better bot left corn/~~ .map(\|a\| { ~~asep=overlay(brc,asep,sepL) /make a better bot right cor/~~ (1..=12) ~~asep=translate(asep,bj,cj) /make a better bot junction./~~ ~~say~~ ~~asep~~ ~~/display a table grid line~~.map(\|b\| /{ ~~say~~ ~~/display~~if a ~~blank line.~~ > b /{ String::from(" ") ~~exit~~ } else { format!("{:4}", a * b) } }) .collect::<String>() }) .collect::<Vec<String>>(); println!("{}", xs.join("\n")) }</syntaxhighlight> =={{header\|Scala}}== ~~buildLine: w='' /start with a blank cell. /~~ <syntaxhighlight lang="scala"> ~~parse arg arow~~ //Multiplication Table print("%5s".format("\|")) for (i <- 1 to 12) print("%5d".format(i)) println() println("-----" * 13) for (i <- 1 to 12) { ~~do col=0 to high /step through 0 to H (12)./~~ print("%4d\|".format(i)) ~~w=w\|\|bar\|\|box.arow.col /build one cell at a time. /~~ ~~end~~ for (j <- 1 to 12) { ~~say w\|\|bar /finish building last cell. /~~ if (i <= j) ~~return~~ print("%5d".format(i * j)) ~~</lang>~~ else ~~Output:~~ print("%5s".format("")) ~~<pre style="height:30ex;overflow:scroll">~~ } println("") ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ } ~~│ │ │ │ │ │ │ │ │ │ │ │ │ │~~ </syntaxhighlight> ~~│times│ 1x │ 2x │ 3x │ 4x │ 5x │ 6x │ 7x │ 8x │ 9x │ 10x │ 11x │ 12x │~~ ~~│ │ │ │ │ │ │ │ │ │ │ │ │ │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 1x │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │ 12 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 2x │ │ 4 │ 6 │ 8 │ 10 │ 12 │ 14 │ 16 │ 18 │ 20 │ 22 │ 24 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 3x │ │ │ 9 │ 12 │ 15 │ 18 │ 21 │ 24 │ 27 │ 30 │ 33 │ 36 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 4x │ │ │ │ 16 │ 20 │ 24 │ 28 │ 32 │ 36 │ 40 │ 44 │ 48 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 5x │ │ │ │ │ 25 │ 30 │ 35 │ 40 │ 45 │ 50 │ 55 │ 60 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 6x │ │ │ │ │ │ 36 │ 42 │ 48 │ 54 │ 60 │ 66 │ 72 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 7x │ │ │ │ │ │ │ 49 │ 56 │ 63 │ 70 │ 77 │ 84 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 8x │ │ │ │ │ │ │ │ 64 │ 72 │ 80 │ 88 │ 96 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 9x │ │ │ │ │ │ │ │ │ 81 │ 90 │ 99 │ 108 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 10x │ │ │ │ │ │ │ │ │ │ 100 │ 110 │ 120 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 11x │ │ │ │ │ │ │ │ │ │ │ 121 │ 132 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 12x │ │ │ │ │ │ │ │ │ │ │ │ 144 │~~ └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ === case === ~~</pre>~~ <syntaxhighlight lang="scala"> ~~<lang rexx>~~ implicit def intToString(i: Int) = i.toString ~~Below is another output when a~~ val cell = (x:String) => print("%5s".format(x)) for { 10 i <- 1 to 14 j <- 1 to 14 ~~is specified as the program's argument.~~ } ~~</lang>~~ yield { ~~Output:~~ (i, j) match { ~~<pre style="height:30ex;overflow:scroll">~~ case (i, 13) => cell("\|") case (i, 14) if i > 12 => cell("\n") ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ case (13, j) => cell("-----") ~~│ │ │ │ │ │ │ │ │ │ │ │~~ case (i, 14) => cell(i + "\n") ~~│times│ 1x │ 2x │ 3x │ 4x │ 5x │ 6x │ 7x │ 8x │ 9x │ 10x │~~ case (14, j) => cell(j) ~~│ │ │ │ │ │ │ │ │ │ │ │~~ case (i, j) if i <= j => cell(ij) ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ case (i, j) => cell("-") ~~│ 1x │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │~~ } ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ } ~~│ 2x │ │ 4 │ 6 │ 8 │ 10 │ 12 │ 14 │ 16 │ 18 │ 20 │~~ </syntaxhighlight> ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 3x │ │ │ 9 │ 12 │ 15 │ 18 │ 21 │ 24 │ 27 │ 30 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 4x │ │ │ │ 16 │ 20 │ 24 │ 28 │ 32 │ 36 │ 40 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 5x │ │ │ │ │ 25 │ 30 │ 35 │ 40 │ 45 │ 50 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 6x │ │ │ │ │ │ 36 │ 42 │ 48 │ 54 │ 60 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 7x │ │ │ │ │ │ │ 49 │ 56 │ 63 │ 70 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 8x │ │ │ │ │ │ │ │ 64 │ 72 │ 80 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 9x │ │ │ │ │ │ │ │ │ 81 │ 90 │~~ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ ~~│ 10x │ │ │ │ │ │ │ │ │ │ 100 │~~ └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ ~~</pre>~~ ~~=={{header\|Ruby}}==~~ ~~<lang ruby>def multiplication_table(n)~~ ~~puts " " + ((" %3d" n) % (1..n).to_a)~~ ~~1.upto(n) do \|x\|~~ ~~print "%3d " % x~~ ~~1.upto(x-1) {\|y\| print " "}~~ ~~x.upto(n) {\|y\| print " %3d" % (xy)}~~ ~~puts ""~~ ~~end~~ ~~end~~ ~~multiplication_table 12</lang>~~ =={{header\|Scheme}}== Line 1,947 ⟶ 7,020: A better implementation of <tt>iota</tt> is provided by SRFI-1 [http://srfi.schemers.org/srfi-1/srfi-1.html]. <~~lang~~syntaxhighlight lang="scheme"> (define iota (lambda (count start step) Line 1,974 ⟶ 7,047: (loop (+ count 1) (cdr numbers))))))) </syntaxhighlight> ~~</lang>~~ <pre> Line 1,991 ⟶ 7,064: 144 </pre> =={{header\|Scilab}}== {{works with\|Scilab\|5.5.1}} <syntaxhighlight lang="scilab"> nmax=12, xx=3 s= blanks(xx)+" \|" for j=1:nmax s=s+part(blanks(xx)+string(j),$-xx:$) end printf("%s\n",s) s=strncpy("-----",xx)+" +" for j=1:nmax s=s+" "+strncpy("-----",xx) end printf("%s\n",s) for i=1:nmax s=part(blanks(xx)+string(i),$-xx+1:$)+" \|" for j = 1:nmax if j >= i then s=s+part(blanks(xx)+string(ij),$-xx:$) else s=s+blanks(xx+1) end end printf("%s\n",s) end</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --- + --- --- --- --- --- --- --- --- --- --- --- --- 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144</pre> =={{header\|Seed7}}== <~~lang~~syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; const proc: main is func Line 2,016 ⟶ 7,129: writeln("\|" <& i lpad 3); end for; end func;</~~lang~~syntaxhighlight> {{out}} ~~Output:~~ <pre> 1 2 3 4 5 6 7 8 9 10 11 12 Line 2,034 ⟶ 7,147: 121 132 \| 11 144 \| 12 </pre> =={{header\|Sidef}}== <syntaxhighlight lang="ruby">var max = 12 var width = (max*2 -> len+1) func fmt_row(items) { items.map {\|s\| "%s" % (width, s) }.join } say fmt_row('x┃', (1..max)...) say "#{'━' (width - 1)}╋#{'━' * (max * width)}" { \|i\| say fmt_row("#{i}┃", {\|j\| i <= j ? ij : ''}.map(1..max)...) } << 1..max</syntaxhighlight> {{out}} <pre> x┃ 1 2 3 4 5 6 7 8 9 10 11 12 ━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1┃ 1 2 3 4 5 6 7 8 9 10 11 12 2┃ 4 6 8 10 12 14 16 18 20 22 24 3┃ 9 12 15 18 21 24 27 30 33 36 4┃ 16 20 24 28 32 36 40 44 48 5┃ 25 30 35 40 45 50 55 60 6┃ 36 42 48 54 60 66 72 7┃ 49 56 63 70 77 84 8┃ 64 72 80 88 96 9┃ 81 90 99 108 10┃ 100 110 120 11┃ 121 132 12┃ 144 </pre> =={{header\|Simula}}== {{trans\|ALGOL W}} <syntaxhighlight lang="simula">begin integer i, j; outtext( " " ); for i := 1 step 1 until 12 do outint( i, 4 ); outimage; outtext( " +" ); for i := 1 step 1 until 12 do outtext( "----" ); outimage; for i := 1 step 1 until 12 do begin outint( i, 3 ); outtext( "\|" ); for j := 1 step 1 until i - 1 do outtext( " " ); for j := i step 1 until 12 do outint( i j, 4 ); outimage end; end</syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 +------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144</pre> =={{header\|Swift}}== <syntaxhighlight lang="swift">import Foundation let size = 12 func printRow(with:Int, upto:Int) { print(String(repeating: " ", count: (with-1)4), terminator: "") for i in with...upto { print(String(format: "%l4d", iwith), terminator: "") } print() } print(" ", terminator: ""); printRow( with: 1, upto: size) print( String(repeating: "–", count: (size+1)4 )) for i in 1...size { print(String(format: "%l4d",i), terminator:"") printRow( with: i, upto: size) } </syntaxhighlight> =={{header\|Tailspin}}== <syntaxhighlight lang="tailspin"> templates formatN&{width:} [ 1..$width -> ' ', '$;'... ] -> '$(last-$width+1..last)...;' ! end formatN ' \|$:1..12 -> formatN&{width: 4}; ' -> !OUT::write '--+$:1..124 -> '-'; ' -> !OUT::write 1..12 -> \( def row: $; '$ -> formatN&{width:2};\|$:1..($-1)4 -> ' ';$:$..12 -> $$row -> formatN&{width:4}; ' ! \) -> !OUT::write </syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| 4 6 8 10 12 14 16 18 20 22 24 3\| 9 12 15 18 21 24 27 30 33 36 4\| 16 20 24 28 32 36 40 44 48 5\| 25 30 35 40 45 50 55 60 6\| 36 42 48 54 60 66 72 7\| 49 56 63 70 77 84 8\| 64 72 80 88 96 9\| 81 90 99 108 10\| 100 110 120 11\| 121 132 12\| 144 </pre> =={{header\|Tcl}}== <~~lang~~syntaxhighlight lang="tcl">puts " x\u2502 1 2 3 4 5 6 7 8 9 10 11 12" puts \u0020\u2500\u2500\u253c[string repeat \u2500 48] for {set i 1} {$i <= 12} {incr i} { Line 2,047 ⟶ 7,282: } puts "" }</~~lang~~syntaxhighlight> {{out}} ~~Output:~~ <pre> x│ 1 2 3 4 5 6 7 8 9 10 11 12 Line 2,067 ⟶ 7,302: =={{header\|TUSCRIPT}}== <~~lang~~syntaxhighlight lang="tuscript"> $$ MODE TUSCRIPT x=y="1'2'3'4'5'6'7'8'9'10'11'12" Line 2,086 ⟶ 7,321: PRINT col,cnt ENDLOOP </syntaxhighlight> ~~</lang>~~ {{out}} ~~Output:~~ <pre style='height:30ex;overflow:scroll'> 1 2 3 4 5 6 7 8 9 10 11 12 Line 2,101 ⟶ 7,336: 11 121 132 12 144 </pre> == {{header\|TypeScript}} == {{trans\|Modula-2}} <syntaxhighlight lang="javascript"> // Multiplication tables var n = 12; console.clear(); for (j = 1; j < n; j++) process.stdout.write(j.toString().padStart(3, ' ') + " "); console.log(n.toString().padStart(3, ' ')); console.log("----".repeat(n) + "+"); for (i = 1; i <= n; i++) { for (j = 1; j <= n; j++) process.stdout.write(j < i ? " " : (i * j).toString().padStart(3, ' ') + " "); console.log("\| " + i.toString().padStart(2, ' ')); } </syntaxhighlight> {{out}} <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ------------------------------------------------+ 1 2 3 4 5 6 7 8 9 10 11 12 \| 1 4 6 8 10 12 14 16 18 20 22 24 \| 2 9 12 15 18 21 24 27 30 33 36 \| 3 16 20 24 28 32 36 40 44 48 \| 4 25 30 35 40 45 50 55 60 \| 5 36 42 48 54 60 66 72 \| 6 49 56 63 70 77 84 \| 7 64 72 80 88 96 \| 8 81 90 99 108 \| 9 100 110 120 \| 10 121 132 \| 11 144 \| 12 </pre> Line 2,106 ⟶ 7,377: It's no more difficult to express the general case than the size 12 case, so a table generating function parameterized by the size is used. <syntaxhighlight lang="ursala"> ~~<lang Ursala>~~ #import std #import nat Line 2,119 ⟶ 7,390: main = table 12 </syntaxhighlight> ~~</lang>~~ A better way of using Ursala to make tables would be with the <code>tbl</code> library included with the standard package, which can generate LaTeX code for arbitrary heading hierarchies and typesetting options, but here it is in ASCII art. Line 2,137 ⟶ 7,408: 11 \| 121 132 12 \| 144 </pre> =={{header\|VBScript}}== <syntaxhighlight lang="vb"> function pad(s,n) if n<0 then pad= right(space(-n) & s ,-n) else pad= left(s& space(n),n) end if End Function Sub print(s): On Error Resume Next WScript.stdout.Write (s) If err= &h80070006& Then WScript.Echo " Please run this script with CScript": WScript.quit End Sub For i=1 To 12 print pad(i,-4) Next print vbCrLf & String(48,"_") For i=1 To 12 print vbCrLf For j=1 To 12 if j<i Then print Space(4) Else print pad(ij,-4) Next print "\|"& pad(i,-2) Next </syntaxhighlight> {{out}} <small> <pre> 1 2 3 4 5 6 7 8 9 10 11 12 ________________________________________________ 1 2 3 4 5 6 7 8 9 10 11 12\| 1 4 6 8 10 12 14 16 18 20 22 24\| 2 9 12 15 18 21 24 27 30 33 36\| 3 16 20 24 28 32 36 40 44 48\| 4 25 30 35 40 45 50 55 60\| 5 36 42 48 54 60 66 72\| 6 49 56 63 70 77 84\| 7 64 72 80 88 96\| 8 81 90 99 108\| 9 100 110 120\|10 121 132\|11 144\|12 </pre> </small> =={{header\|Wren}}== {{libheader\|Wren-fmt}} <syntaxhighlight lang="wren">import "./fmt" for Fmt var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] Fmt.print(" x \| $4d", nums) System.print("----+%("-" 60)") for (i in 1..12) { var nums2 = nums.map { \|n\| (n >= i) ? (n * i).toString : " " }.toList Fmt.print("$3d \| $4s", i, nums2) }</syntaxhighlight> {{out}} <pre> x \| 1 2 3 4 5 6 7 8 9 10 11 12 ----+------------------------------------------------------------ 1 \| 1 2 3 4 5 6 7 8 9 10 11 12 2 \| 4 6 8 10 12 14 16 18 20 22 24 3 \| 9 12 15 18 21 24 27 30 33 36 4 \| 16 20 24 28 32 36 40 44 48 5 \| 25 30 35 40 45 50 55 60 6 \| 36 42 48 54 60 66 72 7 \| 49 56 63 70 77 84 8 \| 64 72 80 88 96 9 \| 81 90 99 108 10 \| 100 110 120 11 \| 121 132 12 \| 144 </pre> =={{header\|XPL0}}== <syntaxhighlight lang="xpl0">include c:\cxpl\codes; int X, Y; [Format(4, 0); Text(0, " \|"); for X:= 1 to 12 do RlOut(0, float(X)); CrLf(0); Text(0, " --+"); for X:= 1 to 12 do Text(0, "----"); CrLf(0); for Y:= 1 to 12 do [RlOut(0, float(Y)); ChOut(0, ^\|); for X:= 1 to 12 do if X>=Y then RlOut(0, float(XY)) else Text(0, " . ."); CrLf(0); ]; ]</syntaxhighlight> {{out}} <pre> \| 1 2 3 4 5 6 7 8 9 10 11 12 --+------------------------------------------------ 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| . . 4 6 8 10 12 14 16 18 20 22 24 3\| . . . . 9 12 15 18 21 24 27 30 33 36 4\| . . . . . . 16 20 24 28 32 36 40 44 48 5\| . . . . . . . . 25 30 35 40 45 50 55 60 6\| . . . . . . . . . . 36 42 48 54 60 66 72 7\| . . . . . . . . . . . . 49 56 63 70 77 84 8\| . . . . . . . . . . . . . . 64 72 80 88 96 9\| . . . . . . . . . . . . . . . . 81 90 99 108 10\| . . . . . . . . . . . . . . . . . . 100 110 120 11\| . . . . . . . . . . . . . . . . . . . . 121 132 12\| . . . . . . . . . . . . . . . . . . . . . . 144 </pre> =={{header\|zkl}}== <syntaxhighlight lang="zkl">fcn multiplicationTable(n){ w,fmt := (nn).numDigits, " %%%dd".fmt(w).fmt; // eg " %3".fmt header:=[1..n].apply(fmt).concat(); // 1 2 3 4 ... println(" x ", header, "\n ", "-"header.len()); dash:=String(" "w,"-"); // eg " -" foreach a in ([1..n]){ print("%2d\|".fmt(a),dash(a-1)); [a..n].pump(String,'(a),fmt).println(); } }(12);</syntaxhighlight> {{out}} <pre> x 1 2 3 4 5 6 7 8 9 10 11 12 ----------------------------------------------- 1\| 1 2 3 4 5 6 7 8 9 10 11 12 2\| - 4 6 8 10 12 14 16 18 20 22 24 3\| - - 9 12 15 18 21 24 27 30 33 36 4\| - - - 16 20 24 28 32 36 40 44 48 5\| - - - - 25 30 35 40 45 50 55 60 6\| - - - - - 36 42 48 54 60 66 72 7\| - - - - - - 49 56 63 70 77 84 8\| - - - - - - - 64 72 80 88 96 9\| - - - - - - - - 81 90 99 108 10\| - - - - - - - - - 100 110 120 11\| - - - - - - - - - - 121 132 12\| - - - - - - - - - - - 144 </pre>