Introduction

If an array is guaranteed to contain exactly one pair where one number evenly divides the other, the direct solution is to check pairs until you find the divisible one. The logic is simple: for each pair, divide the larger by the smaller and test whether the remainder is zero.

The main design question is not mathematical complexity but how much input size you expect. For small or medium arrays, a straightforward nested-loop solution is usually the clearest and perfectly fast enough.

The Basic Rule

Two numbers a and b evenly divide each other when the larger number is divisible by the smaller one with no remainder:

hi % lo == 0

So if the pair is (4, 8), then 8 % 4 == 0, which means the pair qualifies.

If the pair is (5, 8), then 8 % 5 != 0, so it does not.

A Clear Brute-Force Solution

A clean solution in Python looks like this:

1def find_divisible_pair(numbers):
2    for i in range(len(numbers)):
3        for j in range(i + 1, len(numbers)):
4            a = numbers[i]
5            b = numbers[j]
6            hi, lo = max(a, b), min(a, b)
7
8            if lo != 0 and hi % lo == 0:
9                return lo, hi
10
11    return None
12
13print(find_divisible_pair([5, 9, 2, 8]))

This returns (2, 8).

The code checks each unordered pair exactly once, which is easy to reason about and easy to verify.

If You Need the Quotient Too

Some versions of this problem want the quotient rather than the pair itself. In that case, return hi // lo:

1def divisible_quotient(numbers):
2    for i in range(len(numbers)):
3        for j in range(i + 1, len(numbers)):
4            a = numbers[i]
5            b = numbers[j]
6            hi, lo = max(a, b), min(a, b)
7
8            if lo != 0 and hi % lo == 0:
9                return hi // lo
10
11    return None
12
13print(divisible_quotient([5, 9, 2, 8]))

That prints 4 because 8 / 2 = 4.

A Small Optimization with Sorting

If you want to make the search slightly more structured, sort the numbers first. Then for each number, only check larger numbers that come after it.

1def find_divisible_pair_sorted(numbers):
2    numbers = sorted(numbers)
3
4    for i in range(len(numbers)):
5        for j in range(i + 1, len(numbers)):
6            small = numbers[i]
7            large = numbers[j]
8
9            if small != 0 and large % small == 0:
10                return small, large
11
12    return None
13
14print(find_divisible_pair_sorted([5, 9, 2, 8]))

This does not change the worst-case time complexity much, but it can make the comparisons easier to think about because numbers[i] is always the smaller candidate.

Complexity

The simple nested-loop solution is O(n^2) because it may inspect every pair in the worst case.

That sounds expensive, but many real inputs are small enough that this is still the best answer. A more complicated optimization is not automatically better if it makes the code harder to understand and offers no meaningful speed benefit for the actual dataset.

Handling Edge Cases

A few edge cases deserve explicit thought:

• zero requires care because division by zero is invalid
• duplicate values can matter if the problem statement allows them
• negative numbers still work with modulo, but sign rules should be intentional

If zero is allowed, always guard the divisor check first:

if lo != 0 and hi % lo == 0:

If the input guarantees positive non-zero integers, the code becomes even simpler.

When Exactly One Pair Is Guaranteed

Many puzzle versions of this problem guarantee that exactly one divisible pair exists in each row. If you have that guarantee, returning the first valid pair is correct and efficient.

Without that guarantee, you may want to collect all valid pairs instead:

1def all_divisible_pairs(numbers):
2    pairs = []
3    for i in range(len(numbers)):
4        for j in range(i + 1, len(numbers)):
5            a = numbers[i]
6            b = numbers[j]
7            hi, lo = max(a, b), min(a, b)
8            if lo != 0 and hi % lo == 0:
9                pairs.append((lo, hi))
10    return pairs

That changes the problem from "find the one pair" to "enumerate every pair."

Common Pitfalls

The biggest pitfall is checking only a % b == 0 without also considering the reverse direction. For a pair like (2, 8), only one ordering works.

Another common issue is forgetting about zero. x % 0 is an error, so any robust solution must avoid zero as the divisor.

Developers also sometimes over-optimize too early. The nested-loop solution is usually the best starting point because it is correct, readable, and sufficient for typical puzzle or interview-sized inputs.

Finally, be explicit about what the function should return: the pair, the quotient, or all qualifying pairs. Those are related but different tasks.

Summary

• Check pairs of numbers and test whether the larger is divisible by the smaller.
• A nested-loop solution is usually the clearest and most practical answer.
• Guard against division by zero if zero can appear in the input.
• If the problem guarantees exactly one pair, return the first valid match.
• Decide up front whether you want the pair itself or the quotient derived from it.