💡 Problem Formulation: Given a list of integers, the goal is to write a Python program that prints out all the elements which are multiples of each individual element within the list. For instance, for the input list [2, 3, 5], the output should include numbers like 6 (multiple of 2 and 3), 10 (multiple of 2 and 5), etc., depending on a specified range or conditions.
Method 1: Nested Loops
This method involves two nested loops. The outer loop iterates over the list to target each element, and the inner loop goes through a range of numbers, checking for multiples of the current element from the outer loop. This is a straightforward approach and easy to implement.
Here’s an example:
given_list = [2, 3, 5]
max_val = 30
for num in range(1, max_val + 1):
for multiple in given_list:
if num % multiple == 0:
print(f"{num} is a multiple of {multiple}.")
Output:
2 is a multiple of 2. 3 is a multiple of 3. 4 is a multiple of 2. 5 is a multiple of 5. 6 is a multiple of 2. 6 is a multiple of 3. ... 30 is a multiple of 2. 30 is a multiple of 3. 30 is a multiple of 5.
This code snippet initializes a list of numbers and a maximum value. It then iterates over a range up to that maximum value, checking if the current number is divisible by any of the list elements. If it is, the number and its multiple are printed.
Method 2: List Comprehensions
List comprehensions in Python provide a concise way to create lists. It can be used to build a list of multiples by iterating over each number and checking divisibility using modular arithmetic. This is a more Pythonic and compact method.
Here’s an example:
given_list = [2, 3, 5]
max_val = 30
multiples = [(num, multiple) for num in range(1, max_val + 1) for multiple in given_list if num % multiple == 0]
for num, multiple in multiples:
print(f"{num} is a multiple of {multiple}.")
Output:
The same as Method 1
This code utilizes list comprehension to create a list of tuples containing numbers and the corresponding multiple from the original list when the number is indeed a multiple. Afterwards, it iterates over the list of tuples and prints them in a user-friendly format.
Method 3: Using a Generator Function
A generator function allows us to declare a function that behaves like an iterator. It will yield one multiple at a time and can be iterated over to print all multiples. This is efficient for memory usage as it doesn’t require to store all multiples at once.
Here’s an example:
def find_multiples(given_list, max_val):
for num in range(1, max_val + 1):
for multiple in given_list:
if num % multiple == 0:
yield num, multiple
given_list = [2, 3, 5]
max_val = 30
for num, multiple in find_multiples(given_list, max_val):
print(f"{num} is a multiple of {multiple}.")
Output:
The same as Method 1
Here, the find_multiples() function generates tuples of numbers and their corresponding multiples. The for-loop is used to iterate over the generator, yielding one element at a time, which conserves memory for large ranges of multiples.
Method 4: Functional Programming with filter()
By applying functional programming concepts, we can use the filter() function to compute the multiples. This method is quite expressive and leverages built-in functions for a clean, readable code.
Here’s an example:
given_list = [2, 3, 5]
max_val = 30
def is_multiple(num):
return any(num % multiple == 0 for multiple in given_list)
multiples = filter(is_multiple, range(1, max_val + 1))
for num in multiples:
print(f"{num} is a multiple of elements from {given_list}.")
Output:
The same as Method 1, but without specifying which element from the list the number is a multiple of.
This code defines a function is_multiple() that checks if a given number is a multiple of any element in the list. The filter() function is then used along with this predicate to create an iterator over all multiples in the specified range.
Bonus One-Liner Method 5: Compact Nested List Comprehension
Sometimes we want to keep our code as concise as possible. A one-liner nested list comprehension can be used to achieve our goal. This is a compact version of method two but might be less readable.
Here’s an example:
given_list = [2, 3, 5]
max_val = 30
print(*[f"{num} is a multiple of {multiple}" for num in range(1, max_val + 1) for multiple in given_list if num % multiple == 0], sep="\n")
Output:
The same as Method 1
This one-liner compresses the logic of finding and printing the multiples into a single statement using list comprehension and unpacking the resulting list directly into the print() function with each item separated by a newline.
Summary/Discussion
- Method 1: Nested Loops. Easy to understand and implement. Not the most Pythonic way and could be less efficient for large lists or ranges.
- Method 2: List Comprehensions. Compact code and faster execution due to Python’s optimization for list comprehensions. May consume more memory with large data sets.
- Method 3: Generator Function. More memory-efficient as it yields one item at a time. This approach may be less intuitive for beginners.
- Method 4: Functional Programming with
filter(). Expressive and clean code, may not be as direct or fast as list comprehensions. - Bonus One-Liner. Very concise, but could sacrifice readability for brevity. Best for those familiar with nested list comprehensions.