大二进制字符串的模

简介

大二进制字符串模运算是指对于两个大二进制字符串进行模运算，其中模数可能非常巨大。在很多加密算法中，都需要用到大二进制字符串模运算。

实现

暴力枚举

可以将大二进制字符串转换成对应的十进制数，然后进行取模操作，最后再将结果转换成二进制字符串。但是这种方法的缺点是需要处理的数字太大，可能会导致精度损失和计算时间过长。

def mod_binary_string(s, mod):
    num = int(s, 2)
    mod = int(mod, 2)
    result = num % mod
    return bin(result)[2:]

快速幂

快速幂算法可以高效地计算二进制字符串的指数操作，因此也可以用于大二进制字符串的模运算。

def pow_binary_string(base, exponent, mod):
    base = int(base, 2)
    exponent = int(exponent, 2)
    mod = int(mod, 2)
    result = 1
    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % mod
        base = (base*base) % mod
        exponent //= 2
    return bin(result)[2:]

def mod_binary_string(s, mod):
    return pow_binary_string(s, "1"*(len(s)), mod)

蒙哥马利算法

蒙哥马利算法是一种高效的大数模运算算法。该算法的基本思想是将模数对于某个方便计算的数取模，然后将余数嵌入到一个更大的模数中，利用这个新的模数进行模运算。

def mod_binary_string(s, mod):
    # convert s to Montgomery domain
    R = int("1"*(len(s)+len(mod)), 2)
    s = (int(s,2) * R) % int(mod, 2)
    mod = int(mod, 2)
    # calculate s^T mod R*R (T=R mod m)
    T = R % mod
    s_pow_T = s
    while T > 1:
        if T % 2 == 1:
            s_pow_T = (s_pow_T * s) % (R*R % mod)
        s = (s*s) % (R*R % mod)
        T //= 2
    # calculate s^(mod-2) mod mod
    mod_ = mod - 2
    s_inv = 1
    while mod_ > 0:
        if mod_ % 2 == 1:
            s_inv = (s_inv * s) % mod
        s = (s*s) % mod
        mod_ //= 2
    # calculate result in Montgomery domain
    result = (s_pow_T * s_inv) % (R*R % mod)
    return bin(int(result // R))[2:]

性能

暴力枚举算法的时间复杂度为 $O(n^2)$，其中 $n$ 是二进制字符串的长度。而快速幂算法和蒙哥马利算法的时间复杂度都为 $O(n\log n)$。因此，当二进制字符串较大时，快速幂算法和蒙哥马利算法的效率更高。