Jump to content

Multiplication tables: Difference between revisions

Multiplication tables (view source)

Revision as of 16:53, 25 August 2022

4,199 bytes added ,  1 year ago
Convert <lang> elements to <syntaxhighlight>
(Convert <lang> elements to <syntaxhighlight>)
Line 12:
{{trans|C}}
 
<langsyntaxhighlight lang=11l>V n = 12
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)</langsyntaxhighlight>
 
{{out}}
Line 44:
 
=={{header|360 Assembly}}==
<langsyntaxhighlight lang=360asm>* 12*12 multiplication table 14/08/2015
MULTTABL CSECT
USING MULTTABL,R12
Line 103:
PORT DC C'--+-------------------------------------------------'
YREGS
END MULTTABL</langsyntaxhighlight>
{{out}}
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
Line 122:
=={{header|8080 Assembly}}==
 
<langsyntaxhighlight lang=8080asm> org 100h
lxi h,output
;;; Make the header
Line 218:
inx h
ret
output: equ $</langsyntaxhighlight>
 
{{out}}
Line 240:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<langsyntaxhighlight lang=AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program multtable64.s */
Line 391:
.include "../includeARM64.inc"
 
</syntaxhighlight>
</lang>
{{Output}}
<pre>
Line 410:
 
=={{header|Action!}}==
<langsyntaxhighlight lang=Action!>PROC PrintRight(BYTE num,size)
BYTE i
 
Line 470:
OD
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multiplication_tables.png Screenshot from Atari 8-bit computer]
Line 491:
 
=={{header|ActionScript}}==
<langsyntaxhighlight lang=ActionScript>
package {
Line 571:
 
}
</syntaxhighlight>
</lang>
 
=={{header|Ada}}==
<langsyntaxhighlight 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>
</lang>
<pre>
| 1 2 3 4 5 6 7 8 9 10 11 12
Line 620:
=={{header|Agena}}==
{{Trans|ALGOL_W}}
<langsyntaxhighlight lang=agena>scope
# print a school style multiplication table
# NB: print outputs a newline at the end, write and printf do not
Line 633:
od;
print()
epocs</langsyntaxhighlight>
{{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}} -->
<langsyntaxhighlight lang=Algol68>main:(
INT max = 12;
INT width = ENTIER(log(max)*2)+1;
Line 676:
OD;
printf(($gl$, hr))
)</langsyntaxhighlight>
{{out}}
<pre>
Line 698:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang=algolw>begin
% print a school style multiplication table %
i_w := 3; s_w := 0; % set output formating %
Line 711:
end;
 
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 732:
=={{header|APL}}==
A simple table is trivial:
<syntaxhighlight lang =apl>(⍳12)∘.×⍳12</langsyntaxhighlight>
 
But that prints out all the duplicated results across the diagonal:
Line 753:
 
{{works with|Dyalog APL}}
<langsyntaxhighlight lang=apl>⎕←(' ×',2↑' '),4 0⍕⍳12⋄{⎕←((4 0⍕⍵),⊂1(4×(⍵-1))⍴' '),4 0⍕(⍵-1)↓(⍵×⍳12)}¨⍳12</langsyntaxhighlight>
 
{{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.
 
<langsyntaxhighlight lang=apl>⎕←(' ×',4↑' '),4 0⍕⍳12⋄⍬⊣{⎕←((4 0⍕⍵),⊂1(4×(⍵-1))⍴' '),4 0⍕(⍵-1)↓(⍵×⍳12)}¨⍳12</langsyntaxhighlight>
 
{{Out}}
Line 777:
=={{header|AppleScript}}==
===Iteration===
<langsyntaxhighlight 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}
Line 797:
set text item delimiters to ""
return (characters -4 thru -1 of (" " & x)) as string
end f</langsyntaxhighlight>
{{out}}
<pre>"
Line 819:
 
{{trans|JavaScript}} (ES5 functional version)
<langsyntaxhighlight lang=AppleScript>------------------- MULTIPLICATION TABLE -----------------
 
-- multiplicationTable :: Int -> Int -> String
Line 1,001:
end repeat
return out & dbl
end replicate</langsyntaxhighlight>
{{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}}
<langsyntaxhighlight lang=ARM Assembly>
 
/* ARM assembly Raspberry PI */
Line 1,217:
 
 
</syntaxhighlight>
</lang>
 
=={{header|Arturo}}==
<langsyntaxhighlight lang=rebol>mulTable: function [n][
print [" |"] ++ map 1..n => [pad to :string & 3]
print "----+" ++ join map 1..n => "----"
Line 1,231:
]
 
mulTable 12</langsyntaxhighlight>
 
{{out}}
Line 1,252:
=={{header|ASIC}}==
{{trans|Modula-2}}
<langsyntaxhighlight lang=basic>
REM Multiplication tables
N = 12
Line 1,299:
PRINT S2$;
RETURN
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,319:
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight lang=autohotkey>Gui, -MinimizeBox
Gui, Margin, 0, 0
Gui, Font, s9, Fixedsys
Line 1,354:
}
GuiControl,, Edit2, %Table%
Return</langsyntaxhighlight>
Message box shows:
<pre> x | 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,373:
 
=={{header|AutoIt}}==
<langsyntaxhighlight lang=AutoIt>#AutoIt Version: 3.2.10.0
$tableupto=12
$table=""
Line 1,392:
Next
Next
msgbox(0,"Multiplication Tables",$table)</langsyntaxhighlight>
 
=={{header|AWK}}==
<langsyntaxhighlight lang=AWK>
BEGIN {
for(i=1;i<=12;i++){
Line 1,404:
print
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,423:
=={{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.
<langsyntaxhighlight lang=axe>Fix 5
ClrDraw
For(I,1,10)
Line 1,440:
DispGraph
getKeyʳ
Fix 4</langsyntaxhighlight>
 
Approximate output:
Line 1,460:
 
==={{header|Applesoft BASIC}}===
<langsyntaxhighlight 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
Line 1,469:
170 V$ = STR$(I * J)
180 PRINT TAB(FN T(J)) MID$(" ", 1, 3 - LEN(V$) - (J < 4)) V$;
190 NEXT J, N</langsyntaxhighlight>
 
==={{header|BASIC256}}===
<langsyntaxhighlight lang=freebasic>print " X| 1 2 3 4 5 6 7 8 9 10 11 12"
print "---+------------------------------------------------"
 
Line 1,488:
next j
print nums$
next i</langsyntaxhighlight>
 
==={{header|BBC BASIC}}===
BBC BASIC automatically right-justifies numeric output.
<langsyntaxhighlight lang=bbcbasic> @% = 5 : REM Set column width
FOR row% = 1 TO 12
PRINT row% TAB(row% * @%) ;
Line 1,499:
NEXT col%
PRINT
NEXT row%</langsyntaxhighlight>
{{out}}
<pre> 1 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,516:
==={{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.
<langsyntaxhighlight lang=gwbasic>100 PRINT CHR$(14);CHR$(147);
110 PRINT " X";
120 W=2
Line 1,560:
520 N$=MID$(STR$(N),2)
530 IF LEN(N$)<W THEN N$=" "+N$:GOTO 530
540 RETURN</langsyntaxhighlight>
 
{{Out}}
Line 1,589:
12: : : : : : : : : : : :144</pre>
==={{header|FreeBASIC}}===
<langsyntaxhighlight lang=freebasic>
' FB 1.05.0 Win64
 
Line 1,611:
Print
Print "Press any key to quit"
Sleep</langsyntaxhighlight>
 
{{out}}
Line 1,632:
 
==={{header|FutureBasic}}===
<syntaxhighlight>
<lang>
long i, j
 
Line 1,652:
 
HandleEvents
</syntaxhighlight>
</lang>
{{output}}
<pre>
Line 1,674:
{{trans|Modula-2}}
{{works with|PC-BASIC|any}}
<langsyntaxhighlight lang=qbasic>
10 ' Multiplication Tables
20 LET N% = 12
Line 1,692:
160 PRINT "| "; USING "##"; I%
170 NEXT I%
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,712:
 
==={{header|IS-BASIC}}===
<langsyntaxhighlight lang=IS-BASIC>100 PROGRAM "Multipli.bas"
110 TEXT 80
120 PRINT TAB(7);
Line 1,725:
210 NEXT
220 PRINT
230 NEXT</langsyntaxhighlight>
 
==={{header|Liberty BASIC}}===
<langsyntaxhighlight lang=lb>Print " | 1 2 3 4 5 6 7 8 9 10 11 12"
Print "--+------------------------------------------------------------"
 
Line 1,744:
Next ii
Print nums$
Next i</langsyntaxhighlight>
{{out}}
<pre>
Line 1,765:
==={{header|Microsoft Small Basic}}===
{{trans|Modula-2}}
<langsyntaxhighlight lang=microsoftsmallbasic>
n = 12
For j = 1 To n - 1
Line 1,794:
TextWindow.WriteLine("")
EndFor
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,814:
 
==={{header|PureBasic}}===
<langsyntaxhighlight lang=PureBasic>Procedure PrintMultiplicationTable(maxx, maxy)
sp = Len(Str(maxx*maxy)) + 1
trenner$ = "+"
Line 1,848:
OpenConsole()
PrintMultiplicationTable(12, 12)
Input()</langsyntaxhighlight>
 
Ouput similar to ALGOL 68
 
==={{header|QBasic}}===
<langsyntaxhighlight lang=qbasic>CLS
 
'header row
Line 1,878:
PRINT o$;
NEXT
NEXT</langsyntaxhighlight>
 
{{out}}
Line 1,899:
 
==={{header|Run BASIC}}===
<langsyntaxhighlight 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>"
Line 1,909:
next i
html "</table>"
</langsyntaxhighlight>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|True BASIC}}===
<langsyntaxhighlight lang=qbasic>PRINT " X| 1 2 3 4 5 6 7 8 9 10 11 12"
PRINT "---+------------------------------------------------"
 
Line 1,929:
NEXT i
PRINT
END</langsyntaxhighlight>
 
==={{header|uBasic/4tH}}===
{{trans|BBC BASIC}}
<langsyntaxhighlight>For R = 1 To 12
Print R;Tab(R * 5);
For C = R To 12
Line 1,939:
Next
Print
Next</langsyntaxhighlight>
{{out}}
<pre>1 1 2 3 4 5 6 7 8 9 10 11 12
Line 1,958:
==={{header|Visual Basic}}===
{{works with|Visual Basic|VB6 Standard}}
<langsyntaxhighlight lang=vb>Sub Main()
Const nmax = 12, xx = 3
Const x = xx + 1
Line 1,981:
Debug.Print s
Next i
End Sub 'Main</langsyntaxhighlight>
{{Out}}
<pre>
Line 2,003:
{{trans|Modula-2}}
{{works with|Windows XBasic}}
<langsyntaxhighlight lang=xbasic>
PROGRAM "multiplicationtables"
VERSION "0.0001"
Line 2,031:
END FUNCTION
END PROGRAM
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,051:
 
==={{header|Yabasic}}===
<langsyntaxhighlight lang=freebasic>print " X| 1 2 3 4 5 6 7 8 9 10 11 12"
print "---+------------------------------------------------"
 
Line 2,067:
next j
print nums$
next i</langsyntaxhighlight>
 
=={{header|Batch File}}==
<langsyntaxhighlight lang=dos>@echo off
setlocal enabledelayedexpansion
 
Line 2,116:
for /l %%A in (1,1,%numspaces%) do set "space=!space! "
goto :EOF
::/The Functions.</langsyntaxhighlight>
{{Out}}
<pre>
Line 2,137:
 
=={{header|Befunge}}==
<langsyntaxhighlight 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_$"+---">:#,_$</langsyntaxhighlight>
 
{{out}}
Line 2,161:
<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>).
 
<langsyntaxhighlight lang=bqn>Table ← {
m ← •Repr¨ ×⌜˜1+↕𝕩 # The numbers, formatted individually
main ← ⟨ # Bottom part: three sections
Line 2,172:
}
•Out˘ Table 12</langsyntaxhighlight>
{{Out}}
<langsyntaxhighlight> | 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 2,187:
10| 100 110 120
11| 121 132
12| 144</langsyntaxhighlight>
 
=={{header|Bracmat}}==
<langsyntaxhighlight lang=Bracmat> ( multiplicationTable
= high i j row row2 matrix padFnc tmp
, celPad leftCelPad padFnc celDashes leftDashes
Line 2,245:
)
& out$(multiplicationTable$12)
& done;</langsyntaxhighlight>
{{out}}
<pre> X| 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,263:
 
=={{header|C}}==
<langsyntaxhighlight lang=c>#include <stdio.h>
 
int main(void)
Line 2,279:
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,297:
 
=={{header|C sharp}}==
<langsyntaxhighlight lang=csharp>using System;
 
namespace multtbl
Line 2,335:
}
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,359:
and formats the table columns.
 
<langsyntaxhighlight lang=cpp>#include <iostream>
#include <iomanip>
#include <cmath> // for log10()
Line 2,436:
return 0;
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,470:
=={{header|Chef}}==
 
<langsyntaxhighlight lang=chef>Multigrain Bread.
 
Prints out a multiplication table.
Line 2,534:
Pour contents of the 2nd mixing bowl into the 2nd baking dish.
 
Serves 2.</langsyntaxhighlight>
 
{{out}}
Line 2,555:
This is more generalized.
Any size can be used and the table will be formatted appropriately.
<langsyntaxhighlight lang=lisp>(let [size 12
trange (range 1 (inc size))
fmt-width (+ (.length (str (* size size))) 1)
Line 2,568:
(for [j trange] j))))))]
(println s)))
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,587:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang=COBOL> identification division.
program-id. multiplication-table.
 
Line 2,633:
goback.
end program multiplication-table.
</syntaxhighlight>
</lang>
{{out}}
<pre>prompt$ cobc -xj multiplication-table.cob
Line 2,651:
 
=={{header|CoffeeScript}}==
<langsyntaxhighlight lang=coffeescript>
print_multiplication_tables = (n) ->
width = 4
Line 2,683:
print_multiplication_tables 12
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,705:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang=lisp>
(do ((m 0 (if (= 12 m) 0 (1+ m)))
(n 0 (if (= 12 m) (1+ n) n)))
Line 2,722:
(format t "~4,D" (* m n))
(format t " "))))))
</syntaxhighlight>
</lang>
Output:
<pre>
Line 2,744:
=={{header|D}}==
{{trans|PicoLisp}}
<langsyntaxhighlight lang=d>void main() {
import std.stdio, std.array, std.range, std.algorithm;
 
Line 2,752:
writefln("%4d" ~ " ".replicate(4 * (y - 1)) ~ "%(%4d%)", y,
iota(y, n + 1).map!(x => x * y));
}</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,770:
 
=={{header|DCL}}==
<langsyntaxhighlight lang=DCL>$ max = 12
$ h = f$fao( "!4* " )
$ r = 0
Line 2,795:
$ write sys$output f$fao( "!4SL", r ) + o
$ r = r + 1
$ if r .le. max then $ goto loop1</langsyntaxhighlight>
{{out}}
<pre>$ @multiplication_tables
Line 2,817:
=={{header|Delphi}}==
{{trans|DWScript}}
<langsyntaxhighlight lang=delphi>program MultiplicationTables;
 
{$APPTYPE CONSOLE}
Line 2,846:
Writeln;
end;
end.</langsyntaxhighlight>
 
=={{header|Draco}}==
<langsyntaxhighlight lang=draco>/* Print N-by-N multiplication table */
proc nonrec multab(byte n) void:
byte i,j;
Line 2,874:
 
/* Print 12-by-12 multiplication table */
proc nonrec main() void: multab(12) corp</langsyntaxhighlight>
{{out}}
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
Line 2,893:
=={{header|DWScript}}==
 
<langsyntaxhighlight lang=delphi>const size = 12;
var row, col : Integer;
 
Line 2,911:
PrintLn('');
end;
</syntaxhighlight>
</lang>
 
=={{header|E}}==
 
<langsyntaxhighlight lang=e> def size := 12
println(`{|style="border-collapse: collapse; text-align: right;"`)
println(`|`)
Line 2,928:
}
}
println("|}")</langsyntaxhighlight>
 
Targets MediaWiki markup.
Line 3,120:
=={{header|EasyLang}}==
 
<langsyntaxhighlight>n = 12
func out h . .
if h < 10
Line 3,151:
.
print ""
.</langsyntaxhighlight>
 
=={{header|EchoLisp}}==
<langsyntaxhighlight lang=scheme>
(lib 'matrix)
 
Line 3,167:
(array-print (build-array 13 13 mtable))
 
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,186:
 
=={{header|Elixir}}==
<langsyntaxhighlight lang=elixir>defmodule RC do
def multiplication_tables(n) do
IO.write " X |"
Line 3,201:
end
 
RC.multiplication_tables(12)</langsyntaxhighlight>
 
{{out}}
Line 3,222:
 
=={{header|Erlang}}==
<langsyntaxhighlight lang=Erlang>
-module( multiplication_tables ).
 
Line 3,247:
[io:fwrite("~5B", [Sum]) || {_Y, Sum} <- Uptos],
io:nl().
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,268:
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang=Euphoria>puts(1," x")
for i = 1 to 12 do
printf(1," %3d",i)
Line 3,285:
end for
puts(1,'\n')
end for</langsyntaxhighlight>
 
{{out}}
Line 3,312:
 
{{Works with|Office 365 betas 2021}}
<langsyntaxhighlight lang=lisp>FNOVERHALFCARTESIANPRODUCT
=LAMBDA(f,
LAMBDA(n,
Line 3,328:
)
)
)</langsyntaxhighlight>
 
and also assuming the following generic bindings in the Name Manager for the WorkBook:
 
<langsyntaxhighlight lang=lisp>MUL
=LAMBDA(a, LAMBDA(b, a * b))
 
Line 3,341:
POWER(n, e)
)
)</langsyntaxhighlight>
 
(The single formula in cell '''B2''' below populates the whole 12*12 grid)
Line 3,758:
=={{header|F Sharp|F#}}==
Translation of C#
<langsyntaxhighlight lang=FSharp>
open System
 
Line 3,778:
 
multTable ()
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,798:
 
=={{header|Factor}}==
<langsyntaxhighlight lang=factor>USING: io kernel math math.parser math.ranges sequences ;
IN: multiplication-table
 
Line 3,814:
" +" write
12 [ "----" write ] times nl
1 12 [a,b] [ print-row ] each ;</langsyntaxhighlight>
 
<pre>
Line 3,834:
 
=={{header|FALSE}}==
<langsyntaxhighlight lang=false>[$100\>[" "]?$10\>[" "]?." "]p:
[$p;! m: 2[$m;\>][" "1+]# [$13\>][$m;*p;!1+]#%"
"]l:
1[$13\>][$l;!1+]#%</langsyntaxhighlight>
 
=={{header|Fantom}}==
 
<langsyntaxhighlight lang=fantom>
class Main
{
Line 3,863:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Forth}}==
<langsyntaxhighlight lang=forth>
: multiplication-table
cr 2 spaces 13 2 do i 4 u.r loop
Line 3,876:
loop
loop ;
</syntaxhighlight>
</lang>
 
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang=fortran>program multtable
implicit none
 
Line 3,898:
end do
 
end program multtable</langsyntaxhighlight>
 
===Traditional approach===
Line 3,904:
 
So instead, write the table by first writing a line to a CHARACTER variable then blanking out the unwanted part.
<langsyntaxhighlight lang=Fortran>
Cast forth a twelve times table, suitable for chanting at school.
INTEGER I,J !Steppers.
Line 3,916:
3 WRITE (6,"(A)") ALINE !Print the text.
END !"One one is one! One two is two! One three is three!...
</syntaxhighlight>
</lang>
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:
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.
<langsyntaxhighlight lang=Fortran>
Cast forth a twelve times table, suitable for chanting at school.
INTEGER I,J !Steppers.
Line 3,944:
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>
</lang>
The output is the same, so instead, here are the generated FORMAT texts:
(I3,'|',0X,12I4)
Line 3,965:
 
===VAX FORTRAN===
<langsyntaxhighlight lang=Fortran>
PROGRAM TABLES
IMPLICIT NONE
Line 3,990:
C
END
</langsyntaxhighlight>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===
<langsyntaxhighlight lang=Fortran> PROGRAM TABLES
C
C Produce a formatted multiplication table of the kind memorised by rote
Line 4,026:
3 CONTINUE
C
END</langsyntaxhighlight>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.
<langsyntaxhighlight lang=Fortran> PROGRAM TABLES
C
C Produce a formatted multiplication table of the kind memorised by rote
Line 4,062:
3 CONTINUE
C
END</langsyntaxhighlight>Inserting the following two lines before the inner DO loop will print the format specifier used to print each row of the table.<langsyntaxhighlight lang=Fortran> WRITE(1,4) (A(J), J = 1,24)
4 FORMAT(1x,24A1)</langsyntaxhighlight>Running the program produces the following output<langsyntaxhighlight>
| 1 2 3 4 5 6 7 8 9 10 11 12
--+------------------------------------------------
Line 4,077:
10| 100 110 120
11| 121 132
12| 144</langsyntaxhighlight>
 
=={{header|Frink}}==
<langsyntaxhighlight lang=frink>a = makeArray[[13,13], {|a,b| a==0 ? b : (b==0 ? a : (a<=b ? a*b : ""))}]
formatTable[a,"right"]</langsyntaxhighlight>
 
{{out}}
Line 4,102:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=3a3a987766a9a9a383b3e0e8a65d9ea2 Click this link to run this code]'''
<langsyntaxhighlight lang=gambas>'Code 'stolen' from Free Basic and altered to work in Gambas
 
Public Sub Main()
Line 4,124:
Next
 
End</langsyntaxhighlight>
Output:
<pre>
Line 4,144:
 
=={{header|Go}}==
<syntaxhighlight lang=go>
<lang go>
package main
 
Line 4,172:
fmt.Println("")
}
</syntaxhighlight>
</lang>
 
=={{header|Groovy}}==
Solution:
<langsyntaxhighlight lang=groovy>def printMultTable = { size = 12 ->
assert size > 1
Line 4,194:
}
 
printMultTable()</langsyntaxhighlight>
 
{{out}}
Line 4,214:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang=haskell>import Data.Maybe (fromMaybe, maybe)
 
------------------- MULTIPLICATION TABLE -----------------
Line 4,249:
gap = replicate w ' '
rows = (maybe gap (rjust w ' ' . show) =<<) <$> xs
rjust n c = (drop . length) <*> (replicate n c <>)</langsyntaxhighlight>
{{Out}}
<pre> 13 14 15 16 17 18 19 20
Line 4,287:
 
Or, more roughly and directly:
<langsyntaxhighlight lang=haskell>import Data.List (groupBy)
import Data.Function (on)
import Control.Monad (join)
Line 4,297:
groupBy
(on (==) fst)
(filter (uncurry (>=)) $ join ((<*>) . fmap (,)) [1 .. 12])</langsyntaxhighlight>
{{Out}}
<pre>[1]
Line 4,313:
 
=={{header|hexiscript}}==
<langsyntaxhighlight lang=hexiscript>fun format n l
let n tostr n
while len n < l; let n (" " + n); endwhile
Line 4,331:
endfor
println ""
endfor</langsyntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight 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 4,340:
WRITE(Row=line+2, Column=4*col, Format='i3') line*col
ENDDO
ENDDO</langsyntaxhighlight>
 
=={{header|HolyC}}==
{{trans|C}}
<langsyntaxhighlight lang=holyc>U8 i, j, n = 12;
for (j = 1; j <= n; j++)
if (j != n)
Line 4,364:
Print("%3d ", i * j);
Print("| %d\n", i);
}</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
<langsyntaxhighlight lang=Icon>procedure main()
lim := 13
wid := 5
Line 4,373:
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 </langsyntaxhighlight>
 
The above example is a somewhat exaggerated example of contractions.
Line 4,397:
 
=={{header|J}}==
<langsyntaxhighlight lang=j> multtable=: <:/~ * */~
format=: 'b4.0' 8!:2 ]
(('*' ; ,.) ,. ({. ; ])@format@multtable) >:i.12
Line 4,415:
│11│ 121 132│
│12│ 144│
└──┴────────────────────────────────────────────────┘</langsyntaxhighlight>
 
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}}==
<langsyntaxhighlight lang=Java>public class MultiplicationTable {
public static void main(String[] args) {
for (int i = 1; i <= 12; i++)
Line 4,439:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 4,462:
===Imperative===
 
<langsyntaxhighlight 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" >
Line 4,513:
<div id='target'></div>
</body>
</html></langsyntaxhighlight>
 
{{out}} (minus the style):
Line 4,520:
===Functional===
====ES5====
<langsyntaxhighlight lang=JavaScript>(function (m, n) {
// [m..n]
Line 4,568:
JSON.stringify(lstTable);
})(1, 12);</langsyntaxhighlight>
 
{{out}}
Line 4,601:
|}
 
<langsyntaxhighlight 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],
Line 4,613:
[10,"","","","","","","","","",100,110,120],
[11,"","","","","","","","","","",121,132],
[12,"","","","","","","","","","","",144]]</langsyntaxhighlight>
 
====ES6====
<langsyntaxhighlight lang=JavaScript>(() => {
"use strict";
 
Line 4,689:
// MAIN ---
return main();
})();</langsyntaxhighlight>
{{Out}}
{| class="wikitable" style="text-align:center;width:33em;height:33em;table-layout:fixed"
Line 4,720:
 
=={{header|Jsish}}==
<langsyntaxhighlight lang=javascript>/* Multiplication tables, is Jsish */
var m, n, tableSize = 12;
 
Line 4,740:
}
}
printf('\n');</langsyntaxhighlight>
 
{{out}}
Line 4,768:
 
=={{header|Julia}}==
<langsyntaxhighlight lang=Julia>using Printf
 
println(" X | 1 2 3 4 5 6 7 8 9 10 11 12")
Line 4,781:
print(" ")
end
end</langsyntaxhighlight>
 
{{out}}
Line 4,800:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang=scala>// version 1.0.6
 
fun main(args: Array<String>) {
Line 4,811:
println()
}
}</langsyntaxhighlight>
 
{{out}}
Line 4,835:
Outputs are visible in http://lambdaway.free.fr/lambdawalks/?view=multiplication_table
 
<langsyntaxhighlight lang=scheme>
{def format
{lambda {:w :c}
Line 4,876:
3) {make_table {operation pow} 6 10}
 
</syntaxhighlight>
</lang>
 
=={{header|Lasso}}==
<langsyntaxhighlight lang=lasso>define printTimesTables(max::integer) => {
local(result) = ``
local(padSize) = string(#max*#max)->size + 1
Line 4,907:
}
 
printTimesTables(12)</langsyntaxhighlight>
 
{{out}}
Line 4,927:
=={{header|Logo}}==
{{works with|UCB Logo}}
<langsyntaxhighlight lang=logo>to mult.table :n
type "| | for [i 2 :n] [type form :i 4 0] (print)
(print)
Line 4,940:
 
mult.table 12
</syntaxhighlight>
</lang>
 
=={{header|Lua}}==
<langsyntaxhighlight lang=lua>io.write( " |" )
for i = 1, 12 do
io.write( string.format( "%#5d", i ) )
Line 4,960:
end
io.write( "\n" )
end</langsyntaxhighlight>
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
----------------------------------------------------------------
Line 4,978:
=={{header|M2000 Interpreter}}==
Using jagged array (arrays of arrays)
<langsyntaxhighlight lang=M2000 Interpreter>
Module CheckIt {
Dim Base 1, A(12)
Line 5,005:
}
CheckIt
</syntaxhighlight>
</lang>
 
Final loop can be this, using Each() and r1 as pointer to array.
Line 5,040:
 
=={{header|Maple}}==
<langsyntaxhighlight lang=maple>printf(" ");
for i to 12 do
printf("%-3d ", i);
Line 5,057:
end if
end do
end do</langsyntaxhighlight>
{{out}}
<pre>
Line 5,077:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight lang=Mathematica>Grid[{{Range[12]//Column,Grid[UpperTriangularize[KroneckerProduct[Range[12],Range[12]]]/.{0->""}]}}]</langsyntaxhighlight>
{{out}}
<pre>1 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,095:
timesTable.m: (creates Times Table of N degree)
 
<langsyntaxhighlight lang=MATLAB>function table = timesTable(N)
table = [(0:N); (1:N)' triu( kron((1:N),(1:N)') )];
end</langsyntaxhighlight>
 
A minimally vectorized version of the above code:
 
<langsyntaxhighlight lang=MATLAB>function table = timesTable(N)
 
%Generates a column vector with integers from 1 to N
Line 5,117:
table = [columnLabels; rowLabels triu(table)];
end</langsyntaxhighlight>
{{out}}
Line 5,141:
 
=={{header|Maxima}}==
<langsyntaxhighlight lang=Maxima>for i: 1 thru 12 do (
for j: 1 thru 12 do (
if j>=i or j=1 then printf(true, "~4d", i*j) else printf(true, " ")
),
printf(true, "~%")
);</langsyntaxhighlight>
 
 
=={{header|МК-61/52}}==
<langsyntaxhighlight>П0 КИП0 КИП4 КИП5 ИП4 ИП5 * С/П
ИП5 ИП0 - x=0 03
ИП4 ИП0 - x#0 22 ИП4 П5 БП 02
С/П</langsyntaxhighlight>
 
''Input'': 12 С/П ...
Line 5,175:
=={{header|Modula-2}}==
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<langsyntaxhighlight lang=modula2>
MODULE MultiplicationTables;
 
Line 5,215:
END;
END MultiplicationTables.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 5,236:
=={{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.
<langsyntaxhighlight lang=moo>
@verb me:@tables none none none rxd
@program me:@tables
Line 5,262:
endfor
.
</syntaxhighlight>
</lang>
 
LambdaMOO string utilities version:
<langsyntaxhighlight lang=moo>
@program me:@tables
player:tell(" | 1 2 3 4 5 6 7 8 9 10 11 12");
Line 5,277:
endfor
.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 5,298:
 
=={{header|MUMPS}}==
<langsyntaxhighlight lang=MUMPS>MULTTABLE(SIZE)
;Print out a multiplication table
;SIZE is the size of the multiplication table to make
Line 5,318:
..WRITE:((A-1)>=(D-2))&((D-2)>=1) ?((A-1)*5),$JUSTIFY((D-2)*(A-1),MW)
KILL MW,D,A,BAR
QUIT</langsyntaxhighlight>
 
{{out}}
Line 5,339:
 
=={{header|Neko}}==
<langsyntaxhighlight lang=ActionScript>/**
Multiplication table, in Neko
Tectonics:
Line 5,380:
$print("\n");
j += 1;
}</langsyntaxhighlight>
 
{{out}}
Line 5,403:
=={{header|Nim}}==
{{trans|C}}
<langsyntaxhighlight lang=nim>import strfmt
 
const n = 12
Line 5,414:
for j in 1..n:
stdout.write if j<i: " " else: "{:3d} ".fmt(i*j)
echo "| {:2d}".fmt(i)</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,434:
{{trans|C}}
 
<langsyntaxhighlight lang=ocaml>let () =
let max = 12 in
let fmax = float_of_int max in
Line 5,452:
print_newline()
done;
print_newline()</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
Quick and dirty one-liner:
<langsyntaxhighlight lang=parigp>for(y=1,12,printf("%2Ps| ",y);for(x=1,12,print1(if(y>x,"",x*y)"\t"));print)</langsyntaxhighlight>
 
=={{header|Pascal}}==
Line 5,462:
 
=={{header|Perl}}==
<langsyntaxhighlight lang=perl>our $max = 12;
our $width = length($max**2) + 1;
 
Line 5,471:
foreach "$i|", map { $_ >= $i and $_*$i } 1..$max;
print "\n";
}</langsyntaxhighlight>
 
{{out}}
Line 5,493:
=={{header|Phix}}==
{{Trans|Ada}}
<!--<langsyntaxhighlight 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>
Line 5,505:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre style="font-size: 8px">
Line 5,525:
 
=={{header|Picat}}==
<langsyntaxhighlight lang=Picat>go =>
N=12,
make_table(N),
Line 5,549:
nl
end,
nl.</langsyntaxhighlight>
 
{{out}}
Line 5,569:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight lang=PicoLi/th>sp>(de mulTable (N)
(space 4)
(for X N
Line 5,582:
(prinl) ) )
 
(mulTable 12)</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,600:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang=PL/I>
/* 12 x 12 multiplication table. */
 
Line 5,615:
 
end multiplication_table;
</syntaxhighlight>
</lang>
 
Result:
 
<syntaxhighlight>
<lang>
1 2 3 4 5 6 7 8 9 10 11 12
_________________________________________________
Line 5,634:
11 | 121 132
12 | 144
</syntaxhighlight>
</lang>
 
=={{header|PowerShell}}==
<langsyntaxhighlight lang=powershell># For clarity
$Tab = "`t"
Line 5,657:
# Combine them all together
) -join $Tab
}</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 5,673:
12 144</pre>
<b>A more general solution</b>
<langsyntaxhighlight lang=powershell>function Get-TimesTable ( [int]$Size )
{
# For clarity
Line 5,698:
}
Get-TimesTable 18</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Line 5,721:
 
=={{header|Prolog}}==
<langsyntaxhighlight lang=prolog>make_table(S,E) :-
print_header(S,E),
make_table_rows(S,E),
Line 5,753:
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).</langsyntaxhighlight>
{{out}}
<pre>
Line 5,778:
=={{header|Python}}==
===Procedural===
<langsyntaxhighlight lang=python>>>> size = 12
>>> width = len(str(size**2))
>>> for row in range(-1,size+1):
Line 5,806:
11│ 121 132
12│ 144
>>> </langsyntaxhighlight>
 
The above works with Python 3.X, which uses Unicode strings by default. <br>
Line 5,818:
and then again, for comparison, as an equivalent '''list monad''' expression (''mulTable2'' function):
 
<langsyntaxhighlight lang=python>'''Multiplication table
 
1. by list comprehension (mulTable ),
Line 5,920:
 
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>By list comprehension (mulTable):
Line 5,956:
{{Trans|Haskell}}
{{Works with|Python|3.7}}
<langsyntaxhighlight lang=python>'''Generalised multiplication tables'''
 
import collections
Line 6,222:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre> 13 14 15 16 17 18 19 20
Line 6,262:
=={{header|Quackery}}==
 
<langsyntaxhighlight lang=Quackery> [ swap number$
tuck size -
times sp echo$ ] is echo-rj ( n n --> )
Line 6,281:
[ dip dup
* 4 echo-rj ] ]
cr drop ] ]</langsyntaxhighlight>
 
{{Out}}
Line 6,301:
 
=={{header|R}}==
<syntaxhighlight lang=r>
<lang r>
multiplication_table <- function(n=12)
{
Line 6,312:
}
multiplication_table()
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
 
<langsyntaxhighlight lang=Racket>
#lang racket
 
Line 6,327:
(show-line (cons y (for/list ([x (in-range 1 13)])
(if (<= y x) (* x y) "")))))
</syntaxhighlight>
</lang>
 
{{out}}
Line 6,348:
=={{header|Raku}}==
(formerly Perl 6)
<langsyntaxhighlight lang=perl6>(my $f = "%{$_}s" given my $width = ($_**2).chars ) given my $max = 12;
 
say '×'.fmt($f) ~ ' ┃ ' ~ (1..$max).fmt($f);
Line 6,355:
for 1..$max -> $i {
say $i.fmt($f) ~ ' ┃ ' ~ ( $i ≤ $_ ?? $i×$_ !! '' for 1..$max ).fmt($f);
}</langsyntaxhighlight>
{{out}}
<pre>
Line 6,375:
 
=={{header|REBOL}}==
<langsyntaxhighlight lang=REBOL>REBOL [
Title: "12x12 Multiplication Table"
URL: http://rosettacode.org/wiki/Print_a_Multiplication_Table
Line 6,407:
 
print rejoin [ crlf "How about " size: 20 "?" crlf ]
-- .row " x " 1 -- repeat y size [.row p3 y y] --</langsyntaxhighlight>
 
{{out}} (only 12x12 shown):
Line 6,429:
 
=={{header|REXX}}==
<langsyntaxhighlight lang=REXX>/*REXX program displays a NxN multiplication table (in a boxed grid) to the terminal.*/
parse arg sz . /*obtain optional argument from the CL.*/
if sz=='' | sz=="," then sz= 12 /*Not specified? Then use the default.*/
Line 6,451:
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</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 12 </tt>}}
<pre>
Line 6,523:
 
=={{header|Ring}}==
<langsyntaxhighlight lang=ring>
multiplication_table(12)
func multiplication_table n
Line 6,535:
next
func fsize x,n return string(x) + copy(" ",n-len(string(x)))
</syntaxhighlight>
</lang>
 
Output
<langsyntaxhighlight lang=ring>
| 1 2 3 4 5 6 7 8 9 10 11 12
----+-------------------------------------------------
Line 6,553:
11 | 121 132
12 | 144
</syntaxhighlight>
</lang>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang=ruby>def multiplication_table(n)
puts " |" + (" %3d" * n) % [*1..n]
puts "----+" + "----" * n
Line 6,567:
end
 
multiplication_table 12</langsyntaxhighlight>
 
{{out}}
Line 6,588:
 
=={{header|Rust}}==
<langsyntaxhighlight lang=rust>const LIMIT: i32 = 12;
 
fn main() {
Line 6,608:
println!("| {}", i);
}
}</langsyntaxhighlight>
 
or, in terms of map:
 
<langsyntaxhighlight lang=rust>fn main() {
let xs = (1..=12)
.map(|a| {
Line 6,628:
 
println!("{}", xs.join("\n"))
}</langsyntaxhighlight>
 
=={{header|Scala}}==
<langsyntaxhighlight lang=scala>
//Multiplication Table
print("%5s".format("|"))
Line 6,650:
println("")
}
</syntaxhighlight>
</lang>
 
=== case ===
<langsyntaxhighlight lang=scala>
implicit def intToString(i: Int) = i.toString
val cell = (x:String) => print("%5s".format(x))
Line 6,672:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Scheme}}==
Line 6,678:
A better implementation of <tt>iota</tt> is provided by SRFI-1 [http://srfi.schemers.org/srfi-1/srfi-1.html].
 
<langsyntaxhighlight lang=scheme>
(define iota
(lambda (count start step)
Line 6,705:
(loop (+ count 1)
(cdr numbers)))))))
</syntaxhighlight>
</lang>
 
<pre>
Line 6,725:
=={{header|Scilab}}==
{{works with|Scilab|5.5.1}}
<langsyntaxhighlight> nmax=12, xx=3
s= blanks(xx)+" |"
for j=1:nmax
Line 6,746:
end
printf("%s\n",s)
end</langsyntaxhighlight>
{{out}}
<pre> | 1 2 3 4 5 6 7 8 9 10 11 12
Line 6,764:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang=seed7>$ include "seed7_05.s7i";
const proc: main is func
Line 6,787:
writeln("|" <& i lpad 3);
end for;
end func;</langsyntaxhighlight>
 
{{out}}
Line 6,808:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang=ruby>var max = 12
var width = (max**2 -> len+1)
 
Line 6,820:
{ |i| 
say fmt_row("#{i}┃", {|j| i <= j ? i*j : ''}.map(1..max)...)
} << 1..max</langsyntaxhighlight>
{{out}}
<pre>
Line 6,841:
=={{header|Simula}}==
{{trans|ALGOL W}}
<langsyntaxhighlight lang=simula>begin
integer i, j;
outtext( " " );
Line 6,857:
outimage
end;
end</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 6,875:
 
=={{header|Swift}}==
<langsyntaxhighlight lang=swift>import Foundation
 
let size = 12
Line 6,895:
printRow( with: i, upto: size)
}
</syntaxhighlight>
</lang>
 
=={{header|Tailspin}}==
<langsyntaxhighlight lang=tailspin>
templates formatN&{width:}
[ 1..$width -> ' ', '$;'... ] -> '$(last-$width+1..last)...;' !
Line 6,910:
'$ -> formatN&{width:2};|$:1..($-1)*4 -> ' ';$:$..12 -> $*$row -> formatN&{width:4};
' ! \) -> !OUT::write
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 6,930:
 
=={{header|Tcl}}==
<langsyntaxhighlight 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 6,940:
}
puts ""
}</langsyntaxhighlight>
{{out}}
<pre>
Line 6,960:
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang=tuscript>
$$ MODE TUSCRIPT
x=y="1'2'3'4'5'6'7'8'9'10'11'12"
Line 6,979:
PRINT col,cnt
ENDLOOP
</syntaxhighlight>
</lang>
{{out}}
<pre style='height:30ex;overflow:scroll'>
Line 6,998:
== {{header|TypeScript}} ==
{{trans|Modula-2}}
<langsyntaxhighlight lang=javascript>
// Multiplication tables
 
Line 7,013:
console.log("| " + i.toString().padStart(2, ' '));
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 7,035:
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.
<langsyntaxhighlight lang=Ursala>
#import std
#import nat
Line 7,048:
 
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 7,070:
=={{header|VBA}}==
 
<syntaxhighlight lang=vb>
<lang vb>
Option Explicit
 
Line 7,100:
Next i
End Sub
</syntaxhighlight>
</lang>
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 11 12
Line 7,118:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang=ecmascript>import "/fmt" for Fmt
 
var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Line 7,126:
var nums2 = nums.map { |n| (n >= i) ? (n * i).toString : " " }.toList
Fmt.print("$3d | $4s", i, nums2)
}</langsyntaxhighlight>
 
{{out}}
Line 7,148:
 
=={{header|XPL0}}==
<langsyntaxhighlight lang=XPL0>include c:\cxpl\codes;
int X, Y;
[Format(4, 0);
Line 7,161:
CrLf(0);
];
]</langsyntaxhighlight>
 
{{out}}
Line 7,182:
 
=={{header|zkl}}==
<langsyntaxhighlight lang=zkl>fcn multiplicationTable(n){
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:
[a..n].pump(String,'*(a),fmt).println();
}
}(12);</langsyntaxhighlight>
{{out}}
<pre>
Markjreed
1,480

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/326913"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information