Sum multiples of 3 and 5: Difference between revisions

Show output for ''n'' = 1000.

 

 

'''Extra credit:''' do this efficiently for ''n'' = 1e20 or higher.

 

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

V sum = 0

L(i) 1 .< limit

R sum

 

 

{{out}}

</pre>

 

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

SUM35 CSECT

USING SUM35,R13 base register

PG DC CL80'123456789012 : 1234567890123456'

YREGS

{{out}}

<pre>

1000000 : 233333166668

10000000 : 23333331666668

</pre>

 

=={{header|Ada}}==

 

procedure Sum_Multiples is

Ada.Text_IO.Put_Line ("n=1000: " & Sum_3_5 (1000)'Image);

Ada.Text_IO.Put_Line ("n=5e9 : " & Sum_3_5 (5e9)'Image);

{{out}}

<pre>n=1000: 233168

===Extra Credit===

Requires upcoming Ada 202x with big integer package.

with Ada.Numerics.Big_Numbers.Big_Integers;

 

end;

end loop;

{{out}}

<pre> n : Sum_35 (n)

100000000000000000000000000000 : 2333333333333333333333333333316666666666666666666666666668

1000000000000000000000000000000 : 233333333333333333333333333333166666666666666666666666666668</pre>

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses Algol 68G's LONG LONG INT to handle large numbers.

PROC sum of multiples of 3 and 5 below = ( LONG LONG INT n )LONG LONG INT:

BEGIN

, newline

)

{{out}}

<pre>

 

=={{header|APL}}==

{{out}}

<pre>233168</pre>

=={{header|AppleScript}}==

{{Trans|JavaScript}}

 

-- sum35 :: Int -> Int

end script

end if

{{Out}}

10¹ -> 23<br>10² -> 2318<br>10³ -> 233168<br>10⁴ -> 23331668<br>10⁵ -> 2.333316668E+9<br>10⁶ -> 2.33333166668E+11<br>10⁷ -> 2.333333166667E+13<br>10⁸ -> 2.333333316667E+15<br>

=={{header|Arturo}}==

 

sum select 1..n-1 [x][or? 0=x%3 0=x%5]

]

 

 

{{out}}

=={{header|AutoHotkey}}==

 

 

msgbox % "Sum is " . Sum3_5(n) . " for n = " . n

}

return sum

'''Output:''' <pre>Sum is 233168 for n = 1000

Sum is 233168 for n = 1000</pre>

=={{header|AWK}}==

Save this into file "sum_multiples_of3and5.awk"

{

n = $1-1;

m = int(n/d);

return (d*m*(m+1)/2);

 

{{Out}}

=={{header|BASIC}}==

{{works with|FreeBASIC}}

Function mulsum35(n as integer) as integer

Dim s as integer

Print mulsum35(1000)

Sleep

{{out}}

<pre>233168</pre>

 

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

110 DEF MULTSUM35(N)

120 LET S=0

150 NEXT

160 LET MULTSUM35=S

 

==={{header|Sinclair ZX81 BASIC}}===

 

The ZX81 doesn't offer enough numeric precision to try for the extra credit. This program is pretty unsophisticated; the only optimization is that we skip testing whether <math>i</math> is divisible by 5 if we already know it's divisible by 3. (ZX81 BASIC doesn't do this automatically: both sides of an <code>OR</code> are evaluated, even if we don't need the second one.) Even so, with <math>n</math> = 1000 the performance is pretty acceptable.

20 FAST

30 LET SUM=0

80 NEXT I

90 SLOW

{{in}}

<pre>1000</pre>

=={{header|bc}}==

{{trans|Groovy}}

auto m

 

 

s(1000)

{{Out}}

<pre>233168

=={{header|BCPL}}==

There is both the naive method and the fast inclusion/exclusion method demonstrated. The code is limited to values that don't overflow a 64 bit integer.

GET "libhdr"

 

RESULTIS 0

}

{{Out}}

<pre>

=={{header|Befunge}}==

Slow (iterative) version:

>+\:v >:5%#v_^

{{Out}}

<pre>233168</pre>

Fast (analytic) version:

{{Out}}

<pre>233168</pre>

 

=={{header|C}}==

===Simple version===

#include <stdlib.h>

 

printf("%lld\n", sum35(limit));

return 0;

{{Out}}

<pre>$ ./a.out

===Fast version with arbitrary precision===

{{libheader|GMP}}

#include <gmp.h>

 

mpz_clear(limit);

return 0;

{{Out}}

<pre>$ ./a.out

The following C# 5 / .Net 4 code is an <i>efficient solution</i> in that it does not iterate through the numbers 1 ... n - 1 in order to calculate the answer. On the other hand, the System.Numerics.BigInteger class (.Net 4 and upwards) is not itself efficient because calculations take place in software instead of hardware. Consequently, it may be <i>faster</i> to conduct the calculation for smaller values with native ("primitive") types using a 'brute force' iteration approach.

 

using System;

using System.Collections.Generic;

}

}

{{out}}

The sum of numbers divisible by 3 or 5 between 1 and 999 is 233168

 

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

#include <iostream>

 

return system( "pause" );

}

{{out}}

 

=={{header|Clojure}}==

Quick, concise way:

(let [pred (apply some-fn

(map #(fn [x] (zero? (mod x %))) mults))]

(->> (range n) (filter pred) (reduce +))))

 

 

Transducers approach:

(transduce (filter (fn [x] (some (fn [mult] (zero? (mod x mult))) mults)))

+ (range n)))

 

 

Or optimized (translated from Groovy):

(let [n1 (/' (inc' n) f)]

(*' f n1 (inc' n1) 1/2)))

 

(def sum-35 #(-> % (sum-mul 3) (+ (sum-mul % 5)) (- (sum-mul % 15))))

 

=={{header|COBOL}}==

Using OpenCOBOL.

 

Identification division.

Program-id. three-five-sum.

or function mod(ws-the-number, 5) = zero

then add ws-the-number to ws-the-sum.

 

Output:

 

Using triangular numbers:

Identification division.

Program-id. three-five-sum-fast.

Compute ls-ret = ls-fac * ws-n1 * ws-n2 / 2.

goback.

 

Output:

A brute-method using only comparisons and adds. Compiles and runs as is in GnuCOBOL 2.0 and Micro Focus Visual COBOL 2.3. Takes about 7.3 seconds to calculate 1,000,000,000 iterations (AMD A6 quadcore 64bit)

 

IDENTIFICATION DIVISION.

PROGRAM-ID. SUM35.

EXIT.

END PROGRAM SUM35.

Output

<pre>+00233333333166666668</pre>

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

Slow, naive version:

(loop for x below limit

when (or (zerop (rem x 3)) (zerop (rem x 5)))

 

Fast version (adapted translation of [[#Tcl|Tcl]]):

(flet ((triangular (n) (truncate (* n (1+ n)) 2)))

(let ((n (1- limit))) ; Sum multiples *below* the limit

(- (+ (* 3 (triangular (truncate n 3)))

(* 5 (triangular (truncate n 5))))

 

{{Out}}

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Sum3_5;

IMPORT StdLog, Strings, Args;

 

END Sum3_5.

Execute: ^Q Sum3_5.Compute 1000 ~ <br/>

Output:

 

=={{header|Cowgol}}==

 

# sum multiples up to given input

print("Naive method: "); print_i32(sum35(1000, naiveSumMulTo)); print_nl();

print("Fast method: "); print_i32(sum35(1000, fastSumMulTo)); print_nl();

 

{{out}}

{{trans|Ruby}}

Short, but not optimized.

(0...n).select { |i| i % 3 == 0 || i % 5 == 0 }.sum

end

 

{{out}}

<pre>

To conform to task requirements, and other versions,

modified to find sums below n.

 

def g(n1, n2, n3)

# For extra credit

puts g(3,5,"100000000000000000000".to_big_i - 1)

{{out}}

<pre>

 

Alternative faster version 2.

 

def sumMul(n, f)

(1..20).each do |e| limit = 10.to_big_i ** e

puts "%2d:%22d %s" % [e, limit, sum35(limit)]

{{out}}

<pre>

 

=={{header|D}}==

 

BigInt sum35(in BigInt n) pure nothrow {

1000.BigInt.sum35.writeln;

(10.BigInt ^^ 20).sum35.writeln;

{{out}}

<pre>

2333333333333333333316666666666666666668</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

end;

writeln(sum);

{{out}}

<pre>233168</pre>

 

=={{header|Déjà Vu}}==

0

for i range 1 -- n:

+ i

 

{{out}}

<pre>233168</pre>

 

=={{header|EchoLisp}}==

(lib 'math) ;; divides?

(lib 'sequences) ;; sum/when

❌ error: expected coprimes (42 666)

 

=={{header|Eiffel}}==

 

class

end

 

{{out}}

<pre>

=={{header|Elixir}}==

Simple (but slow)

 

Fast version:

{{trans|Ruby}}

def sumMul(n, f) do

n1 = div(n - 1, f)

n = round(:math.pow(10, i))

IO.puts RC.sum35(n)

 

{{out}}

 

=={{header|Emacs Lisp}}==

 

=={{header|Erlang}}==

sum_3_5(X, Total) when X < 3 -> Total;

sum_3_5(X, Total) when X rem 3 =:= 0 orelse X rem 5 =:= 0 ->

sum_3_5(X-1, Total).

 

 

{{out}}

 

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

let sum35 n = Seq.init n (id) |> Seq.reduce (fun sum i -> if i % 3 = 0 || i % 5 = 0 then sum + i else sum)

 

 

[for i = 0 to 30 do yield i]

{{out}}

<pre style="height:5em">233168

<br>

{{works with|Factor|0.99 2019-10-06}}

 

: sum-multiples ( m n upto -- sum )

 

3 5 1000 sum-multiples .

{{out}}

<pre>

=={{header|FBSL}}==

Derived from BASIC version

 

FUNCTION sumOfThreeFiveMultiples(n AS INTEGER)

PRINT sumOfThreeFiveMultiples(1000)

PAUSE

Output

<pre>233168

 

=={{header|Forth}}==

0 swap

3 do

. ;

 

 

Another FORTH version using the Inclusion/Exclusion Principle. The result is a double precision integer (128 bits on a 64 bit computer) which lets us calculate up to 10^18 (the max precision of a single precision 64 bit integer) Since this is Project Euler problem 1, the name of the main function is named euler1tower.

 

 

: >dtriangular ( n -- d )

100000000000000000 2333333333333333316666666666666668

1000000000000000000 233333333333333333166666666666666668 ok

 

=={{header|Fortran}}==

 

Early Fortrans did not offer such monsters as INTEGER*8 but the F95 compiler I have does so. Even so, the source is in the style of F77 which means that in the absence of the MODULE protocol, the types of the functions must be specified if they are not default types. F77 also does not accept the <code>END FUNCTION ''name''</code> protocol that F90 does, but such documentation enables compiler checks and not using it makes me wince.

INTEGER*8 FUNCTION SUMI(N) !Sums the integers 1 to N inclusive.

Calculates as per the young Gauss: N*(N + 1)/2 = 1 + 2 + 3 + ... + N.

GO TO 10 !Have another go.

END !So much for that.

Sample output:

<pre>

 

=={{header|FreeBASIC}}==

 

Function sum35 (n As UInteger) As UInteger

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Frink}}==

Program has a brute-force approach for n=1000, and also inclusion/exclusion for larger values.

sum999 = sum[select[1 to 999, {|n| n mod 3 == 0 or n mod 5 == 0}]]

 

println["The sum of all the multiples of 3 or 5 below 1000 is $sum999"]

println["The sum of all multiples less than 1e20 is " + sum35big[1_00000_00000_00000_00000 - 1]]

{{Out}}

<pre>

The sum of all the multiples of 3 or 5 below 1000 is 233168

The sum of all multiples less than 1e20 is 2333333333333333333316666666666666666668

</pre>

 

=={{header|Go}}==

 

import "fmt"

return n

{{out}}

<pre>

</pre>

Extra credit:

 

import (

s := sum2(b3)

return s.Rsh(s.Sub(s.Add(s, sum2(b5)), sum2(b15)), 1)

{{out}}

<pre>

 

=={{header|Groovy}}==

Test Code:

println "Checking $arg == $value"

assert sum35(arg) == value

{{out}}

<pre>Checking 1000 == 233168

=={{header|Haskell}}==

Also a method for calculating sum of multiples of any list of numbers.

 

----------------- SUM MULTIPLES OF 3 AND 5 ---------------

where

f = sumMul n

{{out}}

<pre>233168

The following works in both langauges.

 

n := (integer(A[1]) | 1000)-1

write(sum(n,3)+sum(n,5)-sum(n,15))

procedure sum(n,m)

return m*((n/m)*(n/m+1)/2)

 

Sample output:

 

=={{header|J}}==

 

The problem can also be solved with a simple use of inclusion/exclusion; this solution is more in keeping with how one could approach the problem from a more traditional language.

NB. Naive method

NB. joins two lists of the multiples of 3 and 5, then uses the ~. operator to remove duplicates.

 

 

 

 

echo 'For 10^20 - 1, the sum is ', ": +/ (".(20#'9'),'x') sumdiv 3 5 _15

 

{{Out}}

<pre>

The sum of the multiples of 3 or 5 < 1000 is 233168

For 10^20 - 1, the sum is 2333333333333333333316666666666666666668

</pre>

=={{header|Java}}==

===Simple Version===

public static long getSum(long n) {

long sum = 0;

System.out.println(getSum(1000));

}

{{out}}

<pre>233168</pre>

===Extra Credit===

import java.math.BigInteger;

 

 

}

{{out}}

<pre>

===ES5===

 

 

As ''Number.MAX_SAFE_INTEGER < 1E20'' evaluates to ''true'', the most obvious JS attack on a solution for 1E20 might involve some string processing …

At more modest scales, however, we can generalise a little to allow for an arbitrary list of integer factors, and write a simple generate, filter and sum approach:

 

 

// [n] -> n -> n

JSON.stringify(lstTable);

 

 

 

|}

 

["10^4",23331668],["10^5",2333316668],["10^6",233333166668],

====With wheel increments====

var s=0, inc=[3,2,1,3,1,2,3]

for (var j=6, i=0; i<n; j+=j==6?-j:1, i+=inc[j]) s+=i

return s

====With triangular numbers====

return tri(n,3) + tri(n,5) - tri(n,15)

function tri(n, f) {

return f * n * (n+1) / 2

}

'''This:'''

document.write(10, '^{', i, '} ', sm35(n), '<br>')

{{out}}

10¹ 23

===ES6===

 

 

// sum35 :: Int -> Int

// ---

return main();

{{Out}}

<pre>Sums for n = 10^1 thru 10^8:

100000000 -> 2333333316666668</pre>

 

=={{header|jq}}==

def sum_multiples(d):

((./d) | floor) | (d * . * (.+1))/2 ;

def task(a;b):

. - 1

 

jq does not (yet) support arbitrary-precision integer arithmetic but converts large integers to floats, so:

1000 | task(3;5) # => 233168

 

 

=={{header|Julia}}==

sum multiples of each, minus multiples of the least common multiple (lcm). Similar to MATLAB's version.

Output:

<pre>julia> multsum(3, 5, 1000)

(100000000000000000000,2333333333333333333316666666666666666668)</pre>

a slightly more efficient version

 

=={{header|Kotlin}}==

 

import java.math.BigInteger

val e20 = big100k * big100k * big100k * big100k

println("The sum of multiples of 3 or 5 below 1e20 is ${sum35(e20)}")

 

{{out}}

 

=={{header|Lasso}}==

while(#limit <= 100000) => {^

local(s = 0)

'The sum of multiples of 3 or 5 between 1 and '+(#limit-1)+' is: '+#s+'\r'

#limit = integer(#limit->asString + '0')

{{out}}

<pre>The sum of multiples of 3 or 5 between 1 and 0 is: 0

Uses the IPints library when the result will be very large.

 

 

include "sys.m"; sys: Sys;

sub(isum_multiples(ints[15], limit)));

}

 

{{out}}

 

=={{header|Lingo}}==

res = 0

repeat with i = 0 to (n-1)

end repeat

return res

 

 

=={{header|LiveCode}}==

repeat with i = 0 to (n-1)

if i mod 3 = 0 or i mod 5 = 0 then

end sumUntil

 

 

=={{header|Lua}}==

{{trans|Tcl}}

function tri (n) return n * (n + 1) / 2 end

 

print(sum35(1000))

print(sum35(1e+20))

{{out}}

<pre>

=={{header|Maple}}==

By using symbolic function <code>sum</code> instead of numeric function <code>add</code> the program <code>F</code> will run O(1) rather than O(n).

F := unapply( sum(3*i,i=1..floor((n-1)/3))

+ sum(5*i,i=1..floor((n-1)/5))

 

F(10^20);

Output:

<pre>

 

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

Sum[k, {k, 3, n - 1, 3}] + Sum[k, {k, 5, n - 1, 5}] -

Sum[k, {k, 15, n - 1, 15}]

{{out}}

<pre>233168</pre>

{{out}}

<pre>233333333333333333333166666666666666666668</pre>

Another alternative is

 

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

<pre>ans = 233168</pre>

Another alternative is

Of course, it's more efficient to use [http://mathforum.org/library/drmath/view/57919.html Gauss' approach] of adding subsequent integers:

n3=floor(n/3);

n5=floor(n/5);

n15=floor(n/15);

<pre>ans = 233168</pre>

 

=={{header|Maxima}}==

[kmax],

 

 

sum35(1000);

Output:

<pre>

 

First, the simple implementation. It loops by threes and fives, and in the second loop, skips any multiples of five that are also divisible by three.

sum35 = function(n)

sum = 0

end function

 

{{out}}

<pre>233168</pre>

Now the fast version.

{{trans|D}}

sumMul = function(n, f)

n1 = floor((n - 1) / f)

end function

 

{{out}}

<pre>233168</pre>

 

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

17 ИП4 5 / {x} x=0 21 ИП0 ИП4 +

 

Input: ''n''.

{{trans|Java}}

This solution is translated from the simple Java version. Since all integers are arbitrary precision in Nanoquery, it is possible to use this solution for large n, but it is inefficient.

sum = 0

for i in range(3, n - 1)

end

 

{{out}}

<pre>233168</pre>

=={{header|NetRexx}}==

Portions translation of [[#Raku|Raku]]

options replace format comments java crossref symbols nobinary

numeric digits 40

say

return

{{out}}

<pre>

=={{header|Nim}}==

Here is the solution using normal integers.

for x in 0 ..< n:

if x mod 3 == 0 or x mod 5 == 0:

result += x

 

 

{{out}}

{{trans|Raku}}

{{libheader|bigints}}

 

proc sumMults(first: int32, limit: BigInt): BigInt =

while x < "1000000000000000000000000000000".initBigInt:

echo sum35 x

 

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

function : native : GetSum(n : Int) ~ Int {

sum := 0;

}

}

 

Output:

</pre>

 

=={{header|OCaml}}==

 

{{out}}

 

=={{header|Oforth}}==

 

 

Output:

 

=={{header|Ol}}==

(print

(fold (lambda (s x)

0 (iota 1000)))

; ==> 233168

 

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

a(n)=ct(n,3)+ct(n,5)-ct(n,15);

a(1000)

{{output}}

<pre>

{{works with|Free Pascal|2.6.2}}

 

function Multiple(x, y: integer): Boolean;

{ Show sum of all multiples less than 1000. }

writeln(SumMultiples(1000))

===alternative===

using gauss summation formula, but subtract double counted.

adapted translation of [[#Tcl|Tcl]]

//sum of all positive multiples of 3 or 5 below n

 

sum := sum-cntSumdivisibleBelowN(n,3*5);

writeln(sum);

output

<pre>233168</pre>

 

=={{header|Perl}}==

use List::Util qw( sum ) ;

 

return sum grep { $_ % 3 == 0 || $_ % 5 == 0 } ( 1..$limit - 1 ) ;

}

 

{{Out}}

 

{{Trans|Tcl}}

An alternative approach, using the analytical solution from the Tcl example.

}

 

}

 

use bigint; # Machine precision was sufficient for the first calculation

{{Out}}

<pre>233168

===native===

note the result of sum35() is inaccurate above 2^53 on 32-bit, 2^64 on 64-bit.

<span style="color: #008080;">function</span> <span style="color: #000000;">sumMul</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">((</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)</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;">"%s%s%s %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">sp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sum35</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">))})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

{{libheader|Phix/mpfr}}

Fast analytical version with arbitrary precision

<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: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #0000FF;">{</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_free</span><span style="color: #0000FF;">({</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">})</span>

{{Out}}

<pre>

Naive version (slow) :

 

$sum = 0;

for ($i = 1 ; $i < $max ; $i++) {

}

echo $sum, PHP_EOL;

 

{{out}}

Fast version:

 

// Number of multiples of $divisor <= $max

$num = floor($max / $divisor);

+ sum_multiples($max - 1, 5)

- sum_multiples($max - 1, 15);

 

{{out}}

These functions allow for arbitrary-length integers to be worked with.

 

// Number of multiples of $divisor <= $max

$num = gmp_div($max, $divisor);

);

printf('%22s : %s' . PHP_EOL, gmp_strval($n), $sum);

 

{{out}}

=={{header|Picat}}==

Uses both the naive method and inclusion/exclusion.

sumdiv(N, D) = S =>

M = N div D,

writef("The sum of all multiples of 3 and 5 below 1000 is %w%n", Upto1K),

writef("The sum of all multiples less than 1e20 is %w%n", sum35big(99999_99999_99999_99999)).

{{Out}}

<pre>

</pre>

=={{header|PicoLisp}}==

(let N1 (/ (dec N) F)

(*/ F N1 (inc N1) 2) ) )

(-

(+ (sumMul N 3) (sumMul N 5))

{{out}}

<pre>

 

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

declare (i, n) fixed(10), sum fixed (31) static initial (0);

 

put edit ( trim(sum) ) (A);

 

Outputs:

<pre>

The number of multiples of 3 or 5 below 10000000 is 23333331666668

The number of multiples of 3 or 5 below 100000000 is 2333333316666668</pre>

 

=={{header|PowerShell}}==

function SumMultiples ( [int]$Base, [int]$Upto )

{

# Calculate the sum of the multiples of 3 and 5 up to 1000

( SumMultiples -Base 3 -Upto 1000 ) + ( SumMultiples -Base 5 -Upto 1000 ) - ( SumMultiples -Base 15 -Upto 1000 )

{{out}}

<pre>

</pre>

For arbitrarily large integers, simply change the variable type.

function SumMultiples ( [bigint]$Base, [bigint]$Upto )

{

$Upto = [bigint]::Pow( 10, 210 )

( SumMultiples -Base 3 -Upto $Upto ) + ( SumMultiples -Base 5 -Upto $Upto ) - ( SumMultiples -Base 15 -Upto $Upto )

{{out}}

<pre>

</pre>

Here is a cmdlet that will provide the sum of unique multiples of any group of numbers below a given limit. I haven't attempted the extra credit here as the math is too complex for me at the moment.

{

Param

}

$Sum

{{out}}

<pre>Get-SumOfMultiples</pre>

=={{header|Prolog}}==

===Slow version===

sum_of_multiples_of_3_and_5(N, 1, 0, TT).

 

sum_of_multiples_of_3_and_5(N, K1, C5, S).

 

 

===Fast version===

maplist(compute_sum(N), [3,5,15], [TT3, TT5, TT15]),

TT is TT3 + TT5 - TT15.

; N2 is N div N1),

Sum is N1 * N2 * (N2 + 1) / 2.

 

Output :

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

=={{header|Python}}==

Three ways of performing the calculation are shown including direct calculation of the value without having to do explicit sums in sum35c()

'Direct count'

# note: ranges go to n-1

# Scalability

p = 20

 

{{out}}

Or, more generally – taking the area under the straight line between the first multiple and the last:

{{Works with|Python|3.7}}

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Summed multiples of 3 and 5 up to n:

 

=={{header|Q}}==

 

Extra credit, using the summation formula:

 

s35:{a:x-1; (3*sn floor a%3) + (5*sn floor a%5) - (15*sn floor a%15)}

 

=={{header|Quackery}}==

 

[ 1 -

1000 sum-of-3s&5s echo cr

 

{{out}}

=={{header|R}}==

 

seq(3, n-1, by = 3), seq(5, n-1, by = 5))))

 

=={{header|Racket}}==

#lang racket

(require math)

 

(for/list ([k 20]) (analytical k))

Output:

'(0 23 2318 233168 23331668 2333316668 233333166668)

'(0

233333333333333333166666666666666668

23333333333333333331666666666666666668)

 

=={{header|Raku}}==

(formerly Perl 6)

 

{{out}}

<pre>233168</pre>

Here's an analytical approach that scales much better for large values.

(my $last = $limit - 1) -= $last % $first;

($last div $first) * ($first + $last) div 2;

}

 

{{out}}

<pre>0

=={{header|REXX}}==

===version 1===

* 14.05.2013 Walter Pachl

**********************************************************************/

s=s+i

End

Output:

<pre>233168</pre>

 

===version 2===

* Translation from Raku->NetRexx->REXX

* 15.05.2013 Walter Pachl

last = last - last // first

sum = (last % first) * (first + last) % 2

Output:

<pre> 1 0

 

The formula used is a form of the Gauss Summation formula.

parse arg N t . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 1000 /*Not specified? Then use the default.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

see sum35(1000) + nl

func tri n

return n * (n + 1) / 2

 

=={{header|Ruby}}==

Simple Version (Slow):

(1...n).select{|i|i%3==0 or i%5==0}.sum

end

 

Fast Version:

#

# Nigel_Galloway

 

# For extra credit

 

{{out}}

Other way:

{{trans|D}}

n1 = (n - 1) / f

f * n1 * (n1 + 1) / 2

for i in 1..20

puts "%2d:%22d %s" % [i, 10**i, sum35(10**i)]

 

{{out}}

 

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

end

function multSum35(n)

If (i mod 3 = 0) or (i mod 5 = 0) then multSum35 = multSum35 + i

next i

 

=={{header|Rust}}==

extern crate rug;

 

}

}

Output :

<pre>

 

</pre>

 

=={{header|Scala}}==

 

// Simplest solution but limited to Ints only

{

for( i <- (0 to 20); n = "1"+"0"*i ) println( (" " * (21 - i)) + n + " => " + (" " * (21 - i)) + sum35(BigInt(n)) )

{{out}}

<pre> 1 => 0

 

=={{header|Scheme}}==

 

Output:

Or, more clearly by decomposition:

 

(or (zero? (remainder x 3))

(zero? (remainder x 5))))

(+ tot (if (fac35? x) x 0)))

 

 

Output:

For larger numbers iota can take quite a while just to build the list -- forget about waiting for all the computation to finish!

 

(let* ((n1 (quotient (- n 1) fac))

(n2 (+ n1 1)))

(fast35sum 1000)

(fast35sum 100000000000000000000)

 

Output:

 

=={{header|Seed7}}==

include "bigint.s7i";

 

writeln(sum35(1000_));

writeln(sum35(10_ ** 20));

 

{{out}}

=={{header|Sidef}}==

{{trans|Ruby}}

var m = int((n - 1) / f)

f * m * (m + 1) / 2

for i in (1..20) {

printf("%2s:%22s %s\n", i, 10**i, sum35(10**i))

{{out}}

<pre>

=={{header|Simula}}==

(referenced from [[Greatest common divisor#Simula|Greatest common divisor]])

! Project Euler problem 1: multiples of 3 or 5 below 1000 & 10**20;

BEGIN

OUTIMAGE

END

{{out}}

sum of positive multiples of 3 and 5: 233168<br />

=={{header|Stata}}==

=== With a dataset ===

set obs 999

gen a=_n

 

=== With Mata ===

a=1..999

 

=={{header|Swift}}==

 

 

print(sumofmult)

 

 

=={{header|Tcl}}==

proc mul35sum {n} {

for {set total [set threes [set fives 0]]} {$threes<$n||$fives<$n} {} {

}

return $total

However, that's pretty dumb. We can do much better by observing that the sum of the multiples of <math>k</math> below some <math>n+1</math> is <math>k T_{n/k}</math>, where <math>T_i</math> is the <math>i</math>'th [[wp:Triangular number|triangular number]], for which there exists a trivial formula. Then we simply use an overall formula of <math>3T_{n/3} + 5T_{n/5} - 15T_{n/15}</math> (that is, summing the multiples of three and the multiples of five, and then subtracting the multiples of 15 which were double-counted).

proc tcl::mathfunc::triangle {n} {expr {

$n * ($n+1) / 2

incr n -1

expr {3*triangle($n/3) + 5*triangle($n/5) - 15*triangle($n/15)}

Demonstrating:

puts [mul35sum 10000000],[sum35 10000000]

# Just the quick one; waiting for the other would get old quickly...

{{out}}

<pre>233168,233168

</pre>

 

=={{header|VBA}}==

{{trans|VBScript}}

Dim i As Double

For i = 1 To n - 1

End If

Next

Other way :

Dim i As Double

For i = 3 To n - 1 Step 3

If i Mod 15 <> 0 Then SumMult3and5 = SumMult3and5 + i

Next

Better way :

Dim i As Double

For i = 3 To n - 1 Step 3

SumMult3and5BETTER = SumMult3and5BETTER - i

Next

 

Call :

 

Sub Main()

Debug.Print "-------------------------"

Debug.Print SumMult3and5BETTER(1000)

{{Out}}

<pre>2,33333331666667E+15 9,059 sec.

=={{header|VBScript}}==

{{trans|Run BASIC}}

Function multsum35(n)

For i = 1 To n - 1

WScript.StdOut.Write multsum35(CLng(WScript.Arguments(0)))

WScript.StdOut.WriteLine

 

{{Out}}

<pre>

F:\>cscript /nologo multsum35.vbs 1000

233168

</pre>

 

=={{header|Wortel}}==

sum35 ^(@sum \!-@(\~%%3 || \~%%5) @til)

!sum35 1000 ; returns 233168

 

=={{header|Wren}}==

n = n - 1

var s3 = (n/3).floor

}

 

 

{{out}}

<pre>

233168

</pre>

 

=={{header|XPL0}}==

 

func Sum1; \Return sum the straightforward way

StrNSub(S, T, 40);

TextN(0, T, 40); CrLf(0);

 

{{out}}

 

=={{header|Zig}}==

const std = @import("std");

 

return @divExact(m * (m + 1), 2) * d;

}

 

return sumdiv(n, 3) + sumdiv(n, 5) - sumdiv(n, 15);

}

 

pub fn main() !void {

}

{{Out}}

<pre>

The sum of the multiples of 3 and 5 below 1000 is 233168

</pre>

=={{header|zkl}}==

Brute force:

{{trans|Groovy}}

Using a formula, making sure the input will cast the result to the same type (ie if called with a BigNum, the result is a BigNum).

{{out}}

<pre>