浅析大整数运算

最新推荐文章于 2024-05-27 17:03:05 发布
最新推荐文章于 2024-05-27 17:03:05 发布
阅读量3.1k 收藏 4
点赞数 1
分类专栏： JAVA 文章标签： java 算法 大整数运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012027907/article/details/12191465
版权

        众所周知，所有的编程语言中，每一种基本数据类型都有范围，就拿整数来说，int型的数据能表示的范围是有限的，但有时我们可能进行很大的整型数据的运算。当然，有人会说，有long int 呀？是的，但long int 能表示的数据仍然是有限的。我们要进行一万位的整型的加、减、乘、除的运算怎么办？此时我们就需要考虑如何实现大整型数据的运算。

        要解决这个问题，就必须考虑别的思路或方法，最普遍的做法就是采用数组存储每一位的数据，这样，即使再大的整型也能进行运算。

整体思路：

1)将一个数字字符串（用字符串接收输入的数据）每一位分割存入整型数组中。

一、加法运算：

   加法运算就像小学学加法运算时的方法。例如有两个整型数组NumA[3] = { 1,3,9},NumB[3] = { 4,7, 2}，保存结果的Result[6];记录中间结果的整型变量Temp。

  A.先让个位运算:

      1       3           9

      4       7           2

                                

              1[进位]  1[本位]

int low = 0;   //记录低位的进位数字

Temp = NumA[2] + NumB[2];

if(Temp >= 10) //有进位

{

   Result[5] = Temp % 10 + low;

   Result[4]  += Temp / 10;

}

B.然后让十位运算，原理和个位运算一样。依次加完所有的数即可完成加法运算。

二、减法运算：

       减法运算和加法类似，只不过一个是加，一个是减，一个是进位，另一个是借位。

三、乘法运算：

      乘法运算稍微复杂一些。但原理和加法类似，只不过是多加法运算的组合。

就拿上面的书来说：

                                  1                      3                         9

                                  4                      7                        2

                                                                                                       

                                   2               6+1(低位进的数)     8[本位]

                    7+2    1+6                   3

  4+1          2+3        6

  6               5             6                  0                             8

用被乘数的个位与乘数的每一位相乘。

int MidResult[5]; //保存中间计算结果

int low  = 0; //低位的进位

MidResult[4] = NumA[2] * NumB[2] % 10 + low;

low = NumA[2]  / NumB[2];

MidResult[3] = NumA[1] * NumB[2] % 10 + low;

依次计算，得到中间结果MidResult；

low = 0;

Result[4] = (Result[4] +MidResult[4] + low) % 10;

low = Result[4] / 10;

Result[3] = (Result[3] + MidResult[4] + low)% 10;

....

上面是NumB个位计算结果，若是十位，则 Result从Reslut[3]与 MidResult[4]加起。

依次计算就可以得到结果。

四、除法：

这和小学学的除法运算也是一样的。

                       1    1   3                                 

    9       [   1   0    2   4

                       1   2

                             9

                             3  4

                             2  7

                                 7

正如上面的运算一样，采用从0 - 9 依次在每一位试，直到有10  - 1[试]*9 的值 >= 0;则改位商 1，依次计算。

具体的代码如下：

/**
 * @计算超大整型
 */
public class LargeInteger {
	
	String FirstNumStr;   //第一个数的字符串
	
	LargeInteger(String var){  //构造方法（给第一个数字符串赋值）
		this.FirstNumStr = var;
	}
	/**
	 * 加方法
	 * @param SecondNumStr 被加数
	 * @return 相加的结果
	 */
	public String add(String SecondNumStr){ //加方法
		
		int LengthA = FirstNumStr.length(); //求出第一个数字符串长度
		int LengthB = SecondNumStr.length();//求出第二个数字符串长度
		
		boolean IsMinus = false; //是否带负号
		if((FirstNumStr.charAt(0) == '-') && (SecondNumStr.charAt(0) == '-')){//都带负号
			IsMinus = !IsMinus;
		}else if(FirstNumStr.charAt(0) == '-'){ //第一个数带负号
			FirstNumStr = FirstNumStr.substring(1);
			String second = FirstNumStr;
			FirstNumStr = SecondNumStr;
			return  subtract(second);
		}else if(SecondNumStr.charAt(0) == '-'){ //第二个数带负号
			SecondNumStr = SecondNumStr.substring(1);
			return subtract(SecondNumStr);
		}
		
		int MaxLength = LengthA >= LengthB?LengthA:LengthB; //求出最大的长度
		MaxLength += 1; //加1是为了给可能的进位留出一位
		
		int []FirstNum = new int[MaxLength];  //定义第一个数整型数组
		int []SecondNum = new int[MaxLength]; //定义第二个数整型数组
			
		int []Result = new int[MaxLength];    //定义存放结果数组
		int MidResult = 0;  //中间结果
        int num = 0;    //记录将字符转为整型的数
	    for(int i = LengthA-1,j = MaxLength-1; i >= 0; i--,j--){ //将第一个数字符串转为整型数组
	    	switch(FirstNumStr.charAt(i)){
	    	case '0':num = 0;break;
	    	case '1':num = 1;break;
	    	case '2':num = 2;break;
	    	case '3':num = 3;break;
	    	case '4':num = 4;break;
	    	case '5':num = 5;break;
	    	case '6':num = 6;break;
	    	case '7':num = 7;break;
	    	case '8':num = 8;break;
	    	case '9':num = 9;break;
	    	default:num = 0;break;
	    	}
	    	FirstNum[j] = num;
	    }
	    num = 0;
	    for(int i = LengthB-1,j = MaxLength-1; i >= 0; i--,j--){//将第二个数字符串转为整型数组
	    	switch(SecondNumStr.charAt(i)){
	    	case '0':num = 0;break;
	    	case '1':num = 1;break;
	    	case '2':num = 2;break;
	    	case '3':num = 3;break;
	    	case '4':num = 4;break;
	    	case '5':num = 5;break;
	    	case '6':num = 6;break;
	    	case '7':num = 7;break;
	    	case '8':num = 8;break;
	    	case '9':num = 9;break;
	    	default:num = 0;break;
	    	}
	    	SecondNum[j] = num;
	    }
	    
	   
		for(int i = MaxLength-1; i >= 0; i--){       //从个位开始加
			MidResult = FirstNum[i] + SecondNum[i];  //记录两数相加的中间结果
			if(MidResult >= 10){    //进位
				Result[i] = MidResult % 10;  //本位的数
				FirstNum[i-1] = FirstNum[i-1] + 1; //进位
			}else{
				Result[i] = MidResult; //没有进位直接赋值
			}
		}
		
		String ResultStr = "";
		if(IsMinus){        //
			ResultStr = "-";
		}
	
		boolean flag = false;
		for(int j = 0 ; j < MaxLength; j++){ //将整型数组转为字符串
			if(Result[j] != 0){	//数组前面有0不赋值给字符串		    
			    flag = true;
			}
			if(flag){
				ResultStr += Result[j];
			}
		}

		return ResultStr;
	}
	/**
	 * 减方法
	 * @param SecondNumStr
	 * @return 相减的结果
	 */
	public String subtract(String SecondNumStr){
		
		int LengthA = FirstNumStr.length(); //求出第一个数字符串长度
		int LengthB = SecondNumStr.length();//求出第二个数字符串长度
		
		if((FirstNumStr.charAt(0) == '-') && (SecondNumStr.charAt(0) == '-')){
			String second = FirstNumStr;
			FirstNumStr = SecondNumStr.substring(1);
			return add(second);
			
		}else if(FirstNumStr.charAt(0) == '-'){
			SecondNumStr = "-"+SecondNumStr;
			return  add(SecondNumStr);
		}else if(SecondNumStr.charAt(0) == '-'){
			SecondNumStr = SecondNumStr.substring(1);
			return add(SecondNumStr);
		}
		
		int MaxLength = LengthA >= LengthB?LengthA:LengthB; //求出最大的长度
		
		int []FirstNum = new int[MaxLength];  //定义第一个数整型数组
		int []SecondNum = new int[MaxLength]; //定义第二个数整型数组
			
		int []Result = new int[MaxLength];    //定义存放结果数组
		int MidResult = 0;  //中间结果
        int num = 0;    //记录将字符转为整型的数
	    for(int i = LengthA-1,j = MaxLength-1; i >= 0; i--,j--){ //将第一个数字符串转为整型数组
	    	switch(FirstNumStr.charAt(i)){
	    	case '0':num = 0;break;
	    	case '1':num = 1;break;
	    	case '2':num = 2;break;
	    	case '3':num = 3;break;
	    	case '4':num = 4;break;
	    	case '5':num = 5;break;
	    	case '6':num = 6;break;
	    	case '7':num = 7;break;
	    	case '8':num = 8;break;
	    	case '9':num = 9;break;
	    	default:num = 0;break;
	    	}
	    	FirstNum[j] = num;
	    }
	    num = 0;
	    for(int i = LengthB-1,j = MaxLength-1; i >= 0; i--,j--){//将第二个数字符串转为整型数组
	    	switch(SecondNumStr.charAt(i)){
	    	case '0':num = 0;break;
	    	case '1':num = 1;break;
	    	case '2':num = 2;break;
	    	case '3':num = 3;break;
	    	case '4':num = 4;break;
	    	case '5':num = 5;break;
	    	case '6':num = 6;break;
	    	case '7':num = 7;break;
	    	case '8':num = 8;break;
	    	case '9':num = 9;break;
	    	default:num = 0;break;
	    	}
	    	SecondNum[j] = num;
	    }
	    
	    boolean FirstNumLarger = false;
Breakflag:for(int i = 0; i <MaxLength; i++){  //判断第一个数是否大于第二个数
	    	if(FirstNum[i] > SecondNum[i]){
	    		FirstNumLarger = true;
	    		break Breakflag;
	    	}else if(FirstNum[i] == SecondNum[i]){
	    		continue;
	    	}else{
	    		break Breakflag;
	    	}
	    }
	   
		for(int i = MaxLength-1; i >= 0; i--){       //从个位开始加
			if(FirstNumLarger){ //大数减小数
			    MidResult = FirstNum[i] - SecondNum[i];  //记录两数相减的中间结果			    
			}else{
				MidResult = SecondNum[i] - FirstNum[i];
			}
			if(MidResult < 0){    //借位
				Result[i] = 10 + MidResult ;  //本位的数
				if(FirstNumLarger){
					FirstNum[i-1] = FirstNum[i-1] - 1; //借位
				}else{
					SecondNum[i-1] = SecondNum[i-1] - 1;
				}
				
			}else{
				Result[i] = MidResult; //没有进位直接赋值
			}
		}
		
		String ResultStr = "";
		if(!FirstNumLarger){
			ResultStr = "-";
		}
		boolean flag = false;
		for(int j = 0 ; j < MaxLength; j++){ //将整型数组转为字符串
			if(Result[j] != 0){	//数组前面有0不赋值给字符串		    
			    flag = true;
			}
			if(flag){
				ResultStr += Result[j];
			}
		}
        if(ResultStr == "-"){ //相减为0时，赋值0
        	ResultStr = "0";
        }
		return ResultStr;
	}
	/**
	 * 乘方法
	 * @param SecondNumStr
	 * @return 相乘的结果
	 */
	public String multiply(String SecondNumStr){
		
	    boolean IsMinus = false; //是否带负号
		if(FirstNumStr.charAt(0) == '-'){
			IsMinus = !IsMinus;
			FirstNumStr = FirstNumStr.substring(1);
		}
		if(SecondNumStr.charAt(0) == '-'){
			IsMinus = !IsMinus;
			SecondNumStr = SecondNumStr.substring(1);
		}
		int LengthA = FirstNumStr.length(); //求出第一个数字符串长度
		int LengthB = SecondNumStr.length();//求出第二个数字符串长度
		
		int MaxLength = LengthA >= LengthB?LengthA:LengthB; //求出最大的长度
		MaxLength++; //多预留一个空间
		int ResultLength = MaxLength*2; //两个数相乘最多为两个数中最大长度的2倍
		
		int []FirstNum = new int[MaxLength];  //定义第一个数整型数组
		int []SecondNum = new int[MaxLength]; //定义第二个数整型数组
		int []TempNum = new int[MaxLength];   //临时整型数组存储中间计算结果
			
		int []Result = new int[ResultLength];    //定义存放结果数组
		int MidResult = 0;  //中间结果
        int num = 0;    //记录将字符转为整型的数
        
        for(int i = LengthA-1,j = MaxLength-1; i >= 0; i--,j--){ //将第一个数字符串转为整型数组
	    	switch(FirstNumStr.charAt(i)){
	    	case '0':num = 0;break;
	    	case '1':num = 1;break;
	    	case '2':num = 2;break;
	    	case '3':num = 3;break;
	    	case '4':num = 4;break;
	    	case '5':num = 5;break;
	    	case '6':num = 6;break;
	    	case '7':num = 7;break;
	    	case '8':num = 8;break;
	    	case '9':num = 9;break;
	    	default:num = 0;break;
	    	}
	    	FirstNum[j] = num;
	    }
	    num = 0;
	    for(int i = LengthB-1,j = MaxLength-1; i >= 0; i--,j--){//将第二个数字符串转为整型数组
	    	switch(SecondNumStr.charAt(i)){
	    	case '0':num = 0;break;
	    	case '1':num = 1;break;
	    	case '2':num = 2;break;
	    	case '3':num = 3;break;
	    	case '4':num = 4;break;
	    	case '5':num = 5;break;
	    	case '6':num = 6;break;
	    	case '7':num = 7;break;
	    	case '8':num = 8;break;
	    	case '9':num = 9;break;
	    	default:num = 0;break;
	    	}
	    	SecondNum[j] = num;
	    }
	    int PriorNum = 0; //进位
	    int k = ResultLength - 1; //Result[k]从个位向前赋值
	    
	    for(int i = MaxLength-1; i > 0; i--){      //控制第二个数的个、十、百向前推移
	    	for(int j = MaxLength-1; j > 0; j--){  //使第二个数与第一个数的每一位相乘
	    		MidResult = SecondNum[i]*FirstNum[j]; //保存两个数相乘的中间结果
	    		PriorNum = MidResult / 10;  //进位数
	    	//	if(MidResult >= 10){    //乘的结果需要进位
	    			TempNum[j] += MidResult % 10; //本位的值
	    			if(TempNum[j] >= 10){    //如果本位的值仍需进位，则再进一位
	    				TempNum[j] = TempNum[j] % 10; //本位的最终值
	    				PriorNum++; //需要的进位数再加一
	    			}
	    			TempNum[j-1] = TempNum[j-1]+PriorNum; //进位
	    	//	}
	    	}
	    	int m = k;
	    	for(int n = MaxLength-1; n >= 0; n--,m--){  //将临时存储的数组复制给最终结果数组
	    		Result[m] += TempNum[n]; //赋值
	    		if(Result[m] >= 10){  //若赋值相加需要进位，则进位
	    			Result[m-1] += Result[m]/10; //先进位
	    			Result[m] = Result[m] % 10;  //后算本位的值（这两句代码不能颠倒）	
	    		}
	    		TempNum[n] = 0; //临时数组置0，以便下一个循环用
	    	}
	    	k--;//下一次临时数组赋值时徐翔高位移一位
	    }
	    String ResultStr = "";
		if(IsMinus){
			ResultStr = "-";
		}
		
	    boolean flag = false;
		for(int j = 0 ; j < ResultLength; j++){ //将整型数组转为字符串
			if(Result[j] != 0){	//数组前面有0不赋值给字符串		    
			    flag = true;
			}
			if(flag){
				ResultStr += Result[j];
			}
		}
		if(ResultStr == ""){ //相乘为0时，显示0
        	ResultStr = "0";
        }
		return ResultStr;
	}
	/**
	 * 除方法
	 * @param SecondNumStr
	 * @return 除的结果
	 */
    public String divide(String SecondNumStr){
				
		boolean IsMinus = false; //是否带负号
		if(FirstNumStr.charAt(0) == '-'){    //第一个数带了负号
			IsMinus = !IsMinus;
			FirstNumStr = FirstNumStr.substring(1);			
		}
		if(SecondNumStr.charAt(0) == '-'){ //第二个数带了负号
			IsMinus = !IsMinus;
			SecondNumStr = SecondNumStr.substring(1);			
		}
		int LengthA = FirstNumStr.length(); //求出第一个数字符串长度
		int LengthB = SecondNumStr.length();//求出第二个数字符串长度
		
		if(LengthA < LengthB){   //因为是整除，所以第一个数小与第二个数时，直接返回 0
			return "0";
		}else if(LengthA == LengthB){ //字符串相等
			String result = subtract(SecondNumStr); 
			if(result.charAt(0) == '-'){ //第一个数小，直接返回0
				return "0";
			}else if(result.charAt(0) == '0'){ //两个数相等，则返回1
				return "1";
			}
		}
		
		int []Result =  new int[LengthA]; //存放最终结果的整型数组
		
		String SubTemp = ""; //存放字串
		String Temp = "";
		String result = "";
		String StoreFirstNumStr = FirstNumStr;//临时存放第一个数
		
		for(int i = LengthB-1 ; i < LengthA; i++ ){
			if(i == LengthB-1){
			    SubTemp = FirstNumStr.substring(0,LengthB);
			}else{
				FirstNumStr = SubTemp;
				SubTemp = subtract(Temp)+StoreFirstNumStr.substring(i,i+1);
			}
			for(int j = 9; j >= 0 ;j--){ //每一位的商值从9-0挨个试
				
				FirstNumStr = Integer.toString(j); //将整型转为字符串
				Temp = multiply(SecondNumStr);     //9-0中的数与被除数相乘
				
				FirstNumStr = SubTemp;
				result = subtract(Temp);//计算差值
				
				if(result.charAt(0) == '-'){ //若差值为负，则继续
					continue;
				}else{                      //否则，确定商，并跳出循环
					Result[i] = j;
					break;
				}
			}
		}
		 String ResultStr = "";//最终返回值的字符串
			if(IsMinus){      //计算结果为负
				ResultStr = "-";
			}
		
		boolean flag = false;  //标记变量,标记从Result[0]-Reslult[n-1]哪一位开始不为0，才赋值给ResultStr
		for(int j = 0 ; j < LengthA; j++){ //将整型数组转为字符串
			if(Result[j] != 0){	//数组前面有0不赋值给字符串		    
			    flag = true;
			}
			if(flag){
				ResultStr += Result[j];
			}
		}
		if(ResultStr == ""){ //相乘为0时，显示0
        	ResultStr = "0";
        }
		
		return ResultStr;
	}
	
}

测试代码：

import java.math.BigInteger;

/**
 *  @author ZhangyaChao(张亚超)
 *  @version 1.0
 *  @date 2013/9/17
 *  @last modify 2013/9/18
 */

public class Basic {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
                  //测试代码
		LargeInteger One = new LargeInteger("1024546448494645445444464545454545456546546548897454644");
		String Two = "1024546448494645454654";

		String result1 = One.add(Two);
		String result2 = One.subtract(Two);
		String result3 = One.multiply(Two);
		String result4 = One.divide(Two);
		
		BigInteger one = new BigInteger("1024546448494645445444464545454545456546546548897454644");
		
		BigInteger Result1 = one.add(new BigInteger("1024546448494645454654"));
		BigInteger Result2 = one.subtract(new BigInteger("1024546448494645454654"));
		BigInteger Result3 = one.multiply(new BigInteger("1024546448494645454654"));
		BigInteger Result4 = one.divide(new BigInteger("1024546448494645454654"));
		
		System.out.println(""+result1+"\n"+Result1+"\n\n");
		System.out.println(""+result2+"\n"+Result2+"\n\n");
		System.out.println(""+result3+"\n"+Result3+"\n\n");
		System.out.println(""+result4+"\n"+Result4+"\n\n");
	}

}



 

                  

           

牟尼
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
位运算浅析
qq_41843697的博客
04-14 172
由于最近刷题时遇见了几道与位运算有关的题目，因此想借此机会把与位运算有关的知识点都整理一下。 要了解位运算，首先来整理一下二进制，二进制即用0和1两个数组及其组合表示任何数，二进制的进位规则是“逢二进一”，数字1在不同的位上代表不同的值，按从右至左的顺序，以2倍递增，二进制在计算机技术中广泛应用。 1.位 而每个二进制(即每个0或1)就被称为位，称为比特(bit)，简记为b，是数据存储的最小...
python 小括号 运算_浅析python 中大括号中括号小括号的区分
weixin_39853892的博客
02-09 1529
python语言最常见的括号有三种，分别是：小括号( )、中括号[ ]和大括号也叫做花括号{ }。其作用也各不相同，分别用来代表不同的python基本内置数据类型。1.python中的小括号( )：代表tuple元组数据类型，元组是一种不可变序列。创建方法很简单，大多时候都是用小括号括起来的。>>> tup = (1,2,3)>>> tup(1, 2, 3)&g...
算法分析c语言大整数乘法,大整数乘法浅析（C语言实现）
weixin_29198045的博客
05-17 798
1.引言最近在做学校网上的OJ题时，碰到了高精度加法和乘法的运算。加法没有太多实现上的困难，但是乘法却卡了一会儿，在网上搜集材料时，很多都是直接贴上了代码，没有具体的分析。为了巩固自己的学习成果并且和大家交流学习，我将学习的过程记录下来，希望可以帮助到有同样困扰的同学。2.思路2.1 大整数加法思路的回顾为了更好的理解高精度乘法处理的基本思路，首先应该回顾一下大整数的加法，再循序渐进到乘法当中。 ...
大整数运算详解升级版
最新发布
m0_72674633的博客
05-27 796
高精度算法升级版理解
java 大整数编程_Java编程--RSA算法中的大整数运算
weixin_36478447的博客
02-13 203
Java编程–RSA算法中的大整数运算RSA原理浅析RSA是利用陷门单向函数实现的，其安全基础依赖于大整数的分解问题的难解性算法过程为了加深对RSA算法的了解，接下来通过简单的一个例子来分析一下：eg:根据已知参数：p=3,q=11,M=2p = 3, q = 11, M = 2p=3,q=11,M=2，手工计算公私钥，并对明文进行加密，然后对密文进行解密。(1)首先计算n=p×q=3×11=33...
java 位运算 优点_Java位运算符浅析
weixin_34943809的博客
02-16 360
在学习源码中，发现有大量使用位运算符，这样做的目的是为了节约内存开销和加快计算效率。位运算符，这个”位”代表这什么？位：二进制位简称“位”，是二进制记数系统中表示小于2的整数的符号，一般用1或 0表示，是具有相等概率的两种状态中的一种。二进制位的位数可表示一个机器字的字长，一个二进制位包含的信息量称为一比特。摘自百度百科int类型占4个字节(byte);一个字节=8bit(位);一个int类型的数...
浅析jsoup和正则运算
俩科的博客
03-24 696
在用jsoup整理数据的时候经常会碰见一些多余的数据， 第一 譬如 李明，李明，李明 我只想要第一个，该如何去处理呢 可以加一个条件 if(数据.contains("，")){ 数据 = 数据.split(",")[0].trim(); } 特别注意，注意，里面替换的符号在获取的数据里面复制，因为你不知道里面是不是有什么英文半角什么中文半角符号什么的，不如直接复制数据里面的 第二 如果获取到的...
Java编程--RSA算法中的大整数运算
考拉研究僧的博客
07-04 1471
Java编程–RSA算法中的大整数运算 1. RSA原理浅析RSA是利用陷门单向函数实现的，其安全基础依赖于大整数的分解问题的难解性2. 算法过程为了加深对RSA算法的了解，接下来通过简单的一个例子来分析一下：eg:根据已知参数：p = 3, q = 11, M = 2 ，手工计算公私钥，并对明文进行加密，然后对密文进行解密。（1）首先计算n = p × q = 3 × 11 =33 （2）Φ(n
数字电源浅析
shiwei0813的博客
03-21 497
数字电源是一种数字控制的电源设备，可以通过数字控制芯片（DSP、MCU等）实现输出电压、电流、功率等参数的精确控制与调节。数字电源具有高精度、高稳定性、高可靠性、高效率、远程控制、自动化调节等特点。随着数字化技术的不断进步，数字电源已经成为电源领域的发展趋势，并在通信行业、工业自动化、医疗行业、航空航天以及研究教育等领域得到广泛的应用。
浅析负数求模运算
Busy-Joy’s Blog
07-16 729
转自:http://loveli0917.blog.163.com 最近带的助教班中，有人问 负数怎么取模，故上网搜了一下，感觉下面这篇帖子写得很不错，故拷过来借鉴下，原文：http://ceeji.net/blog/mod-in-real/ 最近在一道 Java 习题中，看到这样的一道题： What is the output when this statement e
浅析关于PHP位运算的简单权限设计
12-19
在二进制表示中，这些运算符对数字的每一位进行操作。例如，"与"运算符会检查两个数的相应位，如果都是1，则结果位为1，否则为0；"或"运算符只要对应位中有1，结果位就为1；"非"运算符则将每一位取反。 在权限设计...
浅析js中的浮点型运算问题
10-26
在JavaScript中，浮点型运算涉及到的是数字表示和计算精度的问题。由于计算机内部是以二进制形式存储和处理数据的，而十进制的小数在转换为二进制时可能会出现无限循环，导致无法精确表示某些浮点数，这就会引发浮点...
浅析模拟滤波器和数字滤波器的区别
08-20
浅析模拟滤波器和数字滤波器的区别 模拟滤波器和数字滤波器是两种不同的信号处理方式，它们之间有着本质的区别。模拟滤波器用于连续时间系统，也可以用在离散时间系统中，而数字滤波器用于离散系统。 模拟滤波器...
python 中的divmod数字处理函数浅析
09-21
Python中的`divmod()`函数是一个非常实用的内置函数，它用于处理数字的除法运算，并同时返回商和余数。这个函数接受两个参数`a`和`b`，并返回一个包含两部分结果的元组：`(quotient, remainder)`。 在Python 2.3...
浅析Python数字类型和字符串类型的内置方法
09-18
数字类型没有专门的内置方法，它们的主要操作是算术运算（加减乘除、取模、幂等）和比较运算（大于、小于、等于等）。数字类型是不可变的，这意味着一旦创建了数字对象，其值就不能改变，例如，重新赋值`x = 20`实际...
几个有意思的算法题
热门推荐
牟尼的专栏
11-05 3万+
1.题目标题: 高斯日记     大数学家高斯有个好习惯：无论如何都要记日记。     他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210     后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？     高斯出生于：1777年4月30日。
Java实现任意进制转换
牟尼的专栏
08-29 2万+
问题：将m进制num转换为n进制 （2 <= m,n <= 62) ？ 总体思路是：先将m进制转换为10进制，再将10进制转为n进制。 1、m进制数num转为10进制 从低位到高位按权展开即可。 例如：8进制1356 转为10进制 6*8^0 + 5 * 8^1 + 3 * 8^2 + 1 * 8^3 = 750 2、10进制转为n进制 采用除留取余，逆序排列。 例如：1
仿QQ聊天程序
牟尼的专栏
03-16 1万+
仿QQ聊天程序 转载请标明出处：牟尼的专栏 http://blog.csdn.net/u012027907 一、设计内容及要求 1.1综述 A.系统概述 我们要做的就是类似QQ这样的面向企业内部的聊天软件，基本功能和QQ类似。首先，系统分为两大部分，第一部分是客户端，是用户使用的部分，第二部分就是服务器，所有的客户端都是通过服务器来进行用户身份验证及聊天转接的。客户端提供主要的界面及服务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值