# 5 Best Ways to Program to Find the nth Term of a Sequence Divisible by a, b, c in Python

Rate this post

π‘ Problem Formulation: We aim to find the nth term of a sequence where each term is divisible by three given numbers a, b, and c. For instance, if a=2, b=3, c=5 and we want the 5th term, the output should be 30 since the sequence satisfying these conditions would start with 30, 60, 90, 120, 150, …

## Method 1: Brute Force Iteration

Brute Force Iteration involves creating a sequence and checking each number for divisibility by a, b, and c. This method continues until the nth divisible term is found. While this approach is easy to implement, itβs not optimized for large numbers as it may become computationally expensive.

Here’s an example:

```def find_nth_divisible(n, a, b, c):
count = 0
number = 0
while count < n:
number += 1
if number % a == 0 and number % b == 0 and number % c == 0:
count += 1
return number

print(find_nth_divisible(5, 2, 3, 5))```

Output: 30

This code defines a function `find_nth_divisible()` that searches for the nth term in a sequence divisible by a, b, and c by iteratively checking each number, starting from 1. When the nth term is found, it returns that term.

## Method 2: Using Least Common Multiple (LCM)

Using the Least Common Multiple (LCM) of a, b, and c can significantly reduce the number of iterations by directly calculating the terms of the sequence. This is more efficient than brute force especially when the numbers are large.

Here’s an example:

```import math

def find_nth_divisible_lcm(n, a, b, c):
lcm_ab = a * b // math.gcd(a, b)
lcm = lcm_ab * c // math.gcd(lcm_ab, c)
return lcm * n

print(find_nth_divisible_lcm(5, 2, 3, 5))```

Output: 30

This snippet defines a function `find_nth_divisible_lcm()` using Python’s `math.gcd()` to calculate the LCM. It then multiplies the LCM by n to obtain the nth term in the sequence.

## Method 3: Optimized Brute Force with Step Size

This method is a variation of brute force where the stepping increment is the LCM of a, b, and c. Itβs optimized because it avoids unnecessary checks for non-divisible numbers and iterates only through possible options.

Here’s an example:

```def find_nth_divisible_stepwise(n, a, b, c):
lcm = a * b // math.gcd(a, b)
lcm = lcm * c // math.gcd(lcm, c)
return list(range(lcm, lcm*n+1, lcm))[n-1]

print(find_nth_divisible_stepwise(5, 2, 3, 5))```

Output: 30

The function `find_nth_divisible_stepwise()` computes a sequence by stepping through multiples of the LCM of a, b, and c. It then returns the nth value from the resultant list.

## Method 4: Using Itertools.islice()

This method utilizes Python’s `itertools.islice()` to efficiently slice an iterator, avoiding the creation of an entire list in memory. It is memory efficient when dealing with large sequences.

Here’s an example:

```from itertools import count, islice

def find_nth_divisible_islice(n, a, b, c):
lcm = a * b // math.gcd(a, b)
lcm = lcm * c // math.gcd(lcm, c)
return next(islice((num for num in count(lcm, lcm)), n-1, None))

print(find_nth_divisible_islice(5, 2, 3, 5))```

Output: 30

In this script, `find_nth_divisible_islice()` creates an iterator with a step size of the LCM, using `itertools.count()` and then slices it to find the nth term with `itertools.islice()`.

## Bonus One-Liner Method 5: Using a Generator Expression

This concise one-liner approach uses a generator expression along with a function to directly find the nth term. It’s a compact and Pythonic way to solve the problem, although it may not be the most intuitive for beginners.

Here’s an example:

```nth_divisible = lambda n, a, b, c: [x for x in count(0) if x % a == 0 and x % b == 0 and x % c == 0][n-1]
print(nth_divisible(5, 2, 3, 5))```

Output: 30

The lambda function `nth_divisible` is a one-liner that forms a list comprehension checking divisibility, indexed to return the nth term.

## Summary/Discussion

• Method 1: Brute Force Iteration. Simple and straightforward. However, it’s computationally expensive for large values.
• Method 2: Using Least Common Multiple (LCM). Efficient and quick for large numbers. Requires understanding of LCM computation.
• Method 3: Optimized Brute Force with Step Size. Improved brute force approach. Better performance by skipping non-divisible numbers.
• Method 4: Using Itertools.islice(). Memory efficient for large sequences. Relies on Python’s itertools module.
• Bonus Method 5: Using a Generator Expression. Compact code. Not very readable for those unfamiliar with Python’s advanced concepts.