Multiplication tables: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|APL}}) |
m (→{{header|Wren}}: Minor tidy) |
||
(22 intermediate revisions by 13 users not shown) | |||
Line 12:
{{trans|C}}
<
L(j) 1..n
print(‘#3’.format(j), end' ‘ ’)
Line 23:
L(j) 1..n
print(I j < i {‘ ’} E ‘#3 ’.format(i * j), end' ‘’)
print(‘│ ’i)</
{{out}}
Line 44:
=={{header|360 Assembly}}==
<
MULTTABL CSECT
USING MULTTABL,R12
Line 103:
PORT DC C'--+-------------------------------------------------'
YREGS
END MULTTABL</
{{out}}
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
Line 122:
=={{header|8080 Assembly}}==
<
lxi h,output
;;; Make the header
Line 218:
inx h
ret
output: equ $</
{{out}}
Line 240:
=={{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 */
Line 391:
.include "../includeARM64.inc"
</syntaxhighlight>
{{Output}}
<pre>
Line 410:
=={{header|Action!}}==
<
BYTE i
Line 470:
OD
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multiplication_tables.png Screenshot from Atari 8-bit computer]
Line 491:
=={{header|ActionScript}}==
<syntaxhighlight lang="actionscript">
package {
Line 571:
}
</syntaxhighlight>
=={{header|Ada}}==
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
Line 600:
end loop;
end Multiplication_Table;
</syntaxhighlight>
<pre>
| 1 2 3 4 5 6 7 8 9 10 11 12
Line 620:
=={{header|Agena}}==
{{Trans|ALGOL_W}}
<
# print a school style multiplication table
# NB: print outputs a newline at the end, write and printf do not
Line 633:
od;
print()
epocs</
{{out}}
<pre>
Line 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}} -->
<
INT max = 12;
INT width = ENTIER(log(max)*2)+1;
Line 676:
OD;
printf(($gl$, hr))
)</
{{out}}
<pre>
Line 698:
=={{header|ALGOL W}}==
<
% print a school style multiplication table %
i_w := 3; s_w := 0; % set output formating %
Line 711:
end;
end.</
{{out}}
<pre>
Line 732:
=={{header|APL}}==
A simple table is trivial:
<syntaxhighlight lang
But that prints out all the duplicated results across the diagonal:
Line 753:
{{works with|Dyalog APL}}
<
{{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}}
Line 777:
=={{header|AppleScript}}==
===Iteration===
<
repeat with x from 0 to n
if x = 0 then set {table, x} to {{return}, -1}
Line 797:
set text item delimiters to ""
return (characters -4 thru -1 of (" " & x)) as string
end f</
{{out}}
<pre>"
Line 819:
{{trans|JavaScript}} (ES5 functional version)
<
-- multiplicationTable :: Int -> Int -> String
Line 1,001:
end repeat
return out & dbl
end replicate</
{{Out}}
<pre> x 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,034:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 1,217:
</syntaxhighlight>
=={{header|Arturo}}==
<
print [" |"] ++ map 1..n => [pad to :string & 3]
print "----+" ++ join map 1..n => "----"
Line 1,231:
]
mulTable 12</
{{out}}
Line 1,249:
11 | 121 132
12 | 144</pre>
=={{header|AutoHotkey}}==
<
Gui, Margin, 0, 0
Gui, Font, s9, Fixedsys
Line 1,354 ⟶ 1,286:
}
GuiControl,, Edit2, %Table%
Return</
Message box shows:
<pre> x | 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,373 ⟶ 1,305:
=={{header|AutoIt}}==
<
$tableupto=12
$table=""
Line 1,392 ⟶ 1,324:
Next
Next
msgbox(0,"Multiplication Tables",$table)</
=={{header|AWK}}==
<syntaxhighlight lang="awk">
BEGIN {
for(i=1;i<=12;i++){
Line 1,404 ⟶ 1,336:
print
}
}</
{{out}}
<pre>
Line 1,423 ⟶ 1,355:
=={{header|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.
<
ClrDraw
For(I,1,10)
Line 1,440 ⟶ 1,372:
DispGraph
getKeyʳ
Fix 4</
Approximate output:
Line 1,457 ⟶ 1,389:
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<
110 DEF FN T(X) = X * 3 + (X < 4) * (4 - X) + (X > 10) * (X - 10) - 1
120 FOR N = -1 TO M
Line 1,469 ⟶ 1,399:
170 V$ = STR$(I * J)
180 PRINT TAB(FN T(J)) MID$(" ", 1, 3 - LEN(V$) - (J < 4)) V$;
190 NEXT J, N</
==={{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}}===
<
print "---+------------------------------------------------"
Line 1,488 ⟶ 1,486:
next j
print nums$
next i</
==={{header|BBC BASIC}}===
BBC BASIC automatically right-justifies numeric output.
<
FOR row% = 1 TO 12
PRINT row% TAB(row% * @%) ;
Line 1,499 ⟶ 1,497:
NEXT col%
PRINT
NEXT row%</
{{out}}
<pre> 1 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,513 ⟶ 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 (i*4);
200 for j = i to 12
210 print using " ###";i*j;
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.
<
110 PRINT " X";
120 W=2
Line 1,560 ⟶ 1,578:
520 N$=MID$(STR$(N),2)
530 IF LEN(N$)<W THEN N$=" "+N$:GOTO 530
540 RETURN</
{{Out}}
Line 1,589 ⟶ 1,607:
12: : : : : : : : : : : :144</pre>
==={{header|FreeBASIC}}===
<
' FB 1.05.0 Win64
Line 1,611 ⟶ 1,629:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,632 ⟶ 1,650:
==={{header|FutureBasic}}===
<syntaxhighlight lang="basic">
long i, j
Line 1,652 ⟶ 1,670:
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
Line 1,673 ⟶ 1,734:
==={{header|GW-BASIC}}===
{{trans|Modula-2}}
{{works with|BASICA}}
{{works with|PC-BASIC|any}}
<syntaxhighlight lang="gwbasic">
10 ' Multiplication Tables
20 LET N% = 12
Line 1,692 ⟶ 1,754:
160 PRINT "| "; USING "##"; I%
170 NEXT I%
</syntaxhighlight>
{{out}}
<pre>
Line 1,712 ⟶ 1,774:
==={{header|IS-BASIC}}===
<
110 TEXT 80
120 PRINT TAB(7);
Line 1,725 ⟶ 1,787:
210 NEXT
220 PRINT
230 NEXT</
==={{header|Liberty BASIC}}===
<
Print "--+------------------------------------------------------------"
Line 1,744 ⟶ 1,806:
Next ii
Print nums$
Next i</
{{out}}
<pre>
Line 1,765 ⟶ 1,827:
==={{header|Microsoft Small Basic}}===
{{trans|Modula-2}}
<
n = 12
For j = 1 To n - 1
Line 1,794 ⟶ 1,856:
TextWindow.WriteLine("")
EndFor
</syntaxhighlight>
{{out}}
<pre>
Line 1,814 ⟶ 1,876:
==={{header|PureBasic}}===
<
sp = Len(Str(maxx*maxy)) + 1
trenner$ = "+"
Line 1,848 ⟶ 1,910:
OpenConsole()
PrintMultiplicationTable(12, 12)
Input()</
Ouput similar to ALGOL 68
==={{header|QBasic}}===
<
'header row
Line 1,878 ⟶ 1,940:
PRINT o$;
NEXT
NEXT</
{{out}}
Line 1,899 ⟶ 1,961:
==={{header|Run BASIC}}===
<
For i = 1 To 12
html "<TR align=right><TD>";i;"</td>"
Line 1,909 ⟶ 1,971:
next i
html "</table>"
</
<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=I*J
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}}===
<
PRINT "---+------------------------------------------------"
Line 1,929 ⟶ 2,053:
NEXT i
PRINT
END</
==={{header|uBasic/4tH}}===
{{trans|BBC BASIC}}
<syntaxhighlight lang="basic">For R = 1 To 12
Print R;Tab(R * 5);
For C = R To 12
Line 1,939 ⟶ 2,063:
Next
Print
Next</
{{out}}
<pre>1 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,955 ⟶ 2,079:
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}}
<
Const nmax = 12, xx = 3
Const x = xx + 1
Line 1,981 ⟶ 2,151:
Debug.Print s
Next i
End Sub 'Main</
{{Out}}
<pre>
Line 2,003 ⟶ 2,173:
{{trans|Modula-2}}
{{works with|Windows XBasic}}
<
PROGRAM "multiplicationtables"
VERSION "0.0001"
Line 2,031 ⟶ 2,201:
END FUNCTION
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
Line 2,051 ⟶ 2,221:
==={{header|Yabasic}}===
<
print "---+------------------------------------------------"
Line 2,067 ⟶ 2,237:
next j
print nums$
next i</
=={{header|Batch File}}==
<
setlocal enabledelayedexpansion
Line 2,116 ⟶ 2,286:
for /l %%A in (1,1,%numspaces%) do set "space=!space! "
goto :EOF
::/The Functions.</
{{Out}}
<pre>
Line 2,137 ⟶ 2,307:
=={{header|Befunge}}==
<
w^p2<y|!`+66:+1,+*84*"\"!:g25$_,#!>#:<$$_^#!:-1g10/+55\-**<<
"$9"^x>$55+,51g1+:66+`#@_055+68*\>\#<1#*-#9:#5_$"+---">:#,_$</
{{out}}
Line 2,161 ⟶ 2,331:
<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>).
<
m ← •Repr¨ ×⌜˜1+↕𝕩 # The numbers, formatted individually
main ← ⟨ # Bottom part: three sections
Line 2,172 ⟶ 2,342:
}
•Out˘ Table 12</
{{Out}}
<
--+-----------------------------------------------
1| 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,187 ⟶ 2,357:
10| 100 110 120
11| 121 132
12| 144</
=={{header|Bracmat}}==
<
= high i j row row2 matrix padFnc tmp
, celPad leftCelPad padFnc celDashes leftDashes
Line 2,245 ⟶ 2,415:
)
& out$(multiplicationTable$12)
& done;</
{{out}}
<pre> X| 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,263 ⟶ 2,433:
=={{header|C}}==
<
int main(void)
Line 2,279 ⟶ 2,449:
return 0;
}</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,297 ⟶ 2,467:
=={{header|C sharp}}==
<
namespace multtbl
Line 2,335 ⟶ 2,505:
}
}
</syntaxhighlight>
{{out}}
Line 2,359 ⟶ 2,529:
and formats the table columns.
<
#include <iomanip>
#include <cmath> // for log10()
Line 2,436 ⟶ 2,606:
return 0;
}
</syntaxhighlight>
{{out}}
Line 2,470 ⟶ 2,640:
=={{header|Chef}}==
<
Prints out a multiplication table.
Line 2,534 ⟶ 2,704:
Pour contents of the 2nd mixing bowl into the 2nd baking dish.
Serves 2.</
{{out}}
Line 2,555 ⟶ 2,725:
This is more generalized.
Any size can be used and the table will be formatted appropriately.
<
trange (range 1 (inc size))
fmt-width (+ (.length (str (* size size))) 1)
Line 2,568 ⟶ 2,738:
(for [j trange] j))))))]
(println s)))
</syntaxhighlight>
{{out}}
Line 2,587 ⟶ 2,757:
=={{header|COBOL}}==
<
program-id. multiplication-table.
Line 2,633 ⟶ 2,803:
goback.
end program multiplication-table.
</syntaxhighlight>
{{out}}
<pre>prompt$ cobc -xj multiplication-table.cob
Line 2,651 ⟶ 2,821:
=={{header|CoffeeScript}}==
<
print_multiplication_tables = (n) ->
width = 4
Line 2,683 ⟶ 2,853:
print_multiplication_tables 12
</syntaxhighlight>
{{out}}
Line 2,705 ⟶ 2,875:
=={{header|Common Lisp}}==
<
(do ((m 0 (if (= 12 m) 0 (1+ m)))
(n 0 (if (= 12 m) (1+ n) n)))
Line 2,722 ⟶ 2,892:
(format t "~4,D" (* m n))
(format t " "))))))
</syntaxhighlight>
Output:
<pre>
Line 2,744 ⟶ 2,914:
=={{header|D}}==
{{trans|PicoLisp}}
<
import std.stdio, std.array, std.range, std.algorithm;
Line 2,752 ⟶ 2,922:
writefln("%4d" ~ " ".replicate(4 * (y - 1)) ~ "%(%4d%)", y,
iota(y, n + 1).map!(x => x * y));
}</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,770 ⟶ 2,940:
=={{header|DCL}}==
<
$ h = f$fao( "!4* " )
$ r = 0
Line 2,795 ⟶ 2,965:
$ write sys$output f$fao( "!4SL", r ) + o
$ r = r + 1
$ if r .le. max then $ goto loop1</
{{out}}
<pre>$ @multiplication_tables
Line 2,817 ⟶ 2,987:
=={{header|Delphi}}==
{{trans|DWScript}}
<
{$APPTYPE CONSOLE}
Line 2,846 ⟶ 3,016:
Writeln;
end;
end.</
=={{header|Draco}}==
<
proc nonrec multab(byte n) void:
byte i,j;
Line 2,874 ⟶ 3,044:
/* Print 12-by-12 multiplication table */
proc nonrec main() void: multab(12) corp</
{{out}}
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,893 ⟶ 3,063:
=={{header|DWScript}}==
<
var row, col : Integer;
Line 2,911 ⟶ 3,081:
PrintLn('');
end;
</syntaxhighlight>
=={{header|E}}==
<
println(`{|style="border-collapse: collapse; text-align: right;"`)
println(`|`)
Line 2,928 ⟶ 3,098:
}
}
println("|}")</
Targets MediaWiki markup.
Line 3,120 ⟶ 3,290:
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
n = 12
numfmt 0 4
write " "
for i = 1 to n
.
print ""
write " "
for i = 1 to n
write "----"
.
print ""
for i = 1 to n
write "|"
for j = 1 to n
if j < i
write " "
else
.
.
print ""
.
</syntaxhighlight>
=={{header|EchoLisp}}==
<
(lib 'matrix)
Line 3,167 ⟶ 3,331:
(array-print (build-array 13 13 mtable))
</syntaxhighlight>
{{out}}
<pre>
Line 3,186 ⟶ 3,350:
=={{header|Elixir}}==
<
def multiplication_tables(n) do
IO.write " X |"
Line 3,201 ⟶ 3,365:
end
RC.multiplication_tables(12)</
{{out}}
Line 3,219 ⟶ 3,383:
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 ).
Line 3,247 ⟶ 3,443:
[io:fwrite("~5B", [Sum]) || {_Y, Sum} <- Uptos],
io:nl().
</syntaxhighlight>
{{out}}
<pre>
Line 3,268 ⟶ 3,464:
=={{header|Euphoria}}==
<
for i = 1 to 12 do
printf(1," %3d",i)
Line 3,285 ⟶ 3,481:
end for
puts(1,'\n')
end for</
{{out}}
Line 3,312 ⟶ 3,508:
{{Works with|Office 365 betas 2021}}
<
=LAMBDA(f,
LAMBDA(n,
Line 3,328 ⟶ 3,524:
)
)
)</
and also assuming the following generic bindings in the Name Manager for the WorkBook:
<
=LAMBDA(a, LAMBDA(b, a * b))
Line 3,341 ⟶ 3,537:
POWER(n, e)
)
)</
(The single formula in cell '''B2''' below populates the whole 12*12 grid)
Line 3,758 ⟶ 3,954:
=={{header|F Sharp|F#}}==
Translation of C#
<syntaxhighlight lang="fsharp">
open System
Line 3,778 ⟶ 3,974:
multTable ()
</syntaxhighlight>
{{out}}
<pre>
Line 3,798 ⟶ 3,994:
=={{header|Factor}}==
<
IN: multiplication-table
Line 3,814 ⟶ 4,010:
" +" write
12 [ "----" write ] times nl
1 12 [a,b] [ print-row ] each ;</
<pre>
Line 3,834 ⟶ 4,030:
=={{header|FALSE}}==
<
[$p;! m: 2[$m;\>][" "1+]# [$13\>][$m;*p;!1+]#%"
"]l:
1[$13\>][$l;!1+]#%</
=={{header|Fantom}}==
<
class Main
{
Line 3,863 ⟶ 4,059:
}
}
</syntaxhighlight>
=={{header|Forth}}==
<
: multiplication-table
cr 2 spaces 13 2 do i 4 u.r loop
Line 3,876 ⟶ 4,072:
loop
loop ;
</syntaxhighlight>
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
implicit none
Line 3,898 ⟶ 4,094:
end do
end program multtable</
===Traditional approach===
Line 3,904 ⟶ 4,100:
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.
Line 3,916 ⟶ 4,112:
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
Line 3,933 ⟶ 4,129:
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.
Line 3,944 ⟶ 4,140:
3 WRITE (6,FORMAT) I,(I*J, 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)
Line 3,965 ⟶ 4,161:
===VAX FORTRAN===
<syntaxhighlight lang="fortran">
PROGRAM TABLES
IMPLICIT NONE
Line 3,990 ⟶ 4,186:
C
END
</
===FORTRAN-IV===
<
C
C Produce a formatted multiplication table of the kind memorised by rote
Line 4,026 ⟶ 4,222:
3 CONTINUE
C
END</
===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.
<
C
C Produce a formatted multiplication table of the kind memorised by rote
Line 4,062 ⟶ 4,258:
3 CONTINUE
C
END</
4 FORMAT(1x,24A1)</
| 1 2 3 4 5 6 7 8 9 10 11 12
--+------------------------------------------------
Line 4,077 ⟶ 4,273:
10| 100 110 120
11| 121 132
12| 144</
=={{header|Frink}}==
<
formatTable[a,"right"]</
{{out}}
Line 4,098 ⟶ 4,294:
11 121 132
12 144
</pre>
=={{header|Go}}==
<syntaxhighlight lang="go">
package main
Line 4,172 ⟶ 4,325:
fmt.Println("")
}
</syntaxhighlight>
=={{header|Groovy}}==
Solution:
<
assert size > 1
Line 4,194 ⟶ 4,347:
}
printMultTable()</
{{out}}
Line 4,214 ⟶ 4,367:
=={{header|Haskell}}==
<
------------------- MULTIPLICATION TABLE -----------------
Line 4,249 ⟶ 4,402:
gap = replicate w ' '
rows = (maybe gap (rjust w ' ' . show) =<<) <$> xs
rjust n c = (drop . length) <*> (replicate n c <>)</
{{Out}}
<pre> 13 14 15 16 17 18 19 20
Line 4,287 ⟶ 4,440:
Or, more roughly and directly:
<
import Data.Function (on)
import Control.Monad (join)
Line 4,297 ⟶ 4,450:
groupBy
(on (==) fst)
(filter (uncurry (>=)) $ join ((<*>) . fmap (,)) [1 .. 12])</
{{Out}}
<pre>[1]
Line 4,313 ⟶ 4,466:
=={{header|hexiscript}}==
<
let n tostr n
while len n < l; let n (" " + n); endwhile
Line 4,331 ⟶ 4,484:
endfor
println ""
endfor</
=={{header|HicEst}}==
<
DO line = 1, 12
WRITE(Row=line+2, Format='i2') line
Line 4,340 ⟶ 4,493:
WRITE(Row=line+2, Column=4*col, Format='i3') line*col
ENDDO
ENDDO</
=={{header|HolyC}}==
{{trans|C}}
<
for (j = 1; j <= n; j++)
if (j != n)
Line 4,364 ⟶ 4,517:
Print("%3d ", i * j);
Print("| %d\n", i);
}</
=={{header|Icon}} and {{header|Unicon}}==
<
lim := 13
wid := 5
Line 4,373 ⟶ 4,526:
every (i := 1 to lim) &
writes(right( i||" |" | (j := 1 to lim, if j < i then "" else i*j) | "\n",wid)) # table content and triangle
end </
The above example is a somewhat exaggerated example of contractions.
Line 4,395 ⟶ 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}}==
<
format=: 'b4.0' 8!:2 ]
(('*' ; ,.) ,. ({. ; ])@format@multtable) >:i.12
Line 4,415 ⟶ 4,596:
│11│ 121 132│
│12│ 144│
└──┴────────────────────────────────────────────────┘</
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}}==
<
public static void main(String[] args) {
for (int i = 1; i <= 12; i++)
Line 4,439 ⟶ 4,620:
}
}
}</
{{out}}
<pre>
Line 4,460 ⟶ 4,641:
=={{header|JavaScript}}==
===
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 4,502 ⟶ 4,728:
target.appendChild(table);
}
</script>
<style type='text/css'>
Line 4,513 ⟶ 4,738:
<div id='target'></div>
</body>
</html></
{{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====
=====ES5=====
<
// [m..n]
function range(m, n) {
Line 4,533 ⟶ 4,758:
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
}))]}));
Line 4,567 ⟶ 4,789:
// or simply stringified as JSON
JSON.stringify(lstTable);
})(1, 12);</syntaxhighlight>
{{out}}
Line 4,601 ⟶ 4,822:
|}
<
[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 4,613 ⟶ 4,834:
[10,"","","","","","","","","",100,110,120],
[11,"","","","","","","","","","",121,132],
[12,"","","","","","","","","","","",144]]</
=====ES6=====
<
"use strict";
Line 4,689 ⟶ 4,910:
// MAIN ---
return main();
})();</
{{Out}}
{| class="wikitable" style="text-align:center;width:33em;height:33em;table-layout:fixed"
Line 4,719 ⟶ 4,940:
|}
=={{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}}==
<
var m, n, tableSize = 12;
Line 4,740 ⟶ 4,996:
}
}
printf('\n');</
{{out}}
Line 4,768 ⟶ 5,024:
=={{header|Julia}}==
<
println(" X | 1 2 3 4 5 6 7 8 9 10 11 12")
Line 4,781 ⟶ 5,037:
print(" ")
end
end</
{{out}}
Line 4,800 ⟶ 5,056:
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 4,811 ⟶ 5,067:
println()
}
}</
{{out}}
Line 4,835 ⟶ 5,091:
Outputs are visible in http://lambdaway.free.fr/lambdawalks/?view=multiplication_table
<
{def format
{lambda {:w :c}
Line 4,876 ⟶ 5,132:
3) {make_table {operation pow} 6 10}
</syntaxhighlight>
=={{header|Lasso}}==
<
local(result) = ``
local(padSize) = string(#max*#max)->size + 1
Line 4,907 ⟶ 5,163:
}
printTimesTables(12)</
{{out}}
Line 4,927 ⟶ 5,183:
=={{header|Logo}}==
{{works with|UCB Logo}}
<
type "| | for [i 2 :n] [type form :i 4 0] (print)
(print)
Line 4,940 ⟶ 5,196:
mult.table 12
</syntaxhighlight>
=={{header|Lua}}==
<
for i = 1, 12 do
io.write( string.format( "%#5d", i ) )
Line 4,960 ⟶ 5,216:
end
io.write( "\n" )
end</
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
----------------------------------------------------------------
Line 4,978 ⟶ 5,234:
=={{header|M2000 Interpreter}}==
Using jagged array (arrays of arrays)
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Dim Base 1, A(12)
Line 5,005 ⟶ 5,261:
}
CheckIt
</syntaxhighlight>
Final loop can be this, using Each() and r1 as pointer to array.
Line 5,040 ⟶ 5,296:
=={{header|Maple}}==
<
for i to 12 do
printf("%-3d ", i);
Line 5,057 ⟶ 5,313:
end if
end do
end do</
{{out}}
<pre>
Line 5,077 ⟶ 5,333:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{{out}}
<pre>1 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,095 ⟶ 5,351:
timesTable.m: (creates Times Table of N degree)
<
table = [(0:N); (1:N)' triu( kron((1:N),(1:N)') )];
end</
A minimally vectorized version of the above code:
<
%Generates a column vector with integers from 1 to N
Line 5,117 ⟶ 5,373:
table = [columnLabels; rowLabels triu(table)];
end</
{{out}}
Line 5,141 ⟶ 5,397:
=={{header|Maxima}}==
<
for j: 1 thru 12 do (
if j>=i or j=1 then printf(true, "~4d", i*j) else printf(true, " ")
),
printf(true, "~%")
);</
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(k*i,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
С/П</
''Input'': 12 С/П ...
Line 5,175 ⟶ 5,446:
=={{header|Modula-2}}==
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<
MODULE MultiplicationTables;
Line 5,215 ⟶ 5,486:
END;
END MultiplicationTables.
</syntaxhighlight>
{{out}}
<pre>
Line 5,236 ⟶ 5,507:
=={{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.
<
@verb me:@tables none none none rxd
@program me:@tables
Line 5,262 ⟶ 5,533:
endfor
.
</syntaxhighlight>
LambdaMOO string utilities version:
<
@program me:@tables
player:tell(" | 1 2 3 4 5 6 7 8 9 10 11 12");
Line 5,277 ⟶ 5,548:
endfor
.
</syntaxhighlight>
{{out}}
<pre>
Line 5,298 ⟶ 5,569:
=={{header|MUMPS}}==
<
;Print out a multiplication table
;SIZE is the size of the multiplication table to make
Line 5,318 ⟶ 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</
{{out}}
Line 5,337 ⟶ 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:
Line 5,380 ⟶ 5,690:
$print("\n");
j += 1;
}</
{{out}}
Line 5,403 ⟶ 5,713:
=={{header|Nim}}==
{{trans|C}}
<
const n = 12
Line 5,414 ⟶ 5,724:
for j in 1..n:
stdout.write if j<i: " " else: "{:3d} ".fmt(i*j)
echo "| {:2d}".fmt(i)</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,434 ⟶ 5,744:
{{trans|C}}
<
let max = 12 in
let fmax = float_of_int max in
Line 5,452 ⟶ 5,762:
print_newline()
done;
print_newline()</
=={{header|PARI/GP}}==
Quick and dirty one-liner:
<
=={{header|Pascal}}==
Line 5,462 ⟶ 5,772:
=={{header|Perl}}==
<
our $width = length($max**2) + 1;
Line 5,471 ⟶ 5,781:
foreach "$i|", map { $_ >= $i and $_*$i } 1..$max;
print "\n";
}</
{{out}}
Line 5,493 ⟶ 5,803:
=={{header|Phix}}==
{{Trans|Ada}}
<!--<
<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>
Line 5,505 ⟶ 5,815:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre style="font-size: 8px">
Line 5,523 ⟶ 5,833:
12| 144
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/wiki/Multiplication_tables
by Galileo, 11/2022 #/
def tab 9 tochar print enddef
tab 12 for print tab endfor nl
tab '-' 12 8 * repeat print nl
12 for
dup print tab 8 tochar print "|" print
dup for
over * print tab
endfor
drop nl
endfor</syntaxhighlight>
{{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>
=={{header|Picat}}==
<
N=12,
make_table(N),
Line 5,549 ⟶ 5,892:
nl
end,
nl.</
{{out}}
Line 5,566 ⟶ 5,909:
11 | 121 132
12 | 144</pre>
=={{header|PicoLisp}}==
<
(space 4)
(for X N
Line 5,582 ⟶ 5,924:
(prinl) ) )
(mulTable 12)</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,600 ⟶ 5,942:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
/* 12 x 12 multiplication table. */
Line 5,615 ⟶ 5,957:
end multiplication_table;
</syntaxhighlight>
Result:
<
1 2 3 4 5 6 7 8 9 10 11 12
_________________________________________________
Line 5,634 ⟶ 5,976:
11 | 121 132
12 | 144
</
=={{header|PowerShell}}==
<
$Tab = "`t"
Line 5,657 ⟶ 5,999:
# Combine them all together
) -join $Tab
}</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,673 ⟶ 6,015:
12 144</pre>
<b>A more general solution</b>
<
{
# For clarity
Line 5,698 ⟶ 6,040:
}
Get-TimesTable 18</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Line 5,721 ⟶ 6,063:
=={{header|Prolog}}==
<
print_header(S,E),
make_table_rows(S,E),
Line 5,753 ⟶ 6,095:
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).</
{{out}}
<pre>
Line 5,778 ⟶ 6,120:
=={{header|Python}}==
===Procedural===
<
>>> width = len(str(size**2))
>>> for row in range(-1,size+1):
Line 5,806 ⟶ 6,148:
11│ 121 132
12│ 144
>>> </
The above works with Python 3.X, which uses Unicode strings by default. <br>
Line 5,818 ⟶ 6,160:
and then again, for comparison, as an equivalent '''list monad''' expression (''mulTable2'' function):
<
1. by list comprehension (mulTable ),
Line 5,920 ⟶ 6,262:
if __name__ == '__main__':
main()</
{{Out}}
<pre>By list comprehension (mulTable):
Line 5,956 ⟶ 6,298:
{{Trans|Haskell}}
{{Works with|Python|3.7}}
<
import collections
Line 6,222 ⟶ 6,564:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre> 13 14 15 16 17 18 19 20
Line 6,262 ⟶ 6,604:
=={{header|Quackery}}==
<
tuck size -
times sp echo$ ] is echo-rj ( n n --> )
Line 6,281 ⟶ 6,623:
[ dip dup
* 4 echo-rj ] ]
cr drop ] ]</
{{Out}}
Line 6,301 ⟶ 6,643:
=={{header|R}}==
<syntaxhighlight lang="r">
multiplication_table <- function(n=12)
{
Line 6,312 ⟶ 6,654:
}
multiplication_table()
</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 6,327 ⟶ 6,669:
(show-line (cons y (for/list ([x (in-range 1 13)])
(if (<= y x) (* x y) "")))))
</syntaxhighlight>
{{out}}
Line 6,348 ⟶ 6,690:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
say '×'.fmt($f) ~ ' ┃ ' ~ (1..$max).fmt($f);
Line 6,355 ⟶ 6,697:
for 1..$max -> $i {
say $i.fmt($f) ~ ' ┃ ' ~ ( $i ≤ $_ ?? $i×$_ !! '' for 1..$max ).fmt($f);
}</
{{out}}
<pre>
Line 6,375 ⟶ 6,717:
=={{header|REBOL}}==
<
Title: "12x12 Multiplication Table"
URL: http://rosettacode.org/wiki/Print_a_Multiplication_Table
Line 6,407 ⟶ 6,749:
print rejoin [ crlf "How about " size: 20 "?" crlf ]
-- .row " x " 1 -- repeat y size [.row p3 y y] --</
{{out}} (only 12x12 shown):
Line 6,429 ⟶ 6,771:
=={{header|REXX}}==
<
parse arg sz . /*obtain optional argument from the CL.*/
if sz=='' | sz=="," then sz= 12 /*Not specified? Then use the default.*/
Line 6,451 ⟶ 6,793:
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</
{{out|output|text= when using the default input of: <tt> 12 </tt>}}
<pre>
Line 6,523 ⟶ 6,865:
=={{header|Ring}}==
<
multiplication_table(12)
func multiplication_table n
Line 6,535 ⟶ 6,877:
next
func fsize x,n return string(x) + copy(" ",n-len(string(x)))
</syntaxhighlight>
Output
<
| 1 2 3 4 5 6 7 8 9 10 11 12
----+-------------------------------------------------
Line 6,553 ⟶ 6,895:
11 | 121 132
12 | 144
</syntaxhighlight>
=={{header|Ruby}}==
<
puts " |" + (" %3d" * n) % [*1..n]
puts "----+" + "----" * n
Line 6,567 ⟶ 6,909:
end
multiplication_table 12</
{{out}}
Line 6,588 ⟶ 6,930:
=={{header|Rust}}==
<
fn main() {
Line 6,608 ⟶ 6,950:
println!("| {}", i);
}
}</
or, in terms of map:
<
let xs = (1..=12)
.map(|a| {
Line 6,628 ⟶ 6,970:
println!("{}", xs.join("\n"))
}</
=={{header|Scala}}==
<
//Multiplication Table
print("%5s".format("|"))
Line 6,650 ⟶ 6,992:
println("")
}
</syntaxhighlight>
=== case ===
<
implicit def intToString(i: Int) = i.toString
val cell = (x:String) => print("%5s".format(x))
Line 6,672 ⟶ 7,014:
}
}
</syntaxhighlight>
=={{header|Scheme}}==
Line 6,678 ⟶ 7,020:
A better implementation of <tt>iota</tt> is provided by SRFI-1 [http://srfi.schemers.org/srfi-1/srfi-1.html].
<
(define iota
(lambda (count start step)
Line 6,705 ⟶ 7,047:
(loop (+ count 1)
(cdr numbers)))))))
</syntaxhighlight>
<pre>
Line 6,725 ⟶ 7,067:
=={{header|Scilab}}==
{{works with|Scilab|5.5.1}}
<syntaxhighlight lang="scilab"> nmax=12, xx=3
s= blanks(xx)+" |"
for j=1:nmax
Line 6,746 ⟶ 7,088:
end
printf("%s\n",s)
end</
{{out}}
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
Line 6,764 ⟶ 7,106:
=={{header|Seed7}}==
<
const proc: main is func
Line 6,787 ⟶ 7,129:
writeln("|" <& i lpad 3);
end for;
end func;</
{{out}}
Line 6,808 ⟶ 7,150:
=={{header|Sidef}}==
<
var width = (max**2 -> len+1)
Line 6,820 ⟶ 7,162:
{ |i|
say fmt_row("#{i}┃", {|j| i <= j ? i*j : ''}.map(1..max)...)
} << 1..max</
{{out}}
<pre>
Line 6,841 ⟶ 7,183:
=={{header|Simula}}==
{{trans|ALGOL W}}
<
integer i, j;
outtext( " " );
Line 6,857 ⟶ 7,199:
outimage
end;
end</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 6,875 ⟶ 7,217:
=={{header|Swift}}==
<
let size = 12
Line 6,895 ⟶ 7,237:
printRow( with: i, upto: size)
}
</syntaxhighlight>
=={{header|Tailspin}}==
<
templates formatN&{width:}
[ 1..$width -> ' ', '$;'... ] -> '$(last-$width+1..last)...;' !
Line 6,910 ⟶ 7,252:
'$ -> formatN&{width:2};|$:1..($-1)*4 -> ' ';$:$..12 -> $*$row -> formatN&{width:4};
' ! \) -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 6,930 ⟶ 7,272:
=={{header|Tcl}}==
<
puts \u0020\u2500\u2500\u253c[string repeat \u2500 48]
for {set i 1} {$i <= 12} {incr i} {
Line 6,940 ⟶ 7,282:
}
puts ""
}</
{{out}}
<pre>
Line 6,960 ⟶ 7,302:
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
x=y="1'2'3'4'5'6'7'8'9'10'11'12"
Line 6,979 ⟶ 7,321:
PRINT col,cnt
ENDLOOP
</syntaxhighlight>
{{out}}
<pre style='height:30ex;overflow:scroll'>
Line 6,998 ⟶ 7,340:
== {{header|TypeScript}} ==
{{trans|Modula-2}}
<
// Multiplication tables
Line 7,013 ⟶ 7,355:
console.log("| " + i.toString().padStart(2, ' '));
}
</syntaxhighlight>
{{out}}
<pre>
Line 7,035 ⟶ 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">
#import std
#import nat
Line 7,048 ⟶ 7,390:
main = table 12
</syntaxhighlight>
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 7,068 ⟶ 7,410:
</pre>
=={{header|
<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(i*j,-4)
Next
print "|"& pad(i,-2)
Next
</syntaxhighlight>
{{out}}
<small>
<pre>
________________________________________________
81 90 99 108| 9
100 110 120|10
121 132|11
144|12
</pre>
</small>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Line 7,126 ⟶ 7,460:
var nums2 = nums.map { |n| (n >= i) ? (n * i).toString : " " }.toList
Fmt.print("$3d | $4s", i, nums2)
}</
{{out}}
Line 7,145 ⟶ 7,479:
12 | 144
</pre>
=={{header|XPL0}}==
<
int X, Y;
[Format(4, 0);
Line 7,161 ⟶ 7,494:
CrLf(0);
];
]</
{{out}}
Line 7,182 ⟶ 7,515:
=={{header|zkl}}==
<
w,fmt := (n*n).numDigits, " %%%dd".fmt(w).fmt; // eg " %3".fmt
header:=[1..n].apply(fmt).concat(); // 1 2 3 4 ...
Line 7,191 ⟶ 7,524:
[a..n].pump(String,'*(a),fmt).println();
}
}(12);</
{{out}}
<pre>
|