Mathematical background

The multiple of a number is defined such that:

$$ b = n \cdot a $$

In previous expression:

• The integer number $a$ is named the divisor.
• The integer number $b$ is named the multiple.
• The integer number $n$ is named the multiplier.

The modulus and the remainder are not the same!

Let us clarify the difference between modulus and remainder. These two mathematical concepts are not the same. In addition, they are treated differently by different programming languages.

There are plenty of posts explaining this concept all over the web. However, let me explain here the difference using my own words and diagrams.

Remainder

At school, we are taught the “Euclidean division” as one of the basic arithmetic operations. For example, if we split a cake into 9 pieces and there are a total of 4 people, each people receives two slices. This implies 1 slice is left over, this means that it remains in the table without being consumed.

Remember that the Euclid’s division lemma is defined as:

$$ b = aq + r $$

In previous expression:

• The integer $b$ is the divident.
• The integer $a$ is the divisor.
• The integer $q$ is the quotient.
• The integer $r$ is the remainder.

Note that when $r=0$, then $q \equiv n$.

Modulus

The modulus can be defined as the particular value within modular arithmetic for which the system wraps around itself, starting again.

The modulus operation is widely used in criptography due to its “one way function” and in computer graphics for creating the feeling of an infinite game board, as in the Asteroids game.

Possible origin of the confusion

Due to its applications, the modulus operator usually involves dealing with positive integer values. In this situation, the result of the modulus operation is the same as the one for the remainder.

Solution

The solution is presented in three different languages: C, Rust and Python. Note that two constants named LOWER_BOUND and UPPER_BOUND have been defined so this code can be extended on demand.

Also, note that we are using in all the cases the modulo operator. However, because all the quantities involved are unsigned integers, its result is the same as the one for the remainder.

/*
 * This program solves problem 001 from Project Euler. The statement is as
 * follows:
 *
 * If we list all the natural numbers below 10 that are multiples of 3 or 5, we
 * get 3, 5, 6 and 9. The sum of these multiples is 23.
 *
 * Find the sum of all the multiples of 3 or 5 below 1000.
 *
 */

#include <stdio.h>
#include <stdlib.h>

#define LOWER_BOUND 3
#define UPPER_BOUND 1000


int main()
{
    long int multiples_sum = 0;

    for (int number = LOWER_BOUND; number < UPPER_BOUND; number++) {
        if (number % 3 == 0 || number % 5 == 0) {
            multiples_sum += number;
        }
    }
    printf("Answer: %ld\n", multiples_sum);

    return EXIT_SUCCESS;
}

// This program solves problem 001 from Project Euler. The statement is as
// follows:
// 
// If we list all the natural numbers below 10 that are multiples of 3 or 5, we
// get 3, 5, 6 and 9. The sum of these multiples is 23.
// 
// Find the sum of all the multiples of 3 or 5 below 1000.

const LOWER_BOUND: u32  = 3;
const UPPER_BOUND: u32  = 1000;


fn main() {
    let mut multiples_sum: u32 = 0;

    for number in LOWER_BOUND..UPPER_BOUND {
        if number % 3 == 0 || number % 5 == 0 {
            multiples_sum = multiples_sum + number;
        }
    }
    println!("Answer: {multiples_sum}");
}

"""
This program solves problem 001 from Project Euler. The statement is as
follows:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we
get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.
"""

LOWER_BOUND = 3
UPPER_BOUND = 1000


def main():
    multiples_sum = 0

    for number in range(LOWER_BOUND, UPPER_BOUND):
        if number % 3 == 0 or number % 5 == 0:
            multiples_sum += number
    print(f"Answer: {multiples_sum}")


if __name__ == "__main__":
    main()

Output

Answer: 233168