如何在不使用计算器的情况下计算5 ^ 55模数221的模数？
我想密码学中的数论有一些简单的原则来计算这些东西。
答案 0 :(得分：91)
好的，所以你要计算a^b mod m。首先，我们将采取一种天真的方法，然后看看我们如何改进它。
首先，减少a mod m。这意味着，找到一个a1号码，以便0 <= a1 < m和a = a1 mod m。然后在循环中重复乘以a1并再次减少mod m。因此，在伪代码中：
a1 = a reduced mod m
p = 1
for(int i = 1; i <= b; i++) {
p *= a1
p = p reduced mod m
}
通过这样做，我们避免大于m^2的数字。这是关键。我们避免数字大于m^2的原因是因为每一步0 <= p < m和0 <= a1 < m。
举个例子，让我们计算5^55 mod 221。首先，5已经缩减mod 221。
1 * 5 = 5 mod 221 5 * 5 = 25 mod 221 25 * 5 = 125 mod 221 125 * 5 = 183 mod 221 183 * 5 = 31 mod 221 31 * 5 = 155 mod 221 155 * 5 = 112 mod 221 112 * 5 = 118 mod 221 118 * 5 = 148 mod 221 148 * 5 = 77 mod 221 77 * 5 = 164 mod 221 164 * 5 = 157 mod 221 157 * 5 = 122 mod 221 122 * 5 = 168 mod 221 168 * 5 = 177 mod 221 177 * 5 = 1 mod 221 1 * 5 = 5 mod 221 5 * 5 = 25 mod 221 25 * 5 = 125 mod 221 125 * 5 = 183 mod 221 183 * 5 = 31 mod 221 31 * 5 = 155 mod 221 155 * 5 = 112 mod 221 112 * 5 = 118 mod 221 118 * 5 = 148 mod 221 148 * 5 = 77 mod 221 77 * 5 = 164 mod 221 164 * 5 = 157 mod 221 157 * 5 = 122 mod 221 122 * 5 = 168 mod 221 168 * 5 = 177 mod 221 177 * 5 = 1 mod 221 1 * 5 = 5 mod 221 5 * 5 = 25 mod 221 25 * 5 = 125 mod 221 125 * 5 = 183 mod 221 183 * 5 = 31 mod 221 31 * 5 = 155 mod 221 155 * 5 = 112 mod 221 112 * 5 = 118 mod 221 118 * 5 = 148 mod 221 148 * 5 = 77 mod 221 77 * 5 = 164 mod 221 164 * 5 = 157 mod 221 157 * 5 = 122 mod 221 122 * 5 = 168 mod 221 168 * 5 = 177 mod 221 177 * 5 = 1 mod 221 1 * 5 = 5 mod 221 5 * 5 = 25 mod 221 25 * 5 = 125 mod 221 125 * 5 = 183 mod 221 183 * 5 = 31 mod 221 31 * 5 = 155 mod 221 155 * 5 = 112 mod 221 因此，5^55 = 112 mod 221。
现在，我们可以使用exponentiation by squaring来改善这一点;这是一个着名的技巧，我们将求幂减少到只需要log b次乘法而不是b。请注意，使用上面描述的算法，通过平方改进进行取幂，最终得到right-to-left binary method。
a1 = a reduced mod m
p = 1
while (b > 0) {
if (b is odd) {
p *= a1
p = p reduced mod m
}
b /= 2
a1 = (a1 * a1) reduced mod m
}
因此，因为55 = 110111二进制
1 * (5^1 mod 221) = 5 mod 221 5 * (5^2 mod 221) = 125 mod 221 125 * (5^4 mod 221) = 112 mod 221 112 * (5^16 mod 221) = 112 mod 221 112 * (5^32 mod 221) = 112 mod 221 因此答案是5^55 = 112 mod 221。这有效的原因是因为
55 = 1 + 2 + 4 + 16 + 32
这样
5^55 = 5^(1 + 2 + 4 + 16 + 32) mod 221
= 5^1 * 5^2 * 5^4 * 5^16 * 5^32 mod 221
= 5 * 25 * 183 * 1 * 1 mod 221
= 22875 mod 221
= 112 mod 221
在我们计算5^1 mod 221，5^2 mod 221等的步骤中，我们注意到5^(2^k) = 5^(2^(k-1)) * 5^(2^(k-1))，因为2^k = 2^(k-1) + 2^(k-1)因此我们可以先计算{ {1}}并缩小5^1，然后将其平方并减少mod 221以获取mod 221等。
上述算法形式化了这个想法。
答案 1 :(得分：27)
加入Jason的回答：
您可以使用指数的二进制扩展来加快进程（这可能对非常大的指数有用）。首先计算5,5 ^ 2,5 ^ 4,5 ^ 8 mod 221 - 你通过重复平方来做到这一点：
5^1 = 5(mod 221)
5^2 = 5^2 (mod 221) = 25(mod 221)
5^4 = (5^2)^2 = 25^2(mod 221) = 625 (mod 221) = 183(mod221)
5^8 = (5^4)^2 = 183^2(mod 221) = 33489 (mod 221) = 118(mod 221)
5^16 = (5^8)^2 = 118^2(mod 221) = 13924 (mod 221) = 1(mod 221)
5^32 = (5^16)^2 = 1^2(mod 221) = 1(mod 221)
现在我们可以写
55 = 1 + 2 + 4 + 16 + 32
so 5^55 = 5^1 * 5^2 * 5^4 * 5^16 * 5^32
= 5 * 25 * 625 * 1 * 1 (mod 221)
= 125 * 625 (mod 221)
= 125 * 183 (mod 183) - because 625 = 183 (mod 221)
= 22875 ( mod 221)
= 112 (mod 221)
你可以看到非常大的指数如何更快（我相信它是log而不是b中的线性，但不确定。）
答案 2 :(得分：12)
/* The algorithm is from the book "Discrete Mathematics and Its
Applications 5th Edition" by Kenneth H. Rosen.
(base^exp)%mod
*/
int modular(int base, unsigned int exp, unsigned int mod)
{
int x = 1;
int power = base % mod;
for (int i = 0; i < sizeof(int) * 8; i++) {
int least_sig_bit = 0x00000001 & (exp >> i);
if (least_sig_bit)
x = (x * power) % mod;
power = (power * power) % mod;
}
return x;
}
答案 3 :(得分：3)
5^55 mod221
= ( 5^10 * 5^10 * 5^10 * 5^10 * 5^10 * 5^5) mod221
= ( ( 5^10) mod221 * 5^10 * 5^10 * 5^10 * 5^10 * 5^5) mod221
= ( 77 * 5^10 * 5^10 * 5^10 * 5^10 * 5^5) mod221
= ( ( 77 * 5^10) mod221 * 5^10 * 5^10 * 5^10 * 5^5) mod221
= ( 183 * 5^10 * 5^10 * 5^10 * 5^5) mod221
= ( ( 183 * 5^10) mod221 * 5^10 * 5^10 * 5^5) mod221
= ( 168 * 5^10 * 5^10 * 5^5) mod221
= ( ( 168 * 5^10) mod 221 * 5^10 * 5^5) mod221
= ( 118 * 5^10 * 5^5) mod221
= ( ( 118 * 5^10) mod 221 * 5^5) mod221
= ( 25 * 5^5) mod221
= 112
答案 4 :(得分：2)
Chinese Remainder Theorem首先想到的是221 = 13 * 17.因此，将其分解为最终合并的两个部分，一个用于mod 13，一个用于mod 17.其次，我相信对于所有非零a有一些^（p-1）= 1 mod p的证据，这也有助于减少你的问题，因为13 ^ 4 = 52，因为mod 13的情况下5 ^ 55变为5 ^ 3。如果你看一下“有限域”的主题，你可能会发现一些如何解决这个问题的好结果。
编辑：我提到这些因素的原因是，这创造了一种将零因子分解为非零元素的方法，就好像你尝试了13 ^ 2 * 17 ^ 4 mod 221这样的东西，答案为零，因为13 * 17 = 221。虽然有许多方法可以找到大质数，因为它们在密码学和数学中的其他领域中被广泛使用，但很多大数字都不会成为素数。答案 5 :(得分：2)
您正在寻找的是模幂运算，特别是模二进制求积法。这个wikipedia link有伪代码。
答案 6 :(得分：2)
这是我为IBAN验证所做的代码的一部分。随意使用。
static void Main(string[] args)
{
int modulo = 97;
string input = Reverse("100020778788920323232343433");
int result = 0;
int lastRowValue = 1;
for (int i = 0; i < input.Length; i++)
{
// Calculating the modulus of a large number Wikipedia http://en.wikipedia.org/wiki/International_Bank_Account_Number
if (i > 0)
{
lastRowValue = ModuloByDigits(lastRowValue, modulo);
}
result += lastRowValue * int.Parse(input[i].ToString());
}
result = result % modulo;
Console.WriteLine(string.Format("Result: {0}", result));
}
public static int ModuloByDigits(int previousValue, int modulo)
{
// Calculating the modulus of a large number Wikipedia http://en.wikipedia.org/wiki/International_Bank_Account_Number
return ((previousValue * 10) % modulo);
}
public static string Reverse(string input)
{
char[] arr = input.ToCharArray();
Array.Reverse(arr);
return new string(arr);
}
答案 7 :(得分：1)
Jason在Java中的回答（注释SELECTs）。
i < exp答案 8 :(得分：1)
这称为模幂运算（https://en.wikipedia.org/wiki/Modular_exponentiation）。
假设您有以下表达式：
19 ^ 3 mod 7
您可以直接执行以下操作，而不是直接启动19：
(((19 mod 7) * 19) mod 7) * 19) mod 7
但是由于大量的连续乘法，这也需要很长时间，所以你可以乘以平方值：
x mod N -> x ^ 2 mod N -> x ^ 4 mod -> ... x ^ 2 |log y| mod N
模幂运算算法假设：
x ^ y == (x ^ |y/2|) ^ 2 if y is even
x ^ y == x * ((x ^ |y/2|) ^ 2) if y is odd
所以递归模幂运算算法在java中会是这样的：
/**
* Modular exponentiation algorithm
* @param x Assumption: x >= 0
* @param y Assumption: y >= 0
* @param N Assumption: N > 0
* @return x ^ y mod N
*/
public static long modExp(long x, long y, long N) {
if(y == 0)
return 1 % N;
long z = modExp(x, Math.abs(y/2), N);
if(y % 2 == 0)
return (long) ((Math.pow(z, 2)) % N);
return (long) ((x * Math.pow(z, 2)) % N);
}
特别感谢@chux在y和0比较的情况下发现错误，返回值不正确。
答案 9 :(得分：0)
只提供Jason的答案的另一个实现。
根据杰森的解释与同学讨论后，如果你不太关心表现，我更喜欢递归版本：
例如：
#include<stdio.h>
int mypow( int base, int pow, int mod ){
if( pow == 0 ) return 1;
if( pow % 2 == 0 ){
int tmp = mypow( base, pow >> 1, mod );
return tmp * tmp % mod;
}
else{
return base * mypow( base, pow - 1, mod ) % mod;
}
}
int main(){
printf("%d", mypow(5,55,221));
return 0;
}