Sum multiples of 3 and 5: Difference between revisions

Show output for ''n'' = 1000.

 

 

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

<br><br>

 

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

SUM35 CSECT

USING SUM35,R13 base register

PG DC CL80'123456789012 : 1234567890123456'

YREGS

{{out}}

<pre>

1000000 : 233333166668

10000000 : 23333331666668

</pre>

 

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

</pre>

 

{{out}}

<pre>233168</pre>

 

{{Trans|JavaScript}}

 

 

 

 

on run

foldl(sum35Result, "", enumFromTo(1, 8))

end run

 

 

 

-- enumFromTo :: Int -> 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|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}}

2333333333333333333316666666666666666668</pre>

 

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

2333333333333333333316666666666666666668</pre>

 

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

 

Or optimized (translated from Groovy):

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

 

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

> (sum-3-5-fast 1000000000000000000000)

233333333333333333333166666666666666666668</pre>

 

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

BlackBox Component Builder

MODULE Sum3_5;

IMPORT StdLog, Strings, Args;

 

END Sum3_5.

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

Output:

Sum: 233168

</pre>

 

=={{header|Crystal}}==

{{trans|Ruby}}

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

end

 

{{out}}

<pre>

233168

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

 

=={{header|Factor}}==

 

 

{{out}}

<pre>

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

The method here recalls the story of the young Gauss being set the problem of adding up all the integers from one to a hundred by a master who wanted some peace and quiet from his class. The trick here is to apply the formula for multiples of three and for five, then remember that multiples of fifteen will have been counted twice.

 

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

<pre>

Sum of positive integers below 1000 divisible by 3 or 5 is : 233168

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

 

 

sumMul n f = f * n1 * (n1 + 1) `div` 2

where

n1 = (n - 1) `div` f

 

 

main :: IO ()

main =

mapM_

print

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

 

 

 

 

 

 

 

 

 

 

 

=={{header|JavaScript}}==

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

 

 

 

// sumMults :: Int -> Int -> Int

 

 

 

 

// enumFromTo :: Int -> Int -> [Int]

 

 

 

{{Out}}

 

 

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

</pre>

 

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

 

 

sum35(1000);

Output:

 

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

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

 

Input: ''n''.

 

Output for n = 1000: ''233168''.

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

numeric digits 40

 

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

method sum_mults(first, limit) public static

last = limit - 1

say

return

{{out}}

<pre>

 

=={{header|Nim}}==

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

result += x

 

 

 

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

while x < "1000000000000000000000000000000".initBigInt:

echo sum35 x

23

2318

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

2333333333333333333316666666666666666668</pre>

Interestingly, the prime factorization of the second result produces a 35 digit prime number.

 

=={{header|Phix}}==

Fast analytical version with arbitrary precision

{{Out}}

<pre>

</pre>

 

=={{header|PicoLisp}}==

(let N1 (/ (dec N) F)

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

(-

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

 

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

{

Return $Sum

}

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

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

{

Return $Sum

}

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

===version 1===

* 14.05.2013 Walter Pachl

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

s=s+i

End

Output:

<pre>233168</pre>

 

===version 2===

* 15.05.2013 Walter Pachl

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

last = last - last // first

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

Output:

<pre> 1 0

 

===version 3===

 

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

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

say 'The sum of all positive integers that are a multiple of 3 and 5 are:'

say /* [↓] change the format/look of nE+nn*/

say 'integers from 1 ──►' y " is " sumDiv(z,3) + sumDiv(z,5) - sumDiv(z,3*5)

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

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

<pre>

The sum of all positive integers that are a multiple of 3 and 5 are:

integers from 1 ──► 999 is 233168

</pre>

The sum of all positive integers that are a multiple of 3 and 5 are:

 

 

=={{header|Ring}}==

see sum35(1000) + nl

func tri n

return n * (n + 1) / 2

 

=={{header|Ruby}}==

Simple Version (Slow):

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

 

func Sum1; \Return sum the straightforward way

StrNSub(S, T, 40);

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

 

{{out}}

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