5 Best Ways to Find Modulus of a Number by Concatenating N Times in Python

💡 Problem Formulation: We need to calculate the modulus of a number after concatenating it ‘n’ times. For instance, the number 12 concatenated 3 times becomes 121212. The goal is to compute the modulus of this new number with a divisor. If the number 121212 is modulated by 5, the output should be 2.

Method 1: Naive String Concatenation and Modulus Operation

This method involves turning the number into a string, repeating it ‘n’ times, converting it back to an integer, and then performing the modulus operation. It is simple and straightforward but could be inefficient for large values of ‘n’.

Here’s an example:

def calculate_modulus(number, n, divisor):
    concatenated_number = int(str(number) * n)
    return concatenated_number % divisor

print(calculate_modulus(12, 3, 5))

Output: 2

In this code snippet, we define a function calculate_modulus() that takes a number, the number of times it should be concatenated (‘n’), and a divisor. The number is first converted to its string representation, repeated ‘n’ times, converted back to an integer, and the modulus operation is performed with the provided divisor.

Method 2: String Formatting and Modulus Operation

This method leverages Python’s string formatting capabilities to concatenate the number. It’s more Pythonic and still maintains readability. However, like the first method, it is not optimized for very large numbers.

Here’s an example:

def calculate_modulus_fmt(number, n, divisor):
    formatted_number = int("%s" % (str(number) * n))
    return formatted_number % divisor

print(calculate_modulus_fmt(12, 3, 5))

Output: 2

The function calculate_modulus_fmt() uses Python’s string formatting operator to create the repeated string before conversion and modulus calculation. This method works similarly to the first, but employs a different string manipulation approach.

Method 3: Math-Based Concatenation and Modulus

This approach calculates the repeated number using mathematical operations rather than string manipulation. This is beneficial because it avoids the overhead of conversion to and from strings, potentially improving efficiency for larger numbers.

Here’s an example:

def calculate_modulus_math(number, n, divisor):
    concatenated_number = sum(number * 10**(len(str(number)) * i) for i in range(n))
    return concatenated_number % divisor

print(calculate_modulus_math(12, 3, 5))

Output: 2

calculate_modulus_math() avoids the string conversion by computing the concatenated number through a summation where each term is the given number multiplied by an appropriate power of 10. It’s a more mathematically intense solution that remains efficient even for larger ‘n’.

Method 4: Iterative Modulus Calculation

This iterative approach computes the modulus at each step of concatenation. It is the most efficient method when dealing with extremely large numbers as it never actually constructs the full concatenated number.

Here’s an example:

def calculate_modulus_iterative(number, n, divisor):
    result = 0
    for _ in range(n):
        result = (result * (10 ** len(str(number))) + number) % divisor
    return result

print(calculate_modulus_iterative(12, 3, 5))

Output: 2

The function calculate_modulus_iterative() performs modulus calculation iteratively, which handles large numbers well because it keeps the intermediate results small by taking the modulus at each iteration.

Bonus One-Liner Method 5: Using Reduce Function

For those who prefer a functional programming approach, Python’s functools.reduce() can be used to concatenate and calculate the modulus in a concise one-liner.

Here’s an example:

from functools import reduce

calculate_modulus_reduce = lambda number, n, divisor: reduce(lambda acc, _: (acc * (10 ** len(str(number))) + number) % divisor, range(n), 0)

print(calculate_modulus_reduce(12, 3, 5))

Output: 2

This one-liner calculate_modulus_reduce() utilizes reduce() from functools to apply the iterative modulus calculation logic in a single statement, showcasing both brevity and functionality.

Summary/Discussion

• Method 1: Naive String Concatenation. Easy to understand. Not efficient for large ‘n’.
• Method 2: String Formatting. Pythonic and readable. Also not optimized for very large numbers.
• Method 3: Math-Based Concatenation. Avoids string conversion. Efficient for large numbers.
• Method 4: Iterative Modulus Calculation. Most efficient for very large ‘n’. Avoids full number construction.
• Method 5: Using Reduce Function. Compact and functional. May be less readable for some.