精华内容
下载资源
问答
  • Java中一个数的N次方

    万次阅读 多人点赞 2019-03-14 14:12:06
    Java中一个数的N次方不可以写成:a^0这种形式,算得的数不正确; 正确的写法为Math.pow(a,0); 此外,Math中常用的函数有 /** *Math.sqrt()//计算平方根 *Math.cbrt()//计算立方根 *Math.pow(a, b)//计算a...

    在Java中一个数的N次方不可以写成:a^0这种形式,算得的数不正确;

    正确的写法为Math.pow(a,0);

    此外,Math中常用的函数有

    /** 
             *Math.sqrt()//计算平方根
             *Math.cbrt()//计算立方根
             *Math.pow(a, b)//计算a的b次方
             *Math.max( , );//计算最大值
             *Math.min( , );//计算最小值
             */  
    
            System.out.println(Math.sqrt(16));   //4.0 
            System.out.println(Math.cbrt(8));    //2.0
            System.out.println(Math.pow(3,2));     //9.0
            System.out.println(Math.max(2.3,4.5));//4.5
            System.out.println(Math.min(2.3,4.5));//2.3
    
            /** 
             * abs求绝对值 
             */  
            System.out.println(Math.abs(-10.4));    //10.4  
            System.out.println(Math.abs(10.1));     //10.1  
    
            /** 
             * ceil天花板的意思,就是返回大的值
             */  
            System.out.println(Math.ceil(-10.1));   //-10.0  
            System.out.println(Math.ceil(10.7));    //11.0  
            System.out.println(Math.ceil(-0.7));    //-0.0  
            System.out.println(Math.ceil(0.0));     //0.0  
            System.out.println(Math.ceil(-0.0));    //-0.0  
            System.out.println(Math.ceil(-1.7));    //-1.0
    
            /** 
             * floor地板的意思,就是返回小的值 
             */  
            System.out.println(Math.floor(-10.1));  //-11.0  
            System.out.println(Math.floor(10.7));   //10.0  
            System.out.println(Math.floor(-0.7));   //-1.0  
            System.out.println(Math.floor(0.0));    //0.0  
            System.out.println(Math.floor(-0.0));   //-0.0  
    
            /** 
             * random 取得一个大于或者等于0.0小于不等于1.0的随机数 
             */  
            System.out.println(Math.random());  //小于1大于0的double类型的数
            System.out.println(Math.random()*2);//大于0小于1的double类型的数
            System.out.println(Math.random()*2+1);//大于1小于2的double类型的数
    
            /** 
             * rint 四舍五入,返回double值 
             * 注意.5的时候会取偶数    异常的尴尬
             */  
            System.out.println(Math.rint(10.1));    //10.0  
            System.out.println(Math.rint(10.7));    //11.0  
            System.out.println(Math.rint(11.5));    //12.0  
            System.out.println(Math.rint(10.5));    //10.0  
            System.out.println(Math.rint(10.51));   //11.0  
            System.out.println(Math.rint(-10.5));   //-10.0  
            System.out.println(Math.rint(-11.5));   //-12.0  
            System.out.println(Math.rint(-10.51));  //-11.0  
            System.out.println(Math.rint(-10.6));   //-11.0  
            System.out.println(Math.rint(-10.2));   //-10.0  
    
            /** 
             * round 四舍五入,float时返回int值,double时返回long值 
             */  
            System.out.println(Math.round(10.1));   //10  
            System.out.println(Math.round(10.7));   //11  
            System.out.println(Math.round(10.5));   //11  
            System.out.println(Math.round(10.51));  //11  
            System.out.println(Math.round(-10.5));  //-10  
            System.out.println(Math.round(-10.51)); //-11  
            System.out.println(Math.round(-10.6));  //-11  
            System.out.println(Math.round(-10.2));  //-10  
    展开全文
  • Java 计算奇数偶数

    千次阅读 2019-04-28 08:13:54
    开发工具与关键技术:Myeclipse 10,Java 作者:刘俊杰 撰写时间:2019年04月26日 今天讲的是用for循环和while循环,分别计算出100数值以内的奇数和偶数。 计算数值的奇数和偶数并不需要写多少代码,只需要一个循环...

    开发工具与关键技术:Myeclipse 10,Java
    作者:刘俊杰
    撰写时间:2019年04月26日

    今天讲的是用for循环和while循环,分别计算出100数值以内的奇数和偶数。
    计算数值的奇数和偶数并不需要写多少代码,只需要一个循环语句在循环体中再加一个if语句的判断就行了。

    首先是for循环
    for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构

    语法形式
    for(初始化表达式:布尔表达式:步进){
    循环体;
    }

    实例:

    for (int i = 1; i <= 100; i++) {
    	if (i % 2 == 0) {
    		System.out.println("偶数:" + i);
    	} else {
    		System.out.print("奇数:" + i +"\t");
    	}
    }
    

    for循环运行结果

    在这里插入图片描述

    其次是While循环
    While循环在刚开始的时候,会计算一次“布尔表达式”的值,若条件为真,才会执行循环体。而对于后来每一次额外的循环,都会再重新计算一次;

    语法形式
    while(布尔表达式){
    循环体;
    }

    实例:

    int i = 1;
    while (i < 100) {
    	i++;
    	if (i % 2 == 0) {
    		System.out.println("偶数:" + i);
    	} else {
    		System.out.print("奇数:" + i + "\t");
    	}
    }
    

    While循环运行结果:
    在这里插入图片描述

    展开全文
  • 本程序能根据用户的要求,由用户决定比较的数字的总数,并由用户输入要比较的数字,然后打印出最大值
  • 最近看到一个好的方法:开方。 public static BigDecimal getBigDecimal(BigDecimal number, int n, int scale, int roundingMode) { //是否去相反数的标志 boolean negate = ... //不能开负数次方 if (n <...

    最近看到一个好的方法:开方。

      public static BigDecimal getBigDecimal(BigDecimal number, int n, int scale, int roundingMode) {
            //是否去相反数的标志
            boolean negate = false;
            //不能开负数次方
            if (n < 0) {
                throw new ArithmeticException();
            }
            //负数不能开平方
            if (number.compareTo(BigDecimal.ZERO) < 0) {
                if (n % 2 == 0) {
                    throw new ArithmeticException();
                } else {
                    //负数可以开奇数次方,这里取反,后再取回来
                    number = number.negate();
                    //取了相反数的标志
                    negate = true;
                }
            }
    
            BigDecimal root;
    
            if (n == 0) {
                //任何数的0次方为1
                root = BigDecimal.ONE;
            } else if (n == 1) {
                //任何数开1次方是这个数本身
                root = number;
            } else {
                final BigInteger N = BigInteger.valueOf(n);
                final BigInteger N2 = BigInteger.TEN.pow(n);
                final BigInteger N3 = BigInteger.TEN.pow(n - 1);
                final BigInteger NINE = BigInteger.valueOf(9);
    
                BigInteger[] C = new BigInteger[n + 1];
                for (int i = 0; i <= n; i++) {
                    C[i] = combination(n, i);
                }
    
                BigInteger integer = number.toBigInteger();
                String strInt = integer.toString();
                int lenInt = strInt.length();
                for (int i = lenInt % n; i < n && i > 0; i++) {
                    strInt = "0" + strInt;
                }
                lenInt = (lenInt + n - 1) / n * n;
                BigDecimal fraction = number.subtract(number.setScale(0, BigDecimal.ROUND_DOWN));
                int lenFrac = (fraction.scale() + n - 1) / n * n;
                fraction = fraction.movePointRight(lenFrac);
                String strFrac = fraction.toPlainString();
                for (int i = strFrac.length(); i < lenFrac; i++) {
                    strFrac = "0" + strFrac;
                }
    
                BigInteger res = BigInteger.ZERO;
                BigInteger rem = BigInteger.ZERO;
                for (int i = 0; i < lenInt / n; i++) {
                    rem = rem.multiply(N2);
    
                    BigInteger temp = new BigInteger(strInt.substring(i * n, i * n + n));
                    rem = rem.add(temp);
    
                    BigInteger j;
                    if (res.compareTo(BigInteger.ZERO) != 0) {
                        j = rem.divide(res.pow(n - 1).multiply(N).multiply(N3));
                    } else {
                        j = NINE;
                    }
                    BigInteger test = BigInteger.ZERO;
                    temp = res.multiply(BigInteger.TEN);
                    while (j.compareTo(BigInteger.ZERO) >= 0) {
                        test = BigInteger.ZERO;
                        if (j.compareTo(BigInteger.ZERO) > 0)
                            for (int k = 1; k <= n; k++)
                                test = test.add(j.pow(k).multiply(C[k]).multiply(temp.pow(n - k)));
                        if (test.compareTo(rem) <= 0)
                            break;
                        j = j.subtract(BigInteger.ONE);
                    }
    
                    rem = rem.subtract(test);
                    res = res.multiply(BigInteger.TEN);
                    res = res.add(j);
                }
                for (int i = 0; i <= scale; i++) {
                    rem = rem.multiply(N2);
    
                    if (i < lenFrac / n) {
                        BigInteger temp = new BigInteger(strFrac.substring(i * n, i * n + n));
                        rem = rem.add(temp);
                    }
    
                    BigInteger j;
                    if (res.compareTo(BigInteger.ZERO) != 0) {
                        j = rem.divide(res.pow(n - 1).multiply(N).multiply(N3));
                    } else {
                        j = NINE;
                    }
                    BigInteger test = BigInteger.ZERO;
                    BigInteger temp = res.multiply(BigInteger.TEN);
                    while (j.compareTo(BigInteger.ZERO) >= 0) {
    
                        test = BigInteger.ZERO;
                        if (j.compareTo(BigInteger.ZERO) > 0)
                            for (int k = 1; k <= n; k++)
                                test = test.add(j.pow(k).multiply(C[k]).multiply(temp.pow(n - k)));
                        if (test.compareTo(rem) <= 0)
                            break;
                        j = j.subtract(BigInteger.ONE);
                    }
    
                    rem = rem.subtract(test);
                    res = res.multiply(BigInteger.TEN);
                    res = res.add(j);
                }
                root = new BigDecimal(res).movePointLeft(scale + 1);
                if (negate) {
                    //如果取了相反数,那么取回来
                    root = root.negate();
                }
    
            }
            /**
             *  newScale: 保留newScale位小数
             *  roundingMode: 舍去规则(0 <= roundingMode <= 7)
             *  ROUND_UP(0):第newScale位小数进1,后面舍去、ROUND_DOWN(1):第newScale位后面的,直接舍去
             *  ROUND_CEILING(2):如果是正数,同ROUND_UP,如果是负数,同ROUND_DOWN、ROUND_FLOOR(3):与ROUND_CEILING相反
             *  ROUND_HALF_UP(4):四舍五入:小学学过的那种、
             *  */
            return root.setScale(scale, roundingMode);
        }
    
        public static BigInteger combination(int n, int k) {
            if (k > n || n < 0 || k < 0) {
                return BigInteger.ZERO;
            }
            if (k > n / 2) {
                return combination(n, n - k);
            }
            BigInteger N1 = BigInteger.ONE;
            BigInteger N2 = BigInteger.ONE;
            BigInteger N = BigInteger.valueOf(n);
            BigInteger K = BigInteger.valueOf(k);
            for (int i = 0; i < k; i++) {
                N1 = N1.multiply(N);
                N2 = N2.multiply(K);
                N = N.subtract(BigInteger.ONE);
                K = K.subtract(BigInteger.ONE);
            }
            return N1.divide(N2);
        }
    

    注意:第一个为传入参数,即要开方的数字,第二位是开几次方,第三个为保留几位小数,第四位为,舍弃规则,ROUND_HALF_UP为四舍五入

    展开全文
  • 如何使用Java计算次方(次幂)

    万次阅读 2017-11-07 16:10:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
      public static void main(String args[]) {
        int num = 2;
        int pow = 5;
        System.out.print(power(num , pow));
      }
      public static int power(int a , int b) {
        int power = 1;
        for (int c = 0; c < b; c++)
          power *= a;
        return power;
      }

    转载于:https://my.oschina.net/u/3013327/blog/1563878

    展开全文
  • java BigInteger的pow只能输入int ,想要求BigInteger的BigInteger的次方怎么?
  • (java)2的幂次方

    千次阅读 2019-06-08 13:52:59
    何一个正整数都可以用2的幂次方表示。例如:137=2^7+2^3+2^0 同时约定幂次方用括号来表示,即a^b可表示为a(b)。由此可知,137可表示为:2(7)+2(3)+2(0) 进一步:7= 2^2+2+2^0 (21用2表示) 3=2+2^0 所以...
  • Java-数值的整数次方

    2020-07-24 17:06:02
    base的exponent次方。 保证base和exponent不同时为0。 注意: 在判断底数base是不是等于0时,不能直接写base == 0。因为在计算机内部表示小数(包括float和double型小数)都有误差。如果两个小数的差的绝对值很...
  • 要计算2的1000次方,肯定超过了语言定义的数据最大范围,那就需要用其他算法来计算。 基本思路:1.用数组或者链表来存储每次的次方的结果的每一位。(建议用链表)
  • Java水仙花数

    千次阅读 2019-05-31 18:42:38
    第二步要解决的就是,要到水仙花数个位,十位,百位的数。 利用math.pow(x,y)函数相加,判断输入的值是否为水仙花数。 代码如下: Scanner input = new Scanner(System.in); System....
  • JAVA:二进制与十进制转换

    万次阅读 2017-07-12 21:24:48
    思路:对十进制的数进行除2余法: /** * 讲10 进制转化为二进制 * @param de :待转换的十进制 * @return :转换后的二进制(string) */ public static String Decimal2Binary(int de){
  • 原理是newton切线法,就不用介绍...import java.math.BigDecimal; import java.math.BigInteger; public class Test { //num是被开方数,n是开方次数,precision设置保留几位小数 public static String rootN_Decimal
  • java基础类型中,int类型占四个字节,而每个字节在内存中占8位(8byte) 在计算机中,它的二级制表示为00000000 00000000 00000000 00000000 首位加粗的0是符号位,根据正负要求固定为0或1,为0则代表正数,为1则...
  • 题目: ...base的exponent次方 牛客网题目截图: 解答: public class Solution { public double Power(double base, int exponent) { // 当底数为0,指数为负数时,则抛出异常或者返回0.0
  • 为什么在java中计算2的32次方可以用1L&lt;&lt;32表示  java中移位运算符&lt;&lt; : 左移运算符,num &lt;&lt; 1,相当于num乘以2&gt;&gt; : 右移运算符,num &gt;&gt; 1,...
  • base的exponent次方。 保证base和exponent不同时为0。不得使用库函数,同时不需要考虑大数问题,也不用考虑小数点后面0的位数。 输入:2.00000,3 输出:8.00000 输入:2.10000,3 输出:9.26100 输入:2.00000,-2 ...
  • a = 5, 返回 8; a = 13, 返回 16; a = 1021, 返回 1024;...n 代表把数字m在无溢出的前提下乘以2的n次方。 2.右移  右移运算符“>>” - 使指定值的所有位都右移规定的次数。 右移m>&g
  • 4.绝对值 Math.abs(-3.5)=3.5 5.保留两位小数 double f = 0.93333; String.format("%.2f", f);//f=0.93 Math的一些其他用法 Math.sqrt(16)//计算平方根 4 Math.cbrt(8)//计算立方根 2 Math.pow(3, 2)//计算a的b...
  • BigDecimal 开n次方

    2020-12-16 20:10:14
    } /** * BigDecimal开n次方根。 * 转载于:https://www.xuebuyuan.com/1863340.html * @param number 被开方数 * @param n n次方根 * @param scale 精度 * @param roundingMode 舍入规则 * @return 结果 */ public ...
  • Java求指数

    千次阅读 2017-06-30 11:43:32
    Java中,当我们计算2的n次方时,可以直接用Math.pow来计算。非常方便。 但是,已知一个幂的结果为M和幂的底数a , 现在要求幂的指数n。Math中提供的有log(double)方法,但是只能传入一个参数,即M。那么问题来了,...
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则,基于这项原则,使得脚本语言通常比 C 语言、C++语言 或 Java 之类的系统编程语言要简单容易。也让脚本语言另有一些属于脚本语言的特性: • 语法...
  • 数的三次方根 JAVA解法

    千次阅读 2020-01-09 18:59:28
    给定一个浮点数n,它的三次方根。 输入格式 共一行,包含一个浮点数n。 输出格式 共一行,包含一个浮点数,表示问题的解。 注意,结果保留6位小数。 数据范围 −10000≤n≤10000−10000≤n≤10000 输入...
  • Java8中,hashmap的容量大小为什么必须是2的幂次方? 最近在复习基础知识,在复习到hashmap的时候,看到hashmap的容量大小必须是2的幂次方,我当时脑子想到的就是:为了使每一个桶发生哈希冲突的概率相同,从而避免...
  • Java··水仙花数 ** 【程序 3】 题目:打印出n位的 "水仙花数 ",所谓 "水仙花数 "是指一个n位数,其各位数字的n次方和 等于该数本身。例如:153 是一个 "水仙花数 ",因为 153=1 的三次方+5 的三次方+3 的...
  • ① 指数的正负,我们可以先用绝对值,然后出指数次方之后的结果,如果是负数倒数即可; ② 底数不能为0,如果底数为0 可以返回0或1都可以。 ③ 精度问题,计算机中表示小数都有误差,包括float和double,所以不...
  • Java 两个数之间的随机数

    千次阅读 2020-01-10 10:24:50
    Java 两个数之间的随机数 private static int getRandom(int x, int y) { int num = -1; //说明:两个数在合法范围内,并不限制输入的数哪个更大一些 if (x < 0 || y < 0) { return num; } else ...
  • Java笔试题——2的100次方,不用大数据类(Biginteger)来解答 package cn.hncu.offer; public class Two100 { public static void main(String[] args) { int a[]=new int[1];//初始化数组 a[0]=1;//为第一个设置...
  • 对于 2 的 N 次方取余,相当于对 2 的 N 次方减一与运算,这对于高并发分片计算的时候,很有用。为了对用户友好,我们让用户设置分片数量的时候可能不限制必须是 2 的 N 次方,但是内部我们设置分片的时候,将其...
  • a的b次方 public static int quickPower(int a, int b){//是a的b次方 int ans = 1, base = a; //ans为答案,base为a^(2^n) while(b > 0)//b是一个变化的二进制数,如果还没有用完 { if(b%2==1) { ...
  • 数值的整数次方——分析及代码[Java]一、题目二、分析及代码1. 二分求解(1)思路(2)代码(3)结果三、其他 一、题目 给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent。 base 的 exponent 次方。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,656
精华内容 9,462
关键字:

java求取次方

java 订阅