Multiplication tables: Difference between revisions

Line 12:

<~~lang~~ 11l>V n = 12

<syntaxhighlight 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)</~~lang~~>

print(‘│ ’i)</syntaxhighlight>

Line 44:

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

<~~lang~~ 360asm>* 12*12 multiplication table 14/08/2015

<syntaxhighlight lang=360asm>* 12*12 multiplication table 14/08/2015

MULTTABL CSECT

USING MULTTABL,R12

Line 103:

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

YREGS

END MULTTABL</~~lang~~>

END MULTTABL</syntaxhighlight>

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

Line 122:

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

<~~lang~~ 8080asm> org 100h

<syntaxhighlight lang=8080asm> org 100h

lxi h,output

;;; Make the header

Line 218:

inx h

ret

output: equ $</~~lang~~>

output: equ $</syntaxhighlight>

Line 240:

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

<~~lang~~ AArch64 Assembly>

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program multtable64.s */

Line 391:

.include "../includeARM64.inc"

</syntaxhighlight>

</lang>

<pre>

Line 410:

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

<~~lang~~ Action!>PROC PrintRight(BYTE num,size)

<syntaxhighlight lang=Action!>PROC PrintRight(BYTE num,size)

BYTE i

Line 470:

OD

RETURN</~~lang~~>

RETURN</syntaxhighlight>

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

Line 491:

=={{header|ActionScript}}==

<~~lang~~ ActionScript>

package {

Line 571:

}

</syntaxhighlight>

</lang>

=={{header|Ada}}==

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

<~~lang~~ agena>scope

<syntaxhighlight 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</~~lang~~>

epocs</syntaxhighlight>

<pre>

Line 658:

<~~lang~~ Algol68>main:(

<syntaxhighlight lang=Algol68>main:(

INT max = 12;

INT width = ENTIER(log(max)*2)+1;

Line 676:

OD;

printf(($gl$, hr))

)</~~lang~~>

)</syntaxhighlight>

<pre>

Line 698:

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

<~~lang~~ algolw>begin

<syntaxhighlight lang=algolw>begin

% print a school style multiplication table %

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

Line 711:

end;

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 732:

=={{header|APL}}==

A simple table is trivial:

But that prints out all the duplicated results across the diagonal:

Line 753:

<~~lang~~ apl>⎕←(' ×',2↑' '),4 0⍕⍳12⋄{⎕←((4 0⍕⍵),⊂1(4×(⍵-1))⍴' '),4 0⍕(⍵-1)↓(⍵×⍳12)}¨⍳12</~~lang~~>

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.

<~~lang~~ apl>⎕←(' ×',4↑' '),4 0⍕⍳12⋄⍬⊣{⎕←((4 0⍕⍵),⊂1(4×(⍵-1))⍴' '),4 0⍕(⍵-1)↓(⍵×⍳12)}¨⍳12</~~lang~~>

Line 777:

=={{header|AppleScript}}==

===Iteration===

<~~lang~~ AppleScript >set n to 12 -- Size of table.

<syntaxhighlight lang=AppleScript >set n to 12 -- Size of table.

repeat with x from 0 to n

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

Line 797:

set text item delimiters to ""

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

end f</~~lang~~>

end f</syntaxhighlight>

<pre>"

Line 819:

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

<~~lang~~ AppleScript>------------------- MULTIPLICATION TABLE -----------------

<syntaxhighlight lang=AppleScript>------------------- MULTIPLICATION TABLE -----------------

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

Line 1,001:

end repeat

return out & dbl

end replicate</~~lang~~>

end replicate</syntaxhighlight>

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

Line 1,034:

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

<~~lang~~ ARM Assembly>

/* ARM assembly Raspberry PI */

Line 1,217:

</syntaxhighlight>

</lang>

=={{header|Arturo}}==

<~~lang~~ rebol>mulTable: function [n][

<syntaxhighlight lang=rebol>mulTable: function [n][

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

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

Line 1,231:

]

mulTable 12</~~lang~~>

mulTable 12</syntaxhighlight>

Line 1,252:

=={{header|ASIC}}==

<~~lang~~ basic>

REM Multiplication tables

N = 12

Line 1,299:

PRINT S2$;

RETURN

</syntaxhighlight>

</lang>

<pre>

Line 1,319:

=={{header|AutoHotkey}}==

<~~lang~~ autohotkey>Gui, -MinimizeBox

<syntaxhighlight lang=autohotkey>Gui, -MinimizeBox

Gui, Margin, 0, 0

Gui, Font, s9, Fixedsys

Line 1,354:

}

GuiControl,, Edit2, %Table%

Return</~~lang~~>

Return</syntaxhighlight>

Message box shows:

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

Line 1,373:

=={{header|AutoIt}}==

<~~lang~~ AutoIt>#AutoIt Version: 3.2.10.0

<syntaxhighlight lang=AutoIt>#AutoIt Version: 3.2.10.0

$tableupto=12

$table=""

Line 1,392:

msgbox(0,"Multiplication Tables",$table)</~~lang~~>

msgbox(0,"Multiplication Tables",$table)</syntaxhighlight>

=={{header|AWK}}==

<~~lang~~ AWK>

BEGIN {

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

Line 1,404:

print

}

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ axe>Fix 5

<syntaxhighlight lang=axe>Fix 5

ClrDraw

For(I,1,10)

Line 1,440:

DispGraph

getKeyʳ

Fix 4</~~lang~~>

Fix 4</syntaxhighlight>

Approximate output:

Line 1,460:

==={{header|Applesoft BASIC}}===

<~~lang~~ ApplesoftBasic>100 M = 12

<syntaxhighlight lang=ApplesoftBasic>100 M = 12

110 DEF FN T(X) = X * 3 + (X < 4) * (4 - X) + (X > 10) * (X - 10) - 1

120 FOR N = -1 TO M

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</~~lang~~>

190 NEXT J, N</syntaxhighlight>

==={{header|BASIC256}}===

<~~lang~~ freebasic>print " X| 1 2 3 4 5 6 7 8 9 10 11 12"

<syntaxhighlight 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</~~lang~~>

next i</syntaxhighlight>

==={{header|BBC BASIC}}===

BBC BASIC automatically right-justifies numeric output.

<~~lang~~ bbcbasic> @% = 5 : REM Set column width

<syntaxhighlight lang=bbcbasic> @% = 5 : REM Set column width

FOR row% = 1 TO 12

PRINT row% TAB(row% * @%) ;

Line 1,499:

NEXT col%

PRINT

NEXT row%</~~lang~~>

NEXT row%</syntaxhighlight>

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

<~~lang~~ gwbasic>100 PRINT CHR$(14);CHR$(147);

<syntaxhighlight 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</~~lang~~>

540 RETURN</syntaxhighlight>

Line 1,589:

12: : : : : : : : : : : :144</pre>

==={{header|FreeBASIC}}===

<~~lang~~ freebasic>

' FB 1.05.0 Win64

Line 1,611:

Print

Print "Press any key to quit"

Sleep</~~lang~~>

Sleep</syntaxhighlight>

Line 1,632:

==={{header|FutureBasic}}===

<lang>

long i, j

Line 1,652:

HandleEvents

</syntaxhighlight>

</lang>

<pre>

Line 1,674:

<~~lang~~ qbasic>

10 ' Multiplication Tables

20 LET N% = 12

Line 1,692:

160 PRINT "| "; USING "##"; I%

170 NEXT I%

</syntaxhighlight>

</lang>

<pre>

Line 1,712:

==={{header|IS-BASIC}}===

<~~lang~~ IS-BASIC>100 PROGRAM "Multipli.bas"

<syntaxhighlight lang=IS-BASIC>100 PROGRAM "Multipli.bas"

110 TEXT 80

120 PRINT TAB(7);

Line 1,725:

210 NEXT

220 PRINT

230 NEXT</~~lang~~>

230 NEXT</syntaxhighlight>

==={{header|Liberty BASIC}}===

<~~lang~~ lb>Print " | 1 2 3 4 5 6 7 8 9 10 11 12"

<syntaxhighlight 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</~~lang~~>

Next i</syntaxhighlight>

<pre>

Line 1,765:

==={{header|Microsoft Small Basic}}===

<~~lang~~ microsoftsmallbasic>

n = 12

For j = 1 To n - 1

Line 1,794:

TextWindow.WriteLine("")

EndFor

</syntaxhighlight>

</lang>

<pre>

Line 1,814:

==={{header|PureBasic}}===

<~~lang~~ PureBasic>Procedure PrintMultiplicationTable(maxx, maxy)

<syntaxhighlight lang=PureBasic>Procedure PrintMultiplicationTable(maxx, maxy)

sp = Len(Str(maxx*maxy)) + 1

trenner$ = "+"

Line 1,848:

OpenConsole()

PrintMultiplicationTable(12, 12)

Input()</~~lang~~>

Input()</syntaxhighlight>

Ouput similar to ALGOL 68

==={{header|QBasic}}===

<~~lang~~ qbasic>CLS

<syntaxhighlight lang=qbasic>CLS

'header row

Line 1,878:

PRINT o$;

NEXT</~~lang~~>

NEXT</syntaxhighlight>

Line 1,899:

==={{header|Run BASIC}}===

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

<syntaxhighlight lang=Runbasic>html "<TABLE border=1 ><TR bgcolor=silver align=center><TD><TD>1<TD>2<TD>3<TD>4<TD>5<TD>6<TD>7<TD>8<TD>9<TD>10<TD>11<TD>12</td></TR>"

For i = 1 To 12

html "<TR align=right><TD>";i;"</td>"

Line 1,909:

next i

html "</table>"

</~~lang~~>Output:

</syntaxhighlight>Output:

==={{header|True BASIC}}===

<~~lang~~ qbasic>PRINT " X| 1 2 3 4 5 6 7 8 9 10 11 12"

<syntaxhighlight lang=qbasic>PRINT " X| 1 2 3 4 5 6 7 8 9 10 11 12"

PRINT "---+------------------------------------------------"

Line 1,929:

NEXT i

PRINT

END</~~lang~~>

END</syntaxhighlight>

==={{header|uBasic/4tH}}===

<~~lang~~>For R = 1 To 12

<syntaxhighlight>For R = 1 To 12

Print R;Tab(R * 5);

For C = R To 12

Line 1,939:

Print

Next</~~lang~~>

Next</syntaxhighlight>

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

Line 1,958:

==={{header|Visual Basic}}===

<~~lang~~ vb>Sub Main()

<syntaxhighlight lang=vb>Sub Main()

Const nmax = 12, xx = 3

Const x = xx + 1

Line 1,981:

Debug.Print s

Next i

End Sub 'Main</~~lang~~>

End Sub 'Main</syntaxhighlight>

<pre>

Line 2,003:

<~~lang~~ xbasic>

PROGRAM "multiplicationtables"

VERSION "0.0001"

Line 2,031:

END FUNCTION

END PROGRAM

</syntaxhighlight>

</lang>

<pre>

Line 2,051:

==={{header|Yabasic}}===

<~~lang~~ freebasic>print " X| 1 2 3 4 5 6 7 8 9 10 11 12"

<syntaxhighlight 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</~~lang~~>

next i</syntaxhighlight>

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

<~~lang~~ dos>@echo off

<syntaxhighlight lang=dos>@echo off

setlocal enabledelayedexpansion

Line 2,116:

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

goto :EOF

::/The Functions.</~~lang~~>

::/The Functions.</syntaxhighlight>

<pre>

Line 2,137:

=={{header|Befunge}}==

<~~lang~~ befunge>0>51p0>52p51g52g*:51g52g`!*\!51g52g+*+0\3>01p::55+%68*+\!28v

<syntaxhighlight lang=befunge>0>51p0>52p51g52g*:51g52g`!*\!51g52g+*+0\3>01p::55+%68*+\!28v

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

"$9"^x>$55+,51g1+:66+`#@_055+68*\>\#<1#*-#9:#5_$"+---">:#,_$</~~lang~~>

"$9"^x>$55+,51g1+:66+`#@_055+68*\>\#<1#*-#9:#5_$"+---">:#,_$</syntaxhighlight>

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

<~~lang~~ bqn>Table ← {

<syntaxhighlight lang=bqn>Table ← {

m ← •Repr¨ ×⌜˜1+↕𝕩 # The numbers, formatted individually

main ← ⟨ # Bottom part: three sections

Line 2,172:

}

•Out˘ Table 12</~~lang~~>

•Out˘ Table 12</syntaxhighlight>

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

<syntaxhighlight> | 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</~~lang~~>

12| 144</syntaxhighlight>

=={{header|Bracmat}}==

<~~lang~~ Bracmat> ( multiplicationTable

<syntaxhighlight lang=Bracmat> ( multiplicationTable

= high i j row row2 matrix padFnc tmp

, celPad leftCelPad padFnc celDashes leftDashes

Line 2,245:

)

& out$(multiplicationTable$12)

& done;</~~lang~~>

& done;</syntaxhighlight>

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

Line 2,263:

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang=c>#include <stdio.h>

int main(void)

Line 2,279:

return 0;

}</~~lang~~>

}</syntaxhighlight>

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

Line 2,297:

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

<~~lang~~ csharp>using System;

<syntaxhighlight lang=csharp>using System;

namespace multtbl

Line 2,335:

}

</syntaxhighlight>

</lang>

Line 2,359:

and formats the table columns.

<~~lang~~ cpp>#include <iostream>

<syntaxhighlight lang=cpp>#include <iostream>

#include <iomanip>

#include <cmath> // for log10()

Line 2,436:

return 0;

}

</syntaxhighlight>

</lang>

Line 2,470:

=={{header|Chef}}==

<~~lang~~ chef>Multigrain Bread.

<syntaxhighlight 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.</~~lang~~>

Serves 2.</syntaxhighlight>

Line 2,555:

This is more generalized.

Any size can be used and the table will be formatted appropriately.

<~~lang~~ lisp>(let [size 12

<syntaxhighlight lang=lisp>(let [size 12

trange (range 1 (inc size))

fmt-width (+ (.length (str (* size size))) 1)

Line 2,568:

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

(println s)))

</syntaxhighlight>

</lang>

Line 2,587:

=={{header|COBOL}}==

<~~lang~~ COBOL> identification division.

<syntaxhighlight lang=COBOL> identification division.

program-id. multiplication-table.

Line 2,633:

goback.

end program multiplication-table.

</syntaxhighlight>

</lang>

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

Line 2,651:

=={{header|CoffeeScript}}==

<~~lang~~ coffeescript>

print_multiplication_tables = (n) ->

width = 4

Line 2,683:

print_multiplication_tables 12

</syntaxhighlight>

</lang>

Line 2,705:

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

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

<~~lang~~ d>void main() {

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

}</~~lang~~>

}</syntaxhighlight>

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

Line 2,770:

=={{header|DCL}}==

<~~lang~~ DCL>$ max = 12

<syntaxhighlight 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</~~lang~~>

$ if r .le. max then $ goto loop1</syntaxhighlight>

<pre>$ @multiplication_tables

Line 2,817:

=={{header|Delphi}}==

<~~lang~~ delphi>program MultiplicationTables;

<syntaxhighlight lang=delphi>program MultiplicationTables;

{$APPTYPE CONSOLE}

Line 2,846:

Writeln;

end;

end.</~~lang~~>

end.</syntaxhighlight>

=={{header|Draco}}==

<~~lang~~ draco>/* Print N-by-N multiplication table */

<syntaxhighlight 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</~~lang~~>

proc nonrec main() void: multab(12) corp</syntaxhighlight>

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

Line 2,893:

=={{header|DWScript}}==

<~~lang~~ delphi>const size = 12;

<syntaxhighlight lang=delphi>const size = 12;

var row, col : Integer;

Line 2,911:

PrintLn('');

end;

</syntaxhighlight>

</lang>

=={{header|E}}==

<~~lang~~ e> def size := 12

<syntaxhighlight lang=e> def size := 12

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

println(`|`)

Line 2,928:

}

println("|}")</~~lang~~>

println("|}")</syntaxhighlight>

Targets MediaWiki markup.

Line 3,120:

=={{header|EasyLang}}==

<~~lang~~>n = 12

<syntaxhighlight>n = 12

func out h . .

if h < 10

Line 3,151:

.

print ""

.</~~lang~~>

.</syntaxhighlight>

=={{header|EchoLisp}}==

<~~lang~~ scheme>

(lib 'matrix)

Line 3,167:

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

</syntaxhighlight>

</lang>

<pre>

Line 3,186:

=={{header|Elixir}}==

<~~lang~~ elixir>defmodule RC do

<syntaxhighlight lang=elixir>defmodule RC do

def multiplication_tables(n) do

IO.write " X |"

Line 3,201:

end

RC.multiplication_tables(12)</~~lang~~>

RC.multiplication_tables(12)</syntaxhighlight>

Line 3,222:

=={{header|Erlang}}==

<~~lang~~ Erlang>

-module( multiplication_tables ).

Line 3,247:

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

io:nl().

</syntaxhighlight>

</lang>

<pre>

Line 3,268:

=={{header|Euphoria}}==

<~~lang~~ Euphoria>puts(1," x")

<syntaxhighlight 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</~~lang~~>

end for</syntaxhighlight>

Line 3,312:

<~~lang~~ lisp>FNOVERHALFCARTESIANPRODUCT

<syntaxhighlight lang=lisp>FNOVERHALFCARTESIANPRODUCT

=LAMBDA(f,

LAMBDA(n,

Line 3,328:

)

)</~~lang~~>

)</syntaxhighlight>

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

<~~lang~~ lisp>MUL

<syntaxhighlight lang=lisp>MUL

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

Line 3,341:

POWER(n, e)

)

)</~~lang~~>

)</syntaxhighlight>

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

Line 3,758:

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

Translation of C#

<~~lang~~ FSharp>

open System

Line 3,778:

multTable ()

</syntaxhighlight>

</lang>

<pre>

Line 3,798:

=={{header|Factor}}==

<~~lang~~ factor>USING: io kernel math math.parser math.ranges sequences ;

<syntaxhighlight 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 ;</~~lang~~>

1 12 [a,b] [ print-row ] each ;</syntaxhighlight>

<pre>

Line 3,834:

=={{header|FALSE}}==

<~~lang~~ false>[$100\>[" "]?$10\>[" "]?." "]p:

<syntaxhighlight lang=false>[$100\>[" "]?$10\>[" "]?." "]p:

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

"]l:

1[$13\>][$l;!1+]#%</~~lang~~>

1[$13\>][$l;!1+]#%</syntaxhighlight>

=={{header|Fantom}}==

<~~lang~~ fantom>

class Main

{

Line 3,863:

}

</syntaxhighlight>

</lang>

=={{header|Forth}}==

<~~lang~~ forth>

: multiplication-table

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

Line 3,876:

loop

loop ;

</syntaxhighlight>

</lang>

=={{header|Fortran}}==

<~~lang~~ fortran>program multtable

<syntaxhighlight lang=fortran>program multtable

implicit none

Line 3,898:

end do

end program multtable</~~lang~~>

end program multtable</syntaxhighlight>

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

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

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

<~~lang~~ Fortran>

PROGRAM TABLES

IMPLICIT NONE

Line 3,990:

C

END

</~~lang~~>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.

</syntaxhighlight>Based on the above code but with a slight modification as VAX FORTRAN doesn't allow zero width fields in a format statement. The number of rows and columns can also be altered by modifying the value of K which must be in the range 1 - 25.

===FORTRAN-IV===

<~~lang~~ Fortran> PROGRAM TABLES

<syntaxhighlight lang=Fortran> PROGRAM TABLES

C

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

Line 4,026:

3 CONTINUE

C

END</~~lang~~>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.

END</syntaxhighlight>Rather more changes are needed to produce the same result, in particular we cannot modify the format specifier directly and have to rely on overlaying it with an integer array and calculating the ASCII values needed for each byte we need to modify. Nested implicit DO loops are allowed, but not used as it isn't possible to compute K on the fly so we have to calculate (and store) the results for each row before printing it. Note also that the unit numbers for the output devices are different and when using Hollerith strings to define values in a DATA statement the size of each string must match the size of the data type.

===Microsoft FORTRAN-80===

The use of a non standard(?) BYTE data type available in Microsoft FORTRAN-80 makes it easier to understand what is going on.

<~~lang~~ Fortran> PROGRAM TABLES

<syntaxhighlight lang=Fortran> PROGRAM TABLES

C

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

Line 4,062:

3 CONTINUE

C

END</~~lang~~>Inserting the following two lines before the inner DO loop will print the format specifier used to print each row of the table.<~~lang~~ Fortran> WRITE(1,4) (A(J), J = 1,24)

END</syntaxhighlight>Inserting the following two lines before the inner DO loop will print the format specifier used to print each row of the table.<syntaxhighlight lang=Fortran> WRITE(1,4) (A(J), J = 1,24)

4 FORMAT(1x,24A1)</~~lang~~>Running the program produces the following output<~~lang~~>

4 FORMAT(1x,24A1)</syntaxhighlight>Running the program produces the following output<syntaxhighlight>

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

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

Line 4,077:

10| 100 110 120

11| 121 132

12| 144</~~lang~~>

12| 144</syntaxhighlight>

=={{header|Frink}}==

<~~lang~~ frink>a = makeArray[[13,13], {|a,b| a==0 ? b : (b==0 ? a : (a<=b ? a*b : ""))}]

<syntaxhighlight lang=frink>a = makeArray[[13,13], {|a,b| a==0 ? b : (b==0 ? a : (a<=b ? a*b : ""))}]

formatTable[a,"right"]</~~lang~~>

formatTable[a,"right"]</syntaxhighlight>

Line 4,102:

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=3a3a987766a9a9a383b3e0e8a65d9ea2 Click this link to run this code]'''

<~~lang~~ gambas>'Code 'stolen' from Free Basic and altered to work in Gambas

<syntaxhighlight lang=gambas>'Code 'stolen' from Free Basic and altered to work in Gambas

Public Sub Main()

Line 4,124:

End</~~lang~~>

End</syntaxhighlight>

Output:

<pre>

Line 4,144:

=={{header|Go}}==

package main

Line 4,172:

fmt.Println("")

}

</syntaxhighlight>

</lang>

=={{header|Groovy}}==

Solution:

<~~lang~~ groovy>def printMultTable = { size = 12 ->

<syntaxhighlight lang=groovy>def printMultTable = { size = 12 ->

assert size > 1

Line 4,194:

}

printMultTable()</~~lang~~>

printMultTable()</syntaxhighlight>

Line 4,214:

=={{header|Haskell}}==

<~~lang~~ haskell>import Data.Maybe (fromMaybe, maybe)

<syntaxhighlight 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 <>)</~~lang~~>

rjust n c = (drop . length) <*> (replicate n c <>)</syntaxhighlight>

<pre> 13 14 15 16 17 18 19 20

Line 4,287:

Or, more roughly and directly:

<~~lang~~ haskell>import Data.List (groupBy)

<syntaxhighlight 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])</~~lang~~>

(filter (uncurry (>=)) $ join ((<*>) . fmap (,)) [1 .. 12])</syntaxhighlight>

<pre>[1]

Line 4,313:

=={{header|hexiscript}}==

<~~lang~~ hexiscript>fun format n l

<syntaxhighlight lang=hexiscript>fun format n l

let n tostr n

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

Line 4,331:

endfor

println ""

endfor</~~lang~~>

endfor</syntaxhighlight>

=={{header|HicEst}}==

<~~lang~~ HicEst>WRITE(Row=1) " x 1 2 3 4 5 6 7 8 9 10 11 12"

<syntaxhighlight 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</~~lang~~>

ENDDO</syntaxhighlight>

=={{header|HolyC}}==

<~~lang~~ holyc>U8 i, j, n = 12;

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

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ Icon>procedure main()

<syntaxhighlight 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 </~~lang~~>

end </syntaxhighlight>

The above example is a somewhat exaggerated example of contractions.

Line 4,397:

=={{header|J}}==

<~~lang~~ j> multtable=: <:/~ * */~

<syntaxhighlight lang=j> multtable=: <:/~ * */~

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

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

Line 4,415:

│11│ 121 132│

│12│ 144│

└──┴────────────────────────────────────────────────┘</~~lang~~>

└──┴────────────────────────────────────────────────┘</syntaxhighlight>

That said, note that <code>*/~</code> is the core primitive used to construct a multiplication table and this is a general technique so that, for example, <code>+/~</code> would make an addition table. The rest is just to make it look pretty (and to blank out the lower triangle -- we use a less than or equal table (<code><:/~</code>) to control that, and format zeros as spaces to blank them out).

=={{header|Java}}==

<~~lang~~ Java>public class MultiplicationTable {

<syntaxhighlight lang=Java>public class MultiplicationTable {

public static void main(String[] args) {

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

Line 4,439:

}

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 4,462:

===Imperative===

<~~lang~~ html4strict><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<head>

Line 4,513:

</body>

</html></~~lang~~>

</html></syntaxhighlight>

{{out}} (minus the style):

Line 4,520:

===Functional===

====ES5====

<~~lang~~ JavaScript>(function (m, n) {

<syntaxhighlight lang=JavaScript>(function (m, n) {

// [m..n]

Line 4,568:

JSON.stringify(lstTable);

})(1, 12);</~~lang~~>

})(1, 12);</syntaxhighlight>

Line 4,601:

|}

<~~lang~~ JavaScript>[["x",1,2,3,4,5,6,7,8,9,10,11,12],

<syntaxhighlight lang=JavaScript>[["x",1,2,3,4,5,6,7,8,9,10,11,12],

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

[2,"",4,6,8,10,12,14,16,18,20,22,24],

Line 4,613:

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

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

[12,"","","","","","","","","","","",144]]</~~lang~~>

[12,"","","","","","","","","","","",144]]</syntaxhighlight>

====ES6====

<~~lang~~ JavaScript>(() => {

<syntaxhighlight lang=JavaScript>(() => {

"use strict";

Line 4,689:

// MAIN ---

return main();

})();</~~lang~~>

})();</syntaxhighlight>

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

Line 4,720:

=={{header|Jsish}}==

<~~lang~~ javascript>/* Multiplication tables, is Jsish */

<syntaxhighlight lang=javascript>/* Multiplication tables, is Jsish */

var m, n, tableSize = 12;

Line 4,740:

}

printf('\n');</~~lang~~>

printf('\n');</syntaxhighlight>

Line 4,768:

=={{header|Julia}}==

<~~lang~~ Julia>using Printf

<syntaxhighlight lang=Julia>using Printf

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

Line 4,781:

print(" ")

end

end</~~lang~~>

end</syntaxhighlight>

Line 4,800:

=={{header|Kotlin}}==

<~~lang~~ scala>// version 1.0.6

<syntaxhighlight lang=scala>// version 1.0.6

fun main(args: Array<String>) {

Line 4,811:

println()

}

}</~~lang~~>

}</syntaxhighlight>

Line 4,835:

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

<~~lang~~ scheme>

{def format

{lambda {:w :c}

Line 4,876:

3) {make_table {operation pow} 6 10}

</syntaxhighlight>

</lang>

=={{header|Lasso}}==

<~~lang~~ lasso>define printTimesTables(max::integer) => {

<syntaxhighlight lang=lasso>define printTimesTables(max::integer) => {

local(result) = ``

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

Line 4,907:

}

printTimesTables(12)</~~lang~~>

printTimesTables(12)</syntaxhighlight>

Line 4,927:

=={{header|Logo}}==

<~~lang~~ logo>to mult.table :n

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

<~~lang~~ lua>io.write( " |" )

<syntaxhighlight lang=lua>io.write( " |" )

for i = 1, 12 do

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

Line 4,960:

end

io.write( "\n" )

end</~~lang~~>

end</syntaxhighlight>

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

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

<~~lang~~ maple>printf(" ");

<syntaxhighlight lang=maple>printf(" ");

for i to 12 do

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

Line 5,057:

end if

end do

end do</~~lang~~>

end do</syntaxhighlight>

<pre>

Line 5,077:

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

<~~lang~~ Mathematica>Grid[{{Range[12]//Column,Grid[UpperTriangularize[KroneckerProduct[Range[12],Range[12]]]/.{0->""}]}}]</~~lang~~>

<syntaxhighlight lang=Mathematica>Grid[{{Range[12]//Column,Grid[UpperTriangularize[KroneckerProduct[Range[12],Range[12]]]/.{0->""}]}}]</syntaxhighlight>

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

<~~lang~~ MATLAB>function table = timesTable(N)

<syntaxhighlight lang=MATLAB>function table = timesTable(N)

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

end</~~lang~~>

end</syntaxhighlight>

A minimally vectorized version of the above code:

<~~lang~~ MATLAB>function table = timesTable(N)

<syntaxhighlight 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</~~lang~~>

end</syntaxhighlight>

Line 5,141:

=={{header|Maxima}}==

<~~lang~~ Maxima>for i: 1 thru 12 do (

<syntaxhighlight lang=Maxima>for i: 1 thru 12 do (

for j: 1 thru 12 do (

if j>=i or j=1 then printf(true, "~4d", i*j) else printf(true, " ")

),

printf(true, "~%")

);</~~lang~~>

);</syntaxhighlight>

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

<~~lang~~>П0 КИП0 КИП4 КИП5 ИП4 ИП5 * С/П

<syntaxhighlight>П0 КИП0 КИП4 КИП5 ИП4 ИП5 * С/П

ИП5 ИП0 - x=0 03

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

С/П</~~lang~~>

С/П</syntaxhighlight>

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

Line 5,175:

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

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

<~~lang~~ modula2>

MODULE MultiplicationTables;

Line 5,215:

END;

END MultiplicationTables.

</syntaxhighlight>

</lang>

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

<~~lang~~ moo>

@verb me:@tables none none none rxd

@program me:@tables

Line 5,262:

endfor

.

</syntaxhighlight>

</lang>

LambdaMOO string utilities version:

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

<pre>

Line 5,298:

=={{header|MUMPS}}==

<~~lang~~ MUMPS>MULTTABLE(SIZE)

<syntaxhighlight 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</~~lang~~>

QUIT</syntaxhighlight>

Line 5,339:

=={{header|Neko}}==

<~~lang~~ ActionScript>/**

<syntaxhighlight lang=ActionScript>/**

Multiplication table, in Neko

Tectonics:

Line 5,380:

$print("\n");

j += 1;

}</~~lang~~>

}</syntaxhighlight>

Line 5,403:

=={{header|Nim}}==

<~~lang~~ nim>import strfmt

<syntaxhighlight 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)</~~lang~~>

echo "| {:2d}".fmt(i)</syntaxhighlight>

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

Line 5,434:

<~~lang~~ ocaml>let () =

<syntaxhighlight lang=ocaml>let () =

let max = 12 in

let fmax = float_of_int max in

Line 5,452:

print_newline()

done;

print_newline()</~~lang~~>

print_newline()</syntaxhighlight>

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

Quick and dirty one-liner:

<~~lang~~ parigp>for(y=1,12,printf("%2Ps| ",y);for(x=1,12,print1(if(y>x,"",x*y)"\t"));print)</~~lang~~>

<syntaxhighlight lang=parigp>for(y=1,12,printf("%2Ps| ",y);for(x=1,12,print1(if(y>x,"",x*y)"\t"));print)</syntaxhighlight>

=={{header|Pascal}}==

Line 5,462:

=={{header|Perl}}==

<~~lang~~ perl>our $max = 12;

<syntaxhighlight lang=perl>our $max = 12;

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

Line 5,471:

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

print "\n";

}</~~lang~~>

}</syntaxhighlight>

Line 5,493:

=={{header|Phix}}==

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

Line 5,505:

Line 5,525:

=={{header|Picat}}==

<~~lang~~ Picat>go =>

N=12,

make_table(N),

Line 5,549:

nl

end,

nl.</~~lang~~>

nl.</syntaxhighlight>

Line 5,569:

=={{header|PicoLisp}}==

<~~lang~~ PicoLi/th>sp>(de mulTable (N)

<syntaxhighlight lang=PicoLi/th>sp>(de mulTable (N)

(space 4)

(for X N

Line 5,582:

(prinl) ) )

(mulTable 12)</~~lang~~>

(mulTable 12)</syntaxhighlight>

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

Line 5,600:

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

<~~lang~~ PL/I>

/* 12 x 12 multiplication table. */

Line 5,615:

end multiplication_table;

</syntaxhighlight>

</lang>

Result:

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

<~~lang~~ powershell># For clarity

<syntaxhighlight lang=powershell># For clarity

$Tab = "`t"

Line 5,657:

# Combine them all together

) -join $Tab

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ powershell>function Get-TimesTable ( [int]$Size )

<syntaxhighlight lang=powershell>function Get-TimesTable ( [int]$Size )

{

# For clarity

Line 5,698:

}

Get-TimesTable 18</~~lang~~>

Get-TimesTable 18</syntaxhighlight>

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

Line 5,721:

=={{header|Prolog}}==

<~~lang~~ prolog>make_table(S,E) :-

<syntaxhighlight 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).</~~lang~~>

print_num(X) :- X > 99, format(' ~p', X).</syntaxhighlight>

<pre>

Line 5,778:

=={{header|Python}}==

===Procedural===

<~~lang~~ python>>>> size = 12

<syntaxhighlight lang=python>>>> size = 12

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

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

Line 5,806:

11│ 121 132

12│ 144

>>> </~~lang~~>

>>> </syntaxhighlight>

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):

<~~lang~~ python>'''Multiplication table

<syntaxhighlight lang=python>'''Multiplication table

1. by list comprehension (mulTable ),

Line 5,920:

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

<pre>By list comprehension (mulTable):

Line 5,956:

<~~lang~~ python>'''Generalised multiplication tables'''

<syntaxhighlight lang=python>'''Generalised multiplication tables'''

import collections

Line 6,222:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

<pre> 13 14 15 16 17 18 19 20

Line 6,262:

=={{header|Quackery}}==

<~~lang~~ Quackery> [ swap number$

<syntaxhighlight lang=Quackery> [ swap number$

tuck size -

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

Line 6,281:

[ dip dup

* 4 echo-rj ] ]

cr drop ] ]</~~lang~~>

cr drop ] ]</syntaxhighlight>

Line 6,301:

=={{header|R}}==

multiplication_table <- function(n=12)

{

Line 6,312:

}

multiplication_table()

</syntaxhighlight>

</lang>

=={{header|Racket}}==

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

Line 6,348:

=={{header|Raku}}==

(formerly Perl 6)

<~~lang~~ perl6>(my $f = "%{$_}s" given my $width = ($_**2).chars ) given my $max = 12;

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

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 6,375:

=={{header|REBOL}}==

<~~lang~~ REBOL>REBOL [

<syntaxhighlight 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] --</~~lang~~>

-- .row " x " 1 -- repeat y size [.row p3 y y] --</syntaxhighlight>

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

Line 6,429:

=={{header|REXX}}==

<~~lang~~ REXX>/*REXX program displays a NxN multiplication table (in a boxed grid) to the terminal.*/

<syntaxhighlight 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</~~lang~~>

bot: $= '└'__"┴"copies(___'┴', sz); call dap "┘"; say $; return</syntaxhighlight>

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

<pre>

Line 6,523:

=={{header|Ring}}==

<~~lang~~ ring>

multiplication_table(12)

func multiplication_table n

Line 6,535:

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

</syntaxhighlight>

</lang>

Output

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

<~~lang~~ ruby>def multiplication_table(n)

<syntaxhighlight lang=ruby>def multiplication_table(n)

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

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

Line 6,567:

end

multiplication_table 12</~~lang~~>

multiplication_table 12</syntaxhighlight>

Line 6,588:

=={{header|Rust}}==

<~~lang~~ rust>const LIMIT: i32 = 12;

<syntaxhighlight lang=rust>const LIMIT: i32 = 12;

fn main() {

Line 6,608:

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

}

}</~~lang~~>

}</syntaxhighlight>

or, in terms of map:

<~~lang~~ rust>fn main() {

<syntaxhighlight lang=rust>fn main() {

let xs = (1..=12)

.map(|a| {

Line 6,628:

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

}</~~lang~~>

}</syntaxhighlight>

=={{header|Scala}}==

<~~lang~~ scala>

//Multiplication Table

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

Line 6,650:

println("")

}

</syntaxhighlight>

</lang>

=== case ===

<~~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].

<~~lang~~ scheme>

(define iota

(lambda (count start step)

Line 6,705:

(loop (+ count 1)

(cdr numbers)))))))

</syntaxhighlight>

</lang>

<pre>

Line 6,725:

=={{header|Scilab}}==

<~~lang~~> nmax=12, xx=3

<syntaxhighlight> nmax=12, xx=3

s= blanks(xx)+" |"

for j=1:nmax

Line 6,746:

end

printf("%s\n",s)

end</~~lang~~>

end</syntaxhighlight>

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

Line 6,764:

=={{header|Seed7}}==

<~~lang~~ seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang=seed7>$ include "seed7_05.s7i";

const proc: main is func

Line 6,787:

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

end for;

end func;</~~lang~~>

end func;</syntaxhighlight>

Line 6,808:

=={{header|Sidef}}==

<~~lang~~ ruby>var max = 12

<syntaxhighlight 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</~~lang~~>

} << 1..max</syntaxhighlight>

<pre>

Line 6,841:

=={{header|Simula}}==

<~~lang~~ simula>begin

<syntaxhighlight lang=simula>begin

integer i, j;

outtext( " " );

Line 6,857:

outimage

end;

end</~~lang~~>

end</syntaxhighlight>

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

Line 6,875:

=={{header|Swift}}==

<~~lang~~ swift>import Foundation

<syntaxhighlight lang=swift>import Foundation

let size = 12

Line 6,895:

printRow( with: i, upto: size)

}

</syntaxhighlight>

</lang>

=={{header|Tailspin}}==

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

<pre>

Line 6,930:

=={{header|Tcl}}==

<~~lang~~ tcl>puts " x\u2502 1 2 3 4 5 6 7 8 9 10 11 12"

<syntaxhighlight lang=tcl>puts " x\u2502 1 2 3 4 5 6 7 8 9 10 11 12"

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

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

Line 6,940:

}

puts ""

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 6,960:

=={{header|TUSCRIPT}}==

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

Line 6,998:

== {{header|TypeScript}} ==

<~~lang~~ javascript>

// Multiplication tables

Line 7,013:

console.log("| " + i.toString().padStart(2, ' '));

}

</syntaxhighlight>

</lang>

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

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

Option Explicit

Line 7,100:

Next i

End Sub

</syntaxhighlight>

</lang>

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

Line 7,118:

=={{header|Wren}}==

<~~lang~~ ecmascript>import "/fmt" for Fmt

<syntaxhighlight 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)

}</~~lang~~>

}</syntaxhighlight>

Line 7,148:

=={{header|XPL0}}==

<~~lang~~ XPL0>include c:\cxpl\codes;

<syntaxhighlight lang=XPL0>include c:\cxpl\codes;

int X, Y;

[Format(4, 0);

Line 7,161:

CrLf(0);

];

]</~~lang~~>

]</syntaxhighlight>

Line 7,182:

=={{header|zkl}}==

<~~lang~~ zkl>fcn multiplicationTable(n){

<syntaxhighlight 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);</~~lang~~>

}(12);</syntaxhighlight>

<pre>