I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Smallest multiple

Smallest multiple is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Task description is taken from Project Euler
(https://projecteuler.net/problem=5)
2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Related

11l

`F f(n)   V ans = BigInt(1)   L(i) 1..n      ans *= BigInt(i) I/ gcd(BigInt(i), BigInt(ans))   R ans L(n) [10, 20, 200, 2000]   print(n‘: ’f(n))`
Output:
```10: 2520
20: 232792560
200: 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000
2000: 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000
```

ALGOL 68

Translation of: Wren
Works with: ALGOL 68G version Any - tested with release 2.8.3.win32

Uses Algol 68G's LONG LONG INT which has specifiable precision.

`BEGIN # find the smallest number that is divisible by each of the numbers 1..n #      # translation of the Wren sample #    PR precision 1000 PR # set the precision of LONG LONG INT #    PR read "primes.incl.a68" PR    # returns the lowest common multiple of the numbers 1 : n #    PROC lcm = ( INT n )LONG LONG INT:         BEGIN            # sieve the primes to n #            []BOOL prime = PRIMESIEVE n;            LONG LONG INT result := 1;            FOR p TO UPB prime DO                IF prime[ p ] THEN                              LONG LONG INT f := p;           # f will be set to the #                    WHILE f * p <= n DO f *:= p OD; # highest multiple of p <= n #                    result *:= f                FI            OD;            result         END # lcm # ;    # returns a string representation of n with commas #    PROC commatise = ( LONG LONG INT n )STRING:         BEGIN            STRING result      := "";            STRING unformatted  = whole( n, 0 );            INT    ch count    := 0;            FOR c FROM UPB unformatted BY -1 TO LWB unformatted DO                IF   ch count <= 2 THEN ch count +:= 1                ELSE                    ch count  := 1; "," +=: result                FI;                unformatted[ c ] +=: result            OD;            result         END; # commatise #    print( ( "The LCMs of the numbers 1 to N inclusive is:", newline ) );    []INT tests = ( 10, 20, 200, 2000 );    FOR i FROM LWB tests TO UPB tests DO        print( ( whole( tests[ i ], -5 ), ": ", commatise( lcm( tests[ i ] ) ), newline ) )    ODEND`
Output:
```   10: 2,520
20: 232,792,560
200: 337,293,588,832,926,264,639,465,766,794,841,407,432,394,382,785,157,234,228,847,021,917,234,018,060,677,390,066,992,000
2000: 151,117,794,877,444,315,307,536,308,337,572,822,173,736,308,853,579,339,903,227,904,473,000,476,322,347,234,655,122,160,866,668,946,941,993,951,014,270,933,512,030,194,957,221,371,956,828,843,521,568,082,173,786,251,242,333,157,830,450,435,623,211,664,308,500,316,844,478,617,809,101,158,220,672,108,895,053,508,829,266,120,497,031,742,749,376,045,929,890,296,052,805,527,212,315,382,805,219,353,316,270,742,572,401,962,035,464,878,235,703,759,464,796,806,075,131,056,520,079,836,955,770,415,021,318,508,272,982,103,736,658,633,390,411,347,759,000,563,271,226,062,182,345,964,184,167,346,918,225,243,856,348,794,013,355,418,404,695,826,256,911,622,054,015,423,611,375,261,945,905,974,225,257,659,010,379,414,787,547,681,984,112,941,581,325,198,396,634,685,659,217,861,208,771,400,322,507,388,161,967,513,719,166,366,839,894,214,040,787,733,471,287,845,629,833,993,885,413,462,225,294,548,785,581,641,804,620,417,256,563,685,280,586,511,301,918,399,010,451,347,815,776,570,842,790,738,545,306,707,750,937,624,267,501,103,840,324,470,083,425,714,138,183,905,657,667,736,579,430,274,197,734,179,172,691,637,931,540,695,631,396,056,193,786,415,805,463,680,000
```

AutoHotkey

`primes := 1loop 20    if prime_numbers(A_Index).Count() = 1        primes *= A_Index loop{    Result := A_Index*primes    loop 20        if Mod(Result, A_Index)            continue, 2    break}MsgBox % Resultreturn prime_numbers(n) { ; http://www.rosettacode.org/wiki/Prime_decomposition#Optimized_Version    if (n <= 3)        return [n]    ans := [], done := false    while !done     {        if !Mod(n,2){            ans.push(2), n /= 2            continue        }        if !Mod(n,3) {            ans.push(3), n /= 3            continue        }        if (n = 1)            return ans        sr := sqrt(n), done := true        ; try to divide the checked number by all numbers till its square root.        i := 6        while (i <= sr+6){            if !Mod(n, i-1) { ; is n divisible by i-1?                ans.push(i-1), n /= i-1, done := false                break            }            if !Mod(n, i+1) { ; is n divisible by i+1?                ans.push(i+1), n /= i+1, done := false                break            }            i += 6        }    }    ans.push(n)    return ans}`
Output:
`232792560`

F#

This task uses Extensible Prime Generator (F#)

` // Least Multiple. Nigel Galloway: October 22nd., 2021let fG n g=let rec fN i=match i*g with g when n>g->fN g |_->i in fN glet leastMult n=let fG=fG n in primes32()|>Seq.takeWhile((>=)n)|>Seq.map fG|>Seq.reduce((*))printfn \$"%d{leastMult 20}" `
Output:
```232792560
```

Factor

Works with: Factor version 0.98
`USING: math.functions math.ranges prettyprint sequences ; 20 [1,b] 1 [ lcm ] reduce .`
Output:
```232792560
```

Fermat

`Func Ilog( n, b ) =    i:=0;                  {integer logarithm of n to base b, positive only}    while b^i<=n do        i:+;    od;    i-1.; Func Smalmul( n ) =    s:=1;    for a = 1 to n do        if Isprime(a) then s:=s*a^Ilog(n, a) fi;    od;    s.; !Smalmul(20); `
Output:
`232792560`

FreeBASIC

Use the code from the Least common multiple example as an include.

`#include"lcm.bas" redim shared as ulongint smalls(0 to 1)  'calculate and store as we gosmalls(0) = 0: smalls(1) = 1 function smalmul(n as longint) as ulongint    if n<0 then return smalmul(-n)     'deal with negative input    dim as uinteger m = ubound(smalls)    if n<=m then return smalls(n)  'have we calculated this already    'if not, make room for the next bunch of terms    redim preserve as ulongint smalls(0 to n)    for i as uinteger = m+1 to n        smalls(i) = lcm(smalls(i-1), i)    next i    return smalls(n)end function for i as uinteger = 0 to 20    print i, smalmul(i)next i`

Go

Translation of: Wren
Library: Go-rcu
`package main import (    "fmt"    "math/big"    "rcu") func lcm(n int) *big.Int {    lcm := big.NewInt(1)    t := new(big.Int)    for _, p := range rcu.Primes(n) {        f := p        for f*p <= n {            f *= p        }        lcm.Mul(lcm, t.SetUint64(uint64(f)))    }    return lcm} func main() {    fmt.Println("The LCMs of the numbers 1 to N inclusive is:")    for _, i := range []int{10, 20, 200, 2000} {        fmt.Printf("%4d: %s\n", i, lcm(i))    }}`
Output:
```The LCMs of the numbers 1 to N inclusive is:
10: 2520
20: 232792560
200: 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000
2000: 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000
```

`import Text.Printf (printf) --- SMALLEST INTEGER EVENLY DIVISIBLE BY EACH OF [1..N] -- smallest :: Integer -> Integersmallest =  foldr lcm 1 . enumFromTo 1  --------------------------- TEST -------------------------main :: IO ()main =  (putStrLn . unlines) \$    showSmallest <\$> [10, 20, 200, 2000] ------------------------- DISPLAY ------------------------showSmallest :: Integer -> StringshowSmallest =  ((<>) . (<> " -> ") . printf "%4d")    <*> (printf "%d" . smallest)`
Output:
```  10 -> 2520
20 -> 232792560
200 -> 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000
2000 -> 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000```

jq

Works with jq (*)
Works with gojq, the Go implementation of jq

The following uses `is_prime` as defined at Erdős-primes#jq.

(*) The C implementation of jq has sufficient accuracy for N == 20 but not N == 200, so the output shown below is based on a run of gojq.

`# Output: a stream of primes less than \$n in increasing orderdef primes(\$n):  2, (range(3; \$n; 2) | select(is_prime)); # lcm of 1 to \$n inclusivedef lcm:  . as \$n  | reduce primes(\$n) as \$p (1;      . * (\$p | until(. * \$p > \$n; . * \$p)) ) ; "N: LCM of the numbers 1 to N inclusive", ( 10, 20, 200, 2000   | "\(.): \(smallest_multiple)" )`
Output:
```N: LCM of the numbers 1 to N inclusive
10: 2520
20: 232792560
200: 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000
2000: 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000
```

Julia

`julia> foreach(x -> @show(lcm(x)), [1:10, 1:20, big"1":200, big"1":2000])lcm(x) = 2520lcm(x) = 232792560lcm(x) = 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000lcm(x) = 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000 `

Mathematica / Wolfram Language

`LCM @@ Range[20]`
Output:
```
232792560

```

Pascal

Here the simplest way, like Raku, check the highest exponent of every prime in range
Using harded coded primes.

`{\$IFDEF FPC}  {\$MODE DELPHI}{\$ELSE}  {\$APPTAYPE CONSOLE}{\$ENDIF}const smallprimes : array[0..10] of Uint32 = (2,3,5,7,11,13,17,19,23,29,31); MAX = 20; function getmaxfac(pr: Uint32): Uint32;//get the pr^highest exponent of prime used in 2 .. MAXvar  i,fac : integer;Begin  result := pr;  while pr*result <= MAX do    result *= pr;end; var  n,pr,prIdx : Uint32;BEGIN  n := 1;  prIdx := 0;  pr := smallprimes[prIdx];  repeat    pr := smallprimes[prIdx];    n *= getmaxfac(pr);    inc(prIdx);    pr := smallprimes[prIdx];  until pr>MAX;  writeln(n);{\$IFDEF WINDOWS}  READLN;{\$ENDIF}END. `
Output:
```  232792560
```

extended

fascinating find, that the count of digits is nearly a constant x upper rangelimit.
The number of factors is the count of primes til limit.See GetFactorList.
No need for calculating lcm(lcm(lcm(1,2),3),4..) or prime decomposition
Using prime sieve.

`{\$IFDEF FPC}  {\$MODE DELPHI} {\$Optimization On}{\$ELSE}  {\$APPTAYPE CONSOLE}{\$ENDIF}{\$DEFINE USE_GMP}uses  {\$IFDEF USE_GMP}  gmp,  {\$ENDIF}  sysutils; //formatconst  MAX_LIMIT = 2*1000*1000;  UpperLimit = MAX_LIMIT+1000;// so to find a prime beyond MAX_LIMIT  MAX_UINT64 = 46;// unused.Limit to get an Uint64 outputtype  tFactors = array of Uint32;  tprimelist = array of byte;var  primeDeltalist : tPrimelist;  factors,  saveFactors:tFactors;  saveFactorsIdx,  maxFactorsIdx : Uint32;procedure Init_Primes;var  pPrime : pByte;  p,i,delta,cnt: NativeUInt;begin  setlength(primeDeltalist,UpperLimit+3*8+1);  pPrime := @primeDeltalist[0];  //delete multiples of 2,3  i := 0;  repeat    //take care of endianess //0706050403020100    pUint64(@pPrime[i+0])^ := \$0100010000000100;    pUint64(@pPrime[i+8])^ := \$0000010001000000;    pUint64(@pPrime[i+16])^:= \$0100000001000100;    inc(i,24);  until i>UpperLimit;  cnt := 2;// 2,3  p := 5;  delta := 1;//5-3  repeat    if pPrime[p] <> 0 then    begin      i := p*p;      if i > UpperLimit then        break;      inc(cnt);      pPrime[p-2*delta] := delta;      delta := 0;      repeat        pPrime[i] := 0;        inc(i,2*p);      until i>UpperLimit;    end;    inc(p,2);    inc(delta);  until p*p>UpperLimit;  setlength(saveFactors,cnt);  //convert to delta  repeat    if pPrime[p]<> 0 then    begin      pPrime[p-2*delta] := delta;      inc(cnt);      delta := 0;    end;    inc(p,2);    inc(delta);  until p > UpperLimit;  setlength(factors,cnt);  factors[0] := 2;  factors[1] := 3;  i := 2;  p := 5;  repeat    factors[i] := p;    p += 2*pPrime[p];    i += 1;  until i >= cnt;  setlength(primeDeltalist,0);//  writeln(length(savefactors)); writeln(length(factors));end; {\$IFDEF USE_GMP}procedure ConvertToMPZ(const factors:tFactors;dgtCnt:UInt32);const  c19Digits = QWord(10*1000000)*1000000*1000000;var  mp,mpdiv : mpz_t;  s : AnsiString;  rest,last : Uint64;  f : Uint32;  i :int32;begin  //Init and allocate space  mpz_init_set_ui(mp,0);  mpz_init(mpdiv);  mpz_ui_pow_ui(mpdiv,10,dgtCnt);  mpz_add(mp,mp,mpdiv);  mpz_add_ui(mp,mp,1);  mpz_set_ui(mp,1);   i := maxFactorsIdx;  rest := 1;  repeat    last := rest;    f := factors[i];    rest *= f;    if rest div f <> last then    begin      mpz_mul_ui(mp,mp,last);      rest := f;    end;    dec(i);  until i < 0;  mpz_mul_ui(mp,mp,rest);   If dgtcnt>40 then  begin    rest := mpz_fdiv_ui(mp,c19Digits);    s := '..'+Format('%.19u',[rest]);    mpz_fdiv_q_ui (mpdiv,mpdiv,c19Digits);    mpz_fdiv_q(mp,mp,mpdiv);    rest := mpz_get_ui(mp);    writeln(rest:19,s);    mpz_clear(mpdiv);  end  else  Begin    setlength(s,dgtCnt+1000);    mpz_get_str(@s[1],10,mp);    writeln(s);    i := length(s);    while not(s[i] in['0'..'9']) do      dec(i);    setlength(s,i+1);    writeln(s);  end;  mpz_clear(mp);end;{\$ENDIF} procedure CheckDigits(const factors:tFactors);var  dgtcnt : extended;  i : integer;begin  dgtcnt := 0;  i := 0;  repeat    dgtcnt += ln(factors[i]);    inc(i);  until i > maxFactorsIdx;  dgtcnt := trunc(dgtcnt/ln(10))+1;  writeln(' has ',maxFactorsIdx+1:10,' factors and ',dgtcnt:10:0,' digits');  {\$IFDEF USE_GMP}    i := trunc(dgtcnt);    if i < 1000*1000 then      ConvertToMPZ(factors,i);  {\$ENDIF}end; function ConvertToUint64(const factors:tFactors):Uint64;var  i : integer;begin  if maxFactorsIdx >15 then    Exit(0);  result := 1;  for i := 0 to maxFactorsIdx do    result *= factors[i];end; function ConvertToStr(const factors:tFactors):Ansistring;var  s : Ansistring;  i : integer;begin  result := '';  for i := 0 to maxFactorsIdx-1 do  begin    str(factors[i],s);    result += s+'*';  end;  str(factors[maxFactorsIdx],s);  result += s;end; procedure GetFactorList(var factors:tFactors;max:Uint32);var  p,f,lf : Uint32;BEGIN  p := 2;  lf := 0;  saveFactors[lf] := p;  while p*p <= max do  Begin    saveFactors[lf] := p;    f := p*p;    while f*p <= max do      f*= p;    factors[lf] := f;    inc(lf);    p := factors[lf];    if p= 0 then HALT;  end;  if lf>0 then    saveFactorsIdx := lf-1;  repeat    inc(lf)  until factors[lf]>Max;  maxFactorsIdx := lf-1;end; procedure Check(var factors:tFactors;max:Uint32);var  i: Uint32;begin  GetFactorList(factors,max);  write(max:10,': ');  if maxFactorsIdx>15 then    CheckDigits(factors)  else    writeln(ConvertToUint64(factors):21,' = ',ConvertToStr(factors));  for i := 0 to saveFactorsIdx do    factors[i] := savefactors[i];end; var  max: Uint32;BEGIN  Init_Primes;   max := 2;  repeat    check(factors,max);    max *=10;  until max > MAX_LIMIT;   writeln;  For max := 10 to 20 do // < MAX_UINT64    check(factors,max);{\$IFDEF WINDOWS}  READLN;{\$ENDIF}END. `
Output:
```TIO.RUN Real time: 1.161 s User time: 1.106 s Sys. time: 0.049 s CPU share: 99.49 %
2:                     2 = 2
20:             232792560 = 16*9*5*7*11*13*17*19
200:  has         46 factors and         90 digits
3372935888329262646..8060677390066992000
2000:  has        303 factors and        867 digits
1511177948774443153..3786415805463680000
20000:  has       2262 factors and       8676 digits
4879325627288270518..7411295098112000000
200000:  has      17984 factors and      86871 digits
3942319728529926377..9513860925440000000
2000000:  has     148933 factors and     868639 digits
8467191629995920178..6480233472000000000
{ at home
20000000:  has    1270607 factors and    8686151 digits
1681437413936981958..6706037760000000000
200000000:  has   11078937 factors and   86857606 digits
2000000000:  has   98222287 factors and  868583388 digits
}
10:                  2520 = 8*9*5*7
11:                 27720 = 8*9*5*7*11
12:                 27720 = 8*9*5*7*11
13:                360360 = 8*9*5*7*11*13
14:                360360 = 8*9*5*7*11*13
15:                360360 = 8*9*5*7*11*13
16:                720720 = 16*9*5*7*11*13
17:              12252240 = 16*9*5*7*11*13*17
18:              12252240 = 16*9*5*7*11*13*17
19:             232792560 = 16*9*5*7*11*13*17*19
20:             232792560 = 16*9*5*7*11*13*17*19
```

Perl

`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Smallest_multiple#Rakuuse warnings;use ntheory qw( lcm ); print "for \$_, it's @{[ lcm(1 .. \$_) ]}\n" for 10, 20;`
Output:
```for 10, it's 2520
for 20, it's 232792560
```

Phix

Using the builtin, limited to 253 aka N=36 on 32-bit, 264 aka N=46 on 64-bit.

```with javascript_semantics
?lcm(tagset(20))
```
Output:
```232792560
```

Using gmp

Translation of: Wren
```with javascript_semantics
include mpfr.e
procedure plcmz(integer n)
sequence primes = get_primes_le(n)
mpz res = mpz_init(1)
for i=1 to length(primes) do
integer p = primes[i], f = p
while f*p <= n do f *= p end while
mpz_mul_si(res,res,f)
end for
printf(1,"%,5d: %s\n", {n, shorten(mpz_get_str(res,10,true))})
end procedure

printf(1,"The LCMs of the numbers 1 to N inclusive is:\n")
papply({10,20,200,2000},plcmz)
```
Output:
```The LCMs of the numbers 1 to N inclusive is:
10: 2,520
20: 232,792,560
200: 337,293,588,832,926,...,677,390,066,992,000 (90 digits)
2,000: 151,117,794,877,444,...,415,805,463,680,000 (867 digits)
```

Python

`""" Rosetta code task: Smallest_multiple """ from math import gcdfrom functools import reduce  def lcm(a, b):    """ least common multiple """    return 0 if 0 == a or 0 == b else (        abs(a * b) // gcd(a, b)    )  for i in [10, 20, 200, 2000]:    print(str(i) + ':', reduce(lcm, range(1, i + 1)))`
Output:
```10: 2520
20: 232792560
200: 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000
2000: 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000```

Raku

Exercise with some larger values as well.

`say "\$_: ", [lcm] 2..\$_ for <10 20 200 2000>`
Output:
```10: 2520
20: 232792560
200: 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000
2000: 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000```

Ring

` see "working..." + nlsee "Smallest multiple is:" + nln = 0 while true      n++      flag = 0      for m = 1 to 20          if n % m = 0             flag += 1          ok      next      if flag = 20         see "" + n + nl         exit      okend see "done..." + nl `
Output:
```working...
Smallest multiple is:
232792560
done...
```

Wren

Library: Wren-math
Library: Wren-big
Library: Wren-fmt

We don't really need a computer for the task as set because it's just the product of the maximum prime powers <= 20 which is : 16 x 9 x 5 x 7 x 11 x 13 x 17 x 19 = 232,792,560.

More formally and quite quick by Wren standards at 0.017 seconds:

`import "./math" for Intimport "./big" for BigIntimport "./fmt" for Fmt var lcm = Fn.new { |n|    var primes = Int.primeSieve(n)    var lcm = BigInt.one    for (p in primes) {        var f = p        while (f * p <= n) f = f * p        lcm = lcm * f    }    return lcm} System.print("The LCMs of the numbers 1 to N inclusive is:")for (i in [10, 20, 200, 2000]) Fmt.print("\$,5d: \$,i", i, lcm.call(i))`
Output:
```The LCMs of the numbers 1 to N inclusive is:
10: 2,520
20: 232,792,560
200: 337,293,588,832,926,264,639,465,766,794,841,407,432,394,382,785,157,234,228,847,021,917,234,018,060,677,390,066,992,000
2,000: 151,117,794,877,444,315,307,536,308,337,572,822,173,736,308,853,579,339,903,227,904,473,000,476,322,347,234,655,122,160,866,668,946,941,993,951,014,270,933,512,030,194,957,221,371,956,828,843,521,568,082,173,786,251,242,333,157,830,450,435,623,211,664,308,500,316,844,478,617,809,101,158,220,672,108,895,053,508,829,266,120,497,031,742,749,376,045,929,890,296,052,805,527,212,315,382,805,219,353,316,270,742,572,401,962,035,464,878,235,703,759,464,796,806,075,131,056,520,079,836,955,770,415,021,318,508,272,982,103,736,658,633,390,411,347,759,000,563,271,226,062,182,345,964,184,167,346,918,225,243,856,348,794,013,355,418,404,695,826,256,911,622,054,015,423,611,375,261,945,905,974,225,257,659,010,379,414,787,547,681,984,112,941,581,325,198,396,634,685,659,217,861,208,771,400,322,507,388,161,967,513,719,166,366,839,894,214,040,787,733,471,287,845,629,833,993,885,413,462,225,294,548,785,581,641,804,620,417,256,563,685,280,586,511,301,918,399,010,451,347,815,776,570,842,790,738,545,306,707,750,937,624,267,501,103,840,324,470,083,425,714,138,183,905,657,667,736,579,430,274,197,734,179,172,691,637,931,540,695,631,396,056,193,786,415,805,463,680,000
```

XPL0

`int N, D;[N:= 2*3*5*7*11*13*17*19;D:= 1;repeat  D:= D+1;        if rem(N/D) then            [D:= 1;  N:= N + 2*3*5*7*11*13*17*19];until   D = 20;IntOut(0, N);]`
Output:
```232792560
```

Yabasic

Translation of: XPL0
`// Rosetta Code problem: http://rosettacode.org/wiki/Smallest_multiple// by Galileo, 05/2022 M = 2*3*5*7*11*13*17*19N = MD = 1repeat    D = D + 1    if mod(N, D) D = 1 : N = N + Muntil D = 20print N`
Output:
```232792560
---Program done, press RETURN---```