Least common multiple: Difference between revisions

 

=={{header|11l}}==

L b != 0

(a, b) = (b, a % b)

R m I/ gcd(m, n) * n

 

 

{{out}}

For maximum compatibility, this program uses only the basic instruction set (S/360)

with 2 ASSIST macros (XDECO,XPRNT).

USING LCM,R15 use calling register

L R6,A a

XDEC DS CL12 temp for edit

YREGS

{{out}}

<pre>

 

=={{header|8th}}==

: gcd \ a b -- gcd

dup 0 n:= if drop ;; then

 

 

{{out}}

<pre>LCM of 18 and 12 = 36

 

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

CARD tmp,c

 

Test(1,56)

Test(12,0)

{{out}}

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

=={{header|Ada}}==

lcm_test.adb:

 

procedure Lcm_Test is

Put_Line ("LCM of -6, 14 is" & Integer'Image (Lcm (-6, 14)));

Put_Line ("LCM of 35, 0 is" & Integer'Image (Lcm (35, 0)));

 

Output:

 

=={{header|ALGOL 68}}==

BEGIN

PROC gcd = (INT m, n) INT :

"and their greatest common divisor is", gcd(m,n)))

END

{{out}}

<pre>

 

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

integer procedure gcd ( integer value a, b ) ;

if b = 0 then a else gcd( b, a rem abs(b) );

 

write( lcm( 15, 20 ) );

 

=={{header|APL}}==

APL provides this function.

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:

12 LCM 18

 

=={{header|AppleScript}}==

 

 

-- lcm :: Integral a => a -> a -> a

result's |λ|(abs(x), abs(y))

{{Out}}

 

=={{header|Arendelle}}==

 

=={{header|Arturo}}==

x * y / gcd @[x y]

]

 

{{out}}

=={{header|Assembly}}==

==={{header|x86 Assembly}}===

; lcm.asm: calculates the least common multiple

; of two positive integers

ret

 

 

=={{header|ATS}}==

Compile with ‘patscc -o lcm lcm.dats’

 

 

#include "share/atspre_define.hats"

assertloc (lcm (12, 22) = 132ULL);

assertloc (lcm (7ULL, 31ULL) = 217ULL)

 

=={{header|AutoHotkey}}==

{

If (Number1 = 0 || Number2 = 0)

Num1 = 12

Num2 = 18

 

=={{header|AutoIt}}==

Func _LCM($a, $b)

Local $c, $f, $m = $a, $n = $b

Return $m * $n / $b

EndFunc ;==>_LCM

Example

ConsoleWrite(_LCM(12,18) & @LF)

ConsoleWrite(_LCM(-5,12) & @LF)

ConsoleWrite(_LCM(13,0) & @LF)

<pre>

36

 

=={{header|AWK}}==

function gcd(m, n, t) {

# Euclid's method

# Read two integers from each line of input.

# Print their least common multiple.

 

Example input and output: <pre>$ awk -f lcd.awk

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

ported from BBC BASIC

20 INPUT"M=";M%

30 INPUT"N=";N%

250 NEXT B

260 R = ABS(A%)

 

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

{{Works with|BBC BASIC for Windows}}

DEF FN_LCM(M%,N%)

IF M%=0 OR N%=0 THEN =0 ELSE =ABS(M%*N%)/FN_GCD_Iterative_Euclid(M%, N%)

ENDWHILE

= ABS(A%)

 

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

110 DEF GCD(A,B)

120 DO WHILE B>0

150 LET GCD=A

160 END DEF

 

==={{header|Tiny BASIC}}===

20 INPUT A

30 PRINT "Second number"

140 LET Q=R

150 LET R=C

 

=={{header|BASIC256}}==

===Iterative solution===

if m = 0 or n = 0 then return 0

if m < n then

print "lcm( 15, 12) = "; mcm( 15, 12)

print "lcm(-10, -14) = "; mcm(-10, -14)

{{out}}

<pre>lcm( 12, 18) = 36

===Recursive solution===

Reuses code from Greatest_common_divisor#Recursive_solution and correctly handles negative arguments

if b = 0 then return a

return gcdp(b, a mod b)

print "lcm( 15, 12) = "; lcm( 15, 12)

print "lcm(-10, -14) = "; lcm(-10, -14)

{{out}}

<pre>lcm( 12, -18) = 36.0

 

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

setlocal enabledelayedexpansion

set num1=12

set /a res = %1 %% %2

call :lcm %2 %res%

{{Out}}

<pre>LCM = 36</pre>

=={{header|bc}}==

{{trans|AWK}}

define g(m, n) {

auto t

if (r < 0) return (-r)

return (r)

 

=={{header|BCPL}}==

 

let lcm(m,n) =

gcd(n, m rem n)

 

{{out}}

<pre>36</pre>

Inputs are limited to signed 16-bit integers.

 

>28*:*:**+:28*>:*:*/\:vv*-<

|<:%/*:*:*82\%*:*:*82<<>28v

 

{{in}}

 

=={{header|BQN}}==

 

Example:

 

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

a b

. !arg:(?a.?b)

* !a

);

Output:

<pre>36 42 35 234</pre>

 

=={{header|Brat}}==

gcd = { a, b |

true? { a == 0 }

p lcm(12, 18) # 36

p lcm(14, 21) # 42

 

=={{header|C}}==

 

int gcd(int m, int n)

printf("lcm(35, 21) = %d\n", lcm(21,35));

return 0;

 

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

class Program

{

}

}

{{out}}

<pre>lcm(12,18)=36</pre>

=={{header|C++}}==

{{libheader|Boost}}

#include <iostream>

 

<< "and the greatest common divisor " << boost::math::gcd( 12 , 18 ) << " !" << std::endl ;

return 0 ;

 

{{out}}

=== Alternate solution ===

{{works with|C++11}}

#include <cstdlib>

#include <iostream>

return 0;

}

 

=={{header|Clojure}}==

[a b]

(if (zero? b)

;; to calculate the lcm for a variable number of arguments

(defn lcmv [& v] (reduce lcm v))

 

=={{header|CLU}}==

m, n := int$abs(m), int$abs(n)

while n ~= 0 do m, n := n, m // n end

po: stream := stream$primary_output()

stream$putl(po, int$unparse(lcm(12, 18)))

{{out}}

<pre>36</pre>

 

=={{header|COBOL}}==

PROGRAM-ID. show-lcm.

 

GOBACK

.

 

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

Common Lisp provides the <tt>lcm</tt> function. It can accept two or more (or less) parameters.

 

36

CL-USER> (lcm 12 18 22)

 

Here is one way to reimplement it.

 

(reduce (lambda (m n)

(cond ((or (= m 0) (= n 0)) 0)

36

CL-USER> (my-lcm 12 18 22)

 

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

 

sub gcd(m: uint32, n: uint32): (r: uint32) is

 

print_i32(lcm(12, 18));

{{out}}

<pre>36</pre>

 

=={{header|D}}==

 

T gcd(T)(T a, T b) pure nothrow {

lcm("2562047788015215500854906332309589561".BigInt,

"6795454494268282920431565661684282819".BigInt).writeln;

{{out}}

<pre>36

 

=={{header|Dart}}==

main() {

int x=8;

}

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Least_common_multiple#Pascal Pascal].

 

=={{header|DWScript}}==

Output:

<pre>36</pre>

 

=={{header|Draco}}==

word t;

while n /= 0 do

proc main() void:

writeln(lcm(12, 18))

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

(lcm 0 9) → 0

(lcm 444 888)→ 888

(define (lcm* list) (foldl lcm (first list) list)) → lcm*

(lcm* '(444 888 999)) → 7992

 

=={{header|Elena}}==

{{trans|C#}}

import system'math;

lcm = (m,n => (m * n).Absolute / gcd(m,n));

{

console.printLine("lcm(12,18)=",lcm(12,18))

{{out}}

<pre>

 

=={{header|Elixir}}==

def gcd(a,0), do: abs(a)

def gcd(a,b), do: gcd(b, rem(a,b))

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module(lcm).

-export([main/0]).

 

lcm(A,B) ->

 

{{out}}

 

=={{header|ERRE}}==

 

PROCEDURE GCD(A,B->GCD)

LCM(0,35->LCM)

PRINT("LCM of 0 AND 35 =";LCM)

 

{{out}}

LCM of 0 and 35 = 0

</pre>

 

=={{header|Euphoria}}==

integer tmp

while m do

function lcm(integer m, integer n)

return m / gcd(m, n) * n

 

=={{header|Excel}}==

Excel's LCM can handle multiple values. Type in a cell:

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

 

=={{header|Ezhil}}==

## இந்த நிரல் இரு எண்களுக்கு இடையிலான மீச்சிறு பொது மடங்கு (LCM), மீப்பெரு பொது வகுத்தி (GCD) என்ன என்று கணக்கிடும்

 

 

பதிப்பி "நீங்கள் தந்த இரு எண்களின் மீபொம (மீச்சிறு பொது மடங்கு, LCM) = ", மீபொம(அ, ஆ)

 

=={{header|F_Sharp|F#}}==

 

 

=={{header|Factor}}==

The vocabulary ''math.functions'' already provides ''lcm''.

 

 

This program outputs ''364''.

One can also reimplement ''lcm''.

 

IN: script

 

[ * abs ] [ gcd ] 2bi / ;

 

 

=={{header|Fermat}}==

 

=={{header|Forth}}==

begin dup while tuck mod repeat drop ;

 

: lcm ( a b -- n )

over 0= over 0= or if 2drop 0 exit then

 

=={{header|Fortran}}==

This solution is written as a combination of 2 functions, but a subroutine implementation would work great as well.

integer function lcm(a,b)

integer:: a,b

gcd = abs(a)

end function gcd

 

=={{header|FreeBASIC}}==

===Iterative solution===

 

Function lcm (m As Integer, n As Integer) As Integer

Print

Print "Press any key to quit"

 

{{out}}

===Recursive solution===

Reuses code from [[Greatest_common_divisor#Recursive_solution]] and correctly handles negative arguments

if b = 0 then return a

return gcdp( b, a mod b )

print "lcm( 15, 12) = "; lcm(15, 12)

print "lcm(-10, -14) = "; lcm(-10, -14)

 

{{out}}

=={{header|Frink}}==

Frink has a built-in LCM function that handles arbitrarily-large integers.

println[lcm[2562047788015215500854906332309589561, 6795454494268282920431565661684282819]]

 

=={{header|FunL}}==

FunL has function <code>lcm</code> in module <code>integers</code> with the following definition:

 

lcm( _, 0 ) = 0

lcm( 0, _ ) = 0

 

=={{header|GAP}}==

LcmInt(12, 18);

 

=={{header|Go}}==

 

import (

func main() {

fmt.Println(z.Mul(z.Div(&m, z.GCD(nil, nil, &m, &n)), &n))

{{out}}

<pre>

 

=={{header|Groovy}}==

gcd = { m, n -> m = m.abs(); n = n.abs(); n == 0 ? m : m%n == 0 ? n : gcd(n, m % n) }

 

println "LCD of $t.m, $t.n is $t.l"

assert lcd(t.m, t.n) == t.l

{{out}}

<pre>LCD of 12, 18 is 36

{{trans|C}}

{{works with|PC-BASIC|any}}

10 PRINT "LCM(35, 21) = ";

20 LET MLCM = 35

450 LET GCD = NGCD

460 RETURN

 

=={{header|Haskell}}==

That is already available as the function ''lcm'' in the Prelude. Here's the implementation:

 

lcm _ 0 = 0

lcm 0 _ = 0

 

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

The lcm routine from the Icon Programming Library uses gcd. The routine is

 

procedure main()

write("lcm of 18, 36 = ",lcm(18,36))

write("lcm of 0, 9 = ",lcm(0,9))

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn numbers provides lcm and gcd] and looks like this:

if (i = 0) | (j = 0) then return 0

return abs(i * j) / gcd(i, j)

 

=={{header|J}}==

J provides the dyadic verb <code>*.</code> which returns the least common multiple of its left and right arguments.

 

36

12 *. 18 22

*./~ 0 1

0 0

 

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

 

public class LCM{

System.out.println("lcm(" + m + ", " + n + ") = " + lcm);

}

 

=={{header|JavaScript}}==

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

 

{

var n = A.length, a = Math.abs(A[0]);

/* For example:

LCM([-50,25,-45,-18,90,447]) -> 67050

 

 

===ES6===

{{Trans|Haskell}}

'use strict';

 

return lcm(12, 18);

 

 

{{Out}}

=={{header|jq}}==

Direct method

def lcm(m; n):

def _lcm:

# state is [m, n, i]

if (.[2] % .[1]) == 0 then .[2] else (.[0:2] + [.[2] + m]) | _lcm end;

 

=={{header|Julia}}==

Built-in function:

 

=={{header|K}}==

lcm:{_abs _ x*y%gcd[x;y]}

 

lcm .'(12 18; -6 14; 35 0)

36 42 0

 

lcm/1+!20

 

=={{header|Klingphix}}==

abs int swap abs int swap

12 18 lcm print nl { 36 }

 

 

=={{header|Kotlin}}==

fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)

fun lcm(a: Long, b: Long): Long = a / gcd(a, b) * b

println(lcm(15, 9))

}

 

=={{header|LabVIEW}}==

 

=={{header|Lasso}}==

while(#b != 0) => {

local(t = #b)

lcm(12, 18)

lcm(12, 22)

{{out}}

<pre>42

 

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

end

 

GCD = abs(a)

end function

 

=={{header|Logo}}==

output sqrt product :n :n

end

to lcm :m :n

output quotient (abs product :m :n) gcd :m :n

 

Demo code:

 

 

Output:

 

=={{header|Lua}}==

while n ~= 0 do

local q = m

end

 

 

=={{header|m4}}==

 

This should work with any POSIX-compliant m4. I have tested it with OpenBSD m4, GNU m4, and Heirloom Devtools m4.

 

define(`gcd',

lcm(12, 18) = 36

lcm(12, 22) = 132

 

{{out}}

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

36

 

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

 

 

=={{header|MATLAB}} / {{header|Octave}}==

 

=={{header|Maxima}}==

 

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

 

 

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

{{trans|C}}

Textwindow.Write("LCM(35, 21) = ")

mlcm = 35

gcd = ngcd

EndSub

 

=={{header|MiniScript}}==

while b

temp = b

 

print lcm(18,12)

{{output}}

<pre>36</pre>

=={{header|MiniZinc}}==

let {

int:a1 = max(a2,b2);

var int: lcm1 = lcm(18,12);

solve satisfy;

{{output}}

<pre>36</pre>

=={{header|min}}==

{{works with|min|0.19.6}}

((dup 0 ==) (pop abs) (swap over mod) () linrec) :gcd

 

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

ИПA ИПB ПA ИП9 * - ПB x=0 05 ИПC

 

=={{header|ML}}==

==={{header|mLite}}===

| (0, b) = b

| (a, b) where (a < b)

in a * b div d

end

 

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

{{trans|C}}

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

MODULE LeastCommonMultiple;

 

WriteLn;

END LeastCommonMultiple.

 

=={{header|Nanoquery}}==

if (a < 1) or (b < 1)

throw new(InvalidNumberException, "gcd cannot be calculated on values < 1")

println lcm(12, 18)

println lcm(6, 14)

 

{{out}}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

{{out}}

<pre>

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

var

u = u

 

echo lcm(12, 18)

 

{{out}}

=={{header|Objeck}}==

{{trans|C}}

class LCM {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

 

if v <> 0 then (gcd v (u mod v))

else (abs u)

 

let () =

 

=={{header|Oforth}}==

 

lcm is already defined into Integer class :

 

=={{header|ooRexx}}==

say lcm(18, 12)

 

use arg x, y

return x / gcd(x, y) * y

 

=={{header|Order}}==

{{trans|bc}}

 

#define ORDER_PP_DEF_8gcd ORDER_PP_FN( \

// No support for negative numbers

 

 

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

Built-in function:

 

=={{header|Pascal}}==

 

{$IFDEF FPC}

begin

writeln('The least common multiple of 12 and 18 is: ', lcm(12, 18));

Output:

<pre>The least common multiple of 12 and 18 is: 36

=={{header|Perl}}==

Using GCD:

my ($x, $y) = @_;

while ($x) { ($x, $y) = ($y % $x, $x) }

}

 

use integer;

my ($x, $y) = @_;

}

 

 

=={{header|Phix}}==

It is a builtin function, defined in builtins\gcd.e and accepting either two numbers or a single sequence of any length.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

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

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

{{out}}

<pre>

 

=={{header|Phixmonti}}==

abs int swap abs int swap

 

enddef

 

 

=={{header|PHP}}==

{{trans|D}}

 

function lcm($m, $n) {

}

return $a;

 

=={{header|Picat}}==

 

===Function===

 

===Predicate===

 

===Functional (fold/3)===

 

===Test===

L = [

[12,18],

println('1..50'=lcm(1..50)),

nl.

 

{{out}}

=={{header|PicoLisp}}==

Using 'gcd' from [[Greatest common divisor#PicoLisp]]:

 

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

/* Calculate the Least Common Multiple of two integers. */

 

end GCD;

end LCM;

<pre>

The LCM of 14 and 35 is 70

=={{header|PowerShell}}==

===version 1===

function gcd ($a, $b) {

function pgcd ($n, $m) {

}

lcm 12 18

 

===version 2===

version2 is faster than version1

 

function gcd ($a, $b) {

function pgcd ($n, $m) {

}

lcm 12 18

 

<b>Output:</b>

=={{header|Prolog}}==

SWI-Prolog knows gcd.

 

Example:

 

=={{header|PureBasic}}==

Protected r

While b

EndIf

ProcedureReturn t*Sign(t)

 

=={{header|Python}}==

====gcd====

Using the fractions libraries [http://docs.python.org/library/fractions.html?highlight=fractions.gcd#fractions.gcd gcd] function:

>>> def lcm(a,b): return abs(a * b) / fractions.gcd(a,b) if a and b else 0

 

42

>>> assert lcm(0, 2) == lcm(2, 0) == 0

 

Or, for compositional flexibility, a curried '''lcm''', expressed in terms of our own '''gcd''' function:

 

from inspect import signature

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Least common multiples of 60 and [12..20]:

====Prime decomposition====

This imports [[Prime decomposition#Python]]

try:

reduce

print( lcm(12, 18) ) # 36

print( lcm(-6, 14) ) # 42

 

====Iteration over multiples====

values = set([abs(int(v)) for v in values])

if values and 0 not in values:

>>> lcm(12, 18, 22)

396

 

====Repeated modulo====

{{trans|Tcl}}

p, q = abs(p), abs(q)

m = p * q

>>> lcm(2, 0)

0

 

=={{header|Qi}}==

(define gcd

A 0 -> A

 

(define lcm A B -> (/ (* A B) (gcd A B)))

 

=={{header|Quackery}}==

 

tuck mod again ]

drop abs ] is gcd ( n n --> n )

[ 2dup gcd

/ * abs ]

 

=={{header|R}}==

"%gcd%" <- function(u, v) {ifelse(u %% v != 0, v %gcd% (u%%v), v)}

 

 

print (50 %lcm% 75)

 

=={{header|Racket}}==

Racket already has defined both lcm and gcd funtions:

(lcm 3 4 5 6) ;returns 60

(lcm 8 108) ;returns 216

(gcd 8 108) ;returns 4

 

=={{header|Raku}}==

(formerly Perl 6)

This function is provided as an infix so that it can be used productively with various metaoperators.

say [lcm] 1..20; # reduction

{{out}}

<pre>12

This is from the math extensions library included with Retro.

 

 

=={{header|REXX}}==

 

Usage note: &nbsp; the integers can be expressed as a list and/or specified as individual arguments &nbsp; (or as mixed).

numeric digits 10000 /*can handle 10k decimal digit numbers.*/

say 'the LCM of 19 and 0 is ───► ' lcm(19 0 )

x=d%x /*divide the pre─calculated value.*/

end /*while*/ /* [↑] process subsequent args. */

'''output''' &nbsp; when using the (internal) supplied list:

<pre>

{{trans|REXX version 0}} using different argument handling-

Use as lcm(a,b,c,---)

x=abs(arg(1))

do k=2 to arg() While x<>0

end

end

 

=={{header|Ring}}==

see lcm(24,36)

end

return gcd

 

=={{header|Ruby}}==

Ruby has an <tt>Integer#lcm</tt> method, which finds the least common multiple of two integers.

 

 

I can also write my own <tt>lcm</tt> method. This one takes any number of arguments.

 

m, n = n, m % n until n.zero?

m.abs

 

p lcm 12, 18, 22

 

{{out}}

{{works with|Just BASIC}}

{{works with|Liberty BASIC}}

print "lcm( 15, 12) = "; lcm( 15, 12)

print "lcm(-10, -14) = "; lcm(-10, -14)

wend

GCD = abs(a)

 

=={{header|Rust}}==

This implementation uses a recursive implementation of Stein's algorithm to calculate the gcd.

 

fn gcd(a: usize, b: usize) -> usize {

fn main() {

println!("{}", lcm(6324, 234))

 

=={{header|Scala}}==

lcm( 2, 0) // 0

 

=={{header|Scheme}}==

>(define gcd (lambda (a b)

(if (zero? b)

(abs (* b (floor (/ a (gcd a b))))))))

>(lcm 12 18)

 

=={{header|Seed7}}==

 

const func integer: gcd (in var integer: a, in var integer: b) is func

begin

writeln("lcm(35, 21) = " <& lcm(21, 35));

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#lcm]

 

=={{header|SenseTalk}}==

repeat while m is greater than 0

put m into temp

function lcm m, n

return m divided by gcd(m, n) times n

 

=={{header|Sidef}}==

Built-in:

 

Using GCD:

while (a) { (a, b) = (b % a, a) }

return b

}

 

{{out}}

<pre>

=={{header|Smalltalk}}==

Smalltalk has a built-in <code>lcm</code> method on <code>SmallInteger</code>:

 

=={{header|Sparkling}}==

var f = {};

 

function LCM(n, k) {

return n * k / GCD(n, k);

 

=={{header|Standard ML}}==

 

 

=={{header|Swift}}==

Using the Swift GCD function.

return abs(a * b) / gcd_rec(a, b)

 

=={{header|Tcl}}==

set m [expr {$p * $q}]

if {!$m} {return 0}

if {!$q} {return [expr {$m / $p}]}

}

Demonstration

Output:

36

 

=={{header|TI-83 BASIC}}==

 

=={{header|TSE SAL}}==

INTEGER PROC FNMathGetLeastCommonMultipleI( INTEGER x1I, INTEGER x2I )

//

Warn( FNMathGetLeastCommonMultipleI( Val( s1 ), Val( s2 ) ) ) // gives e.g. 10

UNTIL FALSE

 

=={{header|TXR}}==

 

 

== {{header|TypeScript}} ==

{{trans|C}}

 

function gcd(m: number, n: number): number {

 

console.log(`LCM(35, 21) = ${lcm(35, 21)}`);

{{out}}

<pre>

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

{{trans|BBC BASIC}}

 

End

Else

Return (0)

{{out}}

<pre>LCM of 12 : 18 = 36

 

{{works with|Bourne Shell}}

# Calculate $1 % $2 until $2 becomes zero.

until test 0 -eq "$2"; do

 

lcm 30 -42

 

==={{header|C Shell}}===

@ gcd_u=$gcd_args[2] \\

@ gcd_v=$gcd_args[3] \\

lcm result 30 -42

echo $result

 

=={{header|Ursa}}==

{{out}}

<pre>36</pre>

 

=={{header|Vala}}==

int lcm(int a, int b){

/*Return least common multiple of two ints*/

stdout.printf("lcm(%d, %d) = %d\n", a, b, lcm(a, b));

}

 

=={{header|VBA}}==

Dim t As Long

Do While v

Function lcm(m As Long, n As Long) As Long

lcm = Abs(m * n) / gcd(m, n)

 

=={{header|VBScript}}==

LCM = POS((a * b)/GCD(a,b))

End Function

 

WScript.StdOut.Write "The LCM of " & i & " and " & j & " is " & LCM(i,j) & "."

 

{{out}}

=={{header|Wortel}}==

Operator

Number expression

Function (using gcd)

 

=={{header|Wren}}==

while (y != 0) {

var t = y

for (xy in xys) {

System.print("lcm(%(xy[0]), %(xy[1]))\t%("\b"*5) = %(lcm.call(xy[0], xy[1]))")

 

{{out}}

{{trans|C}}

{{works with|Windows XBasic}}

PROGRAM "leastcommonmultiple"

VERSION "0.0001"

 

END PROGRAM

{{out}}

<pre>

 

=={{header|XPL0}}==

 

func GCD(M,N); \Return the greatest common divisor of M and N

 

\Display the LCM of two integers entered on command line

 

=={{header|Yabasic}}==

local t

end sub

 

 

=={{header|zkl}}==

{{out}}

<pre>