分解因式java代码
- 格式:doc
- 大小:19.50 KB
- 文档页数:1
Java代码计算⼀元⼆次⽅程⽼哥们,别⽩嫖,点个赞吧,秋梨膏1.0版本代码如下:(该版本的计算并不完善,例如输⼊1,2,1它会提⽰你"该⽅程中的数据进⾏了开平⽅,所以不太准确",这是个意料之外的错误,以后再改,改版本仅供参考) package calculate;import java.util.Scanner;class calculate_2 {public static void main(String[] args) {System.err.println("请⼤佬每输⼊⼀个数就按⼀次enter");System.out.println("请输⼊a,b,c的数值");Scanner Scanner1 = new Scanner(System.in);//System.out.println("请输⼊b的数值");Scanner Scanner2 = new Scanner(System.in);//System.out.println("请输⼊c的数值");Scanner Scanner3 = new Scanner(System.in);double a = Scanner1.nextDouble();double b = Scanner2.nextDouble();double c = Scanner3.nextDouble();double A = a;//后⾯判断⽅程是否有解时会⽤到double B = b;double C = c;double i, j, k;i = b * b / (4 * a * a);j = c / a;k = b / (2 * a);double d = i - j;d = Math.sqrt(d);String D = String.format("%.2f", d);//取⼩数点后两位String panduan = D.substring(1);//System.out.println("D的值是:"+D);String ling = ".00";//创建⼀个⽤来判断的字符串//System.out.println("被截取之后的字符串是:"+panduan);b = Double.parseDouble(D);double x, y;x = b - k;String X = String.format("%.2f", x);//X为根号下的数据并且将X的值保留⼩数点后两位y = -b - k;if (B * B - 4 * A * C < 0) {//该情况下没有接解System.out.println("你好好输⼊⾏不⾏?该⽅程⽆解");} else {if (B * B - 4 * A * C > 0) {//该情况下有两个解if (panduan != ling) {System.err.println("该⽅程中的数据进⾏了开平⽅,所以不太准确");}System.out.println("该⽅程有两个解:");String Y = String.format("%.2f", y);//将Y的值保留⼩数点后两位String D1 = X.substring(X.length() - 2, X.length());//截取String类型的后两位String panduan2 = "00";if (D1.equals(panduan2)) {String D2 = D.substring(0, D.length() - 3);// D2为最后的X1的值X = D2;String DD = Y.substring(D.length() - 2, Y.length());//截取String类型的后两位if (DD.equals(panduan2)) {String D3 = D.substring(0, D.length() - 3);Y = D3;//如果正确,D3的值将会传给Y} else {Y = Y;}} else {System.out.println("该⽅程有两个解:" + "X1=" + X + ";" + "X2=" + Y);}// System.out.println("x1=" + X + " ; " + "x2=" + Y);} else {//该情况下b*b-4*a*c=0,⽅程只有⼀个解if (panduan != ling) {System.out.println("该⽅程中的数据进⾏了开平⽅,所以不太准确");}String D1 = X.substring(X.length() - 2, X.length());//截取String类型的后两位String panduan2 = "00";if (D1.equals(panduan2)) {String D2 = D.substring(0, D.length() - 3);System.out.println("只有⼀个解:X1= " + D2);} else {System.out.println("只有⼀个解:X1= " + D); }}}}}输出:。
java 数组的切分方法Java 数组的切分方法在Java中,数组是一种用来存储多个相同类型元素的数据结构。
在处理数组时,经常需要对数组进行切分(或者称为分割),以便对其中的特定部分进行操作或者处理。
本文将介绍Java数组的切分方法,包括根据索引范围切分、根据特定元素值切分以及根据特定条件切分等。
1. 根据索引范围切分根据索引范围切分数组是最常见的一种方式。
通过给定起始索引和结束索引,可以将数组切分为一个新的子数组。
下面是一个示例代码:javapublic class ArraySplitDemo {public static void main(String[] args) {int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};int start = 2; 起始索引int end = 7; 结束索引int[] subArray = new int[end - start + 1];int index = 0;for (int i = start; i <= end; i++) {subArray[index] = nums[i];index++;}打印子数组元素for (int num : subArray) {System.out.print(num + " ");}}}这段代码中,我们给定了一个整数数组`nums`,要求切分的索引范围是从2到7,即切分后的子数组应该包括索引2、3、4、5、6、7对应的元素。
通过遍历原数组,将符合范围的元素拷贝到新数组`subArray`中,最终打印出子数组的元素。
2. 根据特定元素值切分有时候,我们需要根据数组中的特定元素值来切分数组。
例如,我们想要切分一个字符串数组,将其中的大写字母和小写字母分别放入两个新的数组。
下面是一个示例代码:javapublic class ArraySplitDemo {public static void main(String[] args) {String[] words = {"Apple", "Banana", "Carrot", "Dog", "Grape"};List<String> upperCaseList = new ArrayList<>();List<String> lowerCaseList = new ArrayList<>();for (String word : words) {if (Character.isUpperCase(word.charAt(0))) {upperCaseList.add(word);} else {lowerCaseList.add(word);}}打印大写字母数组System.out.println("Upper case words:");for (String upperWord : upperCaseList) {System.out.print(upperWord + " ");}打印小写字母数组System.out.println("\nLower case words:");for (String lowerWord : lowerCaseList) {System.out.print(lowerWord + " ");}}}在这个例子中,我们创建了一个字符串数组`words`,遍历数组中的每个元素,根据首字母的大小写将其划分到`upperCaseList`和`lowerCaseList`两个列表中。
Lab 3: Factorization and DLP实验目的有2个问题,因式分解问题中,已知一个大整数35648672663350635631,将它拆分为两个数相乘,这两个数都在[0xFFFFFFFF,0x1FFFFFFFF]中,并给出这两个数。
DLP问题中已知a,b,n。
找到x满足a x = b mod n,并给出x。
实验过程1.因式分解问题思路:由于数据很大故使用JAVA语言,利用JAVA语言的BigInteger 数据类型存储和计算题目中的问题。
本程序采用蛮力破解,因数divisor从0xFFFFFFFF开始循环尝试除35648672663350635631是否余数为0,不为零则加一后继续尝试,为零则输出两个因数运行结果:当divisor运行到5692670441时:用如下代码验证得:BigInteger temp = dividend.mod(divisor);if(temp.equals(new BigInteger("0"))){System.out.println("第一个因数是"+divisor);System.out.println("第二个因数是"+dividend.divide(divisor));break;}因此结果为:5692670441,6262205591。
完整代码如下:publicclass main_Factorization {publicstaticvoid main(String[] args) {// TODO Auto-generated method stubBigInteger dividend =new BigInteger("35648672663350635631");//BigInteger divisor=new BigInteger("5692670441");//0x1fffffff BigInteger divisor=new BigInteger("429496295");=new BigInteger("1");=new BigInteger("1");if(a.equals(b)&&a.mod(b).equals(new BigInteger("0"))){System.out.println("开始循环");}while(pareTo(new BigInteger("8589934591"))==-1){BigInteger temp = dividend.mod(divisor);if(temp.equals(new BigInteger("0"))){System.out.println("第一个因数是"+divisor);System.out.println("第二个因数是"+dividend.divide(divisor));break;}else{divisor=divisor.add(BigInteger.ONE);System.out.println("继续循环,当前除数为:"+divisor);}}System.out.println("运行结束");//Integer.getInteger(nm);//System.out.println(a.divide(b));}}2.DLP问题找出满足条件的x。
四则运算代码(java版本)采⽤正则表达式//加减乘除负数、括号这⼏种//具体看代码以及注释 (测试没发现bug,如发现有bug 请指正)package com.test;import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** 四则运算,可能不是最优的写法,⾃⼰测试没发现bug<br>* 前提:正确的算式,因为没做算式的验证<br>* 思路:<br>* 1、⽤正则拆分所有的元素例⼦:2-5+4*5/(2+2)-4<br>* 拆分为【2,-5,4,*,5,/,(,2,2,),-4】<br>* 2、先计算括号⾥,乘除,最后加减** 总结:总体花了17、8个⼩时,主要原因还是没有仔细总体分析流程导致。
<br>* 以⾄于想到点写点代码、修修改改,没有⼀个完整的把握的思路。
所以⼀个问题⼀定<br>* 先⾛通整个思路、流程其实编码是最容易的,重点是处理的过程思路** @author wangshiyan* @time 2014-12-4 下午12:50:01**/public class SizheTool {public static void main(String[] args) {try {System.out.println(jisuanStr("11.2+3.1*(423-(2+5.7*3.4)+5.6)-6.4/(15.5+24)"));} catch (Exception e) {System.out.println("请检查你的算式格式");e.printStackTrace();}}/*** 拆分算式⾥的各个元素并处理对应所在位置<br>** @param str* @return*/public static List<String> splitStr(String string) throws Exception {List<String> listSplit = new ArrayList<String>();Matcher matcher = pile("\\-?\\d+(\\.\\d+)?|[*/()]|\\-").matcher(string);// ⽤正则拆分成每个元素while (matcher.find()) {// System.out.println(matcher.group(0));listSplit.add(matcher.group(0));}return listSplit;}/*** 计算<br>* 步骤:1、如果有括号<br>* 然后取上⼀个最近的(坐标计算当前括号组合⾥的算式),在继续往下查找括号以此类推,直⾄循环使⽤到所有坐标元素* 计算完毕(运算顺序括号、乘除、加减)** @param str* @return*/public static double jisuanStr(String str) throws Exception {double returnDouble = 0;List<String> listSplit = splitStr(str); // 拆分好的元素List<Integer> zKuohaoIdxList = new ArrayList<Integer>();// 左括号,<所在坐标,>if (pile(".*\\(|\\).*").matcher(str).find()) {// 如果包含括号运算String value = "";// 单个字符值int zIdx = 0;// 上⼀个左括号在zKuoHaoIdxList的下标// 此层循环计算完所有括号⾥的算式List<String> tempList = new ArrayList<String>();// 前⾯没有计算的元素int removeL = 0;int tempListSize = 0;for (int i = 0; i < listSplit.size(); i++) {value = listSplit.get(i);tempList.add(value);tempListSize = tempList.size();if ("(".equals(value)) {// 左括号zKuohaoIdxList.add(tempListSize-1);} else if (")".equals(value)) {// 遇到右括号就计算与上⼀左括号间的算式zIdx = zKuohaoIdxList.size() - 1;// 离当前右括号最近的左括号配对int start = zKuohaoIdxList.get(zIdx);returnDouble = jisuan(tempList, start + 1, tempListSize-1); // 开始位置,就是上⼀个左括号 removeL = tempListSize - start;tempList = removeUseList(tempList, removeL);// 移除已使⽤的元素tempList.add(returnDouble + "");// 刚刚计算的值添加进来zKuohaoIdxList.remove(zIdx);// 计算完毕清除括号}}// 把所有计算完returnDouble = jisuan(tempList, 0, tempList.size());} else {// 没有括号运算returnDouble = jisuan(listSplit, 0, listSplit.size());}return returnDouble;}/*** 倒序删除已⽤过的元素** @param list* @param removeLength* 数量* @return*/public static List<String> removeUseList(List<String> list, int removeLength) {int le = list.size() - removeLength;for (int i = list.size() - 1; i >= le; i--) {list.remove(i);}return list;}/*** 计算算式** @param listSplit* @param start* 括号算式开始符位置* @param end* 括号结束符位置* @return*/public static double jisuan(List<String> listSplit, int start, int end)throws Exception {double returnValue = 0;String strValue = null;// 临时变量List<String> jjValueList = new ArrayList<String>();// 剩下的加减元素// 遍历计算乘除法for (int i = start; i < end; i++) {strValue = listSplit.get(i);if ("*".equals(strValue) || "/".equals(strValue)) {// 乘除strValue = jisuanValue("*".equals(strValue) ? "*" : "/", Double.parseDouble(jjValueList.get(jjValueList.size() - 1)),Double.parseDouble(listSplit.get(i + 1)))+ "";jjValueList.remove(jjValueList.size() - 1);i++;}jjValueList.add(strValue);}// 遍历计算加减for (int j = 0; j < jjValueList.size(); j++) {strValue = jjValueList.get(j);if ("-".equals(strValue) || "+".equals(strValue)) {returnValue = jisuanValue("-".equals(strValue) ? "-" : "+",returnValue, Double.parseDouble(jjValueList.get(j + 1)));j++;} else {returnValue += Double.parseDouble(jjValueList.get(j));}}return returnValue;}/*** 计算2个数间的加减乘除操作如:2*5 ,2/5** @param type* 运算符* @param start* 数相当于上⾯2* @param end* 被数相当于上⾯5* @return*/public static double jisuanValue(String type, double start, double end) throws Exception {double d = 0;if ("-".equals(type)) {d = start - end;} else if ("+".equals(type)) {d = start + end;} else if ("*".equals(type)) {d = start * end;} else if ("/".equals(type)) {if (0 == start || 0 == end)d = 0;elsed = start / end;}return d;}}。
java分解质因数算法⽬的:对⼀个正整数分解质因数⼀、算法分析:1、建⽴整数列表,保存求到的因数。
2、声明整数i=2,⽤以递增取模;整数m,⽤于临时保存n3、建⽴while循环,i⼩于等于整数m时,判断m%i,如果等于0,可以被整除,则令 m = m/i 将 i添加到整数列表;如果m%i不等于0,i++4、判断整数列表长度,如果长度为1,则认定n是质数;否则为合数并打印列表5.加⼊n的开⽅值⽐较,如果i 递增到n的开⽅值但整数列表的⼤⼩仍为0,则认为此数是质数⼆、运算结果抢先看三、基础程序package fundamental;import java.util.ArrayList;import java.util.List;public class Seperate {public static void main(String[] args) {getZ(102039);}/*对n分解质因数,⾸先找到最⼩质因数k,如果k==n,直接打印退出。
n<>k,继续k+1对n进⾏分解*/public static void getZ(int n){List<Integer> l = new ArrayList<Integer>();int i = 2,m = n;long start = System.currentTimeMillis();while(i<=m){ // i<=m 与 i<=n 在运算合数时,效率差很多if(m%i==0){m=m/i;l.add(i);}else i++;}long end = System.currentTimeMillis();// 0x7fffffff 是质数,所以i值会累加到 0x7fffffff,⽐较耗时。
但不会超过9秒,因为i值最多累加到0x7fffffff// 运算时长与n值⼤⼩⽆关,与最⼤因数有关。
java 因数分解Java因数分解是一种常见的数学运算问题,主要涉及到将一个大整数分解成多个小素数的乘积。
这种运算在RSA加密算法、矩阵分解等领域都有重要应用。
Java因数分解可以通过试除法、分治法、线性筛法、Euler筛法等方法来实现。
其中,试除法是最简单的方法,即对给定的整数n,从2到n-1依次试除是否能整除n,但这种方法的时间复杂度较高,不适用于大整数的因数分解。
线性筛法在空间复杂度和时间复杂度上都有较大优势,但实现较复杂。
分治法和Euler筛法则可以在较短时间内对大整数进行因数分解,因此在实际应用中被广泛采用。
以下是一种基于分治法的Java因数分解示例:```import java.util.*;public class Factorization {//分治法求因数public static List<Long> divide(long num){List<Long> list = new ArrayList<>();if(num == 1){list.add(1L);return list;}for(long i=2;i<=Math.sqrt(num);i++){if(num % i == 0){List<Long> res1 = divide(i);List<Long> res2 = divide(num/i);list.addAll(res1);list.addAll(res2);return list;}}list.add(num);return list;}public static void main(String[] args){long n = 1028;List<Long> ans = divide(n);System.out.println(n + "=" +ans.toString().replaceAll("[\\[\\]]","").replaceAll(",","*")); }}```该示例代码首先判断特殊情况,即当输入的整数为1时,直接返回1作为其因数。
Monkey_peach代码package com.sailor.game;/*** 题目:猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个第二天早上又将剩* 下的桃子吃掉一半,又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时,见只剩下一个桃子了。
求第一天共摘了多少。
* 程序分析:采取逆向思维的方法,从后往前推断。
** @author Sailor**/public class Monkey_Peach {public static void main(String[] args) {int[] peach = new int[10];peach[9] = 1;// 下面利用的是数组和循环将每天的桃子数量都求出来了for (int i = peach.length - 1; i > 0; i--) {peach[i - 1] = 2 * (peach[i] + 1);}for (int i = 0; i < peach.length; i++) {System.out.println(peach[i]);}System.out.println("第一天的桃子数:"+getPeach_Num(10, 1));}// 利用递归的方法来求第一天的桃子数,输入参数为天数和当天的桃子数,输出为第一天桃子数public static int getPeach_Num(int day, int peach_num) {if (day == 1)return peach_num;else if (day < 1 || peach_num < 0)return 0;elsereturn getPeach_Num(day - 1, (peach_num + 1) * 2);}}package com.sailor.game;/*** 题目:猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个第二天早上又将剩* 下的桃子吃掉一半,又多吃了一个。
Java基础选择加减乘除运算代码1. 概述Java作为一种广泛应用的编程语言,具有跨评台、面向对象等优点,被广泛用于软件开发、手机应用开发等方面。
在Java编程中,加减乘除运算是最基础的运算之一,本文将介绍Java中实现加减乘除运算的基础代码。
2. 加法运算代码在Java中,实现两个数的加法运算非常简单。
只需使用"+"符号即可进行加法运算。
以下是一个简单的例子:```javapublic class Addition {public static void m本人n(String[] args) {int a = 10;int b = 20;int sum = a + b;System.out.println("两数之和为:" + sum);}}```在上面的代码中,首先定义了两个整数变量a和b,然后使用加法运算符"+"计算它们的和,并将结果打印出来。
3. 减法运算代码和加法类似,Java中实现减法运算也非常简单。
只需使用"-"符号即可进行减法运算。
以下是一个简单的例子:```javapublic class Subtraction {public static void m本人n(String[] args) {int a = 20;int b = 10;int difference = a - b;System.out.println("两数之差为:" + difference);}}```在上面的代码中,首先定义了两个整数变量a和b,然后使用减法运算符"-"计算它们的差,并将结果打印出来。
4. 乘法运算代码和加法、减法类似,Java中实现乘法运算也非常简单。
只需使用"*"符号即可进行乘法运算。
以下是一个简单的例子:```javapublic class Multiplication {public static void m本人n(String[] args) {int a = 5;int b = 8;int product = a * b;System.out.println("两数之积为:" + product);}}```在上面的代码中,首先定义了两个整数变量a和b,然后使用乘法运算符"*"计算它们的积,并将结果打印出来。
1.使用Java语言编写代码,将一个正整数分解质因数,例如:输入90,打印输出90=2*3*3*5。
代码:/***@Title:Test11.java*@Package com.cayden.test*@Description:TODO*Copyright:Copyright(c)2012**@author cuiran*@date2012-2-13下午08:46:17*@version V1.0*/package com.cayden.test;import java.util.Scanner;import java.util.Vector;/***@author cuiran**/public class Test11 {/***@param args*/public static void main(String[] args){System.out.println("请你输入一个正整数:");Scanner sc=new Scanner(System.in);int Num=sc.nextInt();Vector<Integer> vec=new Vector();Lab:for(int i=2;i<=Num;i++){for(int j=2;j<=i/2;j++){if(i%j==0&&i!=2){continue Lab;}}vec.add(i);}System.out.println(Num+"的分解结果是:\n");System.out.print(Num+"=");int theNum=Num;boolean help=true;for(int k=0;k<vec.size();k++){int qq=(int)vec.get(k);if(theNum<qq)break;if(theNum%qq==0){if(help==true){System.out.print(qq);help=false;}else{System.out.print("*"+qq);}k--;theNum=theNum/qq;}}System.out.println("\n分解完毕!");}}2.题目如下:用1、2、2、3、4、5这六个数字,用java写一个main函数,打印出所有不同的排列,如:512234、412345等,要求:"4"不能在第三位,"3"与"5"不能相连。
java 解三元一次方程Java是一种常用的编程语言,也可以用来解三元一次方程。
解三元一次方程是数学中的一种常见问题,通过使用Java编程语言,可以快速而准确地解决这个问题。
我们需要了解什么是三元一次方程。
三元一次方程是指具有三个未知数和一次项的方程,可以表示为以下形式:a1x + b1y + c1z = d1a2x + b2y + c2z = d2a3x + b3y + c3z = d3其中,a1、a2、a3、b1、b2、b3、c1、c2、c3、d1、d2、d3为已知系数和常数项。
我们的目标是求解出x、y、z的值。
为了解决这个问题,我们可以使用Java编程语言中的线性代数库,例如Apache Commons Math库。
该库提供了一系列用于矩阵运算和线性方程求解的类和方法。
我们需要定义一个3x3的系数矩阵A和一个3x1的常数矩阵B,分别表示方程的系数和常数项。
然后,我们可以使用库中的方法,通过矩阵运算求解出未知数向量X。
具体步骤如下:1. 引入Apache Commons Math库的依赖。
在Java项目的pom.xml或者build.gradle文件中添加相应的依赖配置。
2. 创建一个3x3的系数矩阵A和一个3x1的常数矩阵B。
可以通过二维数组或者矩阵对象来表示。
3. 使用库中的方法,通过矩阵运算求解出未知数向量X。
可以使用矩阵的逆、转置、乘法等运算来实现。
4. 输出解向量X的值,即为方程的解。
下面是一个使用Java解三元一次方程的示例代码:```javaimport mons.math3.linear.*;public class LinearEquationSolver {public static void main(String[] args) {// 定义系数矩阵ARealMatrix coefficients = MatrixUtils.createRealMatrix(new double[][] {{a1, b1, c1},{a2, b2, c2},{a3, b3, c3}});// 定义常数矩阵BRealMatrix constants = MatrixUtils.createRealMatrix(new double[][] {{d1},{d2},{d3}});try {// 求解方程DecompositionSolver solver = new LUDecomposition(coefficients).getSolver();RealVector solution = solver.solve(constants.getColumnMatrix(0));// 输出解向量X的值System.out.println("x = " + solution.getEntry(0));System.out.println("y = " + solution.getEntry(1));System.out.println("z = " + solution.getEntry(2));} catch (SingularMatrixException e) {System.out.println("方程无解或有无穷多解");}}}```在上述代码中,我们使用了Apache Commons Math库中的LUDecomposition类来求解方程。