If m divides nⁿ, Then all the prime factors of m must also be factors of nⁿ.

Since exponentiation doesn t introduce any new prime factors, n itself must also have all the prime factors of m.

Let P be the product of the unique prime factors of m. Since n needs all of these factors, it will be a multiple of P.

n = P将发挥作用,即P^P将可分到m, Unless 至少是m的主要动力,大于P。

For example, if m = 3x2⁷, then P = 6, and 6⁶ is not divisible by 3x2⁷, because it only has 2⁶.

However, if you just start with i=1 and just try each n = Pi in sequence, then you will never have to count very far before you find a multiple of m, because the powers of the prime factors in m are limited by the length of m.

To solve this problem, we will follow the given steps:

1. 开始与否

Check if n ^n mod m = 0. If true, return n.

如果是假的,那么加固就等于或重复第二步。

Below is the Python code that implements the function:

def f(m):
    n = 1
    while True:
        if pow(n, n, m) == 0:
            return n
        n += 1

# Test the function with given examples
print(f(13))  # 13
print(f(420))  # 210
print(f(666))  # 222
print(f(1234567890))  # 411522630

This function uses the built-in pow function with three arguments: pow(a, b, m) computes a^b mod m efficiently. This allows the program to compute large powers modulo m without having to compute the large power directly.

Note: For very large values of m, this algorithm might take a considerable amount of time because it checks each possible value of n iteratively.

The solution is to factorise m such that you know the prime factors as well as their multiplicity in m, i.e. a prime power factorisation. All primes in this factorisation must appear at least once in our initial pass over n, and then we can just multiply it by the roof of the largest power divided by the result of the unitary power of each prime.

可执行;

import math

def extract_factor(m, f):
    p = 0
    while m%f == 0:
        p += 1
        m //= f
    return (m, p)

def prime_power_factorise(m):
    factors = {}
    if m%2 == 0:
        m, factors[2] = extract_factor(m, 2)
    if m%3 == 0:
        m, factors[3] = extract_factor(m, 3)
    sliding_window = 1
    while m > 1:
        for multiple_of_six in range(6*sliding_window, m+1, 6):
            reduced = False
            for factor in [multiple_of_six-1, multiple_of_six+1]:
                if m%factor == 0:
                    m, factors[factor] = extract_factor(m, factor)
                    reduced = True
            if reduced:
                sliding_window = multiple_of_six // 6 + 1
                continue
    return factors

def modular_zero_root(m):
    result = 1
    for prime, power in prime_power_factorise(m).items():
        result *= prime**math.ceil(power/2)
    return result

# Find the modular "super root" of a tetration
def modular_zero_superroot(m):
    result = 1
    prime_factors = prime_power_factorise(m)
    largest_power = max(prime_factors.values())
    # Firstly, the result must have every prime factor
    for prime in prime_factors.keys():
        result *= prime
        prime_factors[prime] -= 1
    # But now we must ensure the result is greater than
    # or equal to to the largest power of a prime in m.
    result *= math.ceil(largest_power/result)
    return result

回答所提供例子所需的时间;

import time

start = time.time()
val = modular_zero_superroot(1234567890)
end = time.time()
print(f {val} in {end - start} )

# 411522630 in 1.8367185592651367