取余和取模运算

取余和取模运算

取模运算（“Modulus Operation”----MOD）和取余运算（“Remainder Operation ”----REM）两个概念有重叠的部分但又不完全一致。主要的区别在于对负整数进行除法运算时操作不同。取模主要是用于计算机术语中。取余则更多是数学概念。模运算在数论和程序设计中都有着广泛的应用，奇偶数的判别到素数的判别，从模幂运算到最大公约数的求法，从孙子问题到凯撒密码问题，无不充斥着模运算的身影。虽然很多数论教材上对模运算都有一定的介绍，但多数都是以纯理论为主，对于模运算在程序设计中的应用涉及不多。

取余运算区别

对于整型数a，b来说，取模运算或者求余运算的方法都是：
1.求 整数商： c = [a/b];
2.计算模或者余数： r = a - c*b.
求模运算和求余运算在第一步不同: 取余运算在取c的值时，向0 方向舍入(fix()函数)；而取模运算在计算c的值时，向负无穷方向舍入(floor()函数)。
例:

• 计算：-7 Mod 4

a = -7；b = 4；
第一步：求整数商c，如进行求模运算c = -2（向负无穷方向舍入），求余c = -1（向0方向舍入）；
第二步：计算模和余数的公式相同，但因c的值不同，求模时r = 1，求余时r = -3。

归纳：当a和b符号一致时，求模运算和求余运算所得的c的值一致，因此结果一致。
当符号不一致时，结果不一样。求模运算结果的符号和b一致，求余运算结果的符号和a一致。

• 另外各个环境下%运算符的含义不同，比如c/c++，java 为取余，而python则为取模。

补充：补充：
7 mod 4 = 3（商 = 1 或 2，1<2，取商=1）
-7 mod 4 = 1（商 = -1 或 -2，-2<-1，取商=-2）
7 mod -4 = -1（商 = -1或-2，-2<-1，取商=-2）
-7 mod -4 = -3（商 = 1或2，1<2，取商=1）

取模的概念

给定一个正整数p，任意一个整数n，一定存在等式 ：
n = kp + r ；
其中 k、r 是整数，且 0 ≤ r < p，则称 k 为 n 除以 p 的商，r 为 n 除以 p 的余数。
对于正整数 p 和整数 a,b，定义如下运算：
取模运算：a % p（或a mod p），表示a除以p的余数。
模p加法：其结果是a+b算术和除以p的余数。
模p减法：其结果是a-b算术差除以p的余数。
模p乘法：其结果是a*b算术乘法除以p的余数。

说明：

1. 同余式：正整数a，b对p取模，它们的余数相同，记做 或者a ≡ b (mod p)。
2. n % p 得到结果的正负由被除数n决定,与p无关。例如：7%4 = 3， -7%4 = -3， 7%-4 = 3， -7%-4 = -3。

运算规则

模运算与基本四则运算有些相似，但是除法例外。其规则如下：
(a + b) % p = (a % p + b % p) % p （1）
(a - b) % p = (a % p - b % p ) % p （2）
(a * b) % p = (a % p * b % p) % p （3）
a ^ b % p = ((a % p)^b) % p （4）
结合律：((a+b) % p + c) % p = (a + (b+c) % p) % p （5）
((ab) % p * c)% p = (a * (bc) % p) % p （6）
交换律：(a + b) % p = (b+a) % p （7）
(a * b) % p = (b * a) % p （8）
分配律：(a+b) % p = ( a % p + b % p ) %p（9）
((a +b)% p * c) % p = ((a * c) % p + (b * c) % p) % p （10）

取模的应用

1.判别奇偶数

/*C++实现
函数名：IsEven
函数功能：判别整数n的奇偶性。能被2整除为偶数，否则为奇数
输入值：intn，整数n
返回值：bool，若整数n是偶数，返回true，否则返回false
*/
bool IsEven(int n)
{
    return(n%2==0);
}

2.判别素数

/*C++实现
函数名：IsPrime函数功能：判别自然数n是否为素数。输入值：intn，自然数n返回值：bool，若自然数n是素数，返回true，否则返回false*/
bool IsPrime(unsigned int n)
{
    unsigned maxFactor=sqrt(n);//n的最大因子
    for(unsigned int i=2;i<=maxFactor;i++)
    {
        if(n%i==0)//n能被i整除，则说明n非素数
        {
            return false;
        }
    }
    return true;
}

3.求最大公约数(辗转相除法)

/*函数功能：利用欧几里德算法，采用递归方式，求两个自然数的最大公约数函数名：Gcd输入值：unsigned int a，自然数a；unsigned int b，自然数b返回值：unsigned int，两个自然数的最大公约数*/
unsigned int Gcd(unsigned int a,unsigned int b)
{
    if(b==0)
    return a;
    return Gcd(b,a%b);
}
**************************************************************************
/*函数功能：利用欧几里德算法，采用迭代方式，求两个自然数的最大公约数函数名：Gcd输入值：unsigned int a，自然数a；unsigned int b，自然数b返回值：unsigned int，两个自然数的最大公约数*/
unsigned int Gcd(unsigned int a,unsigned int b)
{
    unsigned int temp;
    while(b!=0)
    {
        temp=a%b;
        a=b;
        b=temp;
    }
    return a;
}

4.水仙花数（仅提供思路和伪代码，自行编码实现）
程序循环方式：
需要用取余数的整数的方式去完成判断条件：分别从三位数中利用取余去取百位、十位、个位数，加以判断
var a,b,c,d
for(i=1;i<1000;i++){
a = parseInt(i%10); //这一步取到了个位数
b = parseInt(i/10%10); //这一步取到了十位数
c= parseInt(i/100%10); //这一步取到了百位数
d = aaa+bbb+ccc;//水仙花数
if(d==i&&d>99){//比较判断，且是三位数。
alert(d+"是水仙花数") //输出水仙花数。
}
}
5.模幂运算
例:
我们想知道3333^{5555的末位是什么。很明显不可能直接把3333}5555的结果计算出来，那样太大了。但我们想要确定的是3333^5555（%10），所以问题就简化了。
根据运算规则（4）a^b % p = ((a % p)^b) % p ，我们知道3333^5555（%10）= 3^5555（%10）。
根据运算规则（3） (a * b) % p = (a % p * b % p) % p ，由于5555 = 4 * 1388 + 3，我们得到3^{5555（%10）=（3}(41388) * 3^{3）（%10）=（（3}(41388)（%10）* 3^3（%10））（%10）
=（（3^(41388)（%10） 7）（%10）。
根据欧拉定理可以得到 3 ^ (4 * k) % 10 = 1, 所以（（3^(41388)（%10） 7）（%10）= (1 * 7) (% 10) = 7
计算完毕。
利用这些规则我们可以有效地计算X^N(% P)。简单的算法是将result初始化为1，然后重复将result乘以X，每次乘法之后应用%运算符（这样使得result的值变小，以免溢出），执行N次相乘后，result就是我们要找的答案。
这样对于较小的N值来说，实现是合理的，但是当N的值很大时，需要计算很长时间，是不切实际的。下面的结论可以得到一种更好的算法。
如果N是偶数，那么X^N =(XX)^N/2；
如果N是奇数，那么X^N = XX^(N-1) = X(XX)^N/2；
其中[N]是指小于或等于N的最大整数。

/**C++实现
函数功能：利用模运算规则，采用递归方式，计算X^N(%P)函数名：PowerMod输入值：unsigned int x，底数x unsigned int n，指数nunsigned int p，模p返回值：unsigned int，X^N(%P)的结果*/
unsignedintPowerMod(unsignedintx,unsignedintn,unsignedintp)
{
if(n==0)
{
return1;
}
unsignedinttemp=PowerMod((x*x)%p,n/2,p);//递归计算（X*X）^[N/2]
if((n&1)!=0)//判断n的奇偶性
{
temp=(temp*x)%p;
}
returntemp;
}

务须咬牙厉志，蓄其气而长其志，切不可恭然自馁也。😃