Question

Write a short \(\mathrm{C}++\) function, isMultiple, that takes two long values, \(n\) and \(m,\) and returns true if and only if \(n\) is a multiple of \(m,\) that is, \(n=m \cdot i\) for some integer \(i\).

Short answer

Define the function with signature `bool isMultiple(long n, long m)`, return false if `m` is zero, use `return n % m == 0` otherwise.

Step-by-step solution

Define the Function Signature

Start by defining the function signature. The function name is `isMultiple`, and it takes two `long` parameters, for example: `long n` and `long m`. The function returns a `bool` value.

Handle Case of Zero Divider

Think about the case when `m` is zero. Division by zero is undefined, so you should check if `m` equals zero, and if true, return false immediately since no number can be a multiple of zero.

Implement the Multiplicity Check

Use the modulus operator (`%`) to check if `n` is evenly divisible by `m`. If `n % m` equals zero, then `n` is a multiple of `m`. Return true if the condition is satisfied. Otherwise, return false.

Complete and Test the Function

Finalise the function implementation and test it with various inputs to ensure it behaves as expected in different scenarios, such as positive numbers, negative numbers, and zero.

Key concepts

Function Signature

The function signature in C++ defines the name, return type, and parameters of a function. For this problem, we need to create a function called `isMultiple` that takes two `long` integers, `n` and `m`. The return type is `bool`, as the function will return `true` or `false`. A basic function signature for this in C++ would look like: \(bool \, isMultiple(long \, n, \, long \, m);\).
This signature tells us that `isMultiple` will accept two long integers and return a boolean value.

Modulus Operator

The modulus operator (`%`) in C++ gives the remainder of a division between two integers. For example, `5 % 2` returns `1` because when 5 is divided by 2, the remainder is 1. This operator is especially useful for checking multiplicity. In the function `isMultiple`, we use it to check if one number is a multiple of another by seeing if the remainder is zero.
For instance, if `n % m == 0`, then `n` is a multiple of `m`. Otherwise, it is not.

Division by Zero

Division by zero is a special consideration in many programming problems. When you attempt to divide by zero, it leads to undefined behavior or runtime errors. In our function, we want to avoid this by checking if `m` is zero before proceeding.
If `m == 0`, we immediately return `false` because no number can be a multiple of zero. This avoids the division by zero error and ensures the program runs smoothly.

Multiplicity Check

Checking for multiplicity means determining whether a number is a multiple of another. This is done using the modulus operator. In our function, after handling the division by zero case, we perform the multiplicity check.
If `n % m == 0`, then `n` is a multiple of `m` and the function returns `true`. If not, the function returns `false`. This logic ensures that we only return `true` when `n` is exactly divisible by `m`, following the condition \(n = m \, i\) for some integer `i`.