Rosetta Code

Least common multiple: Difference between revisions

← Older edit
Content deleted Content added
Kazinator (talk | contribs)
543 edits
Miks1965 (talk | contribs)
269 edits
PascalABC.NET
 
(99 intermediate revisions by 46 users not shown)
Line 1:
[[Category:Recursion]]
 
{{task}}
 
;Task:
Compute the   least common multiple   (LCM)   of two integers.
 
Given   ''m''   and   ''n'',   the least common multiple is the smallest positive integer that has both   ''m''   and   ''n''   as factors.
Line 8 ⟶ 10:
 
;Example:
The least common multiple of 12 and 18 is 36, because  '''12 is a factor (12''' &timesnbsp; 3 = 36), and 18 is a factor (18 &timesnbsp; 2 = 36), and there is no positive integer less than 36 that has both factors.'''18'''   As a special case, if eitheris   ''m'36''',   or   ''n''   is zero, then the least common multiple is zero.because:
:*   '''12'''   is a factor     ('''12''' × '''3''' = '''36'''),     and
:*   '''18'''   is a factor     ('''18''' × '''2''' = '''36'''),     and
:*   there is no positive integer less than   '''36'''   that has both factors.
 
 
As a special case,   if either   ''m''   or   ''n''   is zero,   then the least common multiple is zero.
 
 
One way to calculate the least common multiple is to iterate all the multiples of   ''m'',   until you find one that is also a multiple of   ''n''.
Line 21 ⟶ 30:
 
 
;Related task
;References:
:*   [https://rosettacode.org/wiki/Greatest_common_divisor greatest common divisor].
*   [http://mathworld.wolfram.com/LeastCommonMultiple.html MathWorld].
 
*   [[wp:Least common multiple|Wikipedia]].
 
;See also:
*   MathWorld entry:   [http://mathworld.wolfram.com/LeastCommonMultiple.html Least Common Multiple].
*   Wikipedia entry:   [[wp:Least common multiple|Least common multiple]].
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">F gcd(=a, =b)
L b != 0
(a, b) = (b, a % b)
R a
 
F lcm(m, n)
R m I/ gcd(m, n) * n
 
print(lcm(12, 18))</syntaxhighlight>
 
{{out}}
<pre>
36
</pre>
 
=={{header|360 Assembly}}==
{{trans|PASCAL}}
For maximum compatibility, this program uses only the basic instruction set (S/360)
with 2 ASSIST macros (XDECO,XPRNT).
<syntaxhighlight lang="360asm">LCM CSECT
USING LCM,R15 use calling register
L R6,A a
L R7,B b
LR R8,R6 c=a
LOOPW LR R4,R8 c
SRDA R4,32 shift to next reg
DR R4,R7 c/b
LTR R4,R4 while c mod b<>0
BZ ELOOPW leave while
AR R8,R6 c+=a
B LOOPW end while
ELOOPW LPR R9,R6 c=abs(u)
L R1,A a
XDECO R1,XDEC edit a
MVC PG+4(5),XDEC+7 move a to buffer
L R1,B b
XDECO R1,XDEC edit b
MVC PG+10(5),XDEC+7 move b to buffer
XDECO R8,XDEC edit c
MVC PG+17(10),XDEC+2 move c to buffer
XPRNT PG,80 print buffer
XR R15,R15 return code =0
BR R14 return to caller
A DC F'1764' a
B DC F'3920' b
PG DC CL80'lcm(00000,00000)=0000000000' buffer
XDEC DS CL12 temp for edit
YREGS
END LCM</syntaxhighlight>
{{out}}
<pre>
lcm( 1764, 3920)= 35280
</pre>
 
=={{header|8th}}==
<langsyntaxhighlight lang="forth">
: gcd \ a b -- gcd
dup 0 n:= if drop ;; then
Line 52 ⟶ 120:
 
 
bye</langsyntaxhighlight>
{{out}}
<pre>LCM of 18 and 12 = 36
Line 59 ⟶ 127:
</pre>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">CARD FUNC Lcm(CARD a,b)
CARD tmp,c
 
IF a=0 OR b=0 THEN
RETURN (0)
FI
 
IF a<b THEN
tmp=a a=b b=tmp
FI
 
c=0
DO
c==+1
UNTIL a*c MOD b=0
OD
RETURN(a*c)
 
PROC Test(CARD a,b)
CARD res
 
res=Lcm(a,b)
PrintF("LCM of %I and %I is %I%E",a,b,res)
RETURN
 
PROC Main()
Test(4,6)
Test(120,77)
Test(24,8)
Test(1,56)
Test(12,0)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Least_common_multiple.png Screenshot from Atari 8-bit computer]
<pre>
LCM of 4 and 6 is 12
LCM of 120 and 77 is 9240
LCM of 24 and 8 is 24
LCM of 1 and 56 is 56
LCM of 12 and 0 is 0
</pre>
 
=={{header|Ada}}==
lcm_test.adb:
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO; use Ada.Text_IO;
 
procedure Lcm_Test is
Line 89 ⟶ 199:
Put_Line ("LCM of -6, 14 is" & Integer'Image (Lcm (-6, 14)));
Put_Line ("LCM of 35, 0 is" & Integer'Image (Lcm (35, 0)));
end Lcm_Test;</langsyntaxhighlight>
 
Output:
Line 97 ⟶ 207:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">
BEGIN
PROC gcd = (INT m, n) INT :
Line 113 ⟶ 223:
"and their greatest common divisor is", gcd(m,n)))
END
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 123 ⟶ 233:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin
integer procedure gcd ( integer value a, b ) ;
if b = 0 then a else gcd( b, a rem abs(b) );
Line 131 ⟶ 241:
 
write( lcm( 15, 20 ) );
end.</langsyntaxhighlight>
 
=={{header|APL}}==
APL provides this function.
<langsyntaxhighlight lang="apl"> 12^18
36</langsyntaxhighlight>
If for any reason we wanted to reimplement it, we could do so in terms of the greatest common divisor by transcribing the formula set out in the task specification into APL notation:
<langsyntaxhighlight lang="apl"> LCM←{(|⍺×⍵)÷⍺∨⍵}
12 LCM 18
36</langsyntaxhighlight>
 
=={{header|AppleScript}}==
 
<syntaxhighlight lang="applescript">------------------ LEAST COMMON MULTIPLE -----------------
<lang AppleScript>-- lcm :: Integral a => a -> a -> a
 
-- lcm :: Integral a => a -> a -> a
on lcm(x, y)
if x0 = 0x or y0 = 0y then
0
else
Line 154 ⟶ 266:
 
 
--------------------------- TEST -------------------------
-- TEST
on run
Line 163 ⟶ 275:
 
 
-------------------- GENERALGENERIC FUNCTIONS -------------------
 
-- abs :: Num a => a -> a
on abs(x)
if x0 <> 0x then
-x
else
Line 173 ⟶ 285:
end if
end abs
 
 
-- gcd :: Integral a => a -> a -> a
on gcd(x, y)
script _gcd
on lambda|λ|(a, b)
if b0 = 0b then
a
else
lambda|λ|(b, a mod b)
end if
end lambda|λ|
end script
_gcdresult's lambda|λ|(abs(x), abs(y))
end gcd</langsyntaxhighlight>
 
{{Out}}
<syntaxhighlight lang="applescript">36</syntaxhighlight>
<lang AppleScript>36</lang>
 
=={{header|Arendelle}}==
Line 205 ⟶ 317:
)</pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">lcm: function [x,y][
x * y / gcd @[x y]
]
 
print lcm 12 18</syntaxhighlight>
{{out}}
 
<pre>36</pre>
 
=={{header|Assembly}}==
==={{header|x86 Assembly}}===
<langsyntaxhighlight lang="asm">
; lcm.asm: calculates the least common multiple
; of two positive integers
Line 300 ⟶ 422:
ret
 
</syntaxhighlight>
</lang>
 
=={{header|ATS}}==
 
Compile with ‘patscc -o lcm lcm.dats’
 
<syntaxhighlight lang="ats">#define ATS_DYNLOADFLAG 0 (* No initialization is needed. *)
 
#include "share/atspre_define.hats"
#include "share/atspre_staload.hats"
 
(********************************************************************)
(* *)
(* Declarations. *)
(* *)
(* (These could be ported to a .sats file.) *)
(* *)
 
(* lcm for unsigned integer types without constraints. *)
extern fun {tk : tkind}
g0uint_lcm (u : g0uint tk,
v : g0uint tk) :<>
g0uint tk
 
(* The gcd template function to be expanded when g0uint_lcm is
expanded. Set it to your favorite gcd function. *)
extern fun {tk : tkind}
g0uint_lcm$gcd (u : g0uint tk,
v : g0uint tk) :<>
g0uint tk
 
(* lcm for signed integer types, giving unsigned results. *)
extern fun {tk_signed, tk_unsigned : tkind}
g0int_lcm (u : g0int tk_signed,
v : g0int tk_signed) :<>
g0uint tk_unsigned
 
overload lcm with g0uint_lcm
overload lcm with g0int_lcm
 
(********************************************************************)
(* *)
(* The implementations. *)
(* *)
 
implement {tk}
g0uint_lcm (u, v) =
let
val d = g0uint_lcm$gcd<tk> (u, v)
in
(* There is no need to take the absolute value, because this
implementation is strictly for unsigned integers. *)
(u * v) / d
end
 
implement {tk_signed, tk_unsigned}
g0int_lcm (u, v) =
let
extern castfn
unsigned :
g0int tk_signed -<> g0uint tk_unsigned
in
g0uint_lcm (unsigned (abs u), unsigned (abs v))
end
 
(********************************************************************)
(* *)
(* A test that it actually works. *)
(* *)
 
implement
main0 () =
let
implement {tk}
g0uint_lcm$gcd (u, v) =
(* An ugly gcd for the sake of demonstrating that it can be done
this way: Euclid’s algorithm written an the ‘Algol’ style,
which is not a natural style in ATS. Almost always you want
to write a tail-recursive function, instead. I did, however
find the ‘Algol’ style very useful when I was migrating
matrix routines from Fortran.
 
In reality, you would implement g0uint_lcm$gcd by having it
simply call whatever gcd template function you are using in
your program. *)
$effmask_all
begin
let
var x : g0uint tk = u
var y : g0uint tk = v
in
while (y <> 0)
let
val z = y
in
y := x mod z;
x := z
end;
x
end
end
in
assertloc (lcm (~6, 14) = 42U);
assertloc (lcm (2L, 0L) = 0ULL);
assertloc (lcm (12UL, 18UL) = 36UL);
assertloc (lcm (12, 22) = 132ULL);
assertloc (lcm (7ULL, 31ULL) = 217ULL)
end</syntaxhighlight>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight lang="autohotkey">LCM(Number1,Number2)
{
If (Number1 = 0 || Number2 = 0)
Line 316 ⟶ 544:
Num1 = 12
Num2 = 18
MsgBox % LCM(Num1,Num2)</langsyntaxhighlight>
 
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">
<lang AutoIt>
Func _LCM($a, $b)
Local $c, $f, $m = $a, $n = $b
Line 333 ⟶ 561:
Return $m * $n / $b
EndFunc ;==>_LCM
</syntaxhighlight>
</lang>
Example
<syntaxhighlight lang="autoit">
<lang AutoIt>
ConsoleWrite(_LCM(12,18) & @LF)
ConsoleWrite(_LCM(-5,12) & @LF)
ConsoleWrite(_LCM(13,0) & @LF)
</syntaxhighlight>
</lang>
<pre>
36
Line 346 ⟶ 574:
</pre>
--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 14:32, 15 November 2013 (UTC)
 
=={{header|AWK}}==
<langsyntaxhighlight lang="awk"># greatest common divisor
function gcd(m, n, t) {
# Euclid's method
Line 368 ⟶ 597:
# Read two integers from each line of input.
# Print their least common multiple.
{ print lcm($1, $2) }</langsyntaxhighlight>
 
Example input and output: <pre>$ awk -f lcd.awk
Line 383 ⟶ 612:
==={{header|Applesoft BASIC}}===
ported from BBC BASIC
<langsyntaxhighlight ApplesoftBasiclang="applesoftbasic">10 DEF FN MOD(A) = INT((A / B - INT(A / B)) * B + .05) * SGN(A / B)
20 INPUT"M=";M%
30 INPUT"N=";N%
Line 404 ⟶ 633:
250 NEXT B
260 R = ABS(A%)
270 RETURN</langsyntaxhighlight>
 
==={{header|BBC BASIC}}===
{{Works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbc basic">
<lang BBC BASIC>
DEF FN_LCM(M%,N%)
IF M%=0 OR N%=0 THEN =0 ELSE =ABS(M%*N%)/FN_GCD_Iterative_Euclid(M%, N%)
Line 420 ⟶ 649:
ENDWHILE
= ABS(A%)
</syntaxhighlight>
</lang>
 
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 DEF LCM(A,B)=(A*B)/GCD(A,B)
110 DEF GCD(A,B)
120 DO WHILE B>0
130 LET T=B:LET B=MOD(A,B):LET A=T
140 LOOP
150 LET GCD=A
160 END DEF
170 PRINT LCM(12,18)</syntaxhighlight>
 
==={{header|Tiny BASIC}}===
{{works with|TinyBasic}}
<syntaxhighlight lang="basic">10 PRINT "First number"
20 INPUT A
30 PRINT "Second number"
40 INPUT B
42 LET Q = A
44 LET R = B
50 IF Q<0 THEN LET Q=-Q
60 IF R<0 THEN LET R=-R
70 IF Q>R THEN GOTO 130
80 LET R = R - Q
90 IF Q=0 THEN GOTO 110
100 GOTO 50
110 LET U = (A*B)/R
111 IF U < 0 THEN LET U = - U
112 PRINT U
120 END
130 LET C=Q
140 LET Q=R
150 LET R=C
160 GOTO 70</syntaxhighlight>
 
=={{header|BASIC256}}==
===Iterative solution===
<syntaxhighlight lang="basic256">function mcm (m, n)
if m = 0 or n = 0 then return 0
if m < n then
t = m : m = n : n = t
end if
cont = 0
do
cont += 1
until (m * cont) mod n = 0
return m * cont
end function
 
print "lcm( 12, 18) = "; mcm( 12, -18)
print "lcm( 15, 12) = "; mcm( 15, 12)
print "lcm(-10, -14) = "; mcm(-10, -14)
print "lcm( 0, 1) = "; mcm( 0, 1)</syntaxhighlight>
{{out}}
<pre>lcm( 12, 18) = 36
lcm( 15, 12) = 60
lcm(-10, -14) = -70
lcm( 0, 1) = 0</pre>
 
 
===Recursive solution===
Reuses code from Greatest_common_divisor#Recursive_solution and correctly handles negative arguments
<syntaxhighlight lang="basic256">function gcdp(a, b)
if b = 0 then return a
return gcdp(b, a mod b)
end function
 
function gcd(a, b)
return gcdp(abs(a), abs(b))
end function
 
function lcm(a, b)
return abs(a * b) / gcd(a, b)
end function
 
print "lcm( 12, -18) = "; lcm( 12, -18)
print "lcm( 15, 12) = "; lcm( 15, 12)
print "lcm(-10, -14) = "; lcm(-10, -14)
print "lcm( 0, 1) = "; lcm( 0, 1)</syntaxhighlight>
{{out}}
<pre>lcm( 12, -18) = 36.0
lcm( 15, 12) = 60.0
lcm(-10, -14) = 70.0
lcm( 0, 1) = 0.0</pre>
 
=={{header|Batch File}}==
<langsyntaxhighlight lang="dos">@echo off
setlocal enabledelayedexpansion
set num1=12
Line 440 ⟶ 752:
set /a res = %1 %% %2
call :lcm %2 %res%
goto :EOF</langsyntaxhighlight>
{{Out}}
<pre>LCM = 36</pre>
Line 446 ⟶ 758:
=={{header|bc}}==
{{trans|AWK}}
<langsyntaxhighlight lang="bc">/* greatest common divisor */
define g(m, n) {
auto t
Line 467 ⟶ 779:
if (r < 0) return (-r)
return (r)
}</langsyntaxhighlight>
 
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
 
let lcm(m,n) =
m=0 -> 0,
n=0 -> 0,
abs(m*n) / gcd(m,n)
and gcd(m,n) =
n=0 -> m,
gcd(n, m rem n)
 
let start() be writef("%N*N", lcm(12, 18))</syntaxhighlight>
{{out}}
<pre>36</pre>
 
=={{header|Befunge}}==
 
Inputs are limited to signed 16-bit integers.
 
<syntaxhighlight lang="befunge">&>:0`2*1-*:&>:#@!#._:0`2*1v
>28*:*:**+:28*>:*:*/\:vv*-<
|<:%/*:*:*82\%*:*:*82<<>28v
>$/28*:*:*/*.@^82::+**:*:*<</syntaxhighlight>
 
{{in}}
<pre>12345
-23044</pre>
 
{{out}}
<pre>345660</pre>
 
=={{header|BQN}}==
<syntaxhighlight lang="bqn">Lcm ← ×÷{𝕨(|𝕊⍟(>⟜0)⊣)𝕩}</syntaxhighlight>
 
Example:
 
<syntaxhighlight lang="bqn">12 Lcm 18</syntaxhighlight>
<pre>36</pre>
 
=={{header|Bracmat}}==
We utilize the fact that Bracmat simplifies fractions (using Euclid's algorithm). The function <code>den$<i>number</i></code> returns the denominator of a number.
<langsyntaxhighlight lang="bracmat">(gcd=
a b
. !arg:(?a.?b)
Line 478 ⟶ 829:
* !a
);
out$(gcd$(12.18) gcd$(-6.14) gcd$(35.0) gcd$(117.18))</langsyntaxhighlight>
Output:
<pre>36 42 35 234</pre>
 
=={{header|Brat}}==
<langsyntaxhighlight lang="brat">
gcd = { a, b |
true? { a == 0 }
Line 496 ⟶ 847:
p lcm(12, 18) # 36
p lcm(14, 21) # 42
</syntaxhighlight>
</lang>
 
=={{header|Bruijn}}==
{{trans|Haskell}}
<syntaxhighlight lang="bruijn">
:import std/Math .
 
lcm [[=?1 1 (=?0 0 |(1 / (gcd 1 0) ⋅ 0))]]
 
:test ((lcm (+12) (+18)) =? (+36)) ([[1]])
:test ((lcm (+42) (+25)) =? (+1050)) ([[1]])
</syntaxhighlight>
 
=={{header|C}}==
<langsyntaxhighlight Clang="c">#include <stdio.h>
 
int gcd(int m, int n)
Line 517 ⟶ 879:
printf("lcm(35, 21) = %d\n", lcm(21,35));
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">Using System;
class Program
{
static int gcd(int m, int n)
{
return n == 0 ? Math.Abs(m) : gcd(n, n % m);
}
static int lcm(int m, int n)
{
return Math.Abs(m * n) / gcd(m, n);
}
static void Main()
{
Console.WriteLine("lcm(12,18)=" + lcm(12,18));
}
}
</syntaxhighlight>
{{out}}
<pre>lcm(12,18)=36</pre>
 
=={{header|C++}}==
{{libheader|Boost}}
<langsyntaxhighlight lang="cpp">#include <boost/math/common_factor.hpp>
#include <iostream>
 
Line 529 ⟶ 912:
<< "and the greatest common divisor " << boost::math::gcd( 12 , 18 ) << " !" << std::endl ;
return 0 ;
}</langsyntaxhighlight>
 
{{out}}
Line 538 ⟶ 921:
=== Alternate solution ===
{{works with|C++11}}
<langsyntaxhighlight lang="cpp">
#include <cstdlib>
#include <iostream>
#include <tuple>
 
using namespace std;
 
int gcd(int a, int b) {
a = abs(a);
b = abs(b);
while (b != 0) {
std::tie(a, b) = std::make_tuple(b, a % b);
}
return a;
}
 
int lcm(int a, int b) {
int c = gcd(a, b);
return c == 0 ? 0 : a / c * b;
}
 
int main() {
std::cout << "The least common multiple of 12 and 18 is " << lcm(12, 18) << ",\n"
<< "and their greatest common divisor is " << gcd(12,\n 18) << "!"
<< std::endl;
<< "and the greatest common divisor " << gcd(12, 18) << " !" << endl;
return 0;
}
</syntaxhighlight>
</lang>
 
=={{header|C sharp|C#}}==
<lang csharp>Using System;
class Program
{
static int gcd(int m, int n)
{
return n == 0 ? Math.Abs(m) : gcd(n, n % m);
}
static int lcm(int m, int n)
{
return Math.Abs(m * n) / gcd(m, n);
}
static void Main()
{
Console.WriteLine("lcm(12,18)=" + lcm(12,18));
}
}
</lang>
{{out}}
<pre>lcm(12,18)=36</pre>
 
=={{header|Clojure}}==
<langsyntaxhighlight Clojurelang="clojure">(defn gcd
[a b]
(if (zero? b)
Line 600 ⟶ 960:
;; to calculate the lcm for a variable number of arguments
(defn lcmv [& v] (reduce lcm v))
</syntaxhighlight>
</lang>
 
=={{header|CLU}}==
<syntaxhighlight lang="clu">gcd = proc (m, n: int) returns (int)
m, n := int$abs(m), int$abs(n)
while n ~= 0 do m, n := n, m // n end
return(m)
end gcd
 
lcm = proc (m, n: int) returns (int)
if m=0 cor n=0
then return(0)
else return(int$abs(m*n) / gcd(m,n))
end
end lcm
 
start_up = proc ()
po: stream := stream$primary_output()
stream$putl(po, int$unparse(lcm(12, 18)))
end start_up</syntaxhighlight>
{{out}}
<pre>36</pre>
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. show-lcm.
 
Line 665 ⟶ 1,046:
GOBACK
.
END FUNCTION gcd.</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Common Lisp provides the <tt>lcm</tt> function. It can accept two or more (or less) parameters.
 
<langsyntaxhighlight lang="lisp">CL-USER> (lcm 12 18)
36
CL-USER> (lcm 12 18 22)
396</langsyntaxhighlight>
 
Here is one way to reimplement it.
 
<langsyntaxhighlight lang="lisp">CL-USER> (defun my-lcm (&rest args)
(reduce (lambda (m n)
(cond ((or (= m 0) (= n 0)) 0)
Line 686 ⟶ 1,067:
36
CL-USER> (my-lcm 12 18 22)
396</langsyntaxhighlight>
 
In this code, the <tt>lambda</tt> finds the least common multiple of two integers, and the <tt>reduce</tt> transforms it to accept any number of parameters. The <tt>reduce</tt> operation exploits how ''lcm'' is associative, <tt>(lcm a b c) == (lcm (lcm a b) c)</tt>; and how 1 is an identity, <tt>(lcm 1 a) == a</tt>.
 
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub gcd(m: uint32, n: uint32): (r: uint32) is
while n != 0 loop
var t := m;
m := n;
n := t % n;
end loop;
r := m;
end sub;
 
sub lcm(m: uint32, n: uint32): (r: uint32) is
if m==0 or n==0 then
r := 0;
else
r := m*n / gcd(m,n);
end if;
end sub;
 
print_i32(lcm(12, 18));
print_nl();</syntaxhighlight>
{{out}}
<pre>36</pre>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.bigint, std.math;
 
T gcd(T)(T a, T b) pure nothrow {
Line 712 ⟶ 1,118:
lcm("2562047788015215500854906332309589561".BigInt,
"6795454494268282920431565661684282819".BigInt).writeln;
}</langsyntaxhighlight>
{{out}}
<pre>36
15669251240038298262232125175172002594731206081193527869</pre>
 
=={{header|DWScript}}==
<lang delphi>PrintLn(Lcm(12, 18));</lang>
Output:
<pre>36</pre>
=={{header|Dart}}==
<langsyntaxhighlight lang="dart">
main() {
int x=8;
Line 739 ⟶ 1,141:
}
</syntaxhighlight>
</lang>
=={{header|Delphi}}==
See [https://rosettacode.org/wiki/Least_common_multiple#Pascal Pascal].
 
=={{header|DWScript}}==
<syntaxhighlight lang="delphi">PrintLn(Lcm(12, 18));</syntaxhighlight>
Output:
<pre>36</pre>
 
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc gcd(word m, n) word:
word t;
while n /= 0 do
t := m;
m := n;
n := t % n
od;
m
corp
 
proc lcm(word m, n) word:
if m=0 or n=0
then 0
else m*n / gcd(m,n)
fi
corp
 
proc main() void:
writeln(lcm(12, 18))
corp</syntaxhighlight>
{{out}}
<pre>36</pre>
 
=={{header|EasyLang}}==
<syntaxhighlight>
func gcd a b .
while b <> 0
h = b
b = a mod b
a = h
.
return a
.
func lcm a b .
return a / gcd a b * b
.
print lcm 12 18
</syntaxhighlight>
{{out}}
<pre>
36
</pre>
 
=={{header|EchoLisp}}==
(lcm a b) is already here as a two arguments function. Use foldl to find the lcm of a list of numbers.
<langsyntaxhighlight lang="lisp">
(lcm 0 9) → 0
(lcm 444 888)→ 888
Line 749 ⟶ 1,203:
(define (lcm* list) (foldl lcm (first list) list)) → lcm*
(lcm* '(444 888 999)) → 7992
</syntaxhighlight>
</lang>
 
=={{header|Elena}}==
{{trans|C#}}
ELENA 6.x :
<syntaxhighlight lang="elena">import extensions;
import system'math;
gcd = (m,n => (n == 0) ? (m.Absolute) : (gcd(n,n.mod(m))));
lcm = (m,n => (m * n).Absolute / gcd(m,n));
public program()
{
console.printLine("lcm(12,18)=",lcm(12,18))
}</syntaxhighlight>
{{out}}
<pre>
lcm(12,18)=36
</pre>
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="elixir">defmodule RC do
def gcd(a,0), do: abs(a)
def gcd(a,b), do: gcd(b, rem(a,b))
Line 760 ⟶ 1,232:
end
 
IO.puts RC.lcm(-12,15)</langsyntaxhighlight>
 
{{out}}
Line 768 ⟶ 1,240:
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="erlang">% Implemented by Arjun Sunel
-module(lcm).
-export([main/0]).
Line 782 ⟶ 1,254:
 
lcm(A,B) ->
abs(A*B div gcd(A,B)).</langsyntaxhighlight>
 
{{out}}
Line 789 ⟶ 1,261:
 
=={{header|ERRE}}==
<langsyntaxhighlight ERRElang="erre">PROGRAM LCM
 
PROCEDURE GCD(A,B->GCD)
Line 818 ⟶ 1,290:
LCM(0,35->LCM)
PRINT("LCM of 0 AND 35 =";LCM)
END PROGRAM</langsyntaxhighlight>
 
{{out}}
Line 825 ⟶ 1,297:
LCM of 0 and 35 = 0
</pre>
 
=={{header|Euler}}==
Note % is integer division in Euler, not the mod operator.
 
'''begin'''
'''new''' gcd; '''new''' lcm;
gcd <- ` '''formal''' a; '''formal''' b;
'''if''' b = 0 '''then''' a '''else''' gcd( b, a '''mod''' '''abs''' b )
'
;
lcm <- ` '''formal''' a; '''formal''' b;
'''abs''' [ a * b ] % gcd( a, b )
'
;
'''out''' lcm( 15, 20 )
'''end''' $
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">function gcd(integer m, integer n)
integer tmp
while m do
Line 839 ⟶ 1,328:
function lcm(integer m, integer n)
return m / gcd(m, n) * n
end function</langsyntaxhighlight>
 
=={{header|Excel}}==
Excel's LCM can handle multiple values. Type in a cell:
<langsyntaxhighlight lang="excel">=LCM(A1:J1)</langsyntaxhighlight>
This will get the LCM on the first 10 cells in the first row. Thus :
<pre>12 3 5 23 13 67 15 9 4 2
Line 850 ⟶ 1,339:
 
=={{header|Ezhil}}==
<langsyntaxhighlight lang="src="Ezhilezhil"">
## இந்த நிரல் இரு எண்களுக்கு இடையிலான மீச்சிறு பொது மடங்கு (LCM), மீப்பெரு பொது வகுத்தி (GCD) என்ன என்று கணக்கிடும்
 
Line 907 ⟶ 1,396:
 
பதிப்பி "நீங்கள் தந்த இரு எண்களின் மீபொம (மீச்சிறு பொது மடங்கு, LCM) = ", மீபொம(அ, ஆ)
</syntaxhighlight>
</lang>
 
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">let rec gcd x y = if y = 0 then abs x else gcd y (x % y)
 
let lcm x y = x * y / (gcd x y)</langsyntaxhighlight>
 
=={{header|Factor}}==
The vocabulary ''math.functions'' already provides ''lcm''.
 
<langsyntaxhighlight lang="factor">USING: math.functions prettyprint ;
26 28 lcm .</langsyntaxhighlight>
 
This program outputs ''364''.
Line 925 ⟶ 1,413:
One can also reimplement ''lcm''.
 
<langsyntaxhighlight lang="factor">USING: kernel math prettyprint ;
IN: script
 
Line 936 ⟶ 1,424:
[ * abs ] [ gcd ] 2bi / ;
 
26 28 lcm .</langsyntaxhighlight>
 
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">Func Lecm(a,b)=|a|*|b|/GCD(a,b).</syntaxhighlight>
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">: gcd ( a b -- n )
begin dup while tuck mod repeat drop ;
 
: lcm ( a b -- n )
over 0= over 0= or if 2drop 0 exit then
2dup gcd abs */ ;</langsyntaxhighlight>
 
=={{header|Fortran}}==
This solution is written as a combination of 2 functions, but a subroutine implementation would work great as well.
<syntaxhighlight lang="fortran">
<lang Fortran>
integer function lcm(a,b)
integer:: a,b
Line 963 ⟶ 1,454:
gcd = abs(a)
end function gcd
</syntaxhighlight>
</lang>
 
=={{header|FreeBASIC}}==
===Iterative solution===
<lang freebasic>' FB 1.05.0 Win64
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Function lcm (m As Integer, n As Integer) As Integer
Line 982 ⟶ 1,475:
Print
Print "Press any key to quit"
Sleep</langsyntaxhighlight>
 
{{out}}
Line 989 ⟶ 1,482:
lcm(15, 12) = 60
lcm(10, 14) = 70
</pre>
 
===Recursive solution===
Reuses code from [[Greatest_common_divisor#Recursive_solution]] and correctly handles negative arguments
<syntaxhighlight lang="freebasic">function gcdp( a as uinteger, b as uinteger ) as uinteger
if b = 0 then return a
return gcdp( b, a mod b )
end function
function gcd(a as integer, b as integer) as uinteger
return gcdp( abs(a), abs(b) )
end function
function lcm(a as integer, b as integer) as uinteger
return abs(a*b)/gcd(a,b)
end function
 
print "lcm( 12, -18) = "; lcm(12, -18)
print "lcm( 15, 12) = "; lcm(15, 12)
print "lcm(-10, -14) = "; lcm(-10, -14)
print "lcm( 0, 1) = "; lcm(0,1)</syntaxhighlight>
 
{{out}}
<pre>
lcm( 12, -18) = 36
lcm( 15, 12) = 60
lcm(-10, -14) = 70
lcm( 0, 1) = 0
</pre>
 
=={{header|Frink}}==
Frink has a built-in LCM function that handles arbitrarily-large integers.
<langsyntaxhighlight lang="frink">
println[lcm[2562047788015215500854906332309589561, 6795454494268282920431565661684282819]]
</syntaxhighlight>
</lang>
 
=={{header|FunL}}==
FunL has function <code>lcm</code> in module <code>integers</code> with the following definition:
 
<langsyntaxhighlight lang="funl">def
lcm( _, 0 ) = 0
lcm( 0, _ ) = 0
lcm( x, y ) = abs( (x\gcd(x, y)) y )</langsyntaxhighlight>
 
=={{header|GAP}}==
<langsyntaxhighlight lang="gap"># Built-in
LcmInt(12, 18);
# 36</langsyntaxhighlight>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,027 ⟶ 1,548:
func main() {
fmt.Println(z.Mul(z.Div(&m, z.GCD(nil, nil, &m, &n)), &n))
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,034 ⟶ 1,555:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def gcd
gcd = { m, n -> m = m.abs(); n = n.abs(); n == 0 ? m : m%n == 0 ? n : gcd(n, m % n) }
 
Line 1,044 ⟶ 1,565:
println "LCD of $t.m, $t.n is $t.l"
assert lcd(t.m, t.n) == t.l
}</langsyntaxhighlight>
{{out}}
<pre>LCD of 12, 18 is 36
LCD of -6, 14 is 42
LCD of 35, 0 is 0</pre>
 
=={{header|GW-BASIC}}==
{{trans|C}}
{{works with|PC-BASIC|any}}
<syntaxhighlight lang="qbasic">
10 PRINT "LCM(35, 21) = ";
20 LET MLCM = 35
30 LET NLCM = 21
40 GOSUB 200: ' Calculate LCM
50 PRINT LCM
60 END
 
195 ' Calculate LCM
200 LET MGCD = MLCM
210 LET NGCD = NLCM
220 GOSUB 400: ' Calculate GCD
230 LET LCM = MLCM / GCD * NLCM
240 RETURN
395 ' Calculate GCD
400 WHILE MGCD <> 0
410 LET TMP = MGCD
420 LET MGCD = NGCD MOD MGCD
430 LET NGCD = TMP
440 WEND
450 LET GCD = NGCD
460 RETURN
</syntaxhighlight>
 
=={{header|Haskell}}==
Line 1,054 ⟶ 1,603:
That is already available as the function ''lcm'' in the Prelude. Here's the implementation:
 
<langsyntaxhighlight lang="haskell">lcm :: (Integral a) => a -> a -> a
lcm _ 0 = 0
lcm 0 _ = 0
lcm x y = abs ((x `quot` (gcd x y)) * y)</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
The lcm routine from the Icon Programming Library uses gcd. The routine is
 
<langsyntaxhighlight Iconlang="icon">link numbers
procedure main()
write("lcm of 18, 36 = ",lcm(18,36))
write("lcm of 0, 9 36 = ",lcm(0,9))
end</langsyntaxhighlight>
 
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn numbers provides lcm and gcd] and looks like this:
<langsyntaxhighlight Iconlang="icon">procedure lcm(i, j) #: least common multiple
if (i = 0) | (j = 0) then return 0
return abs(i * j) / gcd(i, j)
end</langsyntaxhighlight>
 
=={{header|J}}==
J provides the dyadic verb <code>*.</code> which returns the least common multiple of its left and right arguments.
 
<langsyntaxhighlight lang="j"> 12 *. 18
36
12 *. 18 22
Line 1,088 ⟶ 1,637:
*./~ 0 1
0 0
0 1</langsyntaxhighlight>
 
Note: least common multiple is the original boolean multiplication. Constraining the universe of values to 0 and 1 allows us to additionally define logical negation (and boolean algebra was redefined to include this constraint in the early 1900s - the original concept of boolean algebra is now known as a boolean ring (though, talking to some people: there's been some linguistic drift even there)).
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Scanner;
 
public class LCM{
Line 1,119 ⟶ 1,668:
System.out.println("lcm(" + m + ", " + n + ") = " + lcm);
}
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
Line 1,130 ⟶ 1,679:
<math>\operatorname{lcm}(a_1,a_2,\ldots,a_n) = \operatorname{lcm}(\operatorname{lcm}(a_1,a_2,\ldots,a_{n-1}),a_n).</math>
 
<langsyntaxhighlight lang="javascript">function LCM(A) // A is an integer array (e.g. [-50,25,-45,-18,90,447])
{
var n = A.length, a = Math.abs(A[0]);
Line 1,143 ⟶ 1,692:
/* For example:
LCM([-50,25,-45,-18,90,447]) -> 67050
*/</langsyntaxhighlight>
 
 
===ES6===
{{Trans|Haskell}}
<langsyntaxhighlight JavaScriptlang="javascript">(() => {
'use strict';
 
Line 1,165 ⟶ 1,714:
return lcm(12, 18);
 
})();</langsyntaxhighlight>
 
{{Out}}
Line 1,172 ⟶ 1,721:
=={{header|jq}}==
Direct method
<langsyntaxhighlight lang="jq"># Define the helper function to take advantage of jq's tail-recursion optimization
def lcm(m; n):
def _lcm:
# state is [m, n, i]
if (.[2] % .[1]) == 0 then .[2] else (.[0:2] + [.[2] + m]) | _lcm end;
[m, n, m] | _lcm; </langsyntaxhighlight>
 
=={{header|Julia}}==
Built-in function:
<syntaxhighlight lang ="julia">lcm(m,n)</langsyntaxhighlight>
 
=={{header|K}}==
===K3===
<lang K> gcd:{:[~x;y;_f[y;x!y]]}
{{works with|Kona}}
<syntaxhighlight lang="k"> gcd:{:[~x;y;_f[y;x!y]]}
lcm:{_abs _ x*y%gcd[x;y]}
 
lcm .'(12 18; -6 14; 35 0)
36 42 0
lcm/1+!20
232792560</syntaxhighlight>
===K6===
{{works with|ngn/k}}
<syntaxhighlight lang="k"> abs:|/-:\
gcd:{$[~x;y;o[x!y;x]]}
lcm:{abs[`i$x*y%gcd[x;y]]}
 
lcm .'(12 18; -6 14; 35 0)
36 42 0
lcm/1+!20
232792560</langsyntaxhighlight>
 
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">:gcd { u v -- n }
abs int swap abs int swap
[over over mod rot drop]
[dup]
while
drop
;
:lcm { m n -- n }
over over gcd rot swap div mult
;
12 18 lcm print nl { 36 }
 
"End " input</syntaxhighlight>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">fun main(args: Array<String>) {
fun gcd(a: IntLong, b: IntLong): IntLong = if (b == 00L) a else gcd(b, a % b)
fun lcm(a: IntLong, b: IntLong): Long = a * b / gcd(a, b) * b
println(lcm(15, 9))
}
</syntaxhighlight>
</lang>
 
=={{header|LabVIEW}}==
Requires [[Greatest common divisor#LabVIEW|GCD]]. {{VI solution|LabVIEW_Least_common_multiple.png}}
 
 
 
=={{header|Lasso}}==
<langsyntaxhighlight Lassolang="lasso">define gcd(a,b) => {
while(#b != 0) => {
local(t = #b)
Line 1,224 ⟶ 1,801:
lcm(12, 18)
lcm(12, 22)
lcm(7, 31)</langsyntaxhighlight>
{{out}}
<pre>42
Line 1,233 ⟶ 1,810:
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang="lb">print "Least Common Multiple of 12 and 18 is "; LCM(12, 18)
end
 
function LCM(m, n)
LCM = abs(m * n) / GCD(m, n)
end function
 
function GCD(a, b)
while b
c = a
Line 1,247 ⟶ 1,824:
wend
GCD = abs(a)
end function
</langsyntaxhighlight>
 
=={{header|Logo}}==
<langsyntaxhighlight lang="logo">to abs :n
output sqrt product :n :n
end
Line 1,261 ⟶ 1,838:
to lcm :m :n
output quotient (abs product :m :n) gcd :m :n
end</langsyntaxhighlight>
 
Demo code:
 
<syntaxhighlight lang ="logo">print lcm 38 46</langsyntaxhighlight>
 
Output:
Line 1,272 ⟶ 1,849:
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">function gcd( m, n )
while n ~= 0 do
local q = m
Line 1,285 ⟶ 1,862:
end
 
print( lcm(12,18) )</langsyntaxhighlight>
 
=={{header|m4}}==
 
This should work with any POSIX-compliant m4. I have tested it with OpenBSD m4, GNU m4, and Heirloom Devtools m4.
<syntaxhighlight lang="m4">divert(-1)
 
define(`gcd',
`ifelse(eval(`0 <= (' $1 `)'),`0',`gcd(eval(`-(' $1 `)'),eval(`(' $2 `)'))',
eval(`0 <= (' $2 `)'),`0',`gcd(eval(`(' $1 `)'),eval(`-(' $2 `)'))',
eval(`(' $1 `) == 0'),`0',`gcd(eval(`(' $2 `) % (' $1 `)'),eval(`(' $1 `)'))',
eval(`(' $2 `)'))')
 
define(`lcm',
`ifelse(eval(`0 <= (' $1 `)'),`0',`lcm(eval(`-(' $1 `)'),eval(`(' $2 `)'))',
eval(`0 <= (' $2 `)'),`0',`lcm(eval(`(' $1 `)'),eval(`-(' $2 `)'))',
eval(`(' $1 `) == 0'),`0',`eval(`(' $1 `) * (' $2 `) /' gcd(eval(`(' $1 `)'),eval(`(' $2 `)')))')')
 
divert`'dnl
dnl
lcm(-6, 14) = 42
lcm(2, 0) = 0
lcm(12, 18) = 36
lcm(12, 22) = 132
lcm(7, 31) = 217</syntaxhighlight>
 
{{out}}
<pre>42 = 42
0 = 0
36 = 36
132 = 132
217 = 217</pre>
 
=={{header|Maple}}==
The least common multiple of two integers is computed by the built-in procedure ilcm in Maple. This should not be confused with lcm, which computes the least common multiple of polynomials.
<langsyntaxhighlight Maplelang="maple">> ilcm( 12, 18 );
36
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
 
<langsyntaxhighlight Mathematicalang="mathematica">LCM[18,12]
-> 36</langsyntaxhighlight>
 
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang Matlab="matlab"> lcm(a,b) </langsyntaxhighlight>
 
=={{header|Maxima}}==
<langsyntaxhighlight lang="maxima">lcm(a, b); /* a and b may be integers or polynomials */
 
/* In Maxima the gcd of two integers is always positive, and a * b = gcd(a, b) * lcm(a, b),
so the lcm may be negative. To get a positive lcm, simply do */
 
abs(lcm(a, b))</langsyntaxhighlight>
 
=={{header|Microsoft Small Basic}}==
{{trans|C}}
<syntaxhighlight lang="microsoftsmallbasic">
Textwindow.Write("LCM(35, 21) = ")
mlcm = 35
nlcm = 21
CalculateLCM()
TextWindow.WriteLine(lcm)
 
Sub CalculateLCM
mgcd = mlcm
ngcd = nlcm
CalculateGCD()
lcm = mlcm / gcd * nlcm
EndSub
 
Sub CalculateGCD
While mgcd <> 0
tmp = mgcd
mgcd = Math.Remainder(ngcd, mgcd)
ngcd = tmp
EndWhile
gcd = ngcd
EndSub
</syntaxhighlight>
 
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">gcd = function(a, b)
while b
temp = b
b = a % b
a = temp
end while
return abs(a)
end function
 
lcm = function(a,b)
if not a and not b then return 0
return abs(a * b) / gcd(a, b)
end function
 
print lcm(18,12)
</syntaxhighlight>
{{output}}
<pre>36</pre>
=={{header|MiniZinc}}==
<syntaxhighlight lang="minizinc">function var int: lcm(int: a2,int:b2) =
let {
int:a1 = max(a2,b2);
int:b1 = min(a2,b2);
array[0..a1,0..b1] of var int: gcd;
constraint forall(a in 0..a1)(
forall(b in 0..b1)(
gcd[a,b] ==
if (b == 0) then
a
else
gcd[b, a mod b]
endif
)
)
} in (a1*b1) div gcd[a1,b1];
var int: lcm1 = lcm(18,12);
solve satisfy;
output [show(lcm1),"\n"];</syntaxhighlight>
{{output}}
<pre>36</pre>
=={{header|min}}==
{{works with|min|0.19.6}}
<syntaxhighlight lang="min">((0 <) (-1 *) when) :abs
((dup 0 ==) (pop abs) (swap over mod) () linrec) :gcd
(over over gcd '* dip div) :lcm</syntaxhighlight>
 
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">ИПA ИПB * |x| ПC ИПA ИПB / [x] П9
ИПA ИПB ПA ИП9 * - ПB x=0 05 ИПC
ИПA / С/П</langsyntaxhighlight>
 
=={{header|ML}}==
==={{header|mLite}}===
<langsyntaxhighlight lang="ocaml">fun gcd (a, 0) = a
| (0, b) = b
| (a, b) where (a < b)
Line 1,325 ⟶ 2,007:
in a * b div d
end
</syntaxhighlight>
</lang>
 
=={{header|Modula-2}}==
{{trans|C}}
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<syntaxhighlight lang="modula2">
MODULE LeastCommonMultiple;
 
FROM STextIO IMPORT
WriteString, WriteLn;
FROM SWholeIO IMPORT
WriteInt;
 
PROCEDURE GCD(M, N: INTEGER): INTEGER;
VAR
Tmp: INTEGER;
BEGIN
WHILE M <> 0 DO
Tmp := M;
M := N MOD M;
N := Tmp;
END;
RETURN N;
END GCD;
 
PROCEDURE LCM(M, N: INTEGER): INTEGER;
BEGIN
RETURN M / GCD(M, N) * N;
END LCM;
 
BEGIN
WriteString("LCM(35, 21) = ");
WriteInt(LCM(35, 21), 1);
WriteLn;
END LeastCommonMultiple.
</syntaxhighlight>
 
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">def gcd(a, b)
if (a < 1) or (b < 1)
throw new(InvalidNumberException, "gcd cannot be calculated on values < 1")
end
 
c = 0
while b != 0
c = a
a = b
b = c % b
end
 
return a
end
 
def lcm(m, n)
return (m * n) / gcd(m, n)
end
 
println lcm(12, 18)
println lcm(6, 14)
println lcm(1,2) = lcm(2,1)</syntaxhighlight>
 
{{out}}
<pre>36
42
true</pre>
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
 
Line 1,398 ⟶ 2,144:
 
return
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,422 ⟶ 2,168:
 
=={{header|Nim}}==
The standard module "math" provides a function "lcm" for two integers and for an open array of integers. If we absolutely want to compute the least common multiple with our own procedure, it can be done this way (less efficient than the function in the standard library which avoids the modulo):
<lang nim>proc gcd(u, v): auto =
<syntaxhighlight lang="nim">proc gcd(u, v: int): auto =
var
t = 0
u = u
v = v
while v != 0:
tu = u %% v
uswap =u, v
v = t %% v
abs(u)
 
proc lcm(a, b: int): auto = abs(a * b) div gcd(a, b)
 
echo lcm(12, 18)
echo lcm(-6, 14)</langsyntaxhighlight>
 
{{out}}
<pre>36
42</pre>
 
=={{header|Objeck}}==
{{trans|C}}
<langsyntaxhighlight lang="objeck">
class LCM {
function : Main(args : String[]) ~ Nil {
Line 1,456 ⟶ 2,205:
}
}
</syntaxhighlight>
</lang>
 
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">let rec gcd u v =
if v <> 0 then (gcd v (u mod v))
else (abs u)
Line 1,470 ⟶ 2,219:
 
let () =
Printf.printf "lcm(35, 21) = %d\n" (lcm 21 35)</langsyntaxhighlight>
 
 
=={{header|Oforth}}==
 
lcm is already defined into Integer class :
<syntaxhighlight lang Oforth="oforth">12 18 lcm</langsyntaxhighlight>
 
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">
<lang ooRexx>
say lcm(18, 12)
 
Line 1,498 ⟶ 2,246:
use arg x, y
return x / gcd(x, y) * y
</syntaxhighlight>
</lang>
 
=={{header|Order}}==
{{trans|bc}}
<langsyntaxhighlight lang="c">#include <order/interpreter.h>
 
#define ORDER_PP_DEF_8gcd ORDER_PP_FN( \
Line 1,515 ⟶ 2,263:
// No support for negative numbers
 
ORDER_PP( 8to_lit(8lcm(12, 18)) ) // 36</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
Built-in function:
<syntaxhighlight lang ="parigp">lcm</langsyntaxhighlight>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang="pascal">Program LeastCommonMultiple(output);
 
{$IFDEF FPC}
{$MODE DELPHI}
{$ENDIF}
 
function lcm(a, b: longint): longint;
begin
lcmresult := a;
while (lcmresult mod b) <> 0 do
inc(lcmresult, a);
end;
 
begin
writeln('The least common multiple of 12 and 18 is: ', lcm(12, 18));
end.</langsyntaxhighlight>
Output:
<pre>The least common multiple of 12 and 18 is: 36
</pre>
 
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
function GCD(a,b: integer): integer;
begin
while b > 0 do
(a,b) := (b,a mod b);
Result := a;
end;
 
function LCM(a,b: integer): integer := a = 0 ? 0 : a div GCD(a,b) * b;
 
begin
Println(LCM(12,18));
end.
</syntaxhighlight>
{{out}}
<pre>
36
</pre>
 
=={{header|Perl}}==
Using GCD:
<langsyntaxhighlight Perllang="perl">sub gcd {
my ($ax, $by) = @_;
while ($ax) { ($ax, $by) = ($by % $ax, $ax) }
$by
}
 
sub lcm {
my ($ax, $by) = @_;
($ax && $by) and $ax / gcd($ax, $by) * $by or 0
}
 
print lcm(1001, 221);</langsyntaxhighlight>
Or by repeatedly increasing the smaller of the two until LCM is reached:<langsyntaxhighlight lang="perl">sub lcm {
use integer;
my ($x, $y) = @_;
my ($af, $bs) = @_;
while ($af != $bs) {
($af, $bs, $x, $y) = ($bs, $af, $y, $x) if $af > $bs;
$af = $bs / $x * $x;
$af += $x if $af < $bs;
}
$af
}
 
print lcm(1001, 221);</langsyntaxhighlight>
 
=={{header|Perl 6Phix}}==
It is a builtin function, defined in builtins\gcd.e and accepting either two numbers or a single sequence of any length.
This function is provided as an infix so that it can be used productively with various metaoperators.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Perl 6>say 3 lcm 4; # infix
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
say [lcm] 1..20; # reduction
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">lcm</span><span style="color: #0000FF;">(</span><span style="color: #000000;">12</span><span style="color: #0000FF;">,</span><span style="color: #000000;">18</span><span style="color: #0000FF;">)</span>
say ~(1..10 Xlcm 1..10) # cross</lang>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">lcm</span><span style="color: #0000FF;">({</span><span style="color: #000000;">12</span><span style="color: #0000FF;">,</span><span style="color: #000000;">18</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>12
36
232792560
36
1 2 3 4 5 6 7 8 9 10 2 2 6 4 10 6 14 8 18 10 3 6 3 12 15 6 21 24 9 30 4 4 12 4 20 12 28 8 36 20 5 10 15 20 5 30 35 40 45 10 6 6 6 12 30 6 42 24 18 30 7 14 21 28 35 42 7 56 63 70 8 8 24 8 40 24 56 8 72 40 9 18 9 36 45 18 63 72 9 90 10 10 30 20 10 30 70 40 90 10</pre>
</pre>
 
=={{header|PhixPhixmonti}}==
<syntaxhighlight lang="phixmonti">def gcd /# u v -- n #/
<lang Phix>function lcm(integer m, integer n)
abs int swap abs int swap
return m / gcd(m, n) * n
 
end function</lang>
dup
while
over over mod rot drop dup
endwhile
drop
enddef
 
def lcm /# m n -- n #/
over over gcd rot swap / *
enddef
 
12345 50 lcm print</syntaxhighlight>
 
=={{header|PHP}}==
{{trans|D}}
<langsyntaxhighlight lang="php">echo lcm(12, 18) == 36;
 
function lcm($m, $n) {
Line 1,598 ⟶ 2,385:
}
return $a;
}</langsyntaxhighlight>
 
=={{header|Picat}}==
Picat has a built-in function <code>gcd/2</code>.
 
===Function===
<syntaxhighlight lang="picat">lcm(X,Y)= abs(X*Y)//gcd(X,Y).</syntaxhighlight>
 
===Predicate===
<syntaxhighlight lang="picat">lcm(X,Y,LCM) => LCM = abs(X*Y)//gcd(X,Y).</syntaxhighlight>
 
===Functional (fold/3)===
<syntaxhighlight lang="picat">lcm(List) = fold(lcm,1,List).</syntaxhighlight>
 
===Test===
<syntaxhighlight lang="picat">go =>
L = [
[12,18],
[-6,14],
[35,0],
[7,10],
[2562047788015215500854906332309589561,6795454494268282920431565661684282819]
],
foreach([X,Y] in L)
println((X,Y)=lcm(X,Y))
end,
 
println('1..20'=lcm(1..20)),
println('1..50'=lcm(1..50)),
nl.
</syntaxhighlight>
 
{{out}}
<pre>(12,18) = 36
(-6,14) = 42
(35,0) = 0
(7,10) = 70
(2562047788015215500854906332309589561,6795454494268282920431565661684282819) = 15669251240038298262232125175172002594731206081193527869
1..20 = 232792560
1..50 = 3099044504245996706400</pre>
 
=={{header|PicoLisp}}==
Using 'gcd' from [[Greatest common divisor#PicoLisp]]:
<langsyntaxhighlight PicoLisplang="picolisp">(de lcm (A B)
(abs (*/ A B (gcd A B))) )</langsyntaxhighlight>
 
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
<lang PL/I>
/* Calculate the Least Common Multiple of two integers. */
 
Line 1,631 ⟶ 2,457:
end GCD;
end LCM;
</syntaxhighlight>
</lang>
<pre>
The LCM of 14 and 35 is 70
Line 1,638 ⟶ 2,464:
=={{header|PowerShell}}==
===version 1===
<syntaxhighlight lang="powershell">
<lang PowerShell>
function gcd ($a, $b) {
function pgcd ($n, $m) {
Line 1,655 ⟶ 2,481:
}
lcm 12 18
</syntaxhighlight>
</lang>
 
===version 2===
version2 is faster than version1
 
<syntaxhighlight lang="powershell">
<lang PowerShell>
function gcd ($a, $b) {
function pgcd ($n, $m) {
Line 1,677 ⟶ 2,503:
}
lcm 12 18
</syntaxhighlight>
</lang>
 
<b>Output:</b>
Line 1,686 ⟶ 2,512:
=={{header|Prolog}}==
SWI-Prolog knows gcd.
<langsyntaxhighlight Prologlang="prolog">lcm(X, Y, Z) :-
Z is abs(X * Y) / gcd(X,Y).</langsyntaxhighlight>
 
Example:
Line 1,693 ⟶ 2,519:
Z = 36.
</pre>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure GCDiv(a, b); Euclidean algorithm
Protected r
While b
Line 1,710 ⟶ 2,537:
EndIf
ProcedureReturn t*Sign(t)
EndProcedure</langsyntaxhighlight>
 
=={{header|Python}}==
===gcdFunctional===
====gcd====
Using the fractions libraries [http://docs.python.org/library/fractions.html?highlight=fractions.gcd#fractions.gcd gcd] function:
<langsyntaxhighlight lang="python">>>> import fractions
>>> def lcm(a,b): return abs(a * b) / fractions.gcd(a,b) if a and b else 0
 
Line 1,723 ⟶ 2,551:
42
>>> assert lcm(0, 2) == lcm(2, 0) == 0
>>> </langsyntaxhighlight>
 
Or, for compositional flexibility, a curried '''lcm''', expressed in terms of our own '''gcd''' function:
<syntaxhighlight lang="python">'''Least common multiple'''
 
from inspect import signature
 
 
# lcm :: Int -> Int -> Int
def lcm(x):
'''The smallest positive integer divisible
without remainder by both x and y.
'''
return lambda y: 0 if 0 in (x, y) else abs(
y * (x // gcd_(x)(y))
)
 
 
# gcd_ :: Int -> Int -> Int
def gcd_(x):
'''The greatest common divisor in terms of
the divisibility preordering.
'''
def go(a, b):
return go(b, a % b) if 0 != b else a
return lambda y: go(abs(x), abs(y))
 
 
# TEST ----------------------------------------------------
# main :: IO ()
def main():
'''Tests'''
 
print(
fTable(
__doc__ + 's of 60 and [12..20]:'
)(repr)(repr)(
lcm(60)
)(enumFromTo(12)(20))
)
 
pairs = [(0, 2), (2, 0), (-6, 14), (12, 18)]
print(
fTable(
'\n\n' + __doc__ + 's of ' + repr(pairs) + ':'
)(repr)(repr)(
uncurry(lcm)
)(pairs)
)
 
 
# GENERIC -------------------------------------------------
 
# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
'''Integer enumeration from m to n.'''
return lambda n: list(range(m, 1 + n))
 
 
# uncurry :: (a -> b -> c) -> ((a, b) -> c)
def uncurry(f):
'''A function over a tuple, derived from
a vanilla or curried function.
'''
if 1 < len(signature(f).parameters):
return lambda xy: f(*xy)
else:
return lambda xy: f(xy[0])(xy[1])
 
 
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.
'''
return '\n'.join(xs)
 
 
# FORMATTING ----------------------------------------------
 
# fTable :: String -> (a -> String) ->
# (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
'''Heading -> x display function -> fx display function ->
f -> xs -> tabular string.
'''
def go(xShow, fxShow, f, xs):
ys = [xShow(x) for x in xs]
w = max(map(len, ys))
return s + '\n' + '\n'.join(map(
lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)),
xs, ys
))
return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
xShow, fxShow, f, xs
)
 
 
# MAIN ---
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>Least common multiples of 60 and [12..20]:
12 -> 60
13 -> 780
14 -> 420
15 -> 60
16 -> 240
17 -> 1020
18 -> 180
19 -> 1140
20 -> 60
 
Least common multiples of [(0, 2), (2, 0), (-6, 14), (12, 18)]:
(0, 2) -> 0
(2, 0) -> 0
(-6, 14) -> 42
(12, 18) -> 36</pre>
 
===Prime decompositionProcedural===
====Prime decomposition====
This imports [[Prime decomposition#Python]]
<langsyntaxhighlight lang="python">from prime_decomposition import decompose
try:
reduce
Line 1,748 ⟶ 2,694:
print( lcm(12, 18) ) # 36
print( lcm(-6, 14) ) # 42
assert lcm(0, 2) == lcm(2, 0) == 0</langsyntaxhighlight>
 
====Iteration over multiples====
<langsyntaxhighlight lang="python">>>> def lcm(*values):
values = set([abs(int(v)) for v in values])
if values and 0 not in values:
Line 1,769 ⟶ 2,715:
>>> lcm(12, 18, 22)
396
>>> </langsyntaxhighlight>
 
====Repeated modulo====
{{trans|Tcl}}
<langsyntaxhighlight lang="python">>>> def lcm(p,q):
p, q = abs(p), abs(q)
m = p * q
Line 1,790 ⟶ 2,736:
>>> lcm(2, 0)
0
>>> </langsyntaxhighlight>
 
=={{header|Qi}}==
<syntaxhighlight lang="qi">
<lang qi>
(define gcd
A 0 -> A
Line 1,799 ⟶ 2,745:
 
(define lcm A B -> (/ (* A B) (gcd A B)))
</syntaxhighlight>
</lang>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery">[ [ dup while
tuck mod again ]
drop abs ] is gcd ( n n --> n )
 
[ 2dup and iff
[ 2dup gcd
/ * abs ]
else and ] is lcm ( n n --> n )</syntaxhighlight>
 
=={{header|R}}==
<syntaxhighlight lang="r">
<lang R>
"%gcd%" <- function(u, v) {ifelse(u %% v != 0, v %gcd% (u%%v), v)}
 
Line 1,807 ⟶ 2,765:
 
print (50 %lcm% 75)
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
Racket already has defined both lcm and gcd funtions:
<langsyntaxhighlight Racketlang="racket">#lang racket
(lcm 3 4 5 6) ;returns 60
(lcm 8 108) ;returns 216
(gcd 8 108) ;returns 4
(gcd 108 216 432) ;returns 108</langsyntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
This function is provided as an infix so that it can be used productively with various metaoperators.
<syntaxhighlight lang="raku" line>say 3 lcm 4; # infix
say [lcm] 1..20; # reduction
say ~(1..10 Xlcm 1..10) # cross</syntaxhighlight>
{{out}}
<pre>12
232792560
1 2 3 4 5 6 7 8 9 10 2 2 6 4 10 6 14 8 18 10 3 6 3 12 15 6 21 24 9 30 4 4 12 4 20 12 28 8 36 20 5 10 15 20 5 30 35 40 45 10 6 6 6 12 30 6 42 24 18 30 7 14 21 28 35 42 7 56 63 70 8 8 24 8 40 24 56 8 72 40 9 18 9 36 45 18 63 72 9 90 10 10 30 20 10 30 70 40 90 10</pre>
 
=={{header|Retro}}==
This is from the math extensions library included with Retro.
 
<langsyntaxhighlight Retrolang="retro">: gcd ( ab-n ) [ tuck mod dup ] while drop ;
: lcm ( ab-n ) 2over gcd [ * ] dip / ;</langsyntaxhighlight>
 
=={{header|REXX}}==
Line 1,830 ⟶ 2,799:
 
Usage note: &nbsp; the integers can be expressed as a list and/or specified as individual arguments &nbsp; (or as mixed).
<langsyntaxhighlight lang="rexx">/*REXX program finds the LCM (Least Common Multiple) of any number of integers. */
numeric digits 10000 /*can handle 10k decimal digit numbers.*/
say 'the LCM of 19 and 0 is ───► ' lcm(19 0 )
Line 1,846 ⟶ 2,815:
x=abs(x) /*use the absolute value of X. */
do while $\=='' /*process the remainder of args. */
parse var $ ! $; !=abs(!) if !<0 then !=-! /*pick off the next arg (ABS val).*/
if !==0 then return 0 /*if zero, then LCM is also zero. */
d=x*! /*calculate part of the LCM here. */
Line 1,853 ⟶ 2,822:
x=d%x /*divide the pre─calculated value.*/
end /*while*/ /* [↑] process subsequent args. */
return x /*return with the LCM of the args.*/</langsyntaxhighlight>
'''output''' &nbsp; when using the (internal) supplied list:
<pre>
Line 1,868 ⟶ 2,837:
{{trans|REXX version 0}} using different argument handling-
Use as lcm(a,b,c,---)
<langsyntaxhighlight lang="rexx">lcm2: procedure
x=abs(arg(1))
do k=2 to arg() While x<>0
Line 1,888 ⟶ 2,857:
end
end
return x</langsyntaxhighlight>
 
===versions 1 and 2 compared===
The ''(performance) improvement'' of version 2 is due to the different argument handling at the cost of less ''freedom'' of argument specification (you must use lcm2(a,b,c) instead of the ''possible'' lcm1(a b,c). Consider, however, lcm1(3 -4, 5) which, of course, won't work as possibly intended.
<br>The performance improvement is more significant with ooRexx than with Regina.
<br> ''Note:'' $ in version 1 was replaced by d in order to adapt it for this test with ooRexx.
<lang rexx>Parse Version v
Say 'Version='v
Call time 'R'
Do a=0 To 100
Do b=0 To 100
Do c=0 To 100
x1.a.b.c=lcm1(a,b,c)
End
End
End
Say 'version 1' time('E')
Call time 'R'
Do a=0 To 100
Do b=0 To 100
Do c=0 To 100
x2.a.b.c=lcm2(a,b,c)
End
End
End
Say 'version 2' time('E')
cnt.=0
Do a=0 To 100
Do b=0 To 100
Do c=0 To 100
If x1.a.b.c=x2.a.b.c then cnt.0ok=cnt.0ok+1
End
End
End
Say cnt.0ok 'comparisons ok'
Exit
/*----------------------------------LCM subroutine----------------------*/
lcm1: procedure; d=strip(arg(1) arg(2)); do i=3 to arg(); d=d arg(i); end
parse var d x d /*obtain the first value in args.*/
x=abs(x) /*use the absolute value of X. */
do while d\=='' /*process the rest of the args. */
parse var d ! d; !=abs(!) /*pick off the next arg (ABS val)*/
if !==0 then return 0 /*if zero, then LCM is also zero.*/
x=x*!/gcd1(x,!) /*have GCD do the heavy lifting.*/
end /*while*/
return x /*return with LCM of arguments.*/
/*----------------------------------GCD subroutine----------------------*/
gcd1: procedure; d=strip(arg(1) arg(2)); do j=3 to arg(); d=d arg(j); end
parse var d x d /*obtain the first value in args.*/
x=abs(x) /*use the absolute value of X. */
do while d\=='' /*process the rest of the args. */
parse var d y d; y=abs(y) /*pick off the next arg (ABS val)*/
if y==0 then iterate /*if zero, then ignore the value.*/
do until y==0; parse value x//y y with y x; end
end /*while*/
return x /*return with GCD of arguments.*/
 
lcm2: procedure
x=abs(arg(1))
do k=2 to arg() While x<>0
y=abs(arg(k))
x=x*y/gcd2(x,y)
end
return x
 
gcd2: procedure
x=abs(arg(1))
do j=2 to arg()
y=abs(arg(j))
If y<>0 Then Do
do until z==0
z=x//y
x=y
y=z
end
end
end
return x</lang>
{{out}}
Output of rexx lcmt and regina lcmt cut and pasted together:
<pre>Version=REXX-ooRexx_4.2.0(MT)_32-bit 6.04 22 Feb 2014
Version=REXX-Regina_3.9.0(MT) 5.00 16 Oct 2014
version 1 29.652000 version 1 23.821000
version 2 10.857000 version 2 21.209000
1030301 comparisons ok 1030301 comparisons ok</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="text">
see lcm(24,36)
Line 1,989 ⟶ 2,874:
end
return gcd
</syntaxhighlight>
</lang>
 
=={{header|RPL}}==
'''For unsigned integers'''
≪ DUP2 < ≪ SWAP ≫ IFT
'''WHILE''' DUP B→R '''REPEAT'''
SWAP OVER / LAST ROT * - '''END''' DROP
≫ '<span style="color:blue">GCD</span>' STO
≪ DUP2 * ROT ROT <span style="color:blue">GCD</span> /
≫ '<span style="color:blue">LCM</span>' STO
#12d #18d <span style="color:blue">LCM</span>
{{out}}
<pre>
1: #36d
</pre>
'''For usual integers''' (floating point without decimal part)
≪ '''WHILE''' DUP '''REPEAT'''
SWAP OVER MOD '''END''' DROP ABS
≫ '<span style="color:blue">GCD</span>' STO
≪ DUP2 * ROT ROT <span style="color:blue">GCD</span> /
≫ '<span style="color:blue">LCM</span>' STO
 
=={{header|Ruby}}==
Ruby has an <tt>Integer#lcm</tt> method, which finds the least common multiple of two integers.
 
<langsyntaxhighlight lang="ruby">irb(main):001:0> 12.lcm 18
=> 36</langsyntaxhighlight>
 
I can also write my own <tt>lcm</tt> method. This one takes any number of arguments.
 
<langsyntaxhighlight lang="ruby">def gcd(m, n)
m, n = n, m % n until n.zero?
m.abs
Line 2,012 ⟶ 2,920:
 
p lcm 12, 18, 22
p lcm 15, 14, -6, 10, 21</langsyntaxhighlight>
 
{{out}}
Line 2,021 ⟶ 2,929:
 
=={{header|Run BASIC}}==
{{works with|Just BASIC}}
<lang runbasic>print lcm(22,44)
{{works with|Liberty BASIC}}
<syntaxhighlight lang="lb">print "lcm( 12, -18) = "; lcm( 12, -18)
print "lcm( 15, 12) = "; lcm( 15, 12)
print "lcm(-10, -14) = "; lcm(-10, -14)
print "lcm( 0, 1) = "; lcm( 0, 1)
end
 
function lcm(m, n)
lcm = abs(m * n) / GCD(m, n)
while n
end function
t = m
m = n
n = t mod n
wend
lcm = m
end function</lang>
 
function GCD(a, b)
while b
c = a
a = b
b = c mod b
wend
GCD = abs(a)
end function</syntaxhighlight>
 
=={{header|Rust}}==
This implementation uses a recursive implementation of Stein's algorithm to calculate the gcd.
<langsyntaxhighlight lang="rust">use std::cmp::{minmax, maxmin};
 
fn gcd_stein(a: usize, b: usize) -> usize {
fn gcd(a: usize, b: usize) -> usize {
match ((a, b), (a & 1, b & 1)) {
((x, y), _) if x == y => y,
((0, x), _) | ((x, 0), _) => x,
((x, y), (0, 1)) | ((y, x), (1, 0)) => gcd(x >> 1, y),
((x, y), (0, 0)) => gcd(x >> 1, y >> 1) << 1,
((x, y), (1, 1)) => { let (x, y) = (min(x, y), max(x, y));
let (x, y) = gcd(min(x, y), - max(x) >> 1, xy) );
gcd((y - x) >> 1, }x)
}
_ => unreachable!(),
_ => unreachable!(),
}
}
 
fn lcm(a: usize, b: usize) -> usize {
a * b / gcd_steingcd(a, b)
}
}</lang>
 
fn main() {
println!("{}", lcm(6324, 234))
}</syntaxhighlight>
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">def gcd(a: Int, b: Int):Int=if (b==0) a.abs else gcd(b, a%b)
def lcm(a: Int, b: Int)=(a*b).abs/gcd(a,b)</langsyntaxhighlight>
<langsyntaxhighlight lang="scala">lcm(12, 18) // 36
lcm( 2, 0) // 0
lcm(-6, 14) // 42</langsyntaxhighlight>
 
=={{header|Scheme}}==
<syntaxhighlight lang ="scheme">> (lcm 108 8)
>(define gcd (lambda (a b)
216</lang>
(if (zero? b)
a
(gcd b (remainder a b)))))
>(define lcm (lambda (a b)
(if (or (zero? a) (zero? b))
0
(abs (* b (floor (/ a (gcd a b))))))))
>(lcm 12 18)
36</syntaxhighlight>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func integer: gcd (in var integer: a, in var integer: b) is func
Line 2,086 ⟶ 3,019:
begin
writeln("lcm(35, 21) = " <& lcm(21, 35));
end func;</langsyntaxhighlight>
 
Original source: [http://seed7.sourceforge.net/algorith/math.htm#lcm]
 
=={{header|SenseTalk}}==
<syntaxhighlight lang="sensetalk">function gcd m, n
repeat while m is greater than 0
put m into temp
put n modulo m into m
put temp into n
end repeat
return n
end gcd
 
function lcm m, n
return m divided by gcd(m, n) times n
end lcm</syntaxhighlight>
 
=={{header|Sidef}}==
Built-in:
<langsyntaxhighlight lang="ruby">say Math.lcm(1001, 221)</langsyntaxhighlight>
 
Using GCD:
<langsyntaxhighlight lang="ruby">func gcd(a, b) {
while (a) { (a, b) = (b % a, a) }
return b
Line 2,104 ⟶ 3,051:
}
 
say lcm(1001, 221)</langsyntaxhighlight>
{{out}}
<pre>
Line 2,112 ⟶ 3,059:
=={{header|Smalltalk}}==
Smalltalk has a built-in <code>lcm</code> method on <code>SmallInteger</code>:
<syntaxhighlight lang ="smalltalk">12 lcm: 18</langsyntaxhighlight>
 
=={{header|Sparkling}}==
<langsyntaxhighlight lang="sparkling">function factors(n) {
var f = {};
 
Line 2,147 ⟶ 3,094:
function LCM(n, k) {
return n * k / GCD(n, k);
}</langsyntaxhighlight>
 
=={{header|Standard ML}}==
===Readable version===
<syntaxhighlight lang="sml">fun gcd (0,n) = n
| gcd (m,n) = gcd(n mod m, m)
 
fun lcm (m,n) = abs(x * y) div gcd (m, n)</syntaxhighlight>
 
===Alternate version===
<syntaxhighlight lang="sml">val rec gcd = fn (x, 0) => abs x | p as (_, y) => gcd (y, Int.rem p)
 
val lcm = fn p as (x, y) => Int.quot (abs (x * y), gcd p)</syntaxhighlight>
 
=={{header|Swift}}==
Using the Swift GCD function.
<langsyntaxhighlight Swiftlang="swift">func lcm(a:Int, b:Int) -> Int {
return abs(a * b) / gcd_rec(a, b)
}</langsyntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc lcm {p q} {
set m [expr {$p * $q}]
if {!$m} {return 0}
Line 2,164 ⟶ 3,124:
if {!$q} {return [expr {$m / $p}]}
}
}</langsyntaxhighlight>
Demonstration
<syntaxhighlight lang ="tcl">puts [lcm 12 18]</langsyntaxhighlight>
Output:
36
 
=={{header|TI-83 BASIC}}==
<langsyntaxhighlight lang="ti83b">lcm(12,18
36</langsyntaxhighlight>
 
=={{header|TSE SAL}}==
<langsyntaxhighlight TSESALlang="tsesal">// library: math: get: least: common: multiple <description></description> <version control></version control> <version>1.0.0.0.2</version> <version control></version control> (filenamemacro=getmacmu.s) [<Program>] [<Research>] [kn, ri, su, 20-01-2013 14:36:11]
INTEGER PROC FNMathGetLeastCommonMultipleI( INTEGER x1I, INTEGER x2I )
//
Line 2,204 ⟶ 3,164:
Warn( FNMathGetLeastCommonMultipleI( Val( s1 ), Val( s2 ) ) ) // gives e.g. 10
UNTIL FALSE
END</langsyntaxhighlight>
 
 
=={{header|TXR}}==
 
<langsyntaxhighlight lang="bash">$ txr -p '(lcm (expt 2 123) (expt 6 49) 17)'
43259338018880832376582582128138484281161556655442781051813888</langsyntaxhighlight>
 
== {{header|TypeScript}} ==
{{trans|C}}
<syntaxhighlight lang="javascript">// Least common multiple
 
function gcd(m: number, n: number): number {
var tmp: number;
while (m != 0) {
tmp = m;
m = n % m;
n = tmp;
}
return n;
}
 
function lcm(m: number, n: number): number {
return Math.floor(m / gcd(m, n)) * n;
}
 
console.log(`LCM(35, 21) = ${lcm(35, 21)}`);
</syntaxhighlight>
{{out}}
<pre>
LCM(35, 21) = 105
</pre>
 
=={{header|uBasic/4tH}}==
{{trans|BBC BASIC}}
<syntaxhighlight lang="text">Print "LCM of 12 : 18 = "; FUNC(_LCM(12,18))
 
End
Line 2,234 ⟶ 3,218:
Else
Return (0)
EndIf</langsyntaxhighlight>
{{out}}
<pre>LCM of 12 : 18 = 36
Line 2,240 ⟶ 3,224:
0 OK, 0:330</pre>
 
=={{header|Uiua}}==
<syntaxhighlight lang="uiua">
# Greatest Common Divisor using Euclidean algorithm
Gcd ← ⊙◌⍢(⟜◿:|±,)
# Least Common Multiple
Lcm ← ÷⊃(Gcd|⌵×)
</syntaxhighlight>
=={{header|UNIX Shell}}==
<math>\operatorname{lcm}(m, n) = \left | \frac{m \times n}{\operatorname{gcd}(m, n)} \right |</math>
 
{{works with|Bourne Shell}}
<langsyntaxhighlight lang="bash">gcd() {
# Calculate $1 % $2 until $2 becomes zero.
until test 0 -eq "$2"; do
Line 2,264 ⟶ 3,255:
 
lcm 30 -42
# => 210</langsyntaxhighlight>
 
==={{header|C Shell}}===
<langsyntaxhighlight lang="csh">alias gcd eval \''set gcd_args=( \!*:q ) \\
@ gcd_u=$gcd_args[2] \\
@ gcd_v=$gcd_args[3] \\
Line 2,290 ⟶ 3,281:
lcm result 30 -42
echo $result
# => 210</langsyntaxhighlight>
 
=={{header|Ursa}}==
<langsyntaxhighlight lang="ursa">import "math"
out (lcm 12 18) endl console</langsyntaxhighlight>
{{out}}
<pre>36</pre>
 
=={{header|Vala}}==
<langsyntaxhighlight lang="vala">
int lcm(int a, int b){
/*Return least common multiple of two ints*/
Line 2,326 ⟶ 3,317:
stdout.printf("lcm(%d, %d) = %d\n", a, b, lcm(a, b));
}
</syntaxhighlight>
</lang>
 
=={{header|VBA}}==
<syntaxhighlight lang="vb">Function gcd(u As Long, v As Long) As Long
Dim t As Long
Do While v
t = u
u = v
v = t Mod v
Loop
gcd = u
End Function
Function lcm(m As Long, n As Long) As Long
lcm = Abs(m * n) / gcd(m, n)
End Function</syntaxhighlight>
 
=={{header|VBScript}}==
<langsyntaxhighlight lang="vb">Function LCM(a,b)
LCM = POS((a * b)/GCD(a,b))
End Function
Line 2,358 ⟶ 3,363:
 
WScript.StdOut.Write "The LCM of " & i & " and " & j & " is " & LCM(i,j) & "."
WScript.StdOut.WriteLine</langsyntaxhighlight>
 
{{out}}
Line 2,375 ⟶ 3,380:
=={{header|Wortel}}==
Operator
<syntaxhighlight lang ="wortel">@lcm a b</langsyntaxhighlight>
Number expression
<syntaxhighlight lang ="wortel">!#~km a b</langsyntaxhighlight>
Function (using gcd)
<langsyntaxhighlight lang="wortel">&[a b] *b /a @gcd a b</langsyntaxhighlight>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">var gcd = Fn.new { |x, y|
while (y != 0) {
var t = y
y = x % y
x = t
}
return x.abs
}
 
var lcm = Fn.new { |x, y|
if (x == 0 && y == 0) return 0
return (x*y).abs / gcd.call(x, y)
}
 
var xys = [[12, 18], [-6, 14], [35, 0]]
for (xy in xys) {
System.print("lcm(%(xy[0]), %(xy[1]))\t%("\b"*5) = %(lcm.call(xy[0], xy[1]))")
}</syntaxhighlight>
 
{{out}}
<pre>
lcm(12, 18) = 36
lcm(-6, 14) = 42
lcm(35, 0) = 0
</pre>
 
=={{header|XBasic}}==
{{trans|C}}
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">' Least common multiple
PROGRAM "leastcommonmultiple"
VERSION "0.0001"
 
DECLARE FUNCTION Entry()
INTERNAL FUNCTION Gcd(m&, n&)
INTERNAL FUNCTION Lcm(m&, n&)
 
FUNCTION Entry()
PRINT "LCM(35, 21) ="; Lcm(35, 21)
END FUNCTION
 
FUNCTION Gcd(m&, n&)
DO WHILE m& <> 0
tmp& = m&
m& = n& MOD m&
n& = tmp&
LOOP
RETURN n&
END FUNCTION
 
FUNCTION Lcm(m&, n&)
RETURN m& / Gcd(m&, n&) * n&
END FUNCTION
 
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
LCM(35, 21) = 105
</pre>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes;
 
func GCD(M,N); \Return the greatest common divisor of M and N
Line 2,397 ⟶ 3,464:
 
\Display the LCM of two integers entered on command line
IntOut(0, LCM(IntIn(8), IntIn(8)))</langsyntaxhighlight>
 
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">sub gcd(u, v)
local t
u = int(abs(u))
v = int(abs(v))
while(v)
t = u
u = v
v = mod(t, v)
wend
return u
end sub
 
sub lcm(m, n)
return m / gcd(m, n) * n
end sub
 
print "Least common multiple: ", lcm(12345, 23044)</syntaxhighlight>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn lcm(m,n){ (m*n).abs()/m.gcd(n) } // gcd is a number method</langsyntaxhighlight>
{{out}}
<pre>
Retrieved from "https://rosettacode.org/wiki/Least_common_multiple"