出于教育目的，我在Python 3中构建了一个代码来实现这个目标：

我认为我在这个问题上做得很好，因为我是初级/中级水平。这个问题是一个先进的，而不是强制性的。
我做了压力测试，使用一个缓慢但更安全的功能作为“控制组”。在此之后，我可以创建一个更快的功能。
然而，我的实现对于某些 *pisano循环 * 是有问题的。正如你在这里看到的：http://webspace.ship.edu/msrenault/fibonacci/fiblist.htm一些mods可以创建巨大的皮萨诺循环.
我的函数对于<249.然而，我不知道如何处理像1570这样的mods，它会生成一个总长度为4740个数字的模式/周期。不是001和12113而是4740的循环模式...
我试着寻找解决这个问题的方法。我能够找到不同的方法来解决这个问题。尽管如此，我想尝试修复我的实现，使它在周期识别部分更快-如果这是可能的。
这是我的准则

coursera_input = (input())
coursera_input = (coursera_input.split())
n_in = int(coursera_input[0])
mod_in = int(coursera_input[1])

import random

def my_fibo_iter(x):
    if x<=1:
        return x
    else:
        bef_previous_elem = 0
        previous_elem = 1
        current = 0
        count = 1
        while count<x:
            count = count + 1
            current = bef_previous_elem + previous_elem
            bef_previous_elem = previous_elem
            previous_elem = current
        return (current)

def fibo_iter_mod_slow(n,mod):
    if n==0:
        return n%mod
    elif n==1:
        return n%mod
    else:
        previous = 1%mod
        bef_previous = 0%mod 
        count = 1
        while count<(n):
                current = bef_previous%mod + previous%mod 
                bef_previous = previous%mod 
                previous = current%mod 
                count = count + 1
        return current%mod 

#preciso construir um algoritmo para identificar a pisano period/cycle

def pisano_cycle(big_list):
    promising_list = []
    for i in big_list:
        promising_list.append(i)
        p_l_len = len(promising_list)
        p_l_final_index = 2*p_l_len
        if promising_list == big_list[p_l_len:p_l_final_index]:
            break
    return promising_list

def generate_big_pisano_list(mod):
    big_list = []
    if mod<249:
        limit = 700
    if 249<=mod<1000:
        limit = 3001
    else:
        limit = 6000
    for i in range(0,limit):
        big_list.append(fibo_iter_mod_slow(i,mod))
    return big_list

#agora eu sei gerar uma lista pisano
#sei identificar uma lista de pisano
#preciso de uma outra função
#ela deve, sabendo o padrão CÍCLICO, identificar o nth elemento desse padrão

def fibo_iter_mod_fast(n,mod):
    big_pisano_list = generate_big_pisano_list(mod)
    pattern = pisano_cycle(big_pisano_list)
    length_patt = len(pattern)
    index_analogous = (n%length_patt)
    output_in_mod = pattern[index_analogous]
    return output_in_mod

print (fibo_iter_mod_fast(n_in,mod_in))

如果你输入类似这样的内容：

2816213588 30524

它得到正确的输出：

10249

但这需要超过5秒...
另一个问题是当我有一个巨大的数字作为mod的输入时，比如：
失败病例#12/22：（错误答案）
输入：99999999999999999 100000
您的输出：69026
正确输出：90626
(Time使用：0.04/5.00，内存使用：24100864/536870912.）
我的代码返回了一个不正确的输出，由于这部分：

def generate_big_pisano_list(mod):
        big_list = []
        if mod<249:
            limit = 700
        if 249<=mod<1000:
            limit = 3001
        else:
            limit = 6000

我将皮萨诺循环的范围限制在60000个数字的范围内，显然，有些皮萨诺循环可以超越这个范围。