C语言取模取整的深入理解

目录
  • 一:四大取整
    • 1.1、 0向取整
    • 1.2、  -∞取整( 地板取整)
    • 1.3、 +∞取整
    • 1.4、 四舍五入取整
    • 1.5、 例子汇总
  • 二:取模 / 取余
    • 2.1、 概念
    • 2.2、 示例(C和Python)
    • 2.3、 取余和取模一样吗?
    • 2.4、 计算数据同符号
    • 2.5、 计算数据不同符号
    • 2.6、 总结

一:四大取整

1.1、 0向取整

看代码:

#include <stdio.h>
int main()
{
	//本质是向0取整
	int i = -2.9;
	int j = 2.9;
	printf("%d\n", i); //结果是:-2
	printf("%d\n", j); //结果是:2
    printf("%d %d\n", 5 / 2, -5 / 2);  // 2 -2
	return 0;
}

C中默认0向取整,画图解释0向取整:

C语言当中有一个trunc函数,运用的也是0向取整。注意引用头文件#include<math.h>.示例如下:

#include <stdio.h>
#include<math.h>
int main()
{
	int i = -2.9;
	int j = 2.9;
	printf("%d\n", i); //结果是:-2
	printf("%d\n", j); //结果是:2
	printf("%d\n", (int)trunc(2.9)); //结果是:2 //结果是:-2
	printf("%d\n", (int)trunc(-2.9));//结果是:-2
	return 0;
}

1.2、  -∞取整( 地板取整)

其实运用的是floor函数,跟上述trunc一样引用#include<math.h>

看代码:

#include<stdio.h>
#include<math.h>
int main()
{
	printf("%.1f\n", floor(-2.9)); // -3.0
	printf("%.1f\n", floor(-2.1)); // -3.0
	printf("%.1f\n", floor(2.9));  // 2.0
	printf("%.1f\n", floor(2.1));  // 2.0
	return 0;
}

画图解释-∞取整

1.3、 +∞取整

运用的是ceil函数,同样需要#include<math.h>

看代码:

#include<stdio.h>
#include<math.h>
int main()
{
	printf("%.1f\n", ceil(-2.9));  // -2.0
	printf("%.1f\n", ceil(-2.1));  // -2.0
	printf("%.1f\n", ceil(2.9));   // 3.0
	printf("%.1f\n", ceil(2.1));   // 3.0
	return 0;
}

画图解释+∞取整:

1.4、 四舍五入取整

运用的是round函数,同样需要#include<math.h>

看代码:

#include<stdio.h>
#include<math.h>
int main()
{
	printf("%.1f\n", round(-2.9)); // -3.0
	printf("%.1f\n", round(-2.1)); // -2.0
	printf("%.1f\n", round(2.9));  // 3.0
	printf("%.1f\n", round(2.1));  // 2.0
}

1.5、 例子汇总

#include <stdio.h>
#include <math.h>
int main()
{
	const char* format = "%.1f \t%.1f \t%.1f \t%.1f \t%.1f\n";
	printf("value\tround\tfloor\tceil\ttrunc\n");
	printf("-----\t-----\t-----\t----\t-----\n");
	printf(format, 2.3, round(2.3), floor(2.3), ceil(2.3), trunc(2.3));
	printf(format, 3.8, round(3.8), floor(3.8), ceil(3.8), trunc(3.8));
	printf(format, 5.5, round(5.5), floor(5.5), ceil(5.5), trunc(5.5));
	printf(format, -2.3, round(-2.3), floor(-2.3), ceil(-2.3), trunc(-2.3));
	printf(format, -3.8, round(-3.8), floor(-3.8), ceil(-3.8), trunc(-3.8));
	printf(format, -5.5, round(-5.5), floor(-5.5), ceil(-5.5), trunc(-5.5));
	return 0;
}

 结论:

浮点数(整数/整数),是有很多的取整方式的。

二:取模 / 取余

2.1、 概念

如果a和d是两个自然数,d非零,可以证明存在两个唯一的整数 q 和 r,满足 a = q*d + r 且0 ≤ r < d。其中,q 被称为商,r 被称为余数。

2.2、 示例(C和Python)

#include <stdio.h>
int main()
{
	int a = 10;
	int d = 3;
	printf("%d\n", a % d); //结果是1
	//因为:a=10,d=3,q=3,r=1 0<=r<d(3)
	//所以:a = q*d+r -> 10=3*3+1

	int m = -10;
	int n = 3;
	printf("%d\n", m / n); //C语言中是-3,很好理解
	printf("%d\n", m % n); //C语言是-1

	return 0;
}

C语言中,我们对-10/3=-3以及-10%3=-1很好理解,没有争议

而在Python中,-10/3竟然=-4,而-10%3竟然=2

为什么呢?

结论:很显然,上面关于取模的定义,并不能满足语言上的取模运算

解析:

因为在C中,现在-10%3出现了负数,根据定义:满足 a = q*d + r 且0 ≤ r < d,C语言中的余数,是不满足定义的, 因为,r<0了。

故,大家对取模有了一个修订版的定义: 如果a和d是两个自然数,d非零,可以证明存在两个唯一的整数 q 和 r,满足 a = q*d + r , q 为整数,且0 ≤ |r| < |d|。其中,q 被称为商,r 被称为余数。

有了这个新的定义,那么C中或者Python中的“取模”,就都能解释了。

解释C: -10 = (-3) * 3 + (-1)

解释Python:-10 = (?)* 3 + 2,其中,可以推到出来,'?'必须是-4(后面验证).即-10 = (-4)* 3 + 2,才能 满足定义。

所以,在不同语言,同一个计算表达式,负数“取模”结果是不同的。我们可以称之为分别叫做正余数 和 负余数

是什么决定了这种现象?

由上面的例子可以看出,具体余数r的大小,本质是取决于商q的。

而商,又取决谁呢?取决于除法计算的时候,取整规则。

2.3、 取余和取模一样吗?

细心的同学,应该看到了,我上面的取模都是带着""的。说明这两个并不能严格等价(虽然大部分情况差不多) 取余或者取模,都应该要算出商,然后才能得出余数。

本质 1 取整:

取余:尽可能让商,进行向0取整。

取模:尽可能让商,向-∞方向取整。

故:

C中%,本质其实是取余。

Python中%,本质其实是取模。

理解链:

对任何一个大于0的数,对其进行0向取整和-∞取整,取整方向是一致的。故取模等价于取余 对任何一个小于0的数,对其进行0向取整和-∞取整,取整方向是相反的。故取模不等价于取余

同符号数据相除,得到的商,一定是正数(正数vs正整数),即大于0! 故,在对其商进行取整的时候,取模等价于取余。

本质 2 符号:

参与取余的两个数据,如果同符号,取模等价于取余

2.4、 计算数据同符号

看代码:

#include <stdio.h>
int main()
{
	printf("%d\n", 10 / 3);  // 3
	printf("%d\n\n", 10 % 3);// 1
	printf("%d\n", -10 / -3); // 3
	printf("%d\n\n", -10 % -3); // -1
	return 0;
}

在Python中,我们发现运行结果和上述一样。

结论:通过对比试验,更加验证了,参与取余的两个数据,如果同符号,取模等价于取余

2.5、 计算数据不同符号

看代码:

#include <stdio.h>
int main()
{
	printf("%d\n", -10 / 3); //结果:-3
	printf("%d\n\n", -10 % 3); //结果:-1 为什么? -10=(-3)*3+(-1)
	printf("%d\n", 10 / -3); //结果:-3
	printf("%d\n\n", 10 % -3); //结果:1 为什么?10=(-3)*(-3)+1
	return 0;
}

而在Python中,结果却不是这样的。

明显结论:如果不同符号,余数的求法,参考之前定义。而余数符号,与被除数相同。

为什么呢?

重新看看定义:如果a和d是两个自然数,d非零,可以证明存在两个唯一的整数 q 和 r,满足 a = q*d + r , q 为整数,且0 ≤ |r| < |d|。其中,q 被称为商,r 被称为余数

a = q*d + r 变换成 r = a - q*d 变换成 r = a + (-q*d)

对于:x = y + z,这样的表达式,x的符号 与 |y|、|z|中大的数据一致

而r = a + (-q*d)中,|a| 和 |-q*d|的绝对值谁大,取决于商q的取整方式。

c是向0取整的,也就是q本身的绝对值是减小的。如:

-10/3=-3.333.33 向0取整 -3. a=-10 |10|, -q*d=-(-3)*3=9 |9|

10/-3=-3.333.33 向0取整 -3. a=10 |10|, -q*d=-(-3)*(-3)=-9 |9|

绝对值都变小了

python是向-∞取整的,也就是q本身的绝对值是增大的。

-10/3=-3.333.33 '//'向-∞取整 -4. a=-10 |10|, -q*d=-(-4)*3=12 |12|

10/-3=--3.333.33 '//'向-∞取整 -4. a=10 |10|, -q*d=-(-4)*(-3)=-12 |12|

绝对值都变大了

结论:如果参与取余的两个数据符号不同,在C语言中(或者其他采用向0取整的语言如:C++,Java),余数符号,与被除数 相同。

2.6、 总结

(1)浮点数(或者整数相除),是有很多的取整方式的。

(2)如果a和d是两个自然数,d非零,可以证明存在两个唯一的整数 q 和 r,满足 a = q*d + r , q 为整数,且0 ≤ |r| < |d|。其中,q 被称为商,r 被称为余数。

(3)在不同语言,同一个计算表达式,“取模”结果是不同的。我们可以称之为分别叫做正余数 和 负余数

(4)具体余数r的大小,本质是取决于商q的。而商,又取决于除法计算的时候,取整规则。

(5)取余vs取模: 取余尽可能让商,进行向0取整。取模尽可能让商,向-∞方向取整。

(6)参与取余的两个数据,如果同符号,取模等价于取余

(7)如果参与取余的两个数据符号不同,在C语言中(或者其他采用向0取整的语言如:         C++,Java),余数符号,与被 除数相同。(因为采用的向0取整)

到此这篇关于C语言取模取整的深入理解的文章就介绍到这了,更多相关C语言取模取整 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C语言编程深入理解取整取余取模问题示例分析

    目录 1. 取整问题 1.0向取整(C语言默认的取整方案) 2.地板取整(向负无穷的方向取整) 3.天花板取整(向+无穷的方向取整) 4.四舍五入取整 汇总例子 2.取模问题  1.余数的定义 2.两种余数 3.为什么会有这种现象? 3.区分取余与取模 1.取余与与取模的本质区别 2.理解链 3.同符号与不同符号 1.同符号: 2.不同符号 1. 取整问题 1.0向取整(C语言默认的取整方案) #include<stdio.h> #include<windows.h> int ma

  • C语言中四种取整方式,取余/取模运算以及负数取模问题详解

    目录 零向取整.负无穷向取整.正无穷向取整.四舍五入取整 总结 零向取整.负无穷向取整.正无穷向取整.四舍五入取整 如果将一个浮点数赋值给整形,只会保存整数位: 这种取整方式为零向取整,C语言默认采用的是这种方式 C语言中也有对应的零向取整函数: 同理还有一种函数是负无穷大取整: 它的取整方案是向负无穷大取整: 有地板取整,当然也有正无穷大取整的函数: 它的取整方式是向正无穷大取整: 最后,还有四舍五入取整的函数: 取模/取余 取模概念: 如果a和d是两个自然数,d非零,可以证明存在两个唯一的整

  • C语言取模取整的深入理解

    目录 一:四大取整 1.1. 0向取整 1.2.  -∞取整( 地板取整) 1.3. +∞取整 1.4. 四舍五入取整 1.5. 例子汇总 二:取模 / 取余 2.1. 概念 2.2. 示例(C和Python) 2.3. 取余和取模一样吗? 2.4. 计算数据同符号 2.5. 计算数据不同符号 2.6. 总结 一:四大取整 1.1. 0向取整 看代码: #include <stdio.h> int main() { //本质是向0取整 int i = -2.9; int j = 2.9; pr

  • JS取模、取商及取整运算方法示例

    本文实例讲述了JS取模.取商及取整运算方法.分享给大家供大家参考,具体如下: JS代码: //求余数 document.write(1%4); document.write(6%4); //求商 console.info(1/4); console.info(6/4); //求商,取整 console.info(parseInt(1/4)); console.info(parseInt(6/4)); console.info('----'); //天花板取整 console.info(Math.

  • C语言快速幂取模算法小结

    本文实例汇总了C语言实现的快速幂取模算法,是比较常见的算法.分享给大家供大家参考之用.具体如下: 首先,所谓的快速幂,实际上是快速幂取模的缩写,简单的说,就是快速的求一个幂式的模(余).在程序设计过程中,经常要去求一些大数对于某个数的余数,为了得到更快.计算范围更大的算法,产生了快速幂取模算法.我们先从简单的例子入手:求abmodc 算法1.直接设计这个算法: int ans = 1; for(int i = 1;i<=b;i++) { ans = ans * a; } ans = ans %

  • Java语言实现快速幂取模算法详解

    快速幂取模算法的引入是从大数的小数取模的朴素算法的局限性所提出的,在朴素的方法中我们计算一个数比如5^1003%31是非常消耗我们的计算资源的,在整个计算过程中最麻烦的就是我们的5^1003这个过程 缺点1:在我们在之后计算指数的过程中,计算的数字不都拿得增大,非常的占用我们的计算资源(主要是时间,还有空间) 缺点2:我们计算的中间过程数字大的恐怖,我们现有的计算机是没有办法记录这么长的数据的,所以说我们必须要想一个更加高效的方法来解决这个问题 当我们计算AB%C的时候,最便捷的方法就是调用Ma

  • 详解易语言绝对取整和取整的区别

    易语言绝对取整和取整的区别,希望大家都能学懂. 非无私奉献,拒绝看经验不回复,学懂了记得按照下面做: 在底部点击相关按钮,给我投票和点赞. 有心得或者疑问,点击相关按钮反馈. 具体操作请看图. 1.易语言新建一个windows窗口 点击进入代码编辑区 2.我们输入绝对取整() 展开看看 发现只有一个参数 3.在输入取整() 展开看看 发现还是只有一个参数 4.看上去没有什么不同 我们举个例子 我们把这个参数都设为-7.8 5.我们在输入调试输出 用法如图所示 6.然后运行 通过结果发现 绝对取整

  • java 取模与取余的区别说明

    取模与取余的区别 对于整型数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方向舍入): 第二步:计算模和

  • Python中的取模运算方法

    所谓取模运算,就是计算两个数相除之后的余数,符号是%.如a % b就是计算a除以b的余数.用数学语言来描述,就是如果存在整数n和m,其中0 <= m < b,使得a = n * b + m,那么a % b = a - n * b = m. 取模运算的两个操作数都必须是整数,可以是负整数,但是b不可以是0,因为被除数不能为0嘛. 当a和b中存在负整数时,首先计算|a|%|b|=c,然后a%b的符号与b一致.也就是说,如果b>0,则a%b=c:如果b<0,则a%b=-c 比如: 好了,

  • Python中的整除和取模实例

    一 除法 1 正数除法 Python3中的除法中,除法/总是返回一个浮点数,如下: >>> 6/4 1.5 >>> 2/3 0.6666666666666666 如果只想得到整数的结果,丢弃分数部分,可以使用运算符 //: >>> 6//4 1 >>> 2//3 0 // 得到的是整除的结果,但是结果并不一定是整数类型的数,它与分母分子的数据类型有关系: >>> 6//4.0 1.0 >>> 2.0

随机推荐