Smallest multiple: Difference between revisions

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

V ans = BigInt(1)

L(i) 1..n

L(n) [10, 20, 200, 2000]

{{out}}

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

{{libheader|ALGOL 68-primes}}

# translation of the Wren sample #

PR precision 1000 PR # set the precision of LONG LONG INT #

print( ( whole( tests[ i ], -5 ), ": ", commatise( lcm( tests[ i ] ) ), newline ) )

OD

{{out}}

<pre>

=={{header|Asymptote}}==

int smalmul = temp;

int lim = 1;

}

}

=={{header|AutoHotkey}}==

loop 20

if prime_numbers(A_Index).Count() = 1

ans.push(n)

return ans

{{out}}

<pre>232792560</pre>

=={{header|BASIC}}==

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

smalmul = temp

lim = 1

if (smalmul mod lim) then lim = 1 : smalmul += temp

until lim = 20

{{out}}

<pre>232792560</pre>

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

temp.i = 2*3*5*7*11*13*17*19

smalmul.i = temp

PrintN(Str(smalmul))

Input()

{{out}}

<pre>232792560</pre>

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

LET smalmul = temp

LET lim = 1

LOOP UNTIL lim = 20

PRINT smalmul

{{out}}

<pre>232792560</pre>

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

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]

// Least Multiple. Nigel Galloway: October 22nd., 2021

let fG n g=let rec fN i=match i*g with g when n>g->fN g |_->i in fN g

let leastMult n=let fG=fG n in primes32()|>Seq.takeWhile((>=)n)|>Seq.map fG|>Seq.reduce((*))

printfn $"%d{leastMult 20}"

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.98}}

{{out}}

<pre>

=={{header|Fermat}}==

i:=0; {integer logarithm of n to base b, positive only}

while b^i<=n do

!Smalmul(20);

{{out}}<pre>232792560</pre>

=={{header|FreeBASIC}}==

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

redim shared as ulongint smalls(0 to 1) 'calculate and store as we go

for i as uinteger = 0 to 20

print i, smalmul(i)

=={{header|Go}}==

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

fmt.Printf("%4d: %s\n", i, lcm(i))

}

{{out}}

=={{header|Haskell}}==

--- SMALLEST INTEGER EVENLY DIVISIBLE BY EACH OF [1..N] --

showSmallest =

((<>) . (<> " -> ") . printf "%4d")

{{Out}}

<pre> 10 -> 2520

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

def primes($n):

2, (range(3; $n; 2) | select(is_prime));

"N: LCM of the numbers 1 to N inclusive",

( 10, 20, 200, 2000

{{out}}

<pre>

=={{header|Julia}}==

lcm(x) = 2520

lcm(x) = 232792560

lcm(x) = 337293588832926264639465766794841407432394382785157234228847021917234018060677390066992000

lcm(x) = 151117794877444315307536308337572822173736308853579339903227904473000476322347234655122160866668946941993951014270933512030194957221371956828843521568082173786251242333157830450435623211664308500316844478617809101158220672108895053508829266120497031742749376045929890296052805527212315382805219353316270742572401962035464878235703759464796806075131056520079836955770415021318508272982103736658633390411347759000563271226062182345964184167346918225243856348794013355418404695826256911622054015423611375261945905974225257659010379414787547681984112941581325198396634685659217861208771400322507388161967513719166366839894214040787733471287845629833993885413462225294548785581641804620417256563685280586511301918399010451347815776570842790738545306707750937624267501103840324470083425714138183905657667736579430274197734179172691637931540695631396056193786415805463680000

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

{{out}}<pre>

Here the simplest way, like Raku, check the highest exponent of every prime in range<BR>

Using harded coded primes.

{$MODE DELPHI}

{$ELSE}

{$ENDIF}

END.

{{out}}

<pre>

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

Using prime sieve.

{$MODE DELPHI} {$Optimization On}

{$ELSE}

{$ENDIF}

END.

{{out}}

<pre style="height:300px">

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Smallest_multiple#Raku

use ntheory qw( lcm );

{{out}}

<pre>

=={{header|Phix}}==

Using the builtin, limited to 2<small>⁵³</small> aka N=36 on 32-bit, 2<small>⁶⁴</small> aka N=46 on 64-bit.

<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: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

Using gmp

{{trans|Wren}}

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

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The LCMs of the numbers 1 to N inclusive is:\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">,</span><span style="color: #000000;">200</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2000</span><span style="color: #0000FF;">},</span><span style="color: #000000;">plcmz</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

===lcm/2===

<code>lcm/2</code> is defined as:

===Iteration===

A = 1,

foreach(E in 2..N)

A := lcm(A,E)

===fold/3===

===reduce/2===

===Testing===

Of the three implementations the <code>fold/3</code> approach is slightly faster than the other two.

foreach(N in [10,20,200,2000])

println(N=smallest_multiple_range2(N))

{{out}}

=={{header|Python}}==

from math import gcd

for i in [10, 20, 200, 2000]:

{{out}}

<pre>10: 2520

Exercise with some larger values as well.

{{out}}

=={{header|Ring}}==

see "working..." + nl

see "Smallest multiple is:" + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Verilog}}==

{{trans|Yabasic}}

integer temp, smalmul, lim;

$finish ;

end

{{out}}

<pre>232792560</pre>

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

import "./big" for BigInt

import "./fmt" for Fmt

System.print("The LCMs of the numbers 1 to N inclusive is:")

{{out}}

=={{header|XPL0}}==

[N:= 2*3*5*7*11*13*17*19;

D:= 1;

until D = 20;

IntOut(0, N);

{{out}}

=={{header|Yabasic}}==

{{trans|XPL0}}

// by Galileo, 05/2022

if mod(N, D) D = 1 : N = N + M

until D = 20

{{out}}

<pre>232792560