5 Best Ways to Find a Multiple of n with Only Two Digits in Python

by

💡 Problem Formulation: Finding multiples of a number is a common mathematical task, but what if we’re interested in multiples with exactly two digits? In Python, we want to write programs that will return multiples of a given number n, such that the multiples have only two digits. For instance, if the input is 5, the desired output could be 10, 15, 20, etc.

Method 1: Iterative Search

This method involves iterating through a range of two-digit numbers and checking if the number is a multiple of n. This is simple and straightforward, and it doesn’t require any advanced mathematical operations or modules.

Here’s an example:

def find_two_digit_multiples(n):
    result = []
    for i in range(10, 100):
        if i % n == 0:
            result.append(i)
    return result

multiples = find_two_digit_multiples(7)
print(multiples)

Output:

[14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]

This code snippet creates a function called find_two_digit_multiples() that takes an integer n and returns a list of its multiples between 10 and 99 (the range of two-digit numbers). The function iterates through this range, using the modulo operator to check for multiples, and appends them to the result list.

Method 2: List Comprehension

List comprehensions in Python provide a concise way to create lists. We can use them to filter out the two-digit multiples of n in a single line of code.

Here’s an example:

def find_two_digit_multiples(n):
    return [i for i in range(10, 100) if i % n == 0]

multiples = find_two_digit_multiples(8)
print(multiples)

Output:

[16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96]

The find_two_digit_multiples() function uses a list comprehension to generate a list of multiples of n within the two-digit range. The condition inside the list comprehension ensures that only true multiples are included.

Method 3: Using a While Loop

A while loop can be used to continuously find multiples of n and stop as soon as the number exceeds two digits. This method can be more efficient than iterating through an entire fixed range.

Here’s an example:

def find_two_digit_multiples(n):
    result = []
    multiple = n
    while 10 <= multiple < 100:
        result.append(multiple)
        multiple += n
    return result

multiples = find_two_digit_multiples(9)
print(multiples)

Output:

[18, 27, 36, 45, 54, 63, 72, 81, 90, 99]

The find_two_digit_multiples() function initializes a multiple to n and uses a while loop to append successively larger multiples to a list. The loop runs until the multiple is no longer a two-digit number.

Method 4: Using Math and Range

We can mathematically determine the start and end points for our search, ensuring we only look at two-digit numbers. This approach minimizes the number of iterations.

Here’s an example:

def find_two_digit_multiples(n):
    start = (10 // n) * n
    if start < 10:
        start += n
    end = (100 // n) * n
    return list(range(start, end, n))

multiples = find_two_digit_multiples(4)
print(multiples)

Output:

[12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96]

This code snippet calculates the smallest and largest two-digit multiples of n and then uses range() to generate the list of all multiples between them. This is both concise and efficient.

Bonus One-Liner Method 5: Using Generators

We can write an elegant one-liner using a generator expression. This approach offers lazy evaluation, which can save memory if the list of multiples is large.

Here’s an example:

find_two_digit_multiples = lambda n: (i for i in range(10, 100) if i % n == 0)

multiples = list(find_two_digit_multiples(3))
print(multiples)

Output:

[12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

A lambda function is used to create a generator that yields two-digit multiples of n. When we want to retrieve the multiples, we convert the generator into a list.

Summary/Discussion

  • Method 1: Iterative Search. Simple to understand and implement. May be inefficient for large ranges or small values of n.
  • Method 2: List Comprehension. Concise and pythonic. Can be slightly less readable for beginners.
  • Method 3: Using a While Loop. Provides control over the iteration process. Efficiency depends on the value of n.
  • Method 4: Using Math and Range. Mathematically precise and efficient with no unnecessary iterations. Slightly more complex to understand.
  • Method 5: Using Generators. Memory efficient and elegant. Lazy evaluation can be more complex for beginners to understand.