Multiplication tables: Difference between revisions

{{trans|C}}

 

L(j) 1..n

print(‘#3’.format(j), end' ‘ ’)

L(j) 1..n

print(I j < i {‘ ’} E ‘#3 ’.format(i * j), end' ‘’)

 

{{out}}

 

=={{header|360 Assembly}}==

MULTTABL CSECT

USING MULTTABL,R12

PORT DC C'--+-------------------------------------------------'

YREGS

{{out}}

<pre> | 1 2 3 4 5 6 7 8 9 10 11 12

=={{header|8080 Assembly}}==

 

lxi h,output

;;; Make the header

inx h

ret

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program multtable64.s */

.include "../includeARM64.inc"

 

{{Output}}

<pre>

 

=={{header|Action!}}==

BYTE i

 

OD

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multiplication_tables.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

package {

 

}

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

end loop;

end Multiplication_Table;

<pre>

| 1 2 3 4 5 6 7 8 9 10 11 12

=={{header|Agena}}==

{{Trans|ALGOL_W}}

# print a school style multiplication table

# NB: print outputs a newline at the end, write and printf do not

od;

print()

{{out}}

<pre>

 

<!-- {{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;

OD;

printf(($gl$, hr))

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% print a school style multiplication table %

i_w := 3; s_w := 0; % set output formating %

end;

 

{{out}}

<pre>

12| 144

</pre>

 

=={{header|AppleScript}}==

===Iteration===

repeat with x from 0 to n

if x = 0 then set {table, x} to {{return}, -1}

set text item delimiters to ""

return (characters -4 thru -1 of (" " & x)) as string

{{out}}

<pre>"

 

{{trans|JavaScript}} (ES5 functional version)

 

-- multiplicationTable :: Int -> Int -> String

end repeat

return out & dbl

{{Out}}

<pre> x 1 2 3 4 5 6 7 8 9 10 11 12

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

 

 

=={{header|Arturo}}==

print [" |"] ++ map 1..n => [pad to :string & 3]

print "----+" ++ join map 1..n => "----"

]

 

 

{{out}}

11 | 121 132

12 | 144</pre>

 

=={{header|AutoHotkey}}==

Gui, Margin, 0, 0

Gui, Font, s9, Fixedsys

}

GuiControl,, Edit2, %Table%

Message box shows:

<pre> x | 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|AutoIt}}==

$tableupto=12

$table=""

Next

Next

 

=={{header|AWK}}==

BEGIN {

for(i=1;i<=12;i++){

print

}

{{out}}

<pre>

=={{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)

DispGraph

getKeyʳ

 

Approximate output:

 

=={{header|BASIC}}==

 

 

'header row

PRINT o$;

NEXT

 

{{out}}

</pre>

 

 

 

 

print "---+------------------------------------------------"

 

for i = 1 to 12

for j = 1 to 12

if i <= j then

if j >= 1 then

end if

else

end if

next j

print nums$

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

for /l %%A in (1,1,%numspaces%) do set "space=!space! "

goto :EOF

{{Out}}

<pre>

 

Press any key to continue . . .</pre>

 

=={{header|Befunge}}==

w^p2<y|!`+66:+1,+*84*"\"!:g25$_,#!>#:<$$_^#!:-1g10/+55\-**<<

 

{{out}}

<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

}

{{Out}}

--+-----------------------------------------------

1| 1 2 3 4 5 6 7 8 9 10 11 12

10| 100 110 120

11| 121 132

 

=={{header|Bracmat}}==

= high i j row row2 matrix padFnc tmp

, celPad leftCelPad padFnc celDashes leftDashes

)

& out$(multiplicationTable$12)

{{out}}

<pre> X| 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|C}}==

 

int main(void)

return 0;

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|C sharp}}==

 

namespace multtbl

}

}

 

{{out}}

and formats the table columns.

 

#include <iomanip>

#include <cmath> // for log10()

return 0;

}

 

{{out}}

=={{header|Chef}}==

 

 

Prints out a multiplication table.

Pour contents of the 2nd mixing bowl into the 2nd baking dish.

 

 

{{out}}

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)

(for [j trange] j))))))]

(println s)))

 

{{out}}

 

=={{header|COBOL}}==

program-id. multiplication-table.

 

goback.

end program multiplication-table.

{{out}}

<pre>prompt$ cobc -xj multiplication-table.cob

 

=={{header|CoffeeScript}}==

print_multiplication_tables = (n) ->

width = 4

print_multiplication_tables 12

 

{{out}}

 

=={{header|Common Lisp}}==

(do ((m 0 (if (= 12 m) 0 (1+ m)))

(n 0 (if (= 12 m) (1+ n) n)))

(format t "~4,D" (* m n))

(format t " "))))))

Output:

<pre>

=={{header|D}}==

{{trans|PicoLisp}}

import std.stdio, std.array, std.range, std.algorithm;

 

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

 

=={{header|DCL}}==

$ h = f$fao( "!4* " )

$ r = 0

$ write sys$output f$fao( "!4SL", r ) + o

$ r = r + 1

{{out}}

<pre>$ @multiplication_tables

=={{header|Delphi}}==

{{trans|DWScript}}

 

{$APPTYPE CONSOLE}

Writeln;

end;

 

=={{header|Draco}}==

proc nonrec multab(byte n) void:

byte i,j;

 

/* Print 12-by-12 multiplication table */

{{out}}

<pre> | 1 2 3 4 5 6 7 8 9 10 11 12

=={{header|DWScript}}==

 

var row, col : Integer;

 

PrintLn('');

end;

 

=={{header|E}}==

 

println(`{|style="border-collapse: collapse; text-align: right;"`)

println(`|`)

}

}

 

Targets MediaWiki markup.

=={{header|EasyLang}}==

 

write " "

for i = 1 to n

.

print ""

write " "

for i = 1 to n

.

print ""

for i = 1 to n

 

=={{header|EchoLisp}}==

(lib 'matrix)

 

(array-print (build-array 13 13 mtable))

 

{{out}}

<pre>

 

=={{header|Elixir}}==

def multiplication_tables(n) do

IO.write " X |"

end

 

 

{{out}}

11 | 121 132

12 | 144

</pre>

 

=={{header|Erlang}}==

-module( multiplication_tables ).

 

[io:fwrite("~5B", [Sum]) || {_Y, Sum} <- Uptos],

io:nl().

{{out}}

<pre>

 

=={{header|Euphoria}}==

for i = 1 to 12 do

printf(1," %3d",i)

end for

puts(1,'\n')

 

{{out}}

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(f,

LAMBDA(n,

)

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(a, LAMBDA(b, a * b))

 

POWER(n, e)

)

 

(The single formula in cell '''B2''' below populates the whole 12*12 grid)

=={{header|F Sharp|F#}}==

Translation of C#

open System

 

 

multTable ()

{{out}}

<pre>

 

=={{header|Factor}}==

IN: multiplication-table

 

" +" write

12 [ "----" write ] times nl

 

<pre>

 

=={{header|FALSE}}==

[$p;! m: 2[$m;\>][" "1+]# [$13\>][$m;*p;!1+]#%"

"]l:

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

: multiplication-table

cr 2 spaces 13 2 do i 4 u.r loop

loop

loop ;

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end do

 

 

===Traditional approach===

 

So instead, write the table by first writing a line to a CHARACTER variable then blanking out the unwanted part.

Cast forth a twelve times table, suitable for chanting at school.

INTEGER I,J !Steppers.

3 WRITE (6,"(A)") ALINE !Print the text.

END !"One one is one! One two is two! One three is three!...

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

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.

Cast forth a twelve times table, suitable for chanting at school.

INTEGER I,J !Steppers.

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

The output is the same, so instead, here are the generated FORMAT texts:

(I3,'|',0X,12I4)

 

===VAX FORTRAN===

PROGRAM TABLES

IMPLICIT NONE

C

END

===FORTRAN-IV===

C

C Produce a formatted multiplication table of the kind memorised by rote

3 CONTINUE

C

 

===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

3 CONTINUE

C

| 1 2 3 4 5 6 7 8 9 10 11 12

--+------------------------------------------------

10| 100 110 120

11| 121 132

 

=={{header|Frink}}==

 

{{out}}

11 121 132

12 144

</pre>

 

=={{header|Go}}==

package main

 

fmt.Println("")

}

 

=={{header|Groovy}}==

Solution:

assert size > 1

}

 

 

{{out}}

12| 144</pre>

 

 

=={{header|Haskell}}==

 

------------------- MULTIPLICATION TABLE -----------------

gap = replicate w ' '

rows = (maybe gap (rjust w ' ' . show) =<<) <$> xs

{{Out}}

<pre> 13 14 15 16 17 18 19 20

 

Or, more roughly and directly:

import Data.Function (on)

import Control.Monad (join)

groupBy

(on (==) fst)

{{Out}}

<pre>[1]

 

=={{header|hexiscript}}==

let n tostr n

while len n < l; let n (" " + n); endwhile

endfor

println ""

 

=={{header|HicEst}}==

DO line = 1, 12

WRITE(Row=line+2, Format='i2') line

WRITE(Row=line+2, Column=4*col, Format='i3') line*col

ENDDO

 

=={{header|HolyC}}==

{{trans|C}}

for (j = 1; j <= n; j++)

if (j != n)

Print("%3d ", i * j);

Print("| %d\n", i);

 

=={{header|Icon}} and {{header|Unicon}}==

lim := 13

wid := 5

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

 

The above example is a somewhat exaggerated example of contractions.

12 | 144 156

13 | 169 </pre>

 

=={{header|J}}==

format=: 'b4.0' 8!:2 ]

(('*' ; ,.) ,. ({. ; ])@format@multtable) >:i.12

│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++)

}

}

{{out}}

<pre>

=={{header|JavaScript}}==

 

 

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

target.appendChild(table);

}

</script>

<style type='text/css'>

<div id='target'></div>

</body>

 

{{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>

 

// [m..n]

function range(m, n) {

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

}))]}));

// or simply stringified as JSON

JSON.stringify(lstTable);

 

{{out}}

|}

 

[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],

[10,"","","","","","","","","",100,110,120],

[11,"","","","","","","","","","",121,132],

 

"use strict";

 

// MAIN ---

return main();

{{Out}}

{| class="wikitable" style="text-align:center;width:33em;height:33em;table-layout:fixed"

|}

 

=={{header|Jsish}}==

var m, n, tableSize = 12;

 

}

}

 

{{out}}

 

=={{header|Julia}}==

 

println(" X | 1 2 3 4 5 6 7 8 9 10 11 12")

print(" ")

end

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

println()

}

 

{{out}}

Outputs are visible in http://lambdaway.free.fr/lambdawalks/?view=multiplication_table

 

{def format

{lambda {:w :c}

3) {make_table {operation pow} 6 10}

 

 

=={{header|Lasso}}==

local(result) = ``

local(padSize) = string(#max*#max)->size + 1

}

 

 

{{out}}

12| 144</pre>

 

 

=={{header|Logo}}==

{{works with|UCB Logo}}

type "| | for [i 2 :n] [type form :i 4 0] (print)

(print)

 

mult.table 12

 

=={{header|Lua}}==

for i = 1, 12 do

io.write( string.format( "%#5d", i ) )

end

io.write( "\n" )

<pre> | 1 2 3 4 5 6 7 8 9 10 11 12

----------------------------------------------------------------

=={{header|M2000 Interpreter}}==

Using jagged array (arrays of arrays)

Module CheckIt {

Dim Base 1, A(12)

}

CheckIt

 

Final loop can be this, using Each() and r1 as pointer to array.

 

=={{header|Maple}}==

for i to 12 do

printf("%-3d ", i);

end if

end do

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>1 1 2 3 4 5 6 7 8 9 10 11 12

timesTable.m: (creates Times Table of N degree)

 

table = [(0:N); (1:N)' triu( kron((1:N),(1:N)') )];

 

A minimally vectorized version of the above code:

 

 

%Generates a column vector with integers from 1 to N

table = [columnLabels; rowLabels triu(table)];

{{out}}

 

=={{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, "~%")

 

 

=={{header|МК-61/52}}==

ИП5 ИП0 - x=0 03

ИП4 ИП0 - x#0 22 ИП4 П5 БП 02

 

''Input'': 12 С/П ...

=={{header|Modula-2}}==

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE MultiplicationTables;

 

END;

END MultiplicationTables.

{{out}}

<pre>

=={{header|MOO}}==

This quick example is designed to demonstrate raw MOO. In other words it does not use any of the helper functions available in popular DBs such as LambdaMOO.

@verb me:@tables none none none rxd

@program me:@tables

endfor

.

 

LambdaMOO string utilities version:

@program me:@tables

player:tell(" | 1 2 3 4 5 6 7 8 9 10 11 12");

endfor

.

{{out}}

<pre>

 

=={{header|MUMPS}}==

;Print out a multiplication table

;SIZE is the size of the multiplication table to make

..WRITE:((A-1)>=(D-2))&((D-2)>=1) ?((A-1)*5),$JUSTIFY((D-2)*(A-1),MW)

KILL MW,D,A,BAR

 

{{out}}

11 | 121 132

12 | 144</pre>

 

=={{header|Neko}}==

Multiplication table, in Neko

Tectonics:

$print("\n");

j += 1;

 

{{out}}

=={{header|Nim}}==

{{trans|C}}

 

const n = 12

for j in 1..n:

stdout.write if j<i: " " else: "{:3d} ".fmt(i*j)

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 10 11 12

{{trans|C}}

 

let max = 12 in

let fmax = float_of_int max in

print_newline()

done;

 

=={{header|PARI/GP}}==

Quick and dirty one-liner:

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

our $width = length($max**2) + 1;

 

foreach "$i|", map { $_ >= $i and $_*$i } 1..$max;

print "\n";

 

{{out}}

=={{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>

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

12| 144

</pre>

 

=={{header|Picat}}==

N=12,

make_table(N),

nl

end,

 

{{out}}

11 | 121 132

12 | 144</pre>

 

=={{header|PicoLisp}}==

(space 4)

(for X N

(prinl) ) )

 

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|PL/I}}==

/* 12 x 12 multiplication table. */

 

 

end multiplication_table;

 

Result:

 

1 2 3 4 5 6 7 8 9 10 11 12

_________________________________________________

11 | 121 132

12 | 144

 

=={{header|PowerShell}}==

$Tab = "`t"

# Combine them all together

) -join $Tab

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 10 11 12

12 144</pre>

<b>A more general solution</b>

{

# For clarity

}

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

 

=={{header|Prolog}}==

print_header(S,E),

make_table_rows(S,E),

print_num(X) :- X < 10, format(' ~p', X).

print_num(X) :- between(10,99,X), format(' ~p', X).

{{out}}

<pre>

 

?-</pre>

 

=={{header|Python}}==

===Procedural===

>>> width = len(str(size**2))

>>> for row in range(-1,size+1):

11│ 121 132

12│ 144

 

The above works with Python 3.X, which uses Unicode strings by default. <br>

and then again, for comparison, as an equivalent '''list monad''' expression (''mulTable2'' function):

 

 

1. by list comprehension (mulTable ),

 

if __name__ == '__main__':

{{Out}}

<pre>By list comprehension (mulTable):

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

import collections

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre> 13 14 15 16 17 18 19 20

=={{header|Quackery}}==

 

tuck size -

times sp echo$ ] is echo-rj ( n n --> )

[ dip dup

* 4 echo-rj ] ]

 

{{Out}}

 

=={{header|R}}==

multiplication_table <- function(n=12)

{

}

multiplication_table()

 

=={{header|Racket}}==

 

#lang racket

 

(show-line (cons y (for/list ([x (in-range 1 13)])

(if (<= y x) (* x y) "")))))

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

 

 

for 1..$max -> $i {

{{out}}

<pre>

 

=={{header|REBOL}}==

Title: "12x12 Multiplication Table"

URL: http://rosettacode.org/wiki/Print_a_Multiplication_Table

 

print rejoin [ crlf "How about " size: 20 "?" crlf ]

 

{{out}} (only 12x12 shown):

 

=={{header|REXX}}==

parse arg sz . /*obtain optional argument from the CL.*/

if sz=='' | sz=="," then sz= 12 /*Not specified? Then use the default.*/

top: $= '┌'__"┬"copies(___'┬', sz); call dap "┐"; ?= arg(1); say $; call hdr; return

sep: $= '├'__"┼"copies(___'┼', sz); call dap "┤"; say $; return

{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 12 </tt>}}

<pre>

 

=={{header|Ring}}==

multiplication_table(12)

func multiplication_table n

next

func fsize x,n return string(x) + copy(" ",n-len(string(x)))

 

Output

| 1 2 3 4 5 6 7 8 9 10 11 12

----+-------------------------------------------------

11 | 121 132

12 | 144

 

=={{header|Ruby}}==

puts " |" + (" %3d" * n) % [*1..n]

puts "----+" + "----" * n

end

 

 

{{out}}

12 | 144

</pre>

 

=={{header|Rust}}==

 

fn main() {

println!("| {}", i);

}

 

or, in terms of map:

 

let xs = (1..=12)

.map(|a| {

 

println!("{}", xs.join("\n"))

 

=={{header|Scala}}==

//Multiplication Table

print("%5s".format("|"))

println("")

}

 

=== case ===

implicit def intToString(i: Int) = i.toString

val cell = (x:String) => print("%5s".format(x))

}

}

 

=={{header|Scheme}}==

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)

(loop (+ count 1)

(cdr numbers)))))))

 

<pre>

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

s= blanks(xx)+" |"

for j=1:nmax

end

printf("%s\n",s)

{{out}}

<pre> | 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|Seed7}}==

const proc: main is func

writeln("|" <& i lpad 3);

end for;

 

{{out}}

 

=={{header|Sidef}}==

var width = (max**2 -> len+1)

 

{ |i| 

say fmt_row("#{i}┃", {|j| i <= j ? i*j : ''}.map(1..max)...)

{{out}}

<pre>

=={{header|Simula}}==

{{trans|ALGOL W}}

integer i, j;

outtext( " " );

outimage

end;

{{out}}

<pre> 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|Swift}}==

 

let size = 12

printRow( with: i, upto: size)

}

 

=={{header|Tailspin}}==

templates formatN&{width:}

[ 1..$width -> ' ', '$;'... ] -> '$(last-$width+1..last)...;' !

'$ -> formatN&{width:2};|$:1..($-1)*4 -> ' ';$:$..12 -> $*$row -> formatN&{width:4};

' ! \) -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

puts \u0020\u2500\u2500\u253c[string repeat \u2500 48]

for {set i 1} {$i <= 12} {incr i} {

}

puts ""

{{out}}

<pre>

12│ 144

</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

x=y="1'2'3'4'5'6'7'8'9'10'11'12"

PRINT col,cnt

ENDLOOP

{{out}}

<pre style='height:30ex;overflow:scroll'>

== {{header|TypeScript}} ==

{{trans|Modula-2}}

// Multiplication tables

 

var n = 12;

console.clear();

for (j = 1; j < n; j++)

console.log("----".repeat(n) + "+");

for (i = 1; i <= n; i++) {

for (j = 1; j <= n; j++)

}

{{out}}

<pre>

144 | 12

</pre>

 

=={{header|Ursala}}==

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.

#import std

#import nat

 

main = table 12

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.

</pre>

 

End Sub

{{out}}

<pre>

</pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

var nums2 = nums.map { |n| (n >= i) ? (n * i).toString : " " }.toList

Fmt.print("$3d | $4s", i, nums2)

 

{{out}}

11 | 121 132

12 | 144

</pre>

 

=={{header|XPL0}}==

int X, Y;

[Format(4, 0);

CrLf(0);

];

 

{{out}}

12| . . . . . . . . . . . . . . . . . . . . . . 144

</pre>

 

=={{header|zkl}}==

w,fmt := (n*n).numDigits, " %%%dd".fmt(w).fmt; // eg " %3".fmt

header:=[1..n].apply(fmt).concat(); // 1 2 3 4 ...

[a..n].pump(String,'*(a),fmt).println();

}

{{out}}

<pre>