View source for Sum multiples of 3 and 5

{{task}}

;Task:
The objective is to write a function that finds the sum of all positive multiples of 3 or 5 below ''n''. 

Show output for ''n'' = 1000.

This is is the same as [https://projecteuler.net/problem=1 Project Euler problem 1].

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

=={{header|11l}}==
<syntaxhighlight lang="11l">F sum35(limit)
   V sum = 0
   L(i) 1 .< limit
      I i % 3 == 0 | i % 5 == 0
         sum += i
   R sum

print(sum35(1000))</syntaxhighlight>

{{out}}
<pre>
233168
</pre>

=={{header|8th}}==
Implements both the naive method and inclusion/exclusion.
<syntaxhighlight lang="8th">
needs combinators/bi

: mul3or5?  ( 3 mod 0 = ) ( 5 mod 0 = ) bi or ;

"The sum of the multiples of 3 or 5 below 1000 is " .
0 ( mul3or5? if I n:+ then ) 1 999 loop . cr

with: n

: >triangular SED: n -- n
    dup 1+ * 2 / ;
 
: sumdiv SED: n n -- n
    dup >r /mod nip >triangular r> * ;
 
: sumdiv_3,5 SED: n -- n
    ( swap sumdiv ) curry [3, 5, 15] swap a:map a:open neg + + ;

;with

"For 10^20 - 1, the sum is " .  10 20 ^ 1- sumdiv_3,5 . cr
bye
</syntaxhighlight>
{{Out}}
<pre>
The sum of the multiples of 3 or 5 below 1000 is 233168
For 10^20 - 1, the sum is 2333333333333333333316666666666666666668
</pre>
=={{header|360 Assembly}}==
<syntaxhighlight lang="360asm">*        Sum multiples of 3 and 5
SUM35    CSECT
         USING  SUM35,R13          base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         STM    R14,R12,12(R13)    save previous context
         ST     R13,4(R15)         link backward
         ST     R15,8(R13)         link forward
         LR     R13,R15            set addressability
         LA     R9,1               n=1
         LA     R7,7               do j=7 to 1 step -1
LOOPJ    MH     R9,=H'10'            n=n*10
         LR     R10,R9               n
         BCTR   R10,0                n-1
         ZAP    SUM,=PL8'0'          sum=0
         LA     R6,3                 i=3
       DO WHILE=(CR,R6,LE,R10)       do i=3 to n-1
         LR     R4,R6                  i
         SRDA   R4,32
         D      R4,=F'3'               i/3
         LTR    R4,R4                  if mod(i,3)=0
         BZ     CVD
         LR     R4,R6                  i
         SRDA   R4,32
         D      R4,=F'5'               i/5
         LTR    R4,R4                  if  mod(i,5)=0
         BNZ    ITERI
CVD      CVD    R6,IP                  ip=p
         AP     SUM,IP                 sum=sum+i
ITERI    LA     R6,1(R6)               i++
       ENDDO    ,                    enddo i
         XDECO  R9,PG                n
         MVC    PG+15(16),EM16       load mask
         ED     PG+15(16),SUM        packed dec (PL8) to char (CL16)
         XPRNT  PG,L'PG              print
         BCT    R7,LOOPJ           enddo j
         L      R13,4(0,R13)       restore previous savearea pointer
         LM     R14,R12,12(R13)    restore previous context
         XR     R15,R15            rc=0
         BR     R14                exit
SUM      DS     PL8
IP       DS     PL8    		 
EM16     DC     X'40202020202020202020202020202120'  mask CL16 15num
PG       DC     CL80'123456789012 : 1234567890123456'
         YREGS
         END    SUM35</syntaxhighlight>
{{out}}
<pre>
          10 :               23
         100 :             2318
        1000 :           233168
       10000 :         23331668
      100000 :       2333316668
     1000000 :     233333166668
    10000000 :   23333331666668
</pre>

=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

PROC Main()
  REAL sum,r
  INT i

  Put(125) PutE() ;clear the screen
  IntToReal(0,sum)
  FOR i=0 TO 999
  DO
    IF i MOD 3=0 OR i MOD 5=0 THEN
      IntToReal(i,r)
      RealAdd(sum,r,sum)
    FI
  OD

  PrintRE(sum)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_multiples_of_3_and_5.png Screenshot from Atari 8-bit computer]
<pre>
233168
</pre>

=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_IO;

procedure Sum_Multiples is

   type Natural is range 0 .. 2**63 - 1;

   function Sum_3_5 (Limit : in Natural) return Natural is
      Sum : Natural := 0;
   begin
      for N in 1 .. Limit - 1 loop
         if N mod 3 = 0 or else N mod 5 = 0 then
            Sum := Sum + N;
         end if;
      end loop;
      return Sum;
   end Sum_3_5;

begin
   Ada.Text_IO.Put_Line ("n=1000: " & Sum_3_5 (1000)'Image);
   Ada.Text_IO.Put_Line ("n=5e9 : " & Sum_3_5 (5e9)'Image);
end Sum_Multiples;</syntaxhighlight>
{{out}}
<pre>n=1000:  233168
n=5e9 :  5833333329166666668</pre>

===Extra Credit===
Requires upcoming Ada 202x with big integer package.
<syntaxhighlight lang="ada">with Ada.Text_IO;
with Ada.Numerics.Big_Numbers.Big_Integers;

procedure Sum_Multiples_Big is
   use Ada.Numerics.Big_Numbers.Big_Integers;
   use Ada.Text_IO;

   type Natural is new Big_Natural;

   function Sum_Mults (First, Last : Natural) return Natural is
      High : constant Natural := Last - Last mod First;
      Sum  : constant Natural := (High / First) * (First + High) / 2;
   begin
      return Sum;
   end Sum_Mults;

   function Sum_35 (Limit : in Natural) return Natural is
      Last    : constant Natural := Limit - 1;
      Mult_3  : constant Natural := Sum_Mults (3,  Last);
      Mult_5  : constant Natural := Sum_Mults (5,  Last);
      Mult_15 : constant Natural := Sum_Mults (15, Last);
   begin
      return Mult_3 + Mult_5 - Mult_15;
   end Sum_35;

begin
   Put_Line ("                               n : Sum_35 (n)");
   Put_Line ("-----------------------------------------------------------------");
   for E in 0 .. 30 loop
      declare
         N : constant Natural := 10**E;
      begin
         Put (To_String (N, Width => 32));
         Put (" : ");
         Put (Sum_35 (N)'Image);
         New_Line;
      end;
   end loop;
end Sum_Multiples_Big;</syntaxhighlight>
{{out}}
<pre>                               n : Sum_35 (n)
-----------------------------------------------------------------
                               1 :  0
                              10 :  23
                             100 :  2318
                            1000 :  233168
                           10000 :  23331668
                          100000 :  2333316668
                         1000000 :  233333166668
                        10000000 :  23333331666668
                       100000000 :  2333333316666668
                      1000000000 :  233333333166666668
                     10000000000 :  23333333331666666668
                    100000000000 :  2333333333316666666668
                   1000000000000 :  233333333333166666666668
                  10000000000000 :  23333333333331666666666668
                 100000000000000 :  2333333333333316666666666668
                1000000000000000 :  233333333333333166666666666668
               10000000000000000 :  23333333333333331666666666666668
              100000000000000000 :  2333333333333333316666666666666668
             1000000000000000000 :  233333333333333333166666666666666668
            10000000000000000000 :  23333333333333333331666666666666666668
           100000000000000000000 :  2333333333333333333316666666666666666668
          1000000000000000000000 :  233333333333333333333166666666666666666668
         10000000000000000000000 :  23333333333333333333331666666666666666666668
        100000000000000000000000 :  2333333333333333333333316666666666666666666668
       1000000000000000000000000 :  233333333333333333333333166666666666666666666668
      10000000000000000000000000 :  23333333333333333333333331666666666666666666666668
     100000000000000000000000000 :  2333333333333333333333333316666666666666666666666668
    1000000000000000000000000000 :  233333333333333333333333333166666666666666666666666668
   10000000000000000000000000000 :  23333333333333333333333333331666666666666666666666666668
  100000000000000000000000000000 :  2333333333333333333333333333316666666666666666666666666668
 1000000000000000000000000000000 :  233333333333333333333333333333166666666666666666666666666668</pre>

=={{header|ALGOL 60}}==
{{works with|A60}}
<syntaxhighlight lang="ALGOL">
begin

comment - return n mod m;
integer procedure mod(n,m);
  value n, m; integer n, m;
begin
  mod := n - m * entier(n / m);
end;

integer i, limit;
real sum;

limit := 1000;
sum := 0;
for i := 1 step 1 until (limit - 1) do
  if mod(i, 3) = 0 or mod(i, 5) = 0 then
     sum := sum + i;
outreal(1,sum);

end
</syntaxhighlight>
{{out}}
<pre>
 233168
</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.
<syntaxhighlight lang="algol68"># returns the sum of the multiples of 3 and 5 below n #
PROC sum of multiples of 3 and 5 below = ( LONG LONG INT n )LONG LONG INT:
     BEGIN
        # calculate the sum of the multiples of 3 below n #
        LONG LONG INT multiples of  3 = ( n - 1 ) OVER  3;
        LONG LONG INT multiples of  5 = ( n - 1 ) OVER  5;
        LONG LONG INT multiples of 15 = ( n - 1 ) OVER 15;
        ( # twice the sum of multiples of  3 #
          (  3 * multiples of  3 * ( multiples of  3 + 1 ) )
          # plus twice the sum of multiples of  5 #
        + (  5 * multiples of  5 * ( multiples of  5 + 1 ) )
          # less twice the sum of multiples of 15 #
        - ( 15 * multiples of 15 * ( multiples of 15 + 1 ) )
        ) OVER 2
    END # sum of multiples of 3 and 5 below # ;

print( ( "Sum of multiples of 3 and 5 below 1000: "
       , whole( sum of multiples of 3 and 5 below( 1000 ), 0 )
       , newline 
       )
     );
print( ( "Sum of multiples of 3 and 5 below 1e20: "
       , whole( sum of multiples of 3 and 5 below( 100 000 000 000 000 000 000 ), 0 )
       , newline 
       )
     )</syntaxhighlight>
{{out}}
<pre>
Sum of multiples of 3 and 5 below 1000: 233168
Sum of multiples of 3 and 5 below 1e20: 2333333333333333333316666666666666666668
</pre>

=={{header|APL}}==
=== Dyalog APL ===
<syntaxhighlight lang="apl">
Sum ← +/∘⍸1<15∨⍳
</syntaxhighlight>
{{out}}
<pre>      Sum 999
233168</pre>

=== ngn/APL ===
<syntaxhighlight lang="apl">⎕IO←0
{+/((0=3|a)∨0=5|a)/a←⍳⍵} 1000</syntaxhighlight>[http://ngn.github.io/apl/web/index.html#code=%7B+/%28%280%3D3%7Ca%29%u22280%3D5%7Ca%29/a%u2190%u2373%u2375%7D%201000,run=1 run]
{{out}}
<pre>233168</pre>

=={{header|AppleScript}}==
{{Trans|JavaScript}}
<syntaxhighlight lang="applescript">----------------- SUM MULTIPLES OF 3 AND 5 -----------------

-- sum35 :: Int -> Int
on sum35(n)
    tell sumMults(n)
        |λ|(3) + |λ|(5) - |λ|(15)
    end tell
end sum35



-- sumMults :: Int -> Int -> Int
on sumMults(n)
    -- Area under straight line 
    -- between first multiple and last.
    script
        on |λ|(m)
            set n1 to (n - 1) div m
            m * n1 * (n1 + 1) div 2
        end |λ|
    end script
end sumMults


--------------------------- TEST ---------------------------
on run
    -- sum35Result :: String -> Int -> Int -> String
    script sum35Result
        -- sums of all multiples of 3 or 5 below or equal to N
        -- for N = 10 to N = 10E8 (limit of AS integers)
        on |λ|(a, x, i)
            a & "10<sup>" & i & "</sup> -> " & ¬
                sum35(10 ^ x) & "<br>"
        end |λ|
    end script
    foldl(sum35Result, "", enumFromTo(1, 8))
end run


-------------------- GENERIC FUNCTIONS ---------------------

-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
    if m > n then
        set d to -1
    else
        set d to 1
    end if
    set lst to {}
    repeat with i from m to n by d
        set end of lst to i
    end repeat
    return lst
end enumFromTo

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl

-- Lift 2nd class handler function into 1st class script wrapper 
-- mReturn :: Handler -> Script
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn</syntaxhighlight>
{{Out}}
10<sup>1</sup> -> 23<br>10<sup>2</sup> -> 2318<br>10<sup>3</sup> -> 233168<br>10<sup>4</sup> -> 23331668<br>10<sup>5</sup> -> 2.333316668E+9<br>10<sup>6</sup> -> 2.33333166668E+11<br>10<sup>7</sup> -> 2.333333166667E+13<br>10<sup>8</sup> -> 2.333333316667E+15<br>

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">sumMul35: function [n][
	sum select 1..n-1 [x][or? 0=x%3 0=x%5]
]

print sumMul35 1000</syntaxhighlight>

{{out}}

<pre>233168</pre>

=={{header|AutoHotkey}}==

<syntaxhighlight lang="autohotkey">n := 1000

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

;Standard simple Implementation.
Sum3_5(n) {
	sum := 0
	loop % n-1 {
		if (!Mod(a_index,3) || !Mod(a_index,5))
		sum:=sum+A_index
	}
	return sum
}

;Translated from the C++ version.
Sum3_5_b( i ) {
	sum := 0, a := 0
	while (a < 28)
	{
		if (!Mod(a,3) || !Mod(a,5))
		{
			sum += a
			s := 30
			while (s < i)
			{
				if (a+s < i)
					sum += (a+s)
				s+=30
			}
		}
		a+=1
	}
	return sum
}</syntaxhighlight>
'''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"
<syntaxhighlight lang="awk">#!/usr/bin/awk -f
{ 
	n = $1-1;
	print sum(n,3)+sum(n,5)-sum(n,15);
}
function sum(n,d) {
	m = int(n/d);
	return (d*m*(m+1)/2);
}</syntaxhighlight>

{{Out}}
<pre>$ echo 1000 |awk -f sum_multiples_of3and5.awk 
233168</pre>

===Extra credit===
{{Works with|Gawk|4.1}}
In Awk, all numbers are represented internally as double precision floating-point numbers. Thus the result for the extra credit is unprecise. Since version 4.1, GNU Awk supports high precision arithmetic (using [http://www.mpfr.org/ GNU MPFR] and [[GMP]]) which is turned on with the <code>-M / --bignum</code> option. The variable <code>PREC</code> sets the working precision for arithmetic operations (here 80 bits):

<pre>$ echo -e "1000\n1e20" | gawk -M -v PREC=80 -f sum_multiples_of3and5.awk 
233168
2333333333333333333316666666666666666668</pre>

=={{header|BASIC}}==
{{works with|FreeBASIC}}
<syntaxhighlight lang="freebasic">Declare function mulsum35(n as integer) as integer
Function mulsum35(n as integer) as integer
    Dim s as integer
    For i as integer = 1 to n - 1
        If (i mod 3 = 0) or (i mod 5 = 0) then
            s += i
        End if
    Next i
    Return s
End Function
Print mulsum35(1000)
Sleep
End</syntaxhighlight>
{{out}}
<pre>233168</pre>

==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="gwbasic"> 10  INPUT N
 20  LET SUM = 0
 30  FOR I = 3 TO N - 1
 40      IF I / 3 =  INT (I / 3) OR I / 5 =  INT (I / 5) THEN SUM = SUM + I
 50  NEXT I
 60  PRINT SUM</syntaxhighlight>

==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">function multSum35(n)
	if n = 0 then return 0
	suma = 0
	for i = 1 to n
		if (i mod 3 = 0) or (i mod 5 = 0) then suma += i
	next i
	return suma
end function

print multSum35(999)
end</syntaxhighlight>

==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">10 cls
20 print multsum35(1000)
30 end
40 function multsum35(n)
50   suma = 0
60   for i = 1 to n-1
70     if (i mod 3 = 0) or (i mod 5 = 0) then suma = suma+i
80   next i
90 multsum35 = suma
100 end function</syntaxhighlight>

==={{header|Gambas}}===
<syntaxhighlight lang="vbnet">Public Sub Main() 
  
  Print "Sum of positive integers below 1000 divisible by 3 or 5 is : "; multSum35(999)
  
End

Function multSum35(n As Integer) As Integer

  If n = 0 Then Return 0 
  Dim suma As Integer = 0 
  For i As Integer = 1 To n 
    If (i Mod 3 = 0) Or (i Mod 5 = 0) Then suma += i 
  Next 
  Return suma 

End Function</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>

==={{header|GW-BASIC}}===
{{works with|Applesoft BASIC}}
{{works with|Chipmunk Basic}}
{{works with|MSX BASIC|any}}
{{works with|PC-BASIC|any}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 CLS : REM  10 HOME for Applesoft BASIC
20 LET N = 1000
30 GOSUB 60
40 PRINT S
50 END
60 REM multsum35
70   LET S = 0
80   FOR I = 1 TO N-1
90     IF I/3 = INT(I/3) OR I/5 = INT(I/5) THEN LET S = S+I : REM  for Applesoft BASIC & Quite BASIC
90     IF (I MOD 3 = 0) OR (I MOD 5 = 0) THEN LET S = S+I : REM  for MSX Basic & Chipmunk Basic
100   NEXT I
110 RETURN</syntaxhighlight>

==={{header|Minimal BASIC}}===
<syntaxhighlight lang="qbasic">10 INPUT N
20 LET S = 0
30 FOR I = 3 TO N - 1
40   IF I / 3 = INT (I / 3) THEN 70
50   IF I / 5 = INT (I / 5) THEN 70
60 GOTO 80
70 LET S = S + I
80 NEXT I
90 PRINT S
100 END</syntaxhighlight>

==={{header|MSX Basic}}===
See [[#GW-BASIC|GW-BASIC]].

==={{header|QBasic}}===
<syntaxhighlight lang="qbasic">FUNCTION multSum35 (n)
  IF n = 0 THEN multSum35 = 0
  suma = 0
  FOR i = 1 TO n
    IF (i MOD 3 = 0) OR (i MOD 5 = 0) THEN suma = suma + i
  NEXT i
  multSum35 = suma
END FUNCTION

PRINT multSum35(999)</syntaxhighlight>

==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION multSum35(n)
    IF n = 0 THEN LET multSum35 = 0
    LET suma = 0
    FOR i = 1 TO n
        IF MOD(i, 3) = 0 OR MOD(i, 5) = 0 THEN LET suma = suma + i
    NEXT i
    LET multSum35 = suma
END FUNCTION

PRINT multSum35(999)
END</syntaxhighlight>

==={{header|Quite BASIC}}===
See [[#GW-BASIC|GW-BASIC]].

==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">sub multSum35(n)
    if n = 0 then return 0 : fi
    suma = 0
    for i = 1 to n
        if mod(i, 3) = 0 or mod(i, 5) = 0 then suma = suma + i : fi
    next i
    return suma
end sub

print multSum35(999)
end</syntaxhighlight>

==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 PRINT MULTSUM35(1000)
110 DEF MULTSUM35(N)
120   LET S=0
130   FOR I=1 TO N-1
140     IF MOD(I,3)=0 OR MOD(I,5)=0 THEN LET S=S+I
150   NEXT
160   LET MULTSUM35=S
170 END DEF</syntaxhighlight>

==={{header|Sinclair ZX81 BASIC}}===
Works with 1k of RAM.

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.
<syntaxhighlight lang="basic"> 10 INPUT N
 20 FAST
 30 LET SUM=0
 40 FOR I=3 TO N-1
 50 IF I/3=INT (I/3) THEN GOTO 70
 60 IF I/5<>INT (I/5) THEN GOTO 80
 70 LET SUM=SUM+I
 80 NEXT I
 90 SLOW
100 PRINT SUM</syntaxhighlight>
{{in}}
<pre>1000</pre>
{{out}}
<pre>233168</pre>

=={{header|bc}}==
{{trans|Groovy}}
<syntaxhighlight lang="bc">define t(n, f) {
    auto m

    m = (n - 1) / f
    return(f * m * (m + 1) / 2)
}

define s(l) {
    return(t(l, 3) + t(l, 5) - t(l, 15))
}

s(1000)
s(10 ^ 20)</syntaxhighlight>
{{Out}}
<pre>233168
2333333333333333333316666666666666666668</pre>

=={{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.
<syntaxhighlight lang="bcpl">
GET "libhdr"

LET sumdiv(n, d) = VALOF {
    LET m = n/d
    RESULTIS m*(m + 1)/2 * d
}

LET sum3or5(n) = sumdiv(n, 3) + sumdiv(n, 5) - sumdiv(n, 15)

LET start() = VALOF {
    LET sum = 0
    LET n = 1

    FOR k = 1 TO 999 DO
        IF k MOD 3 = 0 | k MOD 5 = 0 THEN sum +:= k
    writef("The sum of the multiples of 3 and 5 < 1000 is %d *n", sum)

    writef("Next, the awesome power of inclusion/exclusion...*n");
    FOR i = 1 TO 10 {
        writef("%11d %d *n", n, sum3or5(n - 1))
        n *:= 10
    }

    RESULTIS 0
}
</syntaxhighlight>
{{Out}}
<pre>
The sum of the multiples of 3 and 5 < 1000 is 233168
Next, the awesome power of inclusion/exclusion...
          1 0
         10 23
        100 2318
       1000 233168
      10000 23331668
     100000 2333316668
    1000000 233333166668
   10000000 23333331666668
  100000000 2333333316666668
 1000000000 233333333166666668
</pre>

=={{header|Befunge}}==
Slow (iterative) version:
<syntaxhighlight lang="befunge">&1-:!#v_:3%#v_     >:>#
      >+\:v >:5%#v_^
  @.$_^#! <      >   ^</syntaxhighlight>
{{Out}}
<pre>233168</pre>
Fast (analytic) version:
<syntaxhighlight lang="befunge">&1-::3/:1+*3*2/\5/:1+*5*2/+\96+/:1+*96+*2/-.@</syntaxhighlight>
{{Out}}
<pre>233168</pre>

=={{header|BQN}}==
A naive solution:
<syntaxhighlight lang="bqn">Sum ← +´·(0=3⊸|⌊5⊸|)⊸/↕</syntaxhighlight>

A much faster solution:
<syntaxhighlight lang="bqn">Sum ← {
  m ← (0=3⊸|⌊5⊸|)↕15 ⋄ h‿l ← 15(⌊∘÷˜∾|)𝕩
  (+´l↑m×15(×+↕∘⊣)h) + (15×(+´m)×2÷˜h×h-1) + h×+´m×↕15
}</syntaxhighlight>

{{out}}

<pre>
   Sum 1000
233168
</pre>

([https://mlochbaum.github.io/BQN/try.html#code=U3VtIOKGkCB7CiAgbSDihpAgKDA9M+KKuHzijIo14oq4fCnihpUxNSDii4QgaOKAv2wg4oaQIDE1KOKMiuKImMO3y5ziiL58KfCdlakKICAoK8K0bOKGkW3DlzE1KMOXK+KGleKImOKKoyloKSArICgxNcOXKCvCtG0pw5cyw7fLnGjDl2gtMSkgKyBow5crwrRtw5fihpUxNQp9CgpTdW0gMTAwMAo= online REPL])

=={{header|C}}==
===Simple version===
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>

unsigned long long sum35(unsigned long long limit)
{
    unsigned long long sum = 0;
    for (unsigned long long i = 0; i < limit; i++)
        if (!(i % 3) || !(i % 5))
            sum += i;
    return sum;
}

int main(int argc, char **argv)
{
    unsigned long long limit;

    if (argc == 2)
        limit = strtoull(argv[1], NULL, 10);
    else
        limit = 1000;

    printf("%lld\n", sum35(limit));
    return 0;
}</syntaxhighlight>
{{Out}}
<pre>$ ./a.out
233168
$ ./a.out 12345
35553600</pre>

===Fast version with arbitrary precision===
{{libheader|GMP}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <gmp.h>

void sum_multiples(mpz_t result, const mpz_t limit, const unsigned f)
{
    mpz_t m;
    mpz_init(m);
    mpz_sub_ui(m, limit, 1);
    mpz_fdiv_q_ui(m, m, f);

    mpz_init_set(result, m);
    mpz_add_ui(result, result, 1);
    mpz_mul(result, result, m);
    mpz_mul_ui(result, result, f);
    mpz_fdiv_q_2exp(result, result, 1);

    mpz_clear(m);
}

int main(int argc, char **argv)
{
    mpf_t temp;
    mpz_t limit;

    if (argc == 2)
    {
        mpf_init_set_str(temp, argv[1], 10);
        mpz_init(limit);
        mpz_set_f(limit, temp);
        mpf_clear(temp);
    }
    else
        mpz_init_set_str(limit, "1000000000000000000000", 10);

    mpz_t temp_sum;
    mpz_t sum35;
    
    mpz_init(temp_sum);
    sum_multiples(temp_sum, limit, 3);
    mpz_init_set(sum35, temp_sum);
    sum_multiples(temp_sum, limit, 5);
    mpz_add(sum35, sum35, temp_sum);
    sum_multiples(temp_sum, limit, 15);
    mpz_sub(sum35, sum35, temp_sum);

    mpz_out_str(stdout, 10, sum35);
    puts("");

    mpz_clear(temp_sum);
    mpz_clear(sum35);
    mpz_clear(limit);
    return 0;
}</syntaxhighlight>
{{Out}}
<pre>$ ./a.out 
233333333333333333333166666666666666666668
$ ./a.out 23e45
123433333333333333333333333333333333333333333314166666666666666666666666666666666666666666668</pre>

=={{header|C sharp|C#}}==
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.

<syntaxhighlight lang="csharp">
using System;
using System.Collections.Generic;
using System.Numerics;

namespace RosettaCode
{
    class Program
    {
        static void Main()
        {
            List<BigInteger> candidates = new List<BigInteger>(new BigInteger[] { 1000, 100000, 10000000, 10000000000, 1000000000000000 });
            candidates.Add(BigInteger.Parse("100000000000000000000"));

            foreach (BigInteger candidate in candidates)
            {
                BigInteger c = candidate - 1;
                BigInteger answer3 = GetSumOfNumbersDivisibleByN(c, 3);
                BigInteger answer5 = GetSumOfNumbersDivisibleByN(c, 5);
                BigInteger answer15 = GetSumOfNumbersDivisibleByN(c, 15);

                Console.WriteLine("The sum of numbers divisible by 3 or 5 between 1 and {0} is {1}", c, answer3 + answer5 - answer15);
            }

            Console.ReadKey(true);
        }

        private static BigInteger GetSumOfNumbersDivisibleByN(BigInteger candidate, uint n)
        {
            BigInteger largest = candidate;
            while (largest % n > 0)
                largest--;
            BigInteger totalCount = (largest / n);
            BigInteger pairCount = totalCount / 2;
            bool unpairedNumberOnFoldLine = (totalCount % 2 == 1);
            BigInteger pairSum = largest + n;
            return pairCount * pairSum + (unpairedNumberOnFoldLine ? pairSum / 2 : 0);
        }

    }
}
</syntaxhighlight>
{{out}}
The sum of numbers divisible by 3 or 5 between 1 and 999 is 233168

The sum of numbers divisible by 3 or 5 between 1 and 99999 is 2333316668

The sum of numbers divisible by 3 or 5 between 1 and 9999999 is 23333331666668

The sum of numbers divisible by 3 or 5 between 1 and 9999999999 is 23333333331666666668

The sum of numbers divisible by 3 or 5 between 1 and 999999999999999 is 233333333333333166666666666668

The sum of numbers divisible by 3 or 5 between 1 and 99999999999999999999 is 2333333333333333333316666666666666666668

=={{header|C++}}==
<syntaxhighlight lang="cpp">
#include <iostream>

//--------------------------------------------------------------------------------------------------
typedef unsigned long long bigInt;

using namespace std;
//--------------------------------------------------------------------------------------------------
class m35
{
public:
    void doIt( bigInt i )
    {
	bigInt sum = 0;
	for( bigInt a = 1; a < i; a++ )
	    if( !( a % 3 ) || !( a % 5 ) ) sum += a;

	cout << "Sum is " << sum << " for n = " << i << endl << endl;
    }
	
    // this method uses less than half iterations than the first one
    void doIt_b( bigInt i )
    {
	bigInt sum = 0;
	for( bigInt a = 0; a < 28; a++ )
	{
	    if( !( a % 3 ) || !( a % 5 ) )
	    {
		sum += a;
		for( bigInt s = 30; s < i; s += 30 )
		    if( a + s < i ) sum += ( a + s );

	    }
	}
	cout << "Sum is " << sum << " for n = " << i << endl << endl;
    }
};
//--------------------------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
    m35 m; m.doIt( 1000 );
    return system( "pause" );
}
</syntaxhighlight>
{{out}}
<pre>
Sum is 233168 for n = 1000
</pre>

===Fast version with arbitrary precision===
{{libheader|Boost}}
<syntaxhighlight lang="cpp">#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>

template <typename T> T sum_multiples(T n, T m) {
    n -= T(1);
    n -= n % m;
    return (n / m) * (m + n) / T(2);
}

template <typename T> T sum35(T n) {
    return sum_multiples(n, T(3)) + sum_multiples(n, T(5)) -
           sum_multiples(n, T(15));
}

int main() {
    using big_int = boost::multiprecision::cpp_int;

    std::cout << sum35(1000) << '\n';
    std::cout << sum35(big_int("100000000000000000000")) << '\n';
}</syntaxhighlight>

{{out}}
<pre>
233168
2333333333333333333316666666666666666668
</pre>

=={{header|Clojure}}==
Quick, concise way:
<syntaxhighlight lang="clojure">(defn sum-mults [n & mults]
  (let [pred (apply some-fn
               (map #(fn [x] (zero? (mod x %))) mults))]
    (->> (range n) (filter pred) (reduce +))))

(println (sum-mults 1000 3 5))</syntaxhighlight>

Transducers approach:
<syntaxhighlight lang="clojure">(defn sum-mults [n & mults]
  (transduce (filter (fn [x] (some (fn [mult] (zero? (mod x mult))) mults)))
             + (range n)))

(println (sum-mults 1000 3 5))</syntaxhighlight>

Or optimized (translated from Groovy):
<syntaxhighlight lang="clojure">(defn sum-mul [n f]
  (let [n1 (/' (inc' n) f)]
    (*' f n1 (inc' n1) 1/2)))

(def sum-35 #(-> % (sum-mul 3) (+ (sum-mul % 5)) (- (sum-mul % 15))))
(println (sum-35 1000000000))</syntaxhighlight>

=={{header|COBOL}}==

Using OpenCOBOL.

<syntaxhighlight lang="cobol">
Identification division.
Program-id. three-five-sum.

Data division.
Working-storage section.
01 ws-the-limit  pic 9(18) value 1000.
01 ws-the-number pic 9(18).
01 ws-the-sum    pic 9(18).
01 ws-sum-out    pic z(18).

Procedure division.
Main-program.
    Perform Do-sum
        varying ws-the-number from 1 by 1 
        until ws-the-number = ws-the-limit.
    Move ws-the-sum to ws-sum-out.
    Display "Sum = " ws-sum-out.
    End-run.

Do-sum.
    If function mod(ws-the-number, 3) = zero
       or function mod(ws-the-number, 5) = zero
       then add ws-the-number to ws-the-sum.
</syntaxhighlight>

Output:
<pre>
Sum =             233168
</pre>

Using triangular numbers:
<syntaxhighlight lang="cobol">
Identification division.
Program-id. three-five-sum-fast.

Data division.
Working-storage section.
01 ws-num     pic 9(18) value 1000000000.
01 ws-n5      pic 9(18).
01 ws-n3      pic 9(18).
01 ws-n15     pic 9(18).
01 ws-sum     pic 9(18).
01 ws-out.
    02 ws-out-num pic z(18).
    02 filler pic x(3) value " = ".
    02 ws-out-sum pic z(18).

Procedure division.
Main-program.
    Perform
        call "tri-sum" using ws-num 3  by reference ws-n3
        call "tri-sum" using ws-num 5  by reference ws-n5
        call "tri-sum" using ws-num 15  by reference ws-n15
    end-perform.
    Compute ws-sum = ws-n3 + ws-n5 - ws-n15.
    Move ws-sum to ws-out-sum.
    Move ws-num to ws-out-num.
    Display ws-out.



Identification division.
Program-id. tri-sum.

Data division.
Working-storage section.
01 ws-n1 pic 9(18).
01 ws-n2 pic 9(18).

Linkage section.
77 ls-num pic 9(18).
77 ls-fac pic 9(18).
77 ls-ret pic 9(18).

Procedure division using ls-num, ls-fac, ls-ret.
    Compute ws-n1 = (ls-num - 1) / ls-fac.
    Compute ws-n2 = ws-n1 + 1.
    Compute ls-ret = ls-fac * ws-n1 * ws-n2 / 2.
    goback.
</syntaxhighlight>

Output:
<pre>
        1000000000 = 233333333166666668
</pre>


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)

<syntaxhighlight lang="cobol">
       IDENTIFICATION DIVISION.
       PROGRAM-ID. SUM35.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  THREE-COUNTER   USAGE BINARY-CHAR value 1.
           88 IS-THREE VALUE 3.
       01  FIVE-COUNTER    USAGE BINARY-CHAR value 1.
           88 IS-FIVE VALUE 5.
       01  SUMMER          USAGE BINARY-DOUBLE value zero. 
       01  I               USAGE BINARY-LONG.
       01  N               USAGE BINARY-LONG.

       PROCEDURE DIVISION.
       10-MAIN-PROCEDURE.
           MOVE 1000000000 TO N.
           MOVE 1 TO I.
           PERFORM 20-INNER-LOOP WITH TEST AFTER UNTIL I >= N.
           DISPLAY SUMMER.
           STOP RUN.
       20-INNER-LOOP.
           IF IS-THREE OR IS-FIVE 
               ADD I TO SUMMER END-ADD
               IF IS-THREE
                   MOVE 1 TO THREE-COUNTER
               ELSE
                   ADD 1 TO THREE-COUNTER
               END-IF
               IF IS-FIVE
                   MOVE 1 TO FIVE-COUNTER
               ELSE    
                   ADD 1 TO FIVE-COUNTER
               END-IF
           ELSE
               ADD 1 TO FIVE-COUNTER END-ADD
               ADD 1 TO THREE-COUNTER END-ADD
           END-IF.
           ADD 1 TO I.
           EXIT.
       END PROGRAM SUM35.
</syntaxhighlight>
Output
<pre>+00233333333166666668</pre>

=={{header|Common Lisp}}==
Slow, naive version:
<syntaxhighlight lang="lisp">(defun sum-3-5-slow (limit)
  (loop for x below limit
        when (or (zerop (rem x 3)) (zerop (rem x 5)))
          sum x))</syntaxhighlight>

Fast version (adapted translation of [[#Tcl|Tcl]]):
<syntaxhighlight lang="lisp">(defun sum-3-5-fast (limit)
  (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)))) 
         (* 15 (triangular (truncate n 15)))))))</syntaxhighlight>

{{Out}}
<pre>> (values (sum-3-5-slow 1000) (sum-3-5-fast 1000))
233168 ;
233168
> (sum-3-5-fast 1000000000000000000000)
233333333333333333333166666666666666666668</pre>

=={{header|Component Pascal}}==
BlackBox Component Builder
<syntaxhighlight lang="oberon2">
MODULE Sum3_5;
IMPORT StdLog, Strings, Args;

PROCEDURE DoSum(n: INTEGER):INTEGER;
VAR
	i,sum: INTEGER;
BEGIN
	sum := 0;i := 0;
	WHILE (i < n) DO
		IF  (i MOD 3 = 0) OR (i MOD 5 = 0) THEN INC(sum,i) END;
		INC(i)
	END;
	RETURN sum
END DoSum;

PROCEDURE Compute*;
VAR
	params: Args.Params;
	i,n,res: INTEGER;
BEGIN
	Args.Get(params);
	Strings.StringToInt(params.args[0],n,res);
	StdLog.String("Sum: ");StdLog.Int(DoSum(n)); StdLog.Ln
END Compute;

END Sum3_5.
</syntaxhighlight>
Execute: ^Q Sum3_5.Compute 1000 ~ <br/>
Output:
<pre>
Sum:  233168
</pre>

=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";

# sum multiples up to given input
interface SumMulTo(mul: uint32, to: uint32): (rslt: uint32);

# naive implementation
sub naiveSumMulTo implements SumMulTo is
    rslt := 0;
    var cur := mul;
    while cur < to loop
        rslt := rslt + cur;
        cur := cur + mul;
    end loop;
end sub;

# number theoretical implementation
sub fastSumMulTo implements SumMulTo is
    to := (to - 1)/mul;
    rslt := mul * to * (to + 1)/2;
end sub;

# sum multiples of 3 and 5 up to given number using given method
sub sum35(to: uint32, sum: SumMulTo): (rslt: uint32) is
    rslt := sum(3, to) + sum(5, to) - sum(15, to);
end sub;

print("Naive method: "); print_i32(sum35(1000, naiveSumMulTo)); print_nl();
print("Fast method:  "); print_i32(sum35(1000, fastSumMulTo)); print_nl();
</syntaxhighlight>

{{out}}

<pre>Naive method: 233168
Fast method:  233168</pre>

=={{header|Crystal}}==
{{trans|Ruby}}
Short, but not optimized.
<syntaxhighlight lang="ruby">def sum_3_5_multiples(n)
  (0...n).select { |i| i % 3 == 0 || i % 5 == 0 }.sum
end

puts sum_3_5_multiples(1000)</syntaxhighlight>
{{out}}
<pre>
233168
</pre>

Alternative fast version 1.
The Ruby version sums up to and including n.
To conform to task requirements, and other versions,
modified to find sums below n.
<syntaxhighlight lang="ruby">require "big"

def g(n1, n2, n3)
   g1 = n1*n2; n3 -= 1
   (1..g1).select{|x| x%n1==0 || x%n2==0}.map{|x| g2=(n3-x)//g1; (x+g1*g2+x)*(g2+1)}.sum // 2
end

puts g(3,5,999)
puts g(3,5,1000)
 
# For extra credit
puts g(3,5,"100000000000000000000".to_big_i - 1)
puts g(3,5,"100000000000000000000".to_big_i)</syntaxhighlight>
{{out}}
<pre>
232169
233168
2333333333333333333216666666666666666669
2333333333333333333316666666666666666668
</pre>

Alternative faster version 2.
<syntaxhighlight lang="ruby">require "big"

def sumMul(n, f)
  n1 = (n.to_big_i - 1) // f  # number of multiples of f < n
  f * n1 * (n1 + 1) // 2      # f * (sum of number of multiples)
end
 
def sum35(n)
  sumMul(n, 3) + sumMul(n, 5) - sumMul(n, 15)
end
 
(1..20).each do |e| limit = 10.to_big_i ** e
  puts "%2d:%22d %s" % [e, limit, sum35(limit)]
end</syntaxhighlight>
{{out}}
<pre>
 1:                    10 23
 2:                   100 2318
 3:                  1000 233168
 4:                 10000 23331668
 5:                100000 2333316668
 6:               1000000 233333166668
 7:              10000000 23333331666668
 8:             100000000 2333333316666668
 9:            1000000000 233333333166666668
10:           10000000000 23333333331666666668
11:          100000000000 2333333333316666666668
12:         1000000000000 233333333333166666666668
13:        10000000000000 23333333333331666666666668
14:       100000000000000 2333333333333316666666666668
15:      1000000000000000 233333333333333166666666666668
16:     10000000000000000 23333333333333331666666666666668
17:    100000000000000000 2333333333333333316666666666666668
18:   1000000000000000000 233333333333333333166666666666666668
19:  10000000000000000000 23333333333333333331666666666666666668
20: 100000000000000000000 2333333333333333333316666666666666666668
</pre>

=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio, std.bigint;

BigInt sum35(in BigInt n) pure nothrow {
    static BigInt sumMul(in BigInt n, in int f) pure nothrow {
        immutable n1 = (f==n?n:(n - 1) ) / f;
        return f * n1 * (n1 + 1) / 2;
    }

    return sumMul(n, 3) + sumMul(n, 5) - sumMul(n, 15);
}

void main() {
    1.BigInt.sum35.writeln;
    3.BigInt.sum35.writeln;
    5.BigInt.sum35.writeln;
    1000.BigInt.sum35.writeln;
    (10.BigInt ^^ 20).sum35.writeln;
}</syntaxhighlight>
{{out}}
<pre>
0
3
8
233168
2333333333333333333316666666666666666668</pre>

=={{header|dc}}==
<syntaxhighlight lang="dc">[ Sm Sn lm 1 - d ln % - d sm ln / ln lm + * 0k 2 / Ss Lm sx Ln sx Ls ]sm

[ d d d 3 r lmx r 5 r lmx + r 15 r lmx - ]ss

[ 27 P 91 P 65 P 27 P 91 P 50 P 50 P 67 P ]su

[ ll p lsx lux p ll 10 * d sl 1000000000000000000000 >d]sd

1 sl ldx</syntaxhighlight>

{{Out}}
<pre>1                     0
10                    23
100                   2318
1000                  233168
10000                 23331668
100000                2333316668
1000000               233333166668
10000000              23333331666668
100000000             2333333316666668
1000000000            233333333166666668
10000000000           23333333331666666668
100000000000          2333333333316666666668
1000000000000         233333333333166666666668
10000000000000        23333333333331666666666668
100000000000000       2333333333333316666666666668
1000000000000000      233333333333333166666666666668
10000000000000000     23333333333333331666666666666668
100000000000000000    2333333333333333316666666666666668
1000000000000000000   233333333333333333166666666666666668
10000000000000000000  23333333333333333331666666666666666668
100000000000000000000 2333333333333333333316666666666666666668</pre>
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">program sum35;

{$APPTYPE CONSOLE}

var
  sum: integer;
  i: integer;

function isMultipleOf(aNumber, aDivisor: integer): boolean;
begin
  result := aNumber mod aDivisor = 0
end;

begin
  sum := 0;
  for i := 3 to 999 do
  begin
    if isMultipleOf(i, 3) or isMultipleOf(i, 5) then
      sum := sum + i;
  end;
  writeln(sum);
end.</syntaxhighlight>
{{out}}
<pre>233168</pre>

=={{header|Déjà Vu}}==
<syntaxhighlight lang="dejavu">sum-divisible n:
	0
	for i range 1 -- n:
		if or = 0 % i 3 = 0 % i 5:
			+ i

!. sum-divisible 1000</syntaxhighlight>
{{out}}
<pre>233168</pre>

=={{header|EasyLang}}==
<syntaxhighlight>
func msum35 n .
   for i = 1 to n
      if i mod 3 = 0 or i mod 5 = 0
         sum += i
      .
   .
   return sum
.
print msum35 999
</syntaxhighlight>

=={{header|EchoLisp}}==
<syntaxhighlight lang="scheme">
(lib 'math) ;; divides?
(lib 'sequences) ;; sum/when

(define (task n  (k 3)  (p 5 ))
	 (when (!= (gcd k p) 1) (error "expected coprimes" (list k p)))
		(- 
	 	(+ (sum/mults n k) (sum/mults n p)) ;; add multiples of k , multiples of p
	 	(sum/mults n (* k p)))) ;; remove multiples of k * p

;; using sequences
;; sum of multiples of k < n 

(define (sum/mults n k)
	(sum/when (rcurry divides? k) [1 .. n]))

(task 1000 3 5)
    → 233168

;; using simple arithmetic - 🎩 young Gauss formula
;; sum of multiples of k < n  = 
;; k*m*(m+1)/2 where m = floor(n/k)
(lib 'bigint)

(define (sum/mults n k)
	(set! n (quotient (1- n) k))
	(/ (* k n (1+ n )) 2))

(task 1e20 3 5)
    → 2333333333333333333316666666666666666668

(task 1000 42 666)
    ❌ error: expected coprimes (42 666)
		
</syntaxhighlight>

=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">

class
	APPLICATION

create
	make

feature {NONE}

	make
		do
			io.put_integer (sum_multiples (1000))
		end

	sum_multiples (n: INTEGER): INTEGER
			-- Sum of all positive multiples of 3 or 5 below 'n'.
		do
			across
				1 |..| (n - 1) as c
			loop
				if c.item \\ 3 = 0 or c.item \\ 5 = 0 then
					Result := Result + c.item
				end
			end
		end

end

</syntaxhighlight>
{{out}}
<pre>
233168
</pre>

=={{header|Elixir}}==
Simple (but slow)
<syntaxhighlight lang="elixir">iex(1)> Enum.filter(0..1000-1, fn x -> rem(x,3)==0 or rem(x,5)==0 end) |> Enum.sum
233168</syntaxhighlight>

Fast version:
{{trans|Ruby}}
<syntaxhighlight lang="elixir">defmodule RC do
  def sumMul(n, f) do
    n1 = div(n - 1, f)
    div(f * n1 * (n1 + 1), 2)
  end
  
  def sum35(n) do
    sumMul(n, 3) + sumMul(n, 5) - sumMul(n, 15)
  end
end

Enum.each(1..20, fn i ->
  n = round(:math.pow(10, i))
  IO.puts RC.sum35(n)
end)</syntaxhighlight>

{{out}}
<pre>
23
2318
233168
23331668
2333316668
233333166668
23333331666668
2333333316666668
233333333166666668
23333333331666666668
2333333333316666666668
233333333333166666666668
23333333333331666666666668
2333333333333316666666666668
233333333333333166666666666668
23333333333333331666666666666668
2333333333333333316666666666666668
233333333333333333166666666666666668
23333333333333333331666666666666666668
2333333333333333333316666666666666666668
</pre>

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

Vanilla:

<syntaxhighlight lang="lisp">(defun sum-3-5 (n)
  (let ((sum 0))
    (dotimes (x n)
      (when (or (zerop (% x 3)) (zerop (% x 5)))
        (setq sum (+ sum x))))
    sum))</syntaxhighlight>

{{libheader|seq.el}}
<syntaxhighlight lang="lisp">(defun sum-3-5 (n)
  (apply #'+ (seq-filter
	      (lambda (x) (or (zerop (% x 3) ) (zerop (% x 5))))
	      (number-sequence 1 (- n 1)))))</syntaxhighlight>

=={{header|Erlang}}==
<syntaxhighlight lang="erlang">sum_3_5(X) when is_number(X) -> sum_3_5(erlang:round(X)-1, 0).
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+X);
sum_3_5(X, Total) ->
  sum_3_5(X-1, Total).

io:format("~B~n", [sum_3_5(1000)]).</syntaxhighlight>

{{out}}
<pre>233168</pre>

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
let sum35 n = Seq.init n (id) |> Seq.reduce (fun sum i -> if i % 3 = 0 || i % 5 = 0 then sum + i else sum)

printfn "%d" (sum35 1000)
printfn "----------"

let sumUpTo (n : bigint) = n * (n + 1I) / 2I

let sumMultsBelow k n = k * (sumUpTo ((n-1I)/k))

let sum35fast n = (sumMultsBelow 3I n) + (sumMultsBelow 5I n) - (sumMultsBelow 15I n)

[for i = 0 to 30 do yield i]
|> List.iter (fun i -> printfn "%A" (sum35fast (bigint.Pow(10I, i))))</syntaxhighlight>
{{out}}
<pre style="height:5em">233168
----------
0
23
2318
233168
23331668
2333316668
233333166668
23333331666668
2333333316666668
233333333166666668
23333333331666666668
2333333333316666666668
233333333333166666666668
23333333333331666666666668
2333333333333316666666666668
233333333333333166666666666668
23333333333333331666666666666668
2333333333333333316666666666666668
233333333333333333166666666666666668
23333333333333333331666666666666666668
2333333333333333333316666666666666666668
233333333333333333333166666666666666666668
23333333333333333333331666666666666666666668
2333333333333333333333316666666666666666666668
233333333333333333333333166666666666666666666668
23333333333333333333333331666666666666666666666668
2333333333333333333333333316666666666666666666666668
233333333333333333333333333166666666666666666666666668
23333333333333333333333333331666666666666666666666666668
2333333333333333333333333333316666666666666666666666666668
233333333333333333333333333333166666666666666666666666666668</pre>

=={{header|Factor}}==
This solution is based on the following formula to find the sum of an arithmetic sequence:<br><br>
<code>n/2 * (2 * a + (n - 1) * d)</code><br><br>
&nbsp; &nbsp; '''where'''
* <code>a</code> is the first term
* <code>d</code> is the common difference between terms
* <code>n</code> is how many terms to add up
<br>
{{works with|Factor|0.99 2019-10-06}}
<syntaxhighlight lang="factor">USING: kernel math prettyprint ;

: sum-multiples ( m n upto -- sum )
    >integer 1 - [ 2dup * ] dip
    [ 2dup swap [ mod - + ] [ /i * 2/ ] 2bi ] curry tri@
    [ + ] [ - ] bi* ;

3 5 1000 sum-multiples .
3 5 1e20 sum-multiples .</syntaxhighlight>
{{out}}
<pre>
233168
2333333333333333333316666666666666666668
</pre>

=={{header|FBSL}}==
Derived from BASIC version
<syntaxhighlight lang="qbasic">#APPTYPE CONSOLE

FUNCTION sumOfThreeFiveMultiples(n AS INTEGER)
    DIM sum AS INTEGER
    FOR DIM i = 1 TO n - 1
        IF (NOT (i MOD 3)) OR (NOT (i MOD 5)) THEN
            INCR(sum, i)
        END IF
    NEXT
    RETURN sum
END FUNCTION

PRINT sumOfThreeFiveMultiples(1000)
PAUSE
</syntaxhighlight>
Output
<pre>233168

Press any key to continue...
</pre>

=={{header|Forth}}==
<syntaxhighlight lang="forth">: main ( n -- )
  0 swap
  3 do
    i 3 mod 0= if
      i +
    else i 5 mod 0= if
      i +
    then then
  loop
  . ;

1000 main    \ 233168  ok</syntaxhighlight>

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.

<syntaxhighlight lang="forth">: third  2 pick ;

: >dtriangular ( n -- d )
    dup 1+ m* d2/ ;

: sumdiv ( n m -- d )
    dup >r / >dtriangular r> 1 m*/ ;

: sumdiv_3,5 ( n -- n )
    dup 3 sumdiv third 5 sumdiv d+ rot 15 sumdiv d- ;

: euler1 ( -- n )
    999 sumdiv_3,5 drop ;

: euler1tower ( -- )
    1  \ power of 10
    19 0 DO
        cr dup 19 .r space dup 1- sumdiv_3,5 d.
        10 *
    LOOP drop ;

euler1 . 233168  ok
euler1tower 
                  1 0 
                 10 23 
                100 2318 
               1000 233168 
              10000 23331668 
             100000 2333316668 
            1000000 233333166668 
           10000000 23333331666668 
          100000000 2333333316666668 
         1000000000 233333333166666668 
        10000000000 23333333331666666668 
       100000000000 2333333333316666666668 
      1000000000000 233333333333166666666668 
     10000000000000 23333333333331666666666668 
    100000000000000 2333333333333316666666666668 
   1000000000000000 233333333333333166666666666668 
  10000000000000000 23333333333333331666666666666668 
 100000000000000000 2333333333333333316666666666666668 
1000000000000000000 233333333333333333166666666666666668  ok
</syntaxhighlight>

=={{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.
<syntaxhighlight lang="fortran">
      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.
       INTEGER*8 N	!The number. Possibly large.
        IF (MOD(N,2).EQ.0) THEN	!So, I'm worried about overflow with N*(N + 1)
          SUMI = N/2*(N + 1)		!But since N is even, N/2 is good.
         ELSE			!Otherwise, if N is odd,
          SUMI = (N + 1)/2*N		!(N + 1) must be even.
        END IF			!Either way, the /2 reduces the result.
      END FUNCTION SUMI		!So overflow of intermediate results is avoided.

      INTEGER*8 FUNCTION SUMF(N,F)	!Sum of numbers up to N divisible by F.
       INTEGER*8 N,F		!The selection.
       INTEGER*8 L		!The last in range. N itself is excluded.
       INTEGER*8 SUMI		!Known type of the function.
        L = (N - 1)/F		!Truncates fractional parts.
        SUMF = F*SUMI(L)	!3 + 6 + 9 + ... = 3(1 + 2 + 3 + ...)
      END FUNCTION SUMF		!Could just put SUMF = F*SUMI((N - 1)/F).

      INTEGER*8 FUNCTION SUMBFI(N)	!Brute force and ignorance summation.
       INTEGER*8 N	!The number.
       INTEGER*8 I,S	!Stepper and counter.
        S = 0		!So, here we go.
        DO I = 3,N - 1	!N itself is not a candidate.
          IF (MOD(I,3).EQ.0 .OR. MOD(I,5).EQ.0) S = S + I	!Whee!
        END DO		!On to the next.
        SUMBFI = S		!The result.
      END FUNCTION SUMBFI	!Oh well, computers are fast these days.

      INTEGER*8 SUMF,SUMBFI	!Known type of the function.
      INTEGER*8 N	!The number.
      WRITE (6,*) "Sum multiples of 3 and 5 up to N"
   10 WRITE (6,11)		!Ask nicely.
   11 FORMAT ("Specify N: ",$)	!Obviously, the $ says 'stay on this line'.
      READ (5,*) N		!If blank input is given, further input will be requested.
      IF (N.LE.0) STOP		!Good enough.
      WRITE (6,*) "By Gauss:",SUMF(N,3) + SUMF(N,5) - SUMF(N,15)
      WRITE (6,*) "BFI sum :",SUMBFI(N)		!This could be a bit slow.
      GO TO 10			!Have another go.
      END	!So much for that.
</syntaxhighlight>
Sample output:
<pre>
 Sum multiples of 3 and 5 up to N
Specify N: 1000
 By Gauss:                233168
 BFI sum :                233168
Specify N: 1001
 By Gauss:                234168
 BFI sum :                234168
Specify N: 1002
 By Gauss:                234168
 BFI sum :                234168
Specify N: 1003
 By Gauss:                235170
 BFI sum :                235170
Specify N: 1000000000
 By Gauss:    233333333166666668
 BFI sum :    233333333166666668
</pre>
The result for a thousand million took about a minute for the brute-force-and-ignorance calculation. For much larger values of N, it should be discarded! Integer overflow even for 64-bit integers impends. The calculations could be conducted in double precision (or better, quadruple precision), a trivial modification to the source. Precise results would require the introduction of multi-precision arithmetic.

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

Function sum35 (n As UInteger) As UInteger
  If n = 0 Then Return 0
  Dim As UInteger i, sum = 0
  For i = 1 To n
    If (i Mod 3 = 0) OrElse (i Mod 5 = 0) Then sum += i
  Next
  Return sum 
End Function

Print "Sum of positive integers below 1000 divisible by 3 or 5 is : "; sum35(999)
Print
Print "Press any key to quit"
Sleep</syntaxhighlight>

{{out}}
<pre>
Sum of positive integers below 1000 divisible by 3 or 5 is : 233168
</pre>

=={{header|Frink}}==
Program has a brute-force approach for n=1000, and also inclusion/exclusion for larger values.
<syntaxhighlight lang="frink">
sum999 = sum[select[1 to 999, {|n| n mod 3 == 0 or n mod 5 == 0}]]

sumdiv[n, d] :=
{
    m = floor[n/d]
    m(m + 1)/2 d
}

sum35big[n] := sumdiv[n, 3] + sumdiv[n, 5] - sumdiv[n, 15]

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]]
</syntaxhighlight>
{{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|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"

_n = 1000

void local fn DoIt
  long i, sum = 0
  
  for i = 0 to _n - 1
    if ( i mod 3 == 0 or i mod 5 == 0 )
      sum += i
    end if
  next
  NSLog(@"%ld",sum)
end fn

fn Doit

HandleEvents
</syntaxhighlight>

{{out}}
<pre>
233168
</pre>

=={{header|Go}}==
<syntaxhighlight lang="go">package main

import "fmt"

func main() {
    fmt.Println(s35(1000))
}

func s35(n int) int {
    n--
    threes := n / 3
    fives := n / 5
    fifteen := n / 15

    threes = 3 * threes * (threes + 1)
    fives = 5 * fives * (fives + 1)
    fifteen = 15 * fifteen * (fifteen + 1)

    n = (threes + fives - fifteen) / 2
	
    return n
}</syntaxhighlight>
{{out}}
<pre>
233168
</pre>
Extra credit:
<syntaxhighlight lang="go">package main

import (
    "fmt"
    "math/big"
)

var (
    b1  = big.NewInt(1)
    b3  = big.NewInt(3)
    b5  = big.NewInt(5)
    b10 = big.NewInt(10)
    b15 = big.NewInt(15)
    b20 = big.NewInt(20)
)

func main() {
    fmt.Println(s35(new(big.Int).Exp(b10, b3, nil)))
    fmt.Println(s35(new(big.Int).Exp(b10, b20, nil)))
}

func s35(i *big.Int) *big.Int {
    j := new(big.Int).Sub(i, b1)
    sum2 := func(d *big.Int) *big.Int {
        n := new(big.Int).Quo(j, d)
        p := new(big.Int).Add(n, b1)
        return p.Mul(d, p.Mul(p, n))
    }
    s := sum2(b3)
    return s.Rsh(s.Sub(s.Add(s, sum2(b5)), sum2(b15)), 1)
}</syntaxhighlight>
{{out}}
<pre>
233168
2333333333333333333316666666666666666668
</pre>

=={{header|Groovy}}==
<syntaxhighlight lang="groovy">def sumMul = { n, f -> BigInteger n1 = (n - 1) / f; f * n1 * (n1 + 1) / 2 }
def sum35 = { sumMul(it, 3) + sumMul(it, 5) - sumMul(it, 15) }</syntaxhighlight>
Test Code:
<syntaxhighlight lang="groovy">[(1000): 233168, (10e20): 233333333333333333333166666666666666666668].each { arg, value ->
    println "Checking $arg == $value"
    assert sum35(arg) == value
}</syntaxhighlight>
{{out}}
<pre>Checking 1000 == 233168
Checking 1.0E+21 == 233333333333333333333166666666666666666668</pre>

=={{header|Haskell}}==
Also a method for calculating sum of multiples of any list of numbers.
<syntaxhighlight lang="haskell">import Data.List (nub)

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

sum35 :: Integer -> Integer
sum35 n = f 3 + f 5 - f 15
  where
    f = sumMul n

sumMul :: Integer -> Integer -> Integer
sumMul n f = f * n1 * (n1 + 1) `div` 2
  where
    n1 = (n - 1) `div` f


--------------------------- TEST -------------------------
main :: IO ()
main =
  mapM_
    print
    [ sum35 1000,
      sum35 100000000000000000000000000000000,
      sumMulS 1000 [3, 5],
      sumMulS 10000000 [2, 3, 5, 7, 11, 13]
    ]

---------------- FOR VARIABLE LENGTH INPUTS --------------

pairLCM :: [Integer] -> [Integer]
pairLCM [] = []
pairLCM (x : xs) = (lcm x <$> xs) <> pairLCM xs

sumMulS :: Integer -> [Integer] -> Integer
sumMulS _ [] = 0
sumMulS n s =
  ( ((-) . sum . fmap f)
      <*> (g . pairLCM)
  )
    (nub s)
  where
    f = sumMul n
    g = sumMulS n</syntaxhighlight>
{{out}}
<pre>233168
2333333333333333333333333333333316666666666666666666666666666668
233168
41426953573049</pre>

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

The following works in both langauges.

<syntaxhighlight lang="unicon">procedure main(A)
    n := (integer(A[1]) | 1000)-1
    write(sum(n,3)+sum(n,5)-sum(n,15))
end

procedure sum(n,m)
    return m*((n/m)*(n/m+1)/2)
end</syntaxhighlight>

Sample output:

<pre>
->sm35
233168
->sm35 100000000000000000000
2333333333333333333316666666666666666668
->
</pre>

=={{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.
<syntaxhighlight lang="j">
NB. Naive method
NB. joins two lists of the multiples of 3 and 5, then uses the ~. operator to remove duplicates.
echo 'The sum of the multiples of 3 or 5 < 1000 is ', ": +/ ~. (3*i.334), (5*i.200)

NB. slightly less naive: select the numbers which have no remainder when divided by 3 or 5:
echo 'The sum of the multiples of 3 or 5 < 1000 is still ', ": +/I.+./0=3 5|/i.1000



NB. inclusion/exclusion

triangular =: -:@:(*: + 1&*)
sumdiv =: dyad define
    (triangular <. x % y) * y
)

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

</syntaxhighlight>
{{Out}}
<pre>
The sum of the multiples of 3 or 5 < 1000 is 233168
The sum of the multiples of 3 or 5 < 1000 is still 233168
For 10^20 - 1, the sum is 2333333333333333333316666666666666666668
</pre>

=={{header|Java}}==
===Simple Version===
<syntaxhighlight lang="java">class SumMultiples {
	public static long getSum(long n) {
		long sum = 0;
		for (int i = 3; i < n; i++) {
			if (i % 3 == 0 || i % 5 == 0) sum += i;
		}
		return sum;
	}
	public static void main(String[] args) {
		System.out.println(getSum(1000));
	}
}</syntaxhighlight>
{{out}}
<pre>233168</pre>
===Extra Credit===
<syntaxhighlight lang="java">
import java.math.BigInteger;

public class SumMultiples {

    public static void main(String[] args) {
        BigInteger m1 = BigInteger.valueOf(3);
        BigInteger m2 = BigInteger.valueOf(5);
        for ( int i = 1 ; i <= 25 ; i++ ) {
            BigInteger limit = BigInteger.valueOf(10).pow(i);
            System.out.printf("Limit = 10^%d, answer = %s%n", i, sumMultiples(limit.subtract(BigInteger.ONE), m1, m2));
        }
    }

    //  Use Inclusion - Exclusion
    private static BigInteger sumMultiples(BigInteger max, BigInteger n1, BigInteger n2) {
        return sumMultiple(max, n1).add(sumMultiple(max, n2)).subtract(sumMultiple(max, n1.multiply(n2)));
    }
    
    private static BigInteger sumMultiple(BigInteger max, BigInteger m) {
        BigInteger maxDivM = max.divide(m);
        return m.multiply(maxDivM.multiply(maxDivM.add(BigInteger.ONE))).divide(BigInteger.valueOf(2));
    }
    
    //  Used for testing
    @SuppressWarnings("unused")
    private static long sumMultiples(long max, long n1, long n2) {
        return sumMultiple(max, n1) + sumMultiple(max, n2) - sumMultiple(max, n1 * n2);
    }
    
    private static long sumMultiple(long max, long n) {
        long sum = 0;
        for ( int i = 1 ; i <= max ; i++ ) {
            if ( i % n == 0 ) {
                sum += i;
            }
        }
        return sum;
    }

}
</syntaxhighlight>
{{out}}
<pre>
Limit = 10^1, answer = 23
Limit = 10^2, answer = 2318
Limit = 10^3, answer = 233168
Limit = 10^4, answer = 23331668
Limit = 10^5, answer = 2333316668
Limit = 10^6, answer = 233333166668
Limit = 10^7, answer = 23333331666668
Limit = 10^8, answer = 2333333316666668
Limit = 10^9, answer = 233333333166666668
Limit = 10^10, answer = 23333333331666666668
Limit = 10^11, answer = 2333333333316666666668
Limit = 10^12, answer = 233333333333166666666668
Limit = 10^13, answer = 23333333333331666666666668
Limit = 10^14, answer = 2333333333333316666666666668
Limit = 10^15, answer = 233333333333333166666666666668
Limit = 10^16, answer = 23333333333333331666666666666668
Limit = 10^17, answer = 2333333333333333316666666666666668
Limit = 10^18, answer = 233333333333333333166666666666666668
Limit = 10^19, answer = 23333333333333333331666666666666666668
Limit = 10^20, answer = 2333333333333333333316666666666666666668
Limit = 10^21, answer = 233333333333333333333166666666666666666668
Limit = 10^22, answer = 23333333333333333333331666666666666666666668
Limit = 10^23, answer = 2333333333333333333333316666666666666666666668
Limit = 10^24, answer = 233333333333333333333333166666666666666666666668
Limit = 10^25, answer = 23333333333333333333333331666666666666666666666668
</pre>

=={{header|JavaScript}}==

===ES5===

JavaScript is better equipped for flexibility than for scale. The value of  <syntaxhighlight lang="javascript"> Number.MAX_SAFE_INTEGER</syntaxhighlight> is 9007199254740991, or 2^53 - 1 – resulting from an IEEE 754 double-precision floating point representation of numeric values).

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:

<syntaxhighlight lang="javascript">(function (lstFactors, intExponent) {

    // [n] -> n -> n
    function sumMultiplesBelow(lstIntegers, limit) {
        return range(1, limit - 1).filter(function (x) {
            return isMultiple(lstIntegers, x);
        }).reduce(function (a, n) {
            return a + n;
        }, 0)
    }

    // [n] -> n -> bool
    function isMultiple(lst, n) {
        var i = lng;
        while (i--)
            if (n % (lst[i]) === 0) return true;
        return false;
    }

    // [m..n]
    function range(m, n) {
        var a = Array(n - m + 1),
            i = n + 1;
        while (i--) a[i - 1] = i;
        return a;
    }


    /*      TESTING     */

    // [[a]] -> bool -> s -> s
    function wikiTable(lstRows, blnHeaderRow, strStyle) {
        return '{| class="wikitable" ' + (
            strStyle ? 'style="' + strStyle + '"' : ''
        ) + lstRows.map(function (lstRow, iRow) {
            var strDelim = ((blnHeaderRow && !iRow) ? '!' : '|');

            return '\n|-\n' + strDelim + ' ' + lstRow.map(function (v) {
                return typeof v === 'undefined' ? ' ' : v;
            }).join(' ' + strDelim + strDelim + ' ');
        }).join('') + '\n|}';
    }

    var lng = lstFactors.length,
        lstSorted = lstFactors.slice(0).sort();

    var lstTable = [['Below', 'Sum']].concat(
        range(1, intExponent).map(function (x) {
            var pwr = Math.pow(10, x);

            return ['10^' + x, sumMultiplesBelow(lstSorted, pwr)];
        })
    );

    return 'For ' + JSON.stringify(lstFactors) + ':\n\n' +
        wikiTable(lstTable, true) + '\n\n' +
        JSON.stringify(lstTable);

})([3, 5], 8);</syntaxhighlight>


For [3,5]:

{| class="wikitable" 
|-
! Below !! Sum
|-
| 10^1 || 23
|-
| 10^2 || 2318
|-
| 10^3 || 233168
|-
| 10^4 || 23331668
|-
| 10^5 || 2333316668
|-
| 10^6 || 233333166668
|-
| 10^7 || 23333331666668
|-
| 10^8 || 2333333316666668
|}

<syntaxhighlight lang="javascript"> [["Below","Sum"],["10^1",23],["10^2",2318],["10^3",233168],
 ["10^4",23331668],["10^5",2333316668],["10^6",233333166668],
 ["10^7",23333331666668],["10^8",2333333316666668]]</syntaxhighlight>
====With wheel increments====
<syntaxhighlight lang="javascript">function sm35(n){
	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
}</syntaxhighlight>
====With triangular numbers====
<syntaxhighlight lang="javascript">function sm35(n){
	return tri(n,3) + tri(n,5) - tri(n,15)
	function tri(n, f) {
		n = Math.floor((n-1) / f)
		return f * n * (n+1) / 2
	}
}</syntaxhighlight>
'''This:'''
<syntaxhighlight lang="javascript">for (var i=1, n=10; i<9; n*=10, i+=1) {
	document.write(10, '<sup>', i, '</sup> ',  sm35(n), '<br>')
}</syntaxhighlight>
{{out}}
 10<sup>1</sup> 23
 10<sup>2</sup> 2318
 10<sup>3</sup> 233168
 10<sup>4</sup> 23331668
 10<sup>5</sup> 2333316668
 10<sup>6</sup> 233333166668
 10<sup>7</sup> 23333331666668
 10<sup>8</sup> 2333333316666668


===ES6===

<syntaxhighlight lang="javascript">(() => {

    // sum35 :: Int -> Int
    const sum35 = n => {
        // The sum of all positive multiples of
        // 3 or 5 below n.
        const f = sumMults(n);
        return f(3) + f(5) - f(15);
    };


    // sumMults :: Int -> Int -> Int
    const sumMults = n =>
        // Area under straight line
        // between first multiple and last.
        factor => {
            const n1 = quot(n - 1)(factor);
            return quot(factor * n1 * (n1 + 1))(2);
        };

    // ------------------------- TEST --------------------------

    // main :: IO ()
    const main = () =>
        fTable('Sums for n = 10^1 thru 10^8:')(str)(str)(
            sum35
        )(
            enumFromTo(1)(8)
            .map(n => Math.pow(10, n))
        );


    // ------------------------ GENERIC ------------------------

    // enumFromTo :: Int -> Int -> [Int]
    const enumFromTo = m =>
        n => !isNaN(m) ? (
            Array.from({
                length: 1 + n - m
            }, (_, i) => m + i)
        ) : enumFromTo_(m)(n);


    // quot :: Int -> Int -> Int
    const quot = n =>
        m => Math.floor(n / m);


    // ------------------------ DISPLAY ------------------------

    // compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
    const compose = (...fs) =>
        // A function defined by the right-to-left
        // composition of all the functions in fs.
        fs.reduce(
            (f, g) => x => f(g(x)),
            x => x
        );


    // fTable :: String -> (a -> String) -> (b -> String)
    //                      -> (a -> b) -> [a] -> String
    const fTable = s =>
        // Heading -> x display function ->
        //           fx display function ->
        //    f -> values -> tabular string
        xShow => fxShow => f => xs => {
            const
                ys = xs.map(xShow),
                w = Math.max(...ys.map(length));
            return s + '\n' + zipWith(
                a => b => a.padStart(w, ' ') + ' -> ' + b
            )(ys)(
                xs.map(x => fxShow(f(x)))
            ).join('\n');
        };


    // length :: [a] -> Int
    const length = xs =>
        // Returns Infinity over objects without finite
        // length. This enables zip and zipWith to choose
        // the shorter argument when one is non-finite,
        // like cycle, repeat etc
        'GeneratorFunction' !== xs.constructor.constructor.name ? (
            xs.length
        ) : Infinity;


    // list :: StringOrArrayLike b => b -> [a]
    const list = xs =>
        // xs itself, if it is an Array,
        // or an Array derived from xs.
        Array.isArray(xs) ? (
            xs
        ) : Array.from(xs);


    // str :: a -> String
    const str = x =>
        Array.isArray(x) && x.every(
            v => ('string' === typeof v) && (1 === v.length)
        ) ? (
            x.join('')
        ) : x.toString();


    // take :: Int -> [a] -> [a]
    // take :: Int -> String -> String
    const take = n =>
        // The first n elements of a list,
        // string of characters, or stream.
        xs => 'GeneratorFunction' !== xs
        .constructor.constructor.name ? (
            xs.slice(0, n)
        ) : [].concat.apply([], Array.from({
            length: n
        }, () => {
            const x = xs.next();
            return x.done ? [] : [x.value];
        }));


    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
    const zipWith = f =>
        // Use of `take` and `length` here allows zipping with non-finite lists
        // i.e. generators like cycle, repeat, iterate.
        xs => ys => {
            const n = Math.min(length(xs), length(ys));
            return (([as, bs]) => Array.from({
                length: n
            }, (_, i) => f(as[i])(
                bs[i]
            )))([xs, ys].map(
                compose(take(n), list)
            ));
        };

    // ---
    return main();
})();</syntaxhighlight>
{{Out}}
<pre>Sums for n = 10^1 thru 10^8:
       10 -> 23
      100 -> 2318
     1000 -> 233168
    10000 -> 23331668
   100000 -> 2333316668
  1000000 -> 233333166668
 10000000 -> 23333331666668
100000000 -> 2333333316666668</pre>

=={{header|Joy}}==
<syntaxhighlight lang="jq">
DEFINE divisor == rem 0 = ;
       mul3or5 == [3 divisor] [5 divisor] cleave or ;
       when == swap [] ifte .

"The sum of the multiples of 3 or 5 below 1000 is " putchars

0 999 [0 =] [pop]
[
   [dup rollup + swap] [mul3or5] when
   pred
] tailrec .
</syntaxhighlight>
{{Out}}
<pre>
The sum of the multiples of 3 or 5 below 1000 is 233168
</pre>
=={{header|jq}}==
<syntaxhighlight lang="jq">
def sum_multiples(d):
 ((./d) | floor) |  (d * . * (.+1))/2 ;

# Sum of multiples of a or b that are less than . (the input)
def task(a;b):
 . - 1
 | sum_multiples(a) + sum_multiples(b) - sum_multiples(a*b);</syntaxhighlight>Examples:

jq does not (yet) support arbitrary-precision integer arithmetic but converts large integers to floats, so:
<syntaxhighlight lang="jq">
1000 | task(3;5)  # => 233168

10e20 | task(3;5) # => 2.333333333333333e+41</syntaxhighlight>


=={{header|Julia}}==
sum multiples of each, minus multiples of the least common multiple (lcm). Similar to MATLAB's version.
<syntaxhighlight lang="julia">multsum(n, m, lim) = sum(0:n:lim-1) + sum(0:m:lim-1) - sum(0:lcm(n,m):lim-1)</syntaxhighlight>
Output:
<pre>julia> multsum(3, 5, 1000)
233168

julia> multsum(3, 5, BigInt(10)^20)
2333333333333333333316666666666666666668

julia> @time multsum(3, 5, BigInt(10)^20)
elapsed time: 5.8114e-5 seconds seconds (3968 bytes allocated)
2333333333333333333316666666666666666668

julia> [(BigInt(10)^n, multsum(3, 5, BigInt(10)^n)) for n=0:20]
21-element Array{(BigInt,BigInt),1}:
 (1,0)                                                           
 (10,23)                                                         
 (100,2318)                                                      
 (1000,233168)                                                   
 (10000,23331668)                                                
 (100000,2333316668)                                             
 (1000000,233333166668)                                          
 (10000000,23333331666668)                                       
 (100000000,2333333316666668)                                    
 (1000000000,233333333166666668)                                 
 (10000000000,23333333331666666668)                              
 (100000000000,2333333333316666666668)                           
 (1000000000000,233333333333166666666668)                        
 (10000000000000,23333333333331666666666668)                     
 (100000000000000,2333333333333316666666666668)                  
 (1000000000000000,233333333333333166666666666668)               
 (10000000000000000,23333333333333331666666666666668)            
 (100000000000000000,2333333333333333316666666666666668)         
 (1000000000000000000,233333333333333333166666666666666668)      
 (10000000000000000000,23333333333333333331666666666666666668)   
 (100000000000000000000,2333333333333333333316666666666666666668)</pre>
a slightly more efficient version
<syntaxhighlight lang="julia">multsum(n, lim) = (occ = div(lim-1, n); div(n*occ*(occ+1), 2))
multsum(n, m, lim) = multsum(n, lim) + multsum(m, lim) - multsum(lcm(n,m), lim)</syntaxhighlight>

=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.2

import java.math.BigInteger

val big2  = BigInteger.valueOf(2)
val big3  = BigInteger.valueOf(3)
val big5  = BigInteger.valueOf(5)
val big15 = big3 * big5

fun sum35(n: Int) = (3 until n).filter { it % 3 == 0 || it % 5 == 0}.sum()

fun sum35(n: BigInteger): BigInteger {
    val nn    = n - BigInteger.ONE
    val num3  = nn / big3
    val end3  = num3 * big3
    val sum3  = (big3 + end3) * num3 / big2
    val num5  = nn / big5
    val end5  = num5 * big5
    val sum5  = (big5 + end5) * num5 / big2
    val num15 = nn / big15
    val end15 = num15 * big15
    val sum15 = (big15 + end15) * num15 / big2
    return sum3 + sum5 - sum15
}

fun main(args: Array<String>) {
    println("The sum of multiples of 3 or 5 below 1000 is ${sum35(1000)}")
    val big100k = BigInteger.valueOf(100_000L)
    val e20 = big100k * big100k * big100k * big100k
    println("The sum of multiples of 3 or 5 below 1e20 is ${sum35(e20)}")
}</syntaxhighlight>

{{out}}
<pre>
The sum of multiples of 3 or 5 below 1000 is 233168
The sum of multiples of 3 or 5 below 1e20 is 2333333333333333333316666666666666666668
</pre>

=={{header|Lasso}}==
<syntaxhighlight lang="lasso">local(limit = 1)
while(#limit <= 100000) => {^
	local(s = 0)
	loop(-from=3,-to=#limit-1) => {
		not (loop_count % 3) || not (loop_count % 5) ? #s += loop_count
	}
	'The sum of multiples of 3 or 5 between 1 and '+(#limit-1)+' is: '+#s+'\r'
	#limit = integer(#limit->asString + '0')
^}</syntaxhighlight>
{{out}}
<pre>The sum of multiples of 3 or 5 between 1 and 0 is: 0
The sum of multiples of 3 or 5 between 1 and 9 is: 23
The sum of multiples of 3 or 5 between 1 and 99 is: 2318
The sum of multiples of 3 or 5 between 1 and 999 is: 233168
The sum of multiples of 3 or 5 between 1 and 9999 is: 23331668
The sum of multiples of 3 or 5 between 1 and 99999 is: 2333316668</pre>

=={{header|Limbo}}==

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

<syntaxhighlight lang="limbo">implement Sum3and5;

include "sys.m"; sys: Sys;
include "draw.m";
include "ipints.m"; ipints: IPints;
	IPint: import ipints;

Sum3and5: module {
	init: fn(nil: ref Draw->Context, args: list of string);
};

ints: array of ref IPint;

init(nil: ref Draw->Context, args: list of string)
{
	sys = load Sys Sys->PATH;
	ipints = load IPints IPints->PATH;

	# We use 1, 2, 3, 5, and 15:
	ints = array[16] of ref IPint;
	for(i := 0; i < len ints; i++)
		ints[i] = IPint.inttoip(i);

	args = tl args;
	while(args != nil) {
		h := hd args;
		args = tl args;
		# If it's big enough that the result might not
		# fit inside a big, we use the IPint version.
		if(len h > 9) {
			sys->print("%s\n", isum3to5(IPint.strtoip(h, 10)).iptostr(10));
		} else {
			sys->print("%bd\n", sum3to5(big h));
		}
	}
}

triangle(n: big): big
{
	return((n * (n + big 1)) / big 2);
}

sum_multiples(n: big, limit: big): big
{
	return(n * triangle((limit - big 1) / n));
}

sum3to5(limit: big): big
{
	return(
		sum_multiples(big 3, limit) +
		sum_multiples(big 5, limit) -
		sum_multiples(big 15, limit));
}

itriangle(n: ref IPint): ref IPint
{
	return n.mul(n.add(ints[1])).div(ints[2]).t0;
}

isum_multiples(n: ref IPint, limit: ref IPint): ref IPint
{
	return n.mul(itriangle(limit.sub(ints[1]).div(n).t0));
}

isum3to5(limit: ref IPint): ref IPint
{
	return(
		isum_multiples(ints[3], limit).
		add(isum_multiples(ints[5], limit)).
		sub(isum_multiples(ints[15], limit)));
}
</syntaxhighlight>

{{out}}
<pre>% sum3and5 1000 100000000000000000000
233168
2333333333333333333316666666666666666668</pre>

=={{header|Lingo}}==
<syntaxhighlight lang="lingo">on sum35 (n)
  res = 0
  repeat with i = 0 to (n-1)
    if i mod 3=0 OR i mod 5=0 then
      res = res + i
    end if
  end repeat
  return res
end</syntaxhighlight>

<syntaxhighlight lang="lingo">put sum35(1000)
-- 233168</syntaxhighlight>

=={{header|LiveCode}}==
<syntaxhighlight lang="livecode">function sumUntil n
    repeat with i = 0 to (n-1)
        if i mod 3 = 0 or i mod 5 = 0 then
            add i to m
        end if
    end repeat
    return m
end sumUntil

put sumUntil(1000)  // 233168</syntaxhighlight>

=={{header|Lua}}==
{{trans|Tcl}}
<syntaxhighlight lang="lua">
function tri (n) return n * (n + 1) / 2 end

function sum35 (n)
	n = n - 1
	return	(	3 * tri(math.floor(n / 3)) + 
			5 * tri(math.floor(n / 5)) - 
			15 * tri(math.floor(n / 15))
		)
end

print(sum35(1000))
print(sum35(1e+20))
</syntaxhighlight>
{{out}}
<pre>
233168
2.3333333333333e+39
</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).
<syntaxhighlight lang="maple">
F := unapply(  sum(3*i,i=1..floor((n-1)/3))
             + sum(5*i,i=1..floor((n-1)/5))
             - sum(15*i,i=1..floor((n-1)/15)), n);

F(1000);

F(10^20);
</syntaxhighlight>
Output:
<pre>
                               2                                      2
               3      /1     2\    3      /1     2\   5      /1     4\ 
     F := n -> - floor|- n + -|  - - floor|- n + -| + - floor|- n + -| 
               2      \3     3/    2      \3     3/   2      \5     5/ 

                                                2                      
          5      /1     4\   15      /1      14\    15      /1      14\
        - - floor|- n + -| - -- floor|-- n + --|  + -- floor|-- n + --|
          2      \5     5/   2       \15     15/    2       \15     15/


                                   233168

                  2333333333333333333316666666666666666668
</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">sum35[n_] := 
 Sum[k, {k, 3, n - 1, 3}] + Sum[k, {k, 5, n - 1, 5}] - 
  Sum[k, {k, 15, n - 1, 15}]
sum35[1000]</syntaxhighlight>
{{out}}
<pre>233168</pre>
<syntaxhighlight lang="mathematica">sum35[10^20]</syntaxhighlight>
{{out}}
<pre>233333333333333333333166666666666666666668</pre>
Another alternative is 
<syntaxhighlight lang="mathematica"> Union @@ Range[0, 999, {3, 5}] // Tr </syntaxhighlight>

=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">n=1:999; sum(n(mod(n,3)==0 | mod(n,5)==0))</syntaxhighlight>
<pre>ans =  233168</pre>
Another alternative is
<syntaxhighlight lang="matlab">n=1000; sum(0:3:n-1)+sum(0:5:n-1)-sum(0:15:n-1)</syntaxhighlight>
Of course, it's more efficient to use [http://mathforum.org/library/drmath/view/57919.html Gauss' approach] of adding subsequent integers:
<syntaxhighlight lang="matlab">n=999; 
n3=floor(n/3);
n5=floor(n/5);
n15=floor(n/15);
(3*n3*(n3+1) + 5*n5*(n5+1) - 15*n15*(n15+1))/2</syntaxhighlight>
<pre>ans =  233168</pre>

=={{header|Maxima}}==
<syntaxhighlight lang="maxima">sumi(n, inc):= block(
  [kmax],

  /* below n means [1 .. n-1] */
  kmax: quotient(n-1, inc),
  return(
    ''(ev(sum(inc*k, k, 1, kmax), simpsum))
  )
);
 
sum35(n):= sumi(n, 3) + sumi(n, 5) - sumi(n, 15);

sum35(1000);
sum35(10^20);</syntaxhighlight>
Output:
<pre>
(%i4) sum35(1000)
(%o4)                               233168
(%i5) sum35(10^20)
(%o5)              2333333333333333333316666666666666666668
</pre>

=={{header|MiniScript}}==

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.
<syntaxhighlight lang="miniscript">// simple version:
sum35 = function(n)
    sum = 0
    for i in range(3, n-1, 3)
        sum = sum + i
    end for
    for i in range(5, n-1, 5)
        if i % 3 then sum = sum + i // (skip multiples of 3 here)
    end for
    return sum
end function

print sum35(1000)</syntaxhighlight>
{{out}}
<pre>233168</pre>

Now the fast version.
{{trans|D}}
<syntaxhighlight lang="miniscript">// fast version:
sumMul = function(n, f)
    n1 = floor((n - 1) / f)
    return f * n1 * (n1 + 1) / 2
end function

sum35fast = function(n)
    return sumMul(n, 3) + sumMul(n, 5) - sumMul(n, 15)
end function

print sum35fast(1000)</syntaxhighlight>
{{out}}
<pre>233168</pre>

=={{header|МК-61/52}}==
<syntaxhighlight lang="text">П1	0	П0	3	П4	ИП4	3	/	{x}	x#0
17	ИП4	5	/	{x}	x=0	21	ИП0	ИП4	+
П0	КИП4	ИП1	ИП4	-	x=0	05	ИП0	С/П</syntaxhighlight>

Input: ''n''.

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

=={{header|Nanoquery}}==
{{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.
<syntaxhighlight lang="nanoquery">def getSum(n)
        sum = 0
        for i in range(3, n - 1)
                if (i % 3 = 0) or (i % 5 = 0)
                        sum += i
                end
        end
        return sum
end

println getSum(1000)</syntaxhighlight>
{{out}}
<pre>233168</pre>

=={{header|NetRexx}}==
Portions translation of [[#Raku|Raku]]
<syntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
numeric digits 40

runSample(arg)
return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method summing(maxLimit = 1000) public static
  mult = 0
  loop mv = 0 while mv < maxLimit
    if mv // 3 = 0 | mv // 5 = 0 then
      mult = mult + mv
    end mv
  return mult

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- translation of Raku
method sum_mults(first, limit) public static
  last = limit - 1
  last = last - last // first
  sum = (last / first) * (first + last) % 2
  return sum

method sum35(maxLimit) public static
  return sum_mults(3, maxLimit) + sum_mults(5, maxLimit) - sum_mults(15, maxLimit)

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static

  offset = 30
  incr = 10

  say 'Limit'.right(offset) || '|' || 'Sum'
  say '-'.copies(offset)    || '+' || '-'.copies(60)
  timing = System.nanoTime
  sum = summing()
  timing = System.nanoTime - timing
  say 1000.format.right(offset)'|'sum
  say 'Elapsed time:' Rexx(timing * 1e-9).format(4, 6)'s'
  say

  say 'Limit'.right(offset) || '|' || 'Sum'
  say '-'.copies(offset)    || '+' || '-'.copies(60)
  tmax = 1e+6
  timing = System.nanoTime
  mm = 1
  loop while mm <= tmax
    say mm.right(offset)'|'summing(mm)
    mm = mm * incr
    end
  timing = System.nanoTime - timing
  say 'Elapsed time:' Rexx(timing * 1e-9).format(4, 6)'s'
  say

  say 'Limit'.right(offset) || '|' || 'Sum'
  say '-'.copies(offset)    || '+' || '-'.copies(60)
  timing = System.nanoTime
  sum = sum35(1000)
  timing = System.nanoTime - timing
  say 1000.format.right(offset)'|'sum
  say 'Elapsed time:' Rexx(timing * 1e-9).format(4, 6)'s'
  say

  say 'Limit'.right(offset) || '|' || 'Sum'
  say '-'.copies(offset)    || '+' || '-'.copies(60)
  tmax = 1e+27
  timing = System.nanoTime
  mm = 1
  loop while mm <= tmax
    say mm.right(offset)'|'sum35(mm)
    mm = mm * incr
    end
  timing = System.nanoTime - timing
  say 'Elapsed time:' Rexx(timing * 1e-9).format(4, 6)'s'
  say
  return
</syntaxhighlight>
{{out}}
<pre>
                         Limit|Sum
------------------------------+------------------------------------------------------------
                          1000|233168
Elapsed time:    0.097668s

                         Limit|Sum
------------------------------+------------------------------------------------------------
                             1|0
                            10|23
                           100|2318
                          1000|233168
                         10000|23331668
                        100000|2333316668
                       1000000|233333166668
Elapsed time:   11.593837s

                         Limit|Sum
------------------------------+------------------------------------------------------------
                          1000|233168
Elapsed time:    0.000140s

                         Limit|Sum
------------------------------+------------------------------------------------------------
                             1|0
                            10|23
                           100|2318
                          1000|233168
                         10000|23331668
                        100000|2333316668
                       1000000|233333166668
                      10000000|23333331666668
                     100000000|2333333316666668
                    1000000000|233333333166666668
                   10000000000|23333333331666666668
                  100000000000|2333333333316666666668
                 1000000000000|233333333333166666666668
                10000000000000|23333333333331666666666668
               100000000000000|2333333333333316666666666668
              1000000000000000|233333333333333166666666666668
             10000000000000000|23333333333333331666666666666668
            100000000000000000|2333333333333333316666666666666668
           1000000000000000000|233333333333333333166666666666666668
          10000000000000000000|23333333333333333331666666666666666668
         100000000000000000000|2333333333333333333316666666666666666668
        1000000000000000000000|233333333333333333333166666666666666666668
       10000000000000000000000|23333333333333333333331666666666666666666668
      100000000000000000000000|2333333333333333333333316666666666666666666668
     1000000000000000000000000|233333333333333333333333166666666666666666666668
    10000000000000000000000000|23333333333333333333333331666666666666666666666668
   100000000000000000000000000|2333333333333333333333333316666666666666666666666668
  1000000000000000000000000000|233333333333333333333333333166666666666666666666666668
Elapsed time:    0.005545s
</pre>

=={{header|Nim}}==
Here is the solution using normal integers.
<syntaxhighlight lang="nim">proc sum35(n: int): int =
  for x in 0 ..< n:
    if x mod 3 == 0 or x mod 5 == 0:
      result += x

echo sum35(1000)</syntaxhighlight>

{{out}}
<pre>233168</pre>

To compute until 1e20, we have to use big integers. As Nim doesn’t provided them in its library, we have to use a third party library, either "bigints" or "bignum".

{{trans|Raku}}
{{libheader|bigints}}
<syntaxhighlight lang="nim">import bigints

proc sumMults(first: int32, limit: BigInt): BigInt =
  var last = limit - 1
  last -= last mod first
  (last div first) * (last + first) div 2

proc sum35(n: BigInt): BigInt =
  result = sumMults(3, n)
  result += sumMults(5, n)
  result -= sumMults(15, n)

var x = 1.initBigInt
while x < "1000000000000000000000000000000".initBigInt:
  echo sum35 x
  x *= 10</syntaxhighlight>

{{out}}
<pre>0
23
2318
233168
23331668
2333316668
233333166668
23333331666668
2333333316666668
233333333166666668
23333333331666666668
2333333333316666666668
233333333333166666666668
23333333333331666666666668
2333333333333316666666666668
233333333333333166666666666668
23333333333333331666666666666668
2333333333333333316666666666666668
233333333333333333166666666666666668
23333333333333333331666666666666666668
2333333333333333333316666666666666666668
233333333333333333333166666666666666666668
23333333333333333333331666666666666666666668
2333333333333333333333316666666666666666666668
233333333333333333333333166666666666666666666668
23333333333333333333333331666666666666666666666668
2333333333333333333333333316666666666666666666666668
233333333333333333333333333166666666666666666666666668
23333333333333333333333333331666666666666666666666666668
2333333333333333333333333333316666666666666666666666666668</pre>

=={{header|Objeck}}==
{{trans|Java}}
<syntaxhighlight lang="objeck">class SumMultiples {
  function : native : GetSum(n : Int) ~ Int {
    sum := 0;
    for(i := 3; i < n; i++;) {
      if(i % 3 = 0 | i % 5 = 0) {
        sum += i;
      };
    };

    return sum;
  }

  function : Main(args : String[]) ~ Nil {
    GetSum(1000)->PrintLine();
  }
}
</syntaxhighlight>

Output:
<pre>
233168
</pre>

=={{header|Odin}}==
Note: 1e19 is the largest sum that can be calculated with 128 bit integers.
<syntaxhighlight lang="odin">
package main

import "core:fmt"

sumdiv :: proc(n, d: i128) -> i128 {
    m := n / d
    return (m % 2 == 0)? \
            m/2 * (m + 1) * d : \
            (m + 1)/2 * m * d
}

sum3or5 :: proc(n: i128) -> i128 {
    return sumdiv(n, 3) + sumdiv(n, 5) - sumdiv(n, 15)
}

main :: proc() {
    sum := 0
    for n in 1..=999 {
        if n % 3 == 0 || n % 5 == 0 {
            sum += n
        }
    }
    fmt.println("The sum of all multiples of 3 and 5 < 1000 is", sum)
    fmt.println("The sum of all multiples of 3 and 5 < 1e19 is", sum3or5(1e19 - 1))
}
</syntaxhighlight>
{{Out}}
<pre>
The sum of all multiples of 3 and 5 < 1000 is 233168
The sum of all multiples of 3 and 5 < 1e19 is 23333333333333333331666666666666666668
</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let sum_m3m5 n =
  let termial x = (x * x + x) lsr 1 in
  3 * (termial (n / 3) - 5 * termial (n / 15)) + 5 * termial (n / 5)

let () =
  let pow10 x = truncate (10. ** (float x)) in
  for i = 1 to 9 do
    let u = pred (pow10 i) in
    Printf.printf "Summing multiples of 3 or 5 in 1..%u: %u\n" u (sum_m3m5 u)
  done</syntaxhighlight>
{{out}}
<pre>
Summing multiples of 3 or 5 in 1..9: 23
Summing multiples of 3 or 5 in 1..99: 2318
Summing multiples of 3 or 5 in 1..999: 233168
Summing multiples of 3 or 5 in 1..9999: 23331668
Summing multiples of 3 or 5 in 1..99999: 2333316668
Summing multiples of 3 or 5 in 1..999999: 233333166668
Summing multiples of 3 or 5 in 1..9999999: 23333331666668
Summing multiples of 3 or 5 in 1..99999999: 2333333316666668
Summing multiples of 3 or 5 in 1..999999999: 233333333166666668
</pre>
=== With wheel increments (slower) ===
<syntaxhighlight lang="ocaml">
open Printf;;

let mul3or5 =
   let rec wheel = 3 :: 2 :: 1 :: 3 :: 1 :: 2 :: 3 :: wheel in
      Seq.scan (+) 0 (List.to_seq wheel);;

let sum3or5 upto =
   mul3or5
   |> Seq.take_while (fun n -> n < upto)
   |> Seq.fold_left (+) 0;;

printf "The sum of the multiples of 3 or 5 below 1000 is %d\n" (sum3or5 1000);;
</syntaxhighlight>
{{Out}}
<pre>
The sum of the multiples of 3 or 5 below 1000 is 233168
</pre>

=={{header|Oforth}}==

<syntaxhighlight lang="oforth">999 seq filter(#[ dup 3 mod 0 == swap 5 mod 0 == or ]) sum println</syntaxhighlight>

Output:
<pre>
233168
</pre>

=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(print
(fold (lambda (s x)
         (+ s (if (or (zero? (remainder x 3)) (zero? (remainder x 5))) x 0)))
   0 (iota 1000)))
; ==> 233168
</syntaxhighlight>

=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">ct(n,k)=n=n--\k;k*n*(n+1)/2;
a(n)=ct(n,3)+ct(n,5)-ct(n,15);
a(1000)
a(1e20)</syntaxhighlight>
{{output}}
<pre>
%1 = 233168
%2 = 2333333333333333333316666666666666666668
</pre>

=={{header|Pascal}}==

{{works with|Free Pascal|2.6.2}}

<syntaxhighlight lang="pascal">program Sum3sAnd5s;
 
function Multiple(x, y: integer): Boolean;
  { Is X a multiple of Y? }
   begin
      Multiple := (X mod Y) = 0
   end;
 
function SumMultiples(n: integer): longint;
  { Return the sum of all multiples of 3 or 5. }
   var i: integer; sum: longint;
   begin
      sum := 0;
      for i := 1 to pred(n) do
         if Multiple(i, 3) or Multiple(i, 5) then
           sum := sum + i;
      SumMultiples := sum
   end;

begin
   { Show sum of all multiples less than 1000. }
   writeln(SumMultiples(1000))
end.</syntaxhighlight>
===alternative===
using gauss summation formula, but subtract double counted.
adapted translation of [[#Tcl|Tcl]]
<syntaxhighlight lang="pascal">program sum35;
//sum of all positive multiples of 3 or 5 below n

function cntSumdivisibleBelowN(n: Uint64;b:Uint64):Uint64;
var
  cnt : Uint64;
Begin
  cnt := (n-1) DIV b;
// Gauß summation formula * b
  cntSumdivisibleBelowN := (cnt*(cnt+1) DIV 2 ) *b;
end;
const
  n = 1000;

var
  sum: Uint64;
begin
  sum := cntSumdivisibleBelowN(n,3)+cntSumdivisibleBelowN(n,5);
//subtract double counted like 15
  sum := sum-cntSumdivisibleBelowN(n,3*5);
  writeln(sum);
end.</syntaxhighlight>
output
<pre>233168</pre>

=={{header|Perl}}==
<syntaxhighlight lang="perl">#!/usr/bin/perl
use v5.20;
use experimental qw(signatures);

use List::Util qw( sum ) ;

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

say "The sum is ${\(sum_3_5 1000)}!\n" ;</syntaxhighlight>
{{Out}}
<pre>The sum is 233168!</pre>

{{Trans|Tcl}}
An alternative approach, using the analytical solution from the Tcl example.
<syntaxhighlight lang="perl">use v5.20;
use experimental qw(signatures);

sub tri($n) {
   $n*($n+1) / 2;
}

sub sum_multiples($n, $limit) {
   $n * tri( int( ($limit - 1) / $n ) )
}

sub sum($n) {
   sum_multiples(3, $n) + sum_multiples(5, $n) - sum_multiples(15, $n);
}

say sum 1e3;
use bigint; # Machine precision was sufficient for the first calculation
say sum 1e20;</syntaxhighlight>
{{Out}}
<pre>233168
2333333333333333333316666666666666666668</pre>
Interestingly, the prime factorization of the second result produces a 35 digit prime number.

=={{header|Phix}}==
===native===
note the result of sum35() is inaccurate above 2^53 on 32-bit, 2^64 on 64-bit.
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <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: #008080;">return</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: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">2</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
  
 <span style="color: #008080;">function</span> <span style="color: #000000;">sum35</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: #008080;">return</span> <span style="color: #000000;">sumMul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">+</span>
            <span style="color: #000000;">sumMul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">-</span>
            <span style="color: #000000;">sumMul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">15</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
  
 <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">8</span> <span style="color: #008080;">do</span>
     <span style="color: #004080;">string</span> <span style="color: #000000;">sp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</span><span style="color: #0000FF;">),</span>
            <span style="color: #000000;">pt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"1"</span><span style="color: #0000FF;">&</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
         1          0
        10         23
       100        2318
      1000       233168
     10000      23331668
    100000     2333316668
   1000000    233333166668
  10000000   23333331666668
 100000000  2333333316666668
</pre>
===gmp===
{{trans|C}}
{{libheader|Phix/mpfr}}
Fast analytical version with arbitrary precision
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <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;">procedure</span> <span style="color: #000000;">sum_multiples</span><span style="color: #0000FF;">(</span><span style="color: #004080;">mpz</span> <span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">limit</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>
     <span style="color: #004080;">mpz</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">()</span>
     <span style="color: #7060A8;">mpz_sub_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">limit</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
     <span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_fdiv_q_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_add_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">);</span>
     <span style="color: #7060A8;">mpz_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_fdiv_q_2exp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">result</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
     <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_free</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
  
 <span style="color: #004080;">mpz</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_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20</span> <span style="color: #008080;">do</span>
     <span style="color: #004080;">string</span> <span style="color: #000000;">sp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</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: #000000;">sp</span><span style="color: #0000FF;">&</span><span style="color: #008000;">"1"</span><span style="color: #0000FF;">&</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)&</span><span style="color: #000000;">sp</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_ui_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">limit</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: #000000;">sum_multiples</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">limit</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
     <span style="color: #000000;">sum_multiples</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: #000000;">5</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</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;">sum_multiples</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: #000000;">15</span><span style="color: #0000FF;">)</span>
     <span style="color: #7060A8;">mpz_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</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: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">))</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>
<!--</syntaxhighlight>-->
{{Out}}
<pre>
                    1                     0
                   10                    23
                  100                   2318
                 1000                  233168
                10000                 23331668
               100000                2333316668
              1000000               233333166668
             10000000              23333331666668
            100000000             2333333316666668
           1000000000            233333333166666668
          10000000000           23333333331666666668
         100000000000          2333333333316666666668
        1000000000000         233333333333166666666668
       10000000000000        23333333333331666666666668
      100000000000000       2333333333333316666666666668
     1000000000000000      233333333333333166666666666668
    10000000000000000     23333333333333331666666666666668
   100000000000000000    2333333333333333316666666666666668
  1000000000000000000   233333333333333333166666666666666668
 10000000000000000000  23333333333333333331666666666666666668
100000000000000000000 2333333333333333333316666666666666666668
</pre>

=={{header|PHP}}==

Naive version (slow) :

<syntaxhighlight lang="php">$max = 1000;
$sum = 0;
for ($i = 1 ; $i < $max ; $i++) {
    if (($i % 3 == 0) or ($i % 5 == 0)) {
        $sum += $i;
    }
}
echo $sum, PHP_EOL;
</syntaxhighlight>

{{out}}
<pre>233168</pre>

Fast version:

<syntaxhighlight lang="php">function sum_multiples($max, $divisor) {
    // Number of multiples of $divisor <= $max
    $num = floor($max / $divisor);
    // Sum of multiples of $divisor
    return ($divisor * $num * ($num + 1) / 2);
}

$max = 1000;
$sum = sum_multiples($max - 1,  3)
     + sum_multiples($max - 1,  5)
     - sum_multiples($max - 1, 15);
echo $sum, PHP_EOL;</syntaxhighlight>

{{out}}
<pre>233168</pre>

{{libheader|GMP}}

Fast version using GNU Multiple Precision library.
These functions allow for arbitrary-length integers to be worked with.

<syntaxhighlight lang="php">function sum_multiples_gmp($max, $divisor) {
    // Number of multiples of $divisor <= $max
    $num = gmp_div($max, $divisor);
    // Sum of multiples of $divisor
    return gmp_div(gmp_mul(gmp_mul($divisor, $num), gmp_add($num, 1)), 2);
}

for ($i = 0, $n = gmp_init(10) ; $i < 21 ; $i++, $n = gmp_mul($n, 10)) {
    $max = gmp_sub($n, 1);
    $sum = 
        gmp_sub(
            gmp_add(
                sum_multiples_gmp($max, 3),
                sum_multiples_gmp($max, 5)
            ),
            sum_multiples_gmp($max, 15)
        );
    printf('%22s : %s' . PHP_EOL, gmp_strval($n), $sum);
}</syntaxhighlight>

{{out}}
<pre>                    10 : 23
                   100 : 2318
                  1000 : 233168
                 10000 : 23331668
                100000 : 2333316668
               1000000 : 233333166668
              10000000 : 23333331666668
             100000000 : 2333333316666668
            1000000000 : 233333333166666668
           10000000000 : 23333333331666666668
          100000000000 : 2333333333316666666668
         1000000000000 : 233333333333166666666668
        10000000000000 : 23333333333331666666666668
       100000000000000 : 2333333333333316666666666668
      1000000000000000 : 233333333333333166666666666668
     10000000000000000 : 23333333333333331666666666666668
    100000000000000000 : 2333333333333333316666666666666668
   1000000000000000000 : 233333333333333333166666666666666668
  10000000000000000000 : 23333333333333333331666666666666666668
 100000000000000000000 : 2333333333333333333316666666666666666668
1000000000000000000000 : 233333333333333333333166666666666666666668
</pre>

=={{header|Picat}}==
Uses both the naive method and inclusion/exclusion.
<syntaxhighlight lang="picat">
sumdiv(N, D) = S =>
    M = N div D,
    S = (M*(M + 1) div 2) * D.

sum35big(N) = sumdiv(N, 3) + sumdiv(N, 5) - sumdiv(N, 15).

main =>
    Upto1K = [N: N in 1..999, (N mod 3 = 0; N mod 5 = 0)].sum,
    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)).
</syntaxhighlight>
{{Out}}
<pre>
The sum of all multiples of 3 and 5 below 1000 is 233168
The sum of all multiples less than 1e20 is 2333333333333333333316666666666666666668
</pre>
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">(de sumMul (N F)
   (let N1 (/ (dec N) F)
      (*/ F N1 (inc N1) 2) ) )

(for I 20
   (let N (** 10 I)
      (println
         (-
            (+ (sumMul N 3) (sumMul N 5))
            (sumMul N 15) ) ) ) )</syntaxhighlight>
{{out}}
<pre>
23
2318
233168
23331668
2333316668
233333166668
23333331666668
2333333316666668
233333333166666668
23333333331666666668
2333333333316666666668
233333333333166666666668
23333333333331666666666668
2333333333333316666666666668
233333333333333166666666666668
23333333333333331666666666666668
2333333333333333316666666666666668
233333333333333333166666666666666668
23333333333333333331666666666666666668
2333333333333333333316666666666666666668
</pre>

=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">threeor5: procedure options (main);      /* 8 June 2014 */
   declare (i, n) fixed(10), sum fixed (31) static initial (0);

   get (n);
   put ('The number of multiples of 3 or 5 below ' || trim(n) || ' is');

   do i = 1 to n-1;
      if mod(i, 3) = 0 | mod(i, 5) = 0 then sum = sum + i;
   end;

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

end threeor5;</syntaxhighlight>
Outputs:
<pre>
The number of multiples of 3 or 5 below 1000 is 233168
The number of multiples of 3 or 5 below 10000 is 23331668
The number of multiples of 3 or 5 below 100000 is 2333316668
The number of multiples of 3 or 5 below 1000000 is 233333166668
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|PL/I-80}}===
Although a brute-force approach gets the job done with a minimum
of fuss, and would generally be the preferred first choice, the use of Gauss's 
summation formula will significantly speed up running time if 
summing to higher limits than required by the problem. The solution
here demonstrates both approaches
<syntaxhighlight lang = "PL/I">
sum35_demo: proc options (main);
    dcl limit fixed bin;
    limit = 1000;
    put skip list ('Sum of all multiples of 3 and 5 below', limit);
    put skip edit ('Sum = ', sum35(limit)) ((a),(f(6)));
    put skip edit ('Also: ', sum35alt(limit)) ((a),(f(6)));

stop;

sum35:
    proc(limit) returns (float bin);
    dcl
        (limit, i) fixed bin,
        sum float bin;
    sum = 0;
    do i=1 to (limit-1);
       if mod(i,3) = 0 | mod(i,5) = 0 then
           sum = sum + i;
    end;
    return (sum);
end sum35;

sum35alt:
    proc(limit) returns (float bin);
    dcl
        limit fixed bin,
        sum float bin;
    sum = sum_of_multiples(3, limit) +
          sum_of_multiples(5, limit) -
          sum_of_multiples(15, limit);
    return (sum);
end sum35alt;

sum_of_multiples:
    proc(n, limit) returns (float bin);
    dcl
        (n, limit, i) fixed bin,
        m float bin;
    m = (limit - 1) / n;
    return (n * m * (m + 1) / 2);
end sum_of_multiples;

end sum35_demo;
</syntaxhighlight>
{{out}}
<pre>
Sum of all multiples of 3 and 5 below    1000
Sum = 233168
Also: 233168
</pre>

=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function SumMultiples ( [int]$Base, [int]$Upto )
    {
    $X = ($Upto - ( $Upto % $Base ) ) / $Base + ( [int] ( $Upto % $Base -ne 0 ) )
    $Sum = ( $X * $X - $X ) * $Base / 2
    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 )
</syntaxhighlight>
{{out}}
<pre>
233168
</pre>
For arbitrarily large integers, simply change the variable type.
<syntaxhighlight lang="powershell">
function SumMultiples ( [bigint]$Base, [bigint]$Upto )
    {
    $X = ($Upto - ( $Upto % $Base ) ) / $Base + ( [int] ( $Upto % $Base -ne 0 ) )
    $Sum = ( $X * $X - $X ) * $Base / 2
    Return $Sum
    }

#  Calculate the sum of the multiples of 3 and 5 up to 10 ^ 210
$Upto = [bigint]::Pow( 10, 210 )
( SumMultiples -Base 3 -Upto $Upto ) + ( SumMultiples -Base 5 -Upto $Upto ) - ( SumMultiples -Base 15 -Upto $Upto )
</syntaxhighlight>
{{out}}
<pre>
233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668
</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.
<syntaxhighlight lang="powershell">function Get-SumOfMultiples
{
    Param
    (
        [Parameter(
        Position=0)]
        $Cap = 1000,

        [Parameter(
        ValueFromRemainingArguments=$True)]
        $Multiplier = (3,5)
    )

    $Multiples = @()
    $Sum = 0
    $multiplier | 
      ForEach-Object {
        For($i = 1; $i -lt $Cap; $i ++)
        {        
          If($i % $_ -eq 0)
          {$Multiples += $i}
        }
      }

     $Multiples | 
         select -Unique | 
         ForEach-Object {
            $Sum += $_
         }
     $Sum
}</syntaxhighlight>
{{out}}
<pre>Get-SumOfMultiples</pre>
<pre>233168</pre>
{{out}}
<pre>Get-SumOfMultiples 1500 3 5 7 13</pre>
<pre>649444</pre>

=={{header|Prolog}}==
===Slow version===
<syntaxhighlight lang="prolog">sum_of_multiples_of_3_and_5_slow(N, TT) :-
	sum_of_multiples_of_3_and_5(N, 1, 0, TT).

sum_of_multiples_of_3_and_5(N, K, S, S) :-
	3 * K >= N.

sum_of_multiples_of_3_and_5(N, K, C, S) :-
	T3 is 3 * K, T3 < N,
	C3 is C + T3,
	T5 is 5 * K,
	(   (T5 < N, K mod 3 =\= 0)
	->  C5 is C3 + T5
	;   C5 = C3),
	K1 is K+1,
	sum_of_multiples_of_3_and_5(N, K1, C5, S).

</syntaxhighlight>

===Fast version===
<syntaxhighlight lang="polog">sum_of_multiples_of_3_and_5_fast(N, TT):-
	maplist(compute_sum(N), [3,5,15], [TT3, TT5, TT15]),
	TT is TT3 + TT5 - TT15.

compute_sum(N, N1, Sum) :-
	(   N mod N1 =:= 0
	->  N2 is N div N1 - 1
	;   N2 is N div N1),
	Sum is N1 * N2 * (N2 + 1) / 2.
</syntaxhighlight>

Output :
<pre> ?- sum_of_multiples_of_3_and_5_slow(1000, TT).
TT = 233168 .

 ?- sum_of_multiples_of_3_and_5_fast(100000000000000000000, TT).
TT = 2333333333333333333316666666666666666668.
</pre>

=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
EnableExplicit

Procedure.q SumMultiples(Limit.q)
  If Limit < 0 : Limit = -Limit : EndIf; convert negative numbers to positive
  Protected.q i, sum = 0
  For i = 3 To Limit - 1
    If i % 3 = 0 Or i % 5 = 0
      sum + i
    EndIf
  Next  
  ProcedureReturn sum
EndProcedure
  
If OpenConsole()
  PrintN("Sum of numbers below 1000 which are multiples of 3 or 5 is : " + SumMultiples(1000))
  PrintN("")
  PrintN("Press any key to close the console")
  Repeat: Delay(10) : Until Inkey() <> ""
  CloseConsole()
EndIf
</syntaxhighlight>

{{out}}
<pre>
Sum of numbers below 1000 which are multiples of 3 or 5 is : 233168
</pre>

=={{header|Python}}==
Three ways of performing the calculation are shown including direct calculation of the value without having to do explicit sums in sum35c()
<syntaxhighlight lang="python">def sum35a(n):
    'Direct count'
    # note: ranges go to n-1
    return sum(x for x in range(n) if x%3==0 or x%5==0)

def sum35b(n): 
    "Count all the 3's; all the 5's; minus double-counted 3*5's"
    # note: ranges go to n-1
    return sum(range(3, n, 3)) + sum(range(5, n, 5)) - sum(range(15, n, 15))
    
def sum35c(n):
    'Sum the arithmetic progressions: sum3 + sum5 - sum15'
    consts = (3, 5, 15)
    # Note: stop at n-1
    divs = [(n-1) // c for c in consts]
    sums = [d*c*(1+d)/2 for d,c in zip(divs, consts)]
    return sums[0] + sums[1] - sums[2]

#test
for n in range(1001):
    sa, sb, sc = sum35a(n), sum35b(n), sum35c(n)
    assert sa == sb == sc  # python tests aren't like those of c.

print('For n = %7i -> %i\n' % (n, sc))

# Pretty patterns
for p in range(7):
    print('For n = %7i -> %i' % (10**p, sum35c(10**p)))

# Scalability 
p = 20
print('\nFor n = %20i -> %i' % (10**p, sum35c(10**p)))</syntaxhighlight>

{{out}}
<pre>For n =    1000 -> 233168

For n =       1 -> 0
For n =      10 -> 23
For n =     100 -> 2318
For n =    1000 -> 233168
For n =   10000 -> 23331668
For n =  100000 -> 2333316668
For n = 1000000 -> 233333166668

For n = 100000000000000000000 -> 2333333333333333333316666666666666666668</pre>


Or, more generally – taking the area under the straight line between the first multiple and the last:
{{Works with|Python|3.7}}
<syntaxhighlight lang="python">'''Summed multiples of 3 and 5 up to n'''


# sum35 :: Int -> Int
def sum35(n):
    '''Sum of all positive multiples
       of 3 or 5 below n.
    '''
    f = sumMults(n)
    return f(3) + f(5) - f(15)


# sumMults :: Int -> Int -> Int
def sumMults(n):
    '''Area under a straight line between
       the first multiple and the last.
    '''
    def go(n, m):
        n1 = (n - 1) // m
        return (m * n1 * (n1 + 1)) // 2
    return lambda x: go(n, x)


# TEST ----------------------------------------------------
def main():
    '''Tests for [10^1 .. 10^5], and [10^8 .. 10^25]
    '''
    print(
        fTable(__doc__ + ':\n')(lambda x: '10E' + str(x))(
            str
        )(compose(sum35)(lambda x: 10**x))(
            enumFromTo(1)(5) + enumFromTo(18)(25)
        )
    )


# GENERIC -------------------------------------------------

# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
    '''Right to left function composition.'''
    return lambda f: lambda x: g(f(x))


# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
    '''Integer enumeration from m to n.'''
    return lambda n: list(range(m, 1 + n))


# fTable :: String -> (a -> String) ->
#                     (b -> String) ->
#        (a -> b) -> [a] -> String
def fTable(s):
    '''Heading -> x display function -> fx display function ->
          f -> value list -> tabular string.'''
    def go(xShow, fxShow, f, xs):
        w = max(map(compose(len)(xShow), xs))
        return s + '\n' + '\n'.join([
            xShow(x).rjust(w, ' ') + ' -> ' + fxShow(f(x)) for x in xs
        ])
    return lambda xShow: lambda fxShow: (
        lambda f: lambda xs: go(
            xShow, fxShow, f, xs
        )
    )


# MAIN ---
if __name__ == '__main__':
    main()</syntaxhighlight>
{{Out}}
<pre>Summed multiples of 3 and 5 up to n:

 10E1 -> 23
 10E2 -> 2318
 10E3 -> 233168
 10E4 -> 23331668
 10E5 -> 2333316668
10E18 -> 233333333333333333166666666666666668
10E19 -> 23333333333333333331666666666666666668
10E20 -> 2333333333333333333316666666666666666668
10E21 -> 233333333333333333333166666666666666666668
10E22 -> 23333333333333333333331666666666666666666668
10E23 -> 2333333333333333333333316666666666666666666668
10E24 -> 233333333333333333333333166666666666666666666668
10E25 -> 23333333333333333333333331666666666666666666666668</pre>

=={{header|Q}}==
<syntaxhighlight lang="q">s35:{sum {?[(0=x mod 3) | 0=x mod 5;x;0]} each 1+til x - 1}
s35 each 10 100 1000 10000 1000000</syntaxhighlight>

Extra credit, using the summation formula:

<syntaxhighlight lang="q">sn:{x*(x+1)%2}      / Sum of 1 to n
s35:{a:x-1; (3*sn floor a%3) + (5*sn floor a%5) - (15*sn floor a%15)}
s35 e+10</syntaxhighlight>

=={{header|Quackery}}==

<syntaxhighlight lang="quackery">  [ dup 1+ * 2 / ]                  is triangulared ( n --> n )
 
  [ 1 - 
    dup   3 / triangulared  3 *
    over  5 / triangulared  5 * +
    swap 15 / triangulared 15 * - ] is sum-of-3s&5s ( n --> n )
 
      1000 sum-of-3s&5s echo cr 
  
  10 20 ** sum-of-3s&5s echo cr</syntaxhighlight>

{{out}}

<pre>233168
2333333333333333333316666666666666666668
</pre>

=={{header|R}}==

<syntaxhighlight lang="rsplus">m35 = function(n) sum(unique(c(
    seq(3, n-1, by = 3), seq(5, n-1, by = 5))))
m35(1000)   # 233168</syntaxhighlight>

=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require math)

;;; A naive solution
(define (naive k)
  (for/sum ([n (expt 10 k)] 
            #:when (or (divides? 3 n) (divides? 5 n)))
    n))

(for/list ([k 7]) (naive k))


;;; Using the formula for an arithmetic sum
(define (arithmetic-sum a1 n Δa)
  ; returns a1+a2+...+an
  (define an (+ a1 (* (- n 1) Δa)))
  (/ (* n (+ a1 an)) 2))

(define (analytical k)
  (define 10^k (expt 10 k))
  (define (n d) (quotient (- 10^k 1) d))
  (+    (arithmetic-sum  3 (n  3)  3)
        (arithmetic-sum  5 (n  5)  5)
     (- (arithmetic-sum 15 (n 15) 15))))

(for/list ([k 20]) (analytical k))
</syntaxhighlight>
Output:
<syntaxhighlight lang="racket">
'(0 23 2318 233168 23331668 2333316668 233333166668)
'(0
  23
  2318
  233168
  23331668
  2333316668
  233333166668
  23333331666668
  2333333316666668
  233333333166666668
  23333333331666666668
  2333333333316666666668
  233333333333166666666668
  23333333333331666666666668
  2333333333333316666666666668
  233333333333333166666666666668
  23333333333333331666666666666668
  2333333333333333316666666666666668
  233333333333333333166666666666666668
  23333333333333333331666666666666666668)
</syntaxhighlight>

=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>sub sum35($n) { [+] grep * %% (3|5), ^$n; }

say sum35 1000;</syntaxhighlight>
{{out}}
<pre>233168</pre>
Here's an analytical approach that scales much better for large values.
<syntaxhighlight lang="raku" line>sub sum-mults($first, $limit) {
    (my $last = $limit - 1) -= $last % $first;
    ($last div $first) * ($first + $last) div 2;
}

sub sum35(\n) {
    sum-mults(3,n) + sum-mults(5,n) - sum-mults(15,n);
}

say sum35($_) for 1,10,100...10**30;</syntaxhighlight>
{{out}}
<pre>0
23
2318
233168
23331668
2333316668
233333166668
23333331666668
2333333316666668
233333333166666668
23333333331666666668
2333333333316666666668
233333333333166666666668
23333333333331666666666668
2333333333333316666666666668
233333333333333166666666666668
23333333333333331666666666666668
2333333333333333316666666666666668
233333333333333333166666666666666668
23333333333333333331666666666666666668
2333333333333333333316666666666666666668
233333333333333333333166666666666666666668
23333333333333333333331666666666666666666668
2333333333333333333333316666666666666666666668
233333333333333333333333166666666666666666666668
23333333333333333333333331666666666666666666666668
2333333333333333333333333316666666666666666666666668
233333333333333333333333333166666666666666666666666668
23333333333333333333333333331666666666666666666666666668
2333333333333333333333333333316666666666666666666666666668
233333333333333333333333333333166666666666666666666666666668</pre>

=={{header|REXX}}==
===version 1===
<syntaxhighlight lang="rexx">/* REXX ***************************************************************
* 14.05.2013 Walter Pachl
**********************************************************************/
Say mul35()
exit
mul35:
s=0
Do i=1 To 999
  If i//3=0 | i//5=0 Then
    s=s+i
  End
Return s</syntaxhighlight>
Output:
<pre>233168</pre>

===version 2===
<syntaxhighlight lang="rexx">/* REXX ***************************************************************
* Translation from Raku->NetRexx->REXX
* 15.05.2013 Walter Pachl
**********************************************************************/
Numeric Digits 100
call time 'R'
n=1
Do i=1 To 30
  Say right(n,30) sum35(n)
  n=n*10
  End
Say time('E') 'seconds'
Exit

sum35: Procedure
  Parse Arg maxLimit
  return sum_mults(3, maxLimit) + sum_mults(5, maxLimit) - sum_mults(15, maxLimit)

sum_mults: Procedure
  Parse Arg first, limit
  last = limit - 1
  last = last - last // first
  sum = (last % first) * (first + last) % 2
  return sum</syntaxhighlight>
Output:
<pre>                             1 0
                            10 23
                           100 2318
                          1000 233168
                         10000 23331668
                        100000 2333316668
                       1000000 233333166668
                      10000000 23333331666668
                     100000000 2333333316666668
                    1000000000 233333333166666668
                   10000000000 23333333331666666668
                  100000000000 2333333333316666666668
                 1000000000000 233333333333166666666668
                10000000000000 23333333333331666666666668
               100000000000000 2333333333333316666666666668
              1000000000000000 233333333333333166666666666668
             10000000000000000 23333333333333331666666666666668
            100000000000000000 2333333333333333316666666666666668
           1000000000000000000 233333333333333333166666666666666668
          10000000000000000000 23333333333333333331666666666666666668
         100000000000000000000 2333333333333333333316666666666666666668
        1000000000000000000000 233333333333333333333166666666666666666668
       10000000000000000000000 23333333333333333333331666666666666666666668
      100000000000000000000000 2333333333333333333333316666666666666666666668
     1000000000000000000000000 233333333333333333333333166666666666666666666668
    10000000000000000000000000 23333333333333333333333331666666666666666666666668
   100000000000000000000000000 2333333333333333333333333316666666666666666666666668
  1000000000000000000000000000 233333333333333333333333333166666666666666666666666668
 10000000000000000000000000000 23333333333333333333333333331666666666666666666666666668
100000000000000000000000000000 2333333333333333333333333333316666666666666666666666666668
0 milliseconds with rexx m35a > m35a.txt
46 millisecond with rexx m35a</pre>

===version 3===
This version automatically adjusts the numeric digits. &nbsp; A little extra code was added to format the output nicely.

The formula used is a form of the Gauss Summation formula.
<syntaxhighlight lang="rexx">/*REXX program counts all  integers  from  1 ──► N─1   that are multiples of  3  or  5. */
parse arg N t .                                  /*obtain optional arguments from the CL*/
if N=='' | N==","  then N= 1000                  /*Not specified?  Then use the default.*/
if t=='' | t==","  then t=    1                  /* "      "         "   "   "      "   */
numeric digits 1000;    w= 2 + length(t)         /*W: used for formatting 'e' part of Y.*/
say 'The sum of all positive integers that are a multiple of  3  and  5  are:'
say                                              /* [↓]  change the format/look of nE+nn*/
     do t;      parse value format(N,2,1,,0) 'E0'  with  m 'E' _ .   /*get the exponent.*/
     y= right( (m/1)'e'  ||  (_+0), w)"-1"       /*this fixes a bug in a certain REXX.  */
     z= n - 1;        if t==1  then y= z         /*handle a special case of a one─timer.*/
     say 'integers from 1 ──►'    y    " is "    sumDiv(z,3) + sumDiv(z,5) - sumDiv(z,3*5)
     N= N'0'                                     /*fast *10 multiply for next iteration.*/
     end   /*t*/                                 /* [↑]  simply append a zero to the num*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
sumDiv: procedure;  parse arg x,d;       $= x % d;              return d * $ * ($+1) % 2</syntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}} 
<pre>
The sum of all positive integers that are a multiple of  3  and  5  are:

integers from 1 ──► 999  is  233168
</pre>
{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 1 &nbsp; 85 </tt>}}

(Shown at three-quarter size.)

<pre style="font-size:75%;height:188ex">
The sum of all positive integers that are a multiple of  3  and  5  are:

integers from 1 ──►  1e0-1  is  0
integers from 1 ──►  1e1-1  is  23
integers from 1 ──►  1e2-1  is  2318
integers from 1 ──►  1e3-1  is  233168
integers from 1 ──►  1e4-1  is  23331668
integers from 1 ──►  1e5-1  is  2333316668
integers from 1 ──►  1e6-1  is  233333166668
integers from 1 ──►  1e7-1  is  23333331666668
integers from 1 ──►  1e8-1  is  2333333316666668
integers from 1 ──►  1e9-1  is  233333333166666668
integers from 1 ──► 1e10-1  is  23333333331666666668
integers from 1 ──► 1e11-1  is  2333333333316666666668
integers from 1 ──► 1e12-1  is  233333333333166666666668
integers from 1 ──► 1e13-1  is  23333333333331666666666668
integers from 1 ──► 1e14-1  is  2333333333333316666666666668
integers from 1 ──► 1e15-1  is  233333333333333166666666666668
integers from 1 ──► 1e16-1  is  23333333333333331666666666666668
integers from 1 ──► 1e17-1  is  2333333333333333316666666666666668
integers from 1 ──► 1e18-1  is  233333333333333333166666666666666668
integers from 1 ──► 1e19-1  is  23333333333333333331666666666666666668
integers from 1 ──► 1e20-1  is  2333333333333333333316666666666666666668
integers from 1 ──► 1e21-1  is  233333333333333333333166666666666666666668
integers from 1 ──► 1e22-1  is  23333333333333333333331666666666666666666668
integers from 1 ──► 1e23-1  is  2333333333333333333333316666666666666666666668
integers from 1 ──► 1e24-1  is  233333333333333333333333166666666666666666666668
integers from 1 ──► 1e25-1  is  23333333333333333333333331666666666666666666666668
integers from 1 ──► 1e26-1  is  2333333333333333333333333316666666666666666666666668
integers from 1 ──► 1e27-1  is  233333333333333333333333333166666666666666666666666668
integers from 1 ──► 1e28-1  is  23333333333333333333333333331666666666666666666666666668
integers from 1 ──► 1e29-1  is  2333333333333333333333333333316666666666666666666666666668
integers from 1 ──► 1e30-1  is  233333333333333333333333333333166666666666666666666666666668
integers from 1 ──► 1e31-1  is  23333333333333333333333333333331666666666666666666666666666668
integers from 1 ──► 1e32-1  is  2333333333333333333333333333333316666666666666666666666666666668
integers from 1 ──► 1e33-1  is  233333333333333333333333333333333166666666666666666666666666666668
integers from 1 ──► 1e34-1  is  23333333333333333333333333333333331666666666666666666666666666666668
integers from 1 ──► 1e35-1  is  2333333333333333333333333333333333316666666666666666666666666666666668
integers from 1 ──► 1e36-1  is  233333333333333333333333333333333333166666666666666666666666666666666668
integers from 1 ──► 1e37-1  is  23333333333333333333333333333333333331666666666666666666666666666666666668
integers from 1 ──► 1e38-1  is  2333333333333333333333333333333333333316666666666666666666666666666666666668
integers from 1 ──► 1e39-1  is  233333333333333333333333333333333333333166666666666666666666666666666666666668
integers from 1 ──► 1e40-1  is  23333333333333333333333333333333333333331666666666666666666666666666666666666668
integers from 1 ──► 1e41-1  is  2333333333333333333333333333333333333333316666666666666666666666666666666666666668
integers from 1 ──► 1e42-1  is  233333333333333333333333333333333333333333166666666666666666666666666666666666666668
integers from 1 ──► 1e43-1  is  23333333333333333333333333333333333333333331666666666666666666666666666666666666666668
integers from 1 ──► 1e44-1  is  2333333333333333333333333333333333333333333316666666666666666666666666666666666666666668
integers from 1 ──► 1e45-1  is  233333333333333333333333333333333333333333333166666666666666666666666666666666666666666668
integers from 1 ──► 1e46-1  is  23333333333333333333333333333333333333333333331666666666666666666666666666666666666666666668
integers from 1 ──► 1e47-1  is  2333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666668
integers from 1 ──► 1e48-1  is  233333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666668
integers from 1 ──► 1e49-1  is  23333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666668
integers from 1 ──► 1e50-1  is  2333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666668
integers from 1 ──► 1e51-1  is  233333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666668
integers from 1 ──► 1e52-1  is  23333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e53-1  is  2333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e54-1  is  233333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e55-1  is  23333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e56-1  is  2333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e57-1  is  233333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e58-1  is  23333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e59-1  is  2333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e60-1  is  233333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e61-1  is  23333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e62-1  is  2333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e63-1  is  233333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e64-1  is  23333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e65-1  is  2333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e66-1  is  233333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e67-1  is  23333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e68-1  is  2333333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e69-1  is  233333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e70-1  is  23333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e71-1  is  2333333333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e72-1  is  233333333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e73-1  is  23333333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e74-1  is  2333333333333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e75-1  is  233333333333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e76-1  is  23333333333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e77-1  is  2333333333333333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e78-1  is  233333333333333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e79-1  is  23333333333333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e80-1  is  2333333333333333333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e81-1  is  233333333333333333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e82-1  is  23333333333333333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e83-1  is  2333333333333333333333333333333333333333333333333333333333333333333333333333333333316666666666666666666666666666666666666666666666666666666666666666666666666666666668
integers from 1 ──► 1e84-1  is  233333333333333333333333333333333333333333333333333333333333333333333333333333333333166666666666666666666666666666666666666666666666666666666666666666666666666666666668
</pre>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
see sum35(1000) + nl
 
func sum35 n
     n = n - 1
     return(3 * tri(floor(n / 3)) + 
	    5 * tri(floor(n / 5)) - 
	    15 * tri(floor(n / 15)))

func tri n
     return n * (n + 1) / 2
</syntaxhighlight>

=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
===Simple solution===
Just counting...
 ≪ 0 1 DO
      1 + 
      IF DUP 3 MOD NOT OVER 5 MOD NOT OR THEN SWAP OVER + SWAP END
    UNTIL DUP 4 PICK == END
    ROT DROP2
 ≫
===Efficient solution===
This is a fast approach to calculate the sum for higher values of n, taking into account that:
# the sum of multiples of 3 and 5 is the sum of multiples of 3 plus the sum of multiples of 5, minus the sum of multiples of 15 to remove double counting
# the sum of multiples of m being < n is equal to m*(1+2+ ... k) with k =[n/m]
# 1+2+...k = k*(k+1)/2
Unfortunately, RPL can only handle double precision numbers, which prevents from precisely calculating the sum for n > 1E+15
 ≪ → n 
   ≪ 0 1 3 FOR j 
         { 3 5 -15 } j GET 
         n OVER / ABS IP 
         DUP 1 + * 2 / * + 
      NEXT
 ≫ ≫
 ‘SUM35’ STO

 999 SUM35
{{out}}
<pre>
1: 233168
</pre>

=={{header|Ruby}}==
Simple Version (Slow):
<syntaxhighlight lang="ruby">def sum35(n)
  (1...n).select{|i|i%3==0 or i%5==0}.sum
end
puts sum35(1000)      #=> 233168</syntaxhighlight>

Fast Version:
<syntaxhighlight lang="ruby"># Given two integers n1,n2 return sum of multiples upto n3
#
#  Nigel_Galloway
#  August 24th., 2013.
def g(n1, n2, n3)
   g1 = n1*n2
   (1..g1).select{|x| x%n1==0 or x%n2==0}.collect{|x| g2=(n3-x)/g1; (x+g1*g2+x)*(g2+1)}.inject{|sum,x| sum+x}/2
end

puts g(3,5,999)

# For extra credit
puts g(3,5,100000000000000000000-1)</syntaxhighlight>

{{out}}
<pre>
233168
2333333333333333333316666666666666666668
</pre>

Other way:
{{trans|D}}
<syntaxhighlight lang="ruby">def sumMul(n, f)
  n1 = (n - 1) / f
  f * n1 * (n1 + 1) / 2
end

def sum35(n)
  sumMul(n, 3) + sumMul(n, 5) - sumMul(n, 15)
end

for i in 1..20
  puts "%2d:%22d %s" % [i, 10**i, sum35(10**i)]
end</syntaxhighlight>

{{out}}
<pre>
 1:                    10 23
 2:                   100 2318
 3:                  1000 233168
 4:                 10000 23331668
 5:                100000 2333316668
 6:               1000000 233333166668
 7:              10000000 23333331666668
 8:             100000000 2333333316666668
 9:            1000000000 233333333166666668
10:           10000000000 23333333331666666668
11:          100000000000 2333333333316666666668
12:         1000000000000 233333333333166666666668
13:        10000000000000 23333333333331666666666668
14:       100000000000000 2333333333333316666666666668
15:      1000000000000000 233333333333333166666666666668
16:     10000000000000000 23333333333333331666666666666668
17:    100000000000000000 2333333333333333316666666666666668
18:   1000000000000000000 233333333333333333166666666666666668
19:  10000000000000000000 23333333333333333331666666666666666668
20: 100000000000000000000 2333333333333333333316666666666666666668
</pre>

=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">print multSum35(1000)
end
function multSum35(n)
    for i = 1 to n - 1
        If (i mod 3 = 0) or (i mod 5 = 0) then  multSum35 = multSum35 + i
    next i
end function</syntaxhighlight><pre>233168</pre>

=={{header|Rust}}==
<syntaxhighlight lang="rust">
extern crate rug;

use rug::Integer;
use rug::ops::Pow;

fn main() {
    for i in [3, 20, 100, 1_000].iter() {
        let ten = Integer::from(10);
        let mut limit = Integer::from(Integer::from(&ten.pow(*i as u32)) - 1);
        let mut aux_3_1 = &limit.mod_u(3u32);
        let mut aux_3_2 = Integer::from(&limit - aux_3_1);
        let mut aux_3_3 = Integer::from(&aux_3_2/3);
        let mut aux_3_4 = Integer::from(3 + aux_3_2);
        let mut aux_3_5 = Integer::from(&aux_3_3*&aux_3_4);
        let mut aux_3_6 = Integer::from(&aux_3_5/2);
 
        let mut aux_5_1 = &limit.mod_u(5u32);
        let mut aux_5_2 = Integer::from(&limit - aux_5_1); 
        let mut aux_5_3 = Integer::from(&aux_5_2/5);
        let mut aux_5_4 = Integer::from(5 + aux_5_2); 
        let mut aux_5_5 = Integer::from(&aux_5_3*&aux_5_4);
        let mut aux_5_6 = Integer::from(&aux_5_5/2); 

        let mut aux_15_1 = &limit.mod_u(15u32);
        let mut aux_15_2 = Integer::from(&limit - aux_15_1); 
        let mut aux_15_3 = Integer::from(&aux_15_2/15);
        let mut aux_15_4 = Integer::from(15 + aux_15_2);
        let mut aux_15_5 = Integer::from(&aux_15_3*&aux_15_4);
        let mut aux_15_6 = Integer::from(&aux_15_5/2); 

        let mut result_aux_1 = Integer::from(&aux_3_6 + &aux_5_6); 
        let mut result = Integer::from(&result_aux_1 - &aux_15_6);
 
        println!("Sum for 10^{} : {}",i,result);
    }
}
</syntaxhighlight>
Output :
<pre>
Sum for 10^3 : 233168
Sum for 10^20 : 2333333333333333333316666666666666666668
Sum for 10^100 : 23333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668
Sum for 10^1000 : 23333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333331666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668

real	0m0.002s
user	0m0.002s
sys	0m0.000s

</pre>

=={{header|S-BASIC}}==
<syntaxhighlight lang="basic">
rem - return n mod m
function mod(n, m = integer) = integer
end = n - m * (n / m)

var i, limit = integer
var sum = real

limit = 1000
sum = 0
for i = 1 to limit-1
   if (mod(i,3) = 0) or (mod(i, 5) = 0) then
      sum = sum + i
next i
print using "Sum = #######"; sum

end
</syntaxhighlight>
{{out}}
<pre>
Sum = 233168
</pre>


=={{header|Scala}}==
<syntaxhighlight lang="scala">def sum35( max:BigInt ) : BigInt = max match {

  // Simplest solution but limited to Ints only
  case j if j < 100000 => (1 until j.toInt).filter( i => i % 3 == 0 || i % 5 == 0 ).sum
  
  // Using a custom iterator that takes Longs
  case j if j < 10e9.toLong => {
    def stepBy( step:Long ) : Iterator[Long] = new Iterator[Long] { private var i = step; def hasNext = true; def next() : Long = { val result = i; i = i + step; result } }
    stepBy(3).takeWhile( _< j ).sum + stepBy(5).takeWhile( _< j ).sum - stepBy(15).takeWhile( _< j ).sum 	
  }
  
  // Using the formula for a Triangular number
  case j => {
    def triangle( i:BigInt ) = i * (i+1) / BigInt(2)
    3 * triangle( (j-1)/3 ) + 5 * triangle( (j-1)/5 ) - 15 * triangle( (j-1)/15 )
  }
}

{
for( i <- (0 to 20); n = "1"+"0"*i ) println( (" " * (21 - i)) + n + " => " + (" " * (21 - i)) + sum35(BigInt(n)) )
}</syntaxhighlight>
{{out}}
<pre>                     1 =>                      0
                    10 =>                     23
                   100 =>                    2318
                  1000 =>                   233168
                 10000 =>                  23331668
                100000 =>                 2333316668
               1000000 =>                233333166668
              10000000 =>               23333331666668
             100000000 =>              2333333316666668
            1000000000 =>             233333333166666668
           10000000000 =>            23333333331666666668
          100000000000 =>           2333333333316666666668
         1000000000000 =>          233333333333166666666668
        10000000000000 =>         23333333333331666666666668
       100000000000000 =>        2333333333333316666666666668
      1000000000000000 =>       233333333333333166666666666668
     10000000000000000 =>      23333333333333331666666666666668
    100000000000000000 =>     2333333333333333316666666666666668
   1000000000000000000 =>    233333333333333333166666666666666668
  10000000000000000000 =>   23333333333333333331666666666666666668
 100000000000000000000 =>  2333333333333333333316666666666666666668</pre>

=={{header|Scheme}}==
<syntaxhighlight lang="scheme">(fold (lambda (x tot) (+ tot (if (or (zero? (remainder x 3)) (zero? (remainder x 5))) x 0))) 0 (iota 1000))</syntaxhighlight>

Output:
<pre>
233168
</pre>

Or, more clearly by decomposition:

<syntaxhighlight lang="scheme">(define (fac35? x)
    (or (zero? (remainder x 3)) 
        (zero? (remainder x 5))))

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

(fold fac35filt 0 (iota 1000))</syntaxhighlight>

Output:
<pre>
233168
</pre>

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

<syntaxhighlight lang="scheme">(define (trisum n fac)
    (let* ((n1 (quotient (- n 1) fac)) 
           (n2 (+ n1 1)))
        (quotient (* fac n1 n2) 2)))

(define (fast35sum n)
    (- (+ (trisum n 5) (trisum n 3)) (trisum n 15)))

(fast35sum 1000)
(fast35sum 100000000000000000000)
</syntaxhighlight>

Output:
<pre>
233168
2333333333333333333316666666666666666668
</pre>

=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
  include "bigint.s7i";

const func bigInteger: sum35 (in bigInteger: n) is func
  result
    var bigInteger: sum35 is 0_;
  local
    const func bigInteger: sumMul (in bigInteger: n, in bigInteger: f) is func
      result
        var bigInteger: sumMul is 0_;
      local
        var bigInteger: n1 is 0_;
      begin
        n1 := pred(n) div f;
        sumMul := f * n1 * succ(n1) div 2_;
      end func;
   begin
     sum35 := sumMul(n, 3_) + sumMul(n, 5_) - sumMul(n, 15_);
   end func;
 
const proc: main is func
  begin
    writeln(sum35(1000_));
    writeln(sum35(10_ ** 20));
  end func;</syntaxhighlight>

{{out}}
<pre>
233168
2333333333333333333316666666666666666668
</pre>

=={{header|Sidef}}==
{{trans|Ruby}}
<syntaxhighlight lang="ruby">func sumMul(n, f) {
    var m = int((n - 1) / f)
    f * m * (m + 1) / 2
}

func sum35(n) {
    sumMul(n, 3) + sumMul(n, 5) - sumMul(n, 15)
}

for i in (1..20) {
    printf("%2s:%22s %s\n", i, 10**i, sum35(10**i))
}</syntaxhighlight>
{{out}}
<pre>
 1:                    10 23
 2:                   100 2318
 3:                  1000 233168
 4:                 10000 23331668
 5:                100000 2333316668
 6:               1000000 233333166668
 7:              10000000 23333331666668
 8:             100000000 2333333316666668
 9:            1000000000 233333333166666668
10:           10000000000 23333333331666666668
11:          100000000000 2333333333316666666668
12:         1000000000000 233333333333166666666668
13:        10000000000000 23333333333331666666666668
14:       100000000000000 2333333333333316666666666668
15:      1000000000000000 233333333333333166666666666668
16:     10000000000000000 23333333333333331666666666666668
17:    100000000000000000 2333333333333333316666666666666668
18:   1000000000000000000 233333333333333333166666666666666668
19:  10000000000000000000 23333333333333333331666666666666666668
20: 100000000000000000000 2333333333333333333316666666666666666668
</pre>

=={{header|Simula}}==
(referenced from [[Greatest common divisor#Simula|Greatest common divisor]])
<syntaxhighlight lang="algol68">! Find the sum of multiples of two factors below a limit -
! Project Euler problem 1: multiples of 3 or 5 below 1000 & 10**20;
BEGIN
    INTEGER PROCEDURE GCD(a, b); INTEGER a, b;
        GCD := IF b = 0 THEN a ELSE GCD(b, MOD(a, b));

    ! sum of multiples of n up to limit;
    INTEGER PROCEDURE multiples(n, limit); INTEGER n, limit;
    BEGIN
        INTEGER m;
        m := limit // n;
    ! moving //2 to sumMultiples() looked just too silly    ;
        multiples := n*((m*(m+1)) // 2) ! and risks overflow;
    END
    ! sum of multiples of n or m below limit;
    INTEGER PROCEDURE sumMultiples(n, m, limit);
        INTEGER n, m, limit;
    BEGIN
        INTEGER LCM;
        LCM:= (n // GCD(n, m)) * m;
        limit := limit-1;
        sumMultiples := multiples(n, limit) + multiples(m, limit)
                        - multiples(LCM, limit)
    END sumMultiples;
    
    ! Extra creditable: math is about avoiding calculation tedium;
    TEXT PROCEDURE repeat(c, n); CHARACTER c; INTEGER n; BEGIN
        TEXT r; r :- BLANKS(n);
        FOR n := n STEP -1 UNTIL 1 DO r.PUTCHAR(c);
        repeat :- r;
    END;
    TEXT PROCEDURE sumOfMultiplesOf3or5below10toThePowerOf(e);
        INTEGER e;
    sumOfMultiplesOf3or5below10toThePowerOf :-
        IF e < 1 THEN "0" ELSE IF e = 1 THEN "23"
        ELSE "23" & repeat('3', e-2)
            & "1" & repeat('6', e-2) & "8";

    INTEGER factor, n;
    FOR factor := 5 !, 2, 6;
                    DO BEGIN
        OUTTEXT("sum of positive multiples of 3 and");
        OUTINT(factor, 2); OUTCHAR(':');
        FOR n := ! 1 STEP 1 UNTIL 15, 100,;
                 1000 DO BEGIN
            OUTCHAR(' '); OUTINT(sumMultiples(3, factor, n), 0)
        END;
        OUTIMAGE
    END;
    FOR n := 0, 1, 3, 5, 10, 20, 40 DO BEGIN
        OUTTEXT(sumOfMultiplesOf3or5below10toThePowerOf(n));
        OUTIMAGE
    END
END</syntaxhighlight>
{{out}}
sum of positive multiples of 3 and 5: 233168<br />
0<br />
23<br />
233168<br />
2333316668<br />
23333333331666666668<br />
2333333333333333333316666666666666666668<br />
23333333333333333333333333333333333333331666666666666666666666666666666666666668

=={{header|Stata}}==
=== With a dataset ===
<syntaxhighlight lang="stata">clear all
set obs 999
gen a=_n
tabstat a if mod(a,3)==0 | mod(a,5)==0, statistic(sum)</syntaxhighlight>

=== With Mata ===
<syntaxhighlight lang="stata">mata
a=1..999
sum(a:*(mod(a,3):==0 :| mod(a,5):==0))</syntaxhighlight>

=={{header|Swift}}==
<syntaxhighlight lang="swift">


var n:Int=1000

func sum(x:Int)->Int{
	
	var s:Int=0
	for i in 0...x{
		if i%3==0 || i%5==0
		{
			s=s+i
		}
		
	}
	return s
}

var sumofmult:Int=sum(x:n)
print(sumofmult)

</syntaxhighlight>

=={{header|Tcl}}==
<syntaxhighlight lang="tcl"># Fairly simple version; only counts by 3 and 5, skipping intermediates
proc mul35sum {n} {
    for {set total [set threes [set fives 0]]} {$threes<$n||$fives<$n} {} {
	if {$threes<$fives} {
	    incr total $threes
	    incr threes 3
	} elseif {$threes>$fives} {
	    incr total $fives
	    incr fives 5
	} else {
	    incr total $threes
	    incr threes 3
	    incr fives 5
	}
    }
    return $total
}</syntaxhighlight>
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).
<syntaxhighlight lang="tcl"># Smart version; no iteration so very scalable!
proc tcl::mathfunc::triangle {n} {expr {
    $n * ($n+1) / 2
}}
# Note that the rounding on integer division is exactly what we need here.
proc sum35 {n} {
    incr n -1
    expr {3*triangle($n/3) + 5*triangle($n/5) - 15*triangle($n/15)}
}</syntaxhighlight>
Demonstrating:
<syntaxhighlight lang="tcl">puts [mul35sum 1000],[sum35 1000]
puts [mul35sum 10000000],[sum35 10000000]
# Just the quick one; waiting for the other would get old quickly...
puts [sum35 100000000000000000000]</syntaxhighlight>
{{out}}
<pre>233168,233168
23333331666668,23333331666668
2333333333333333333316666666666666666668
</pre>

=={{header|TI SR-56}}==
=== Iterative solution ===
{| class="wikitable"
|+ Texas Instruments SR-56 Program Listing for "Sum Multiples" (Iterative)
|-
! Display !! Key  !! Display !! Key !! Display !! Key !! Display !! Key
|-
| 00 22   || GTO  ||   25 33 || STO  ||   50    ||     ||   75    ||     
|-
| 01 04   || 4    ||   26 00 || 0    ||   51    ||     ||   76    ||     
|-
| 02 04   || 4    ||   27 57 || *subr ||   52    ||     ||   77    ||     
|-
| 03 52   || (    ||   28 00 || 0    ||   53    ||     ||   78    ||     
|-
| 04 52   || (    ||   29 03 || 3    ||   54    ||     ||   79    ||     
|-
| 05 34   || RCL  ||   30 12 || INV  ||   55    ||     ||   80    ||     
|-
| 06 00   || 0    ||   31 37 || *x=t ||   56    ||     ||   81    ||     
|-
| 07 54   || /    ||   32 03 || 3    ||   57    ||     ||   82    ||     
|-
| 08 05   || 5    ||   33 08 || 8    ||   58    ||     ||   83    ||     
|-
| 09 53   || )    ||   34 34 || RCL  ||   59    ||     ||   84    ||     
|-
| 10 12   || INV  ||   35 00 || 0    ||   60    ||     ||   85    ||     
|-
| 11 29   || *Int ||   36 35 || SUM  ||   61    ||     ||   86    ||     
|-
| 12 64   || x    ||   37 01 || 1    ||   62    ||     ||   87    ||     
|-
| 13 52   || (    ||   38 27 || *dsz ||   63    ||     ||   88    ||     
|-
| 14 34   || RCL  ||   39 02 || 2    ||   64    ||     ||   89    ||     
|-
| 15 00   || 0    ||   40 07 || 7    ||   65    ||     ||   90    ||     
|-
| 16 54   || /    ||   41 34 || RCL  ||   66    ||     ||   91    ||     
|-
| 17 03   || 3    ||   42 01 || 1    ||   67    ||     ||   92    ||     
|-
| 18 53   || )    ||   43 41 || R/S  ||   68    ||     ||   93    ||     
|-
| 19 12   || INV  ||   44 74 || -    ||   69    ||     ||   94    ||     
|-
| 20 29   || *Int ||   45 01 || 1    ||   70    ||     ||   95    ||     
|-
| 21 53   || )    ||   46 94 || =    ||   71    ||     ||   96    ||     
|-
| 22 58   || *rtn ||   47 22 || GTO  ||   72    ||     ||   97    ||     
|-
| 23 56   || *CP  ||   48 02 || 2    ||   73    ||     ||   98    ||     
|-
| 24 38   || *CMs ||   49 03 || 3    ||   74    ||     ||   99    ||     
|}

Asterisk denotes 2nd function key.

{| class="wikitable"
|+ Register allocation
|-
| 0: Current Term || 1: Sum Of Terms || 2: Unused || 3: Unused || 4: Unused
|-
| 5: Unused || 6: Unused || 7: Unused || 8: Unused || 9: Unused
|}

Annotated listing:
<syntaxhighlight lang="text">
// Address 00: Entry point.
GTO 4 4

// Address 03: Subroutine
// If R0 is divisible by 3 and 5, return 0, else nonzero
( ( RCL 0 / 5 ) INV *Int x ( RCL 0 / 3 ) INV *Int ) *rtn

// Address 23: Main program
*CP *CMs       // Zero all registers and T register.
STO 0          // R0 := Maximum number to consider.
*subr 0 3      // Check divisibility by 3 and 5.
INV *x=t 3 8   // Divisible? 
RCL 0
SUM 1          // R1 += R0
*dsz 2 7       // R0--, repeat while nonzero.
RCL 1          // Retrieve answer.
R/S            // End.

// Address 44: Input parsing
- 1 =          // Consider all numbers *less than* N.
GTO 2 3
</syntaxhighlight>

'''Usage:'''

{{in}}

<pre>1000 RST R/S</pre>

{{out}}

<pre>233168</pre>

This took between 20 and 30 minutes to run.

=== Efficient closed-form solution ===

{| class="wikitable"
|+ Texas Instruments SR-56 Program Listing for "Sum Multiples" (Closed-form)
|-
! Display !! Key  !! Display !! Key !! Display !! Key !! Display !! Key
|-
| 00 22   || GTO  ||   25 29 || *Int  ||   50 54 || /     ||   75    ||     
|-
| 01 01   || 1    ||   26 57 || *subr ||   51 01 || 1     ||   76    ||     
|-
| 02 06   || 6    ||   27 00 || 0     ||   52 05 || 5     ||   77    ||     
|-
| 03 33   || STO  ||   28 03 || 3     ||   53 94 || =     ||   78    ||     
|-
| 04 01   || 1    ||   29 64 || x     ||   54 29 || *Int  ||   79    ||     
|-
| 05 54   || /    ||   30 05 || 5     ||   55 57 || *subr ||   80    ||     
|-
| 06 02   || 2    ||   31 94 || =     ||   56 00 || 0     ||   81    ||     
|-
| 07 64   || x    ||   32 35 || SUM   ||   57 03 || 3     ||   82    ||     
|-
| 08 52   || (    ||   33 02 || 2     ||   58 64 || x     ||   83    ||     
|-
| 09 34   || RCL  ||   34 34 || RCL   ||   59 01 || 1     ||   84    ||     
|-
| 10 01   || 1    ||   35 00 || 0     ||   60 05 || 5     ||   85    ||     
|-
| 11 84   || +    ||   36 54 || /     ||   61 94 || =     ||   86    ||     
|-
| 12 01   || 1    ||   37 03 || 3     ||   62 12 || INV   ||   87    ||     
|-
| 13 53   || )    ||   38 94 || =     ||   63 35 || SUM   ||   88    ||     
|-
| 14 53   || )    ||   39 29 || *Int  ||   64 02 || 2     ||   89    ||     
|-
| 15 58   || *rtn ||   40 57 || *subr ||   65 34 || RCL   ||   90    ||     
|-
| 16 38   || *CMs ||   41 00 || 0     ||   66 02 || 2     ||   91    ||     
|-
| 17 74   || -    ||   42 03 || 3     ||   67 41 || R/S   ||   92    ||     
|-
| 18 01   || 1    ||   43 64 || x     ||   68    ||       ||   93    ||     
|-
| 19 94   || =    ||   44 03 || 3     ||   69    ||       ||   94    ||     
|-
| 20 33   || STO  ||   45 94 || =     ||   70    ||       ||   95    ||     
|-
| 21 00   || 0    ||   46 35 || SUM   ||   71    ||       ||   96    ||     
|-
| 22 54   || /    ||   47 02 || 2     ||   72    ||       ||   97    ||     
|-
| 23 05   || 5    ||   48 34 || RCL   ||   73    ||       ||   98    ||     
|-
| 24 94   || =    ||   49 00 || 0     ||   74    ||       ||   99    ||     
|}

Asterisk denotes 2nd function key.

{| class="wikitable"
|+ Register allocation
|-
| 0: Maximum Term || 1: Parameter || 2: Answer || 3: Unused || 4: Unused
|-
| 5: Unused || 6: Unused || 7: Unused || 8: Unused || 9: Unused
|}

Annotated listing:
<syntaxhighlight lang="text">
// Address 00: Entry point.
GTO 1 6

// Address 03: Subroutine
// Calculates sum of nums 1-N as (N/2)(N+1).
STO 1
/ 2 x ( RCL 1 + 1 ) ) *rtn

// Address 16: Main program
*CMs                                             // Clear registers.
- 1 = STO 0                                      // R0 := N-1
      / 5   = *Int *subr 0 3 x 5   =     SUM 2   // R2 += fives
RCL 0 / 3   = *Int *subr 0 3 x 3   =     SUM 2   // R2 += threes
RCL 0 / 1 5 = *Int *subr 0 3 x 1 5 = INV SUM 2   // R2 -= fifteens
RCL 2                                            // Retrieve answer.
R/S                                              // End.
</syntaxhighlight>

'''Usage:'''

{{in}}

<pre>1000 RST R/S</pre>

{{out}}

<pre>233168</pre>

Completed in 4 seconds.

{{in}}

<pre>1 EE 20 RST R/S</pre>

{{out}}

<pre>2.333333333 39</pre>

Completed in 4 seconds.

=={{header|Uiua}}==
<syntaxhighlight>
End ← 1000

MultOfthree ← ⊚=0◿3 # indices where divisible by 3
Indicesthree ← MultOfthree ↘1⇡End
MultOffive ← ⊚=0◿5 # indices where divisible by 5
IndicesFive ← MultOffive ↘1⇡End

/+ ⊏⊂ Indicesthree IndicesFive ↘1⇡End # join, select and sum
</syntaxhighlight>
{{out}}
233168
</pre>

=={{header|UNIX Shell}}==
{{works with|Bourne Again SHell}}
{{works with|Korn Shell}}
{{works with|Zsh}}
Only works up to 1000000000 due to limits of shell integer representation.

<syntaxhighlight lang="sh">function sum_multiples {
  typeset -i n=$1 limit=$2
  typeset -i max=limit-1
  (( max -= max % n ))
  printf '%d\n' $(( max / n * (n+max)/2 ))
}

function sum35 {
  typeset -i limit=$1
  printf '%d\n' $((  $(sum_multiples  3 $limit)
                   + $(sum_multiples  5 $limit)
                   - $(sum_multiples 15 $limit) ))
}

for (( l=1; l<=1000000000; l*=10 )); do
  printf '%10d\t%18d\n' "$l" "$(sum35 "$l")"
done</syntaxhighlight>

{{Out}}
<pre>         1	                 0
        10	                23
       100	              2318
      1000	            233168
     10000	          23331668
    100000	        2333316668
   1000000	      233333166668
  10000000	    23333331666668
 100000000	  2333333316666668
1000000000	233333333166666668</pre>
=={{header|VBA}}==
{{trans|VBScript}}
<syntaxhighlight lang="vb">Private Function SumMult3and5VBScript(n As Double) As Double
Dim i As Double
    For i = 1 To n - 1
        If i Mod 3 = 0 Or i Mod 5 = 0 Then
            SumMult3and5VBScript = SumMult3and5VBScript + i
        End If
    Next
End Function</syntaxhighlight>
Other way :
<syntaxhighlight lang="vb">Private Function SumMult3and5(n As Double) As Double
Dim i As Double
    For i = 3 To n - 1 Step 3
        SumMult3and5 = SumMult3and5 + i
    Next
    For i = 5 To n - 1 Step 5
        If i Mod 15 <> 0 Then SumMult3and5 = SumMult3and5 + i
    Next
End Function</syntaxhighlight>
Better way :
<syntaxhighlight lang="vb">Private Function SumMult3and5BETTER(n As Double) As Double
Dim i As Double
    For i = 3 To n - 1 Step 3
        SumMult3and5BETTER = SumMult3and5BETTER + i
    Next
    For i = 5 To n - 1 Step 5
        SumMult3and5BETTER = SumMult3and5BETTER + i
    Next
    For i = 15 To n - 1 Step 15
        SumMult3and5BETTER = SumMult3and5BETTER - i
    Next
End Function</syntaxhighlight>

Call :
<syntaxhighlight lang="vb">Option Explicit

Sub Main()
Dim T#
    T = Timer
    Debug.Print SumMult3and5VBScript(100000000) & "   " & Format(Timer - T, "0.000 sec.")
    T = Timer
    Debug.Print SumMult3and5(100000000) & "   " & Format(Timer - T, "0.000 sec.")
    T = Timer
    Debug.Print SumMult3and5BETTER(100000000) & "   " & Format(Timer - T, "0.000 sec.")
    Debug.Print "-------------------------"
    Debug.Print SumMult3and5BETTER(1000)
End Sub</syntaxhighlight>
{{Out}}
<pre>2,33333331666667E+15   9,059 sec.
2,33333331666667E+15   2,107 sec.
2,33333331666667E+15   1,799 sec.
-------------------------
233168
</pre>

=={{header|VBScript}}==
{{trans|Run BASIC}}
<syntaxhighlight lang="vb">
Function multsum35(n)
	For i = 1 To n - 1
		If i Mod 3 = 0 Or i Mod 5 = 0 Then
			multsum35 = multsum35 + i
		End If
	Next
End Function

WScript.StdOut.Write multsum35(CLng(WScript.Arguments(0)))
WScript.StdOut.WriteLine
</syntaxhighlight>

{{Out}}
<pre>
F:\>cscript /nologo multsum35.vbs 1000
233168
</pre>


=={{header|Verilog}}==
<syntaxhighlight lang="verilog">module main;
  integer i, suma;
  
  initial begin
  suma = 0;
    for(i = 1; i <= 999; i=i+1) 
    begin
        if(i % 3 == 0) suma = suma + i;
        else if(i % 5 == 0) suma = suma + i;
    end
    $display(suma);
    $finish ;
    end
endmodule</syntaxhighlight>

=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="go">fn s35(n int) int {
    mut nn := n-1
    mut threes := nn/3
    mut fives := nn/5
    mut fifteen := nn/15

    threes = 3 * threes * (threes + 1)
    fives = 5 * fives * (fives + 1)
    fifteen = 15 * fifteen * (fifteen + 1)

    nn = (threes + fives - fifteen) / 2
 
    return nn
}

fn main(){
    println(s35(1000))
}</syntaxhighlight>
{{out}}
<pre>
233168
</pre>

=={{header|Wortel}}==
<syntaxhighlight lang="wortel">@let {
  sum35 ^(@sum \!-@(\~%%3 || \~%%5) @til)
	
  !sum35 1000 ; returns 233168
}</syntaxhighlight>

=={{header|Wren}}==
===Simple version===
<syntaxhighlight lang="wren">var sum35 = Fn.new { |n|
    n = n - 1
    var s3 = (n/3).floor
    var s5 = (n/5).floor
    var s15 = (n/15).floor
    s3 = 3 * s3 * (s3+1)
    s5 = 5 * s5 * (s5+1)
    s15 = 15 * s15 * (s15+1)
    return (s3 + s5 - s15)/2
}

System.print(sum35.call(1000))</syntaxhighlight>

{{out}}
<pre>
233168
</pre>
<br>
===Fast version with arbitrary precision===
{{trans|C}}
{{libheader|Wren-gmp}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./gmp" for Mpz
import "./fmt" for Fmt

var sumMultiples = Fn.new { |result, limit, f|
    var m = Mpz.from(limit).sub(1).fdiv(f)
    result.set(m).inc.mul(m).mul(f).rsh(1)
}

var limit = Mpz.one
var tempSum = Mpz.new()
var sum35 = Mpz.new()
var max = 25
Fmt.print("$*s  $s", max + 1, "limit", "sum")
for (i in 0..max) {
    Fmt.write("$*s  ", max + 1, limit)
    sumMultiples.call(tempSum, limit, 3)
    sum35.set(tempSum)
    sumMultiples.call(tempSum, limit, 5)
    sum35.add(tempSum)
    sumMultiples.call(tempSum, limit, 15)
    sum35.sub(tempSum)
    System.print(sum35)
    limit.mul(10)
}</syntaxhighlight>

{{out}}
<pre>
                     limit  sum
                         1  0
                        10  23
                       100  2318
                      1000  233168
                     10000  23331668
                    100000  2333316668
                   1000000  233333166668
                  10000000  23333331666668
                 100000000  2333333316666668
                1000000000  233333333166666668
               10000000000  23333333331666666668
              100000000000  2333333333316666666668
             1000000000000  233333333333166666666668
            10000000000000  23333333333331666666666668
           100000000000000  2333333333333316666666666668
          1000000000000000  233333333333333166666666666668
         10000000000000000  23333333333333331666666666666668
        100000000000000000  2333333333333333316666666666666668
       1000000000000000000  233333333333333333166666666666666668
      10000000000000000000  23333333333333333331666666666666666668
     100000000000000000000  2333333333333333333316666666666666666668
    1000000000000000000000  233333333333333333333166666666666666666668
   10000000000000000000000  23333333333333333333331666666666666666666668
  100000000000000000000000  2333333333333333333333316666666666666666666668
 1000000000000000000000000  233333333333333333333333166666666666666666666668
10000000000000000000000000  23333333333333333333333331666666666666666666666668
</pre>

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">include c:\cxpl\stdlib;

func Sum1;      \Return sum the straightforward way
int  N, S;
[S:= 0;
for N:= 1 to 999 do
    if rem(N/3)=0 or rem(N/5)=0 then S:= S+N;
return S;
];

func Sum2(D);   \Return sum of sequence using N*(N+1)/2
int  D;
int  Q;
[Q:= (1000-1)/D;
return Q*(Q+1)/2*D;
];

func Sum3(D);   \Return sum of sequence for really big number
string 0;       \don't terminate strings by setting most significant bit
int  D;         \divisor
int  I;
char P(40), Q(40), R(40);       \product, quotient, result
[StrNDiv("99999999999999999999", D, Q, 20);     \Q:= (1E20-1)/D
for I:= 0 to 17 do R(I):= ^0;                   \R:= D
R(18):= D/10 +^0;
R(19):= rem(0) +^0;
StrNMul(Q, R, P, 20);                           \P:= Q*R = Q*D
StrNAdd("00000000000000000001", Q, 20);         \Q:= Q+1
StrNMul(P+20, Q, R, 20);                        \R:= P*Q = Q*D*(Q+1)
StrNDiv(R, 2, Q, 40);                           \Q:= P/2 = Q*D*(Q+1)/2
return Q;                                       \(very temporary location)
];

char S(40), T;
[IntOut(0, Sum1);  CrLf(0);
 IntOut(0, Sum2(3) + Sum2(5) - Sum2(3*5));  CrLf(0);
StrNCopy(Sum3(3), S, 40);
StrNAdd(Sum3(5), S, 40);
T:= Sum3(3*5);
StrNSub(S, T, 40);
TextN(0, T, 40);  CrLf(0);
]</syntaxhighlight>

{{out}}
<pre>
233168
233168
2333333333333333333316666666666666666668
</pre>

=={{header|Zig}}==
Note that solving for 1e20 requires numbers > 128 bits. However, Zig supports fixed size integers up to 65,556 bits, and with Zig, it's possible to figure out at compile-time what the maximum width of an integer should be at run-time.
<syntaxhighlight lang="zig">
const std = @import("std");

fn DoubleWide(comptime n: anytype) type {
    const Signedness = std.builtin.Signedness;
    switch (@typeInfo(@TypeOf(n))) {
        .Int => |t|
            return std.meta.Int(t.signedness, t.bits * 2),
        .ComptimeInt => {
            const sz = @as(u16, @intFromFloat(@log2(@as(f64, @floatFromInt(n))))) + 1;
            return std.meta.Int(Signedness.signed, sz * 2);
        },
        else =>
            @compileError("must have integral type for DoubleWide")
    }
}

fn sumdiv(n: anytype, d: anytype) DoubleWide(n) {
    var m: DoubleWide(n) = @divFloor(n, d);
    return @divExact(m * (m + 1), 2) * d;
}

fn sum3or5(n: anytype) DoubleWide(n) {
    return sumdiv(n, 3) + sumdiv(n, 5) - sumdiv(n, 15);
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    var s: usize = 0;
    for (1..1000) |n| {
        if (n % 3 == 0 or n % 5 == 0)
            s += n;
    }
    try stdout.print("The sum of the multiples of 3 and 5 below 1000 is {}\n", .{s});
    try stdout.print("The sum of the multiples of 3 and 5 below 1e20 is {}\n", .{sum3or5(99_999_999_999_999_999_999)});
}

</syntaxhighlight>
{{Out}}
<pre>
The sum of the multiples of 3 and 5 below 1000 is 233168
The sum of the multiples of 3 and 5 below 1e20 is 2333333333333333333316666666666666666668

</pre>
=={{header|zkl}}==
Brute force:
<syntaxhighlight lang="zkl">[3..999,3].reduce('+,0) + [5..999,5].reduce('+,0) - [15..999,15].reduce('+,0)
233168</syntaxhighlight>
{{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).
<syntaxhighlight lang="zkl">fcn sumMul(N,m){N=(N-1)/m; N*(N+1)*m/2}
fcn sum35(N){sumMul(N,3) + sumMul(N,5) - sumMul(N,15)}</syntaxhighlight>
{{out}}
<pre>
zkl: sum35(1000)  // int-->int
233168

zkl: var BN=Import("zklBigNum");
zkl: sum35(BN("1"+"0"*21))  // 1 with 21 zeros, BigNum-->BigNum
233333333333333333333166666666666666666668
sum35(BN("1"+"0"*15)) : "%,d".fmt(_)// 1e15, BigNum don't like float format input
233,333,333,333,333,166,666,666,666,668
</pre>