java输入方程

⑴ java编程：输入a,b,c,求方程 ax^2+bx+c=0 的解.(提示:可使用Math.pow()方法)

代码供参考，有空多学习，祝好运
importjava.util.Scanner;
publicclassequation2{
	publicstaticvoidmain(String[]args){
		Scannersc=newScanner(System.in);
		System.out.println("请输入abc：");
		doublea,b,c;
		a=sc.nextDouble();
		b=sc.nextDouble();
		c=sc.nextDouble();
		doubled=b*b-4*a*c;
		if(d==0){
			System.out.println("x="+(-b)/(2*a));
		}
		elseif(d<0){
			System.out.println("无解");
		}
		else{
			System.out.println("x1="+(-b+Math.sqrt(d))/(2*a));
			System.out.println("x2="+(-b-Math.sqrt(d))/(2*a));
		}
	}
}

⑵ 【java】用户输入二元一次方程的三个系数，计算机求解二元一次方程。

最简单的方法，没有用到面向对象方法，只用了一个主类：
import java.util.Scanner;
import java.math.*;
public class Test{
public static void main(String[] args){
int a,b, c; //系数
double x1, x2;//方程解
Scanner s = new Scanner(System.in);
System.out.println("请输入二元一次方程的第一个系数：");
a = s.nextInt();
System.out.println("请输入二元一次方程的第二个系数：");
b = s.nextInt();
System.out.println("请输入二元一次方程的第三个系数：");
c = s.nextInt(); //输入系数
if(b*b > 4*a*c){
x1 = (- b + Math.sqrt(b*b - (4*a*c)))/2*a;
x2 = ( -b - Math.sqrt(b*b - (4*a*c)))/2*a;
System.out.println("方程解为x1= " + x1 + ", x2=" + x2); //求解方程根
}else if(b*b == 4*a*c){
x1 = (- b + Math.sqrt(b*b - (4*a*c)))/2*a;
System.out.println("方程有一个解 x1=x2=" + x1);
}else{
System.out.println("方程无解");
}
}
}

⑶ java 如何解方程

我估计需要你先手动操作。
虽然我不知道dp是啥但是我觉得这个可以化成n=XXX的代数式。专
然后调用java的算术和属Math里面的log之类的把结果算出来。
假如你是希望写个java程序分析你的题目然后自己给出n=XXX的代数式然后再把它算出来的话，那就要比较麻烦了
-----------------
附，如果dp跟Dp是一样的当做一个未知量的话那我可以帮你手动算算。
20=2*(1-r)²，那么1-r=√10，然后带入第三个式子得出n=log√10(1.25)
public class t{
public static void main(String[] args){
System.out.println(Math.log(1.25)/Math.log(Math.sqrt(10)));
}
}
然后算出来等于0.1938200260161128

⑷ 用Java求一元二次方程ax2＋bx＋c=0的根,要求a、b、c从控制台输入

import java.util.Scanner;
public class Compare {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
System.out.println("请输入a");
int a = sc.nextInt();
System.out.println("请输入b");
int b = sc.nextInt();
System.out.println("请输入c");
int c = sc.nextInt();

if(b*b - 4*a*c < 0){
System.out.println("对不起，无解！");
}else if(b*b - 4*a*c == 0){
System.out.println("此方程解x=" + -b/(2*a));
}else{
System.out.println("此方程解x1=" + ((-b+ "/"+ 2*a +"+√(" + (b*b - 4*a*c)) +")/" +(2*a)) + " , x2=" + ((-b+ "/"+ 2*a + "-√(" + (b*b - 4*a*c)) +")/" +(2*a)) );
}
}
}

⑸ 用Java解方程

建议用解非线性方程组的方法求解，fsolve()函数，先设定初值，知道解的大致的范围后，再以此值为初值，在设定的精度下求解。用matlab解一道复杂的多元非线性方程组

⑹ 编写一个java程序，从键盘输入一元二次方程的3个系数a,b和c，输出这个方程的解

publicstaticvoidmain(String[]args){
Scannerinput=newScanner(System.in);
inta=input.nextInt();
intb=input.nextInt();
intc=input.nextInt();
intx=0;
while(true){
if(a*x+b*x*x+c==42){
System.out.println("解得:x="+x);
break;
}
x=x+1;
}
}

这个就是个强行拿一个个数字去套这个方程，成功，即返回结果，如果方程无解，那这就是个死循环了。不清楚这题考的知识点，我猜想应该是考循环，所以这么写的答案，不见得正确。另外，Java中平方可以用Math.pow(x,2)来表示x的平方。

⑺ 用JAVA编程求一元二次方程的根，一元二次方程的系数从键盘输入

import java.util.Scanner;

public class Demo

{

public static void main(String [] args){

Scanner sc = new Scanner(System.in);

System.out.println("输入2次方的系数");

int a = sc.nextInt();

System.out.println("输入1次方的系数");

int b = sc.nextInt();

System.out.println("输入0次方的系数");

int c = sc.nextInt();

double x1 = (-b + Math.sqrt(b*b - 4*a*c))/2*a;

double x2 = (-b - Math.sqrt(b*b - 4*a*c))/2*a;

System.out.println("根分别是 " + x1 + "," + x2);

}

}

⑻ JAVA 输入参数a,b,c，求一元二次方程a*x*x＋b*x＋c＝0的根，结果保留2位小数

package first;

import java.util.Scanner;

// 输入abc 求出x a*x的2次方+b*x+c = 0
public class exercise161 {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
int c = scan.nextInt();
int x = 0;
double s = Math.pow(b, 2) - 4 * a * c;
if(s > 0){
System.out.println( ((-1*b) + Math.sqrt(s)) /( 2 * a) );
System.out.println( ((-1*b) - Math.sqrt(s)) /( 2 * a) );
}else if(s == 0){
System.out.println( (-1*b) / ( 2 * a));
}else{
System.out.println("无解");
}
}
}

⑼ java 怎么根据输入的公式计算结果

深圳远标为你解答这个问题
通过栈实现,先用栈将中缀表达式转化为后缀表达式，然后再用栈计算后缀表达式的值的
package com.saturday;

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MyParse {
static Map<String,Integer> optrOrder;
static {
optrOrder=new HashMap<String,Integer>();
optrOrder.put("(", 0);
optrOrder.put("*", 1);
optrOrder.put("/", 1);
optrOrder.put("%", 1);
optrOrder.put("+",2);
optrOrder.put("-",2);
optrOrder.put("^",3);
optrOrder.put("#",3);
}

public static void main(String[] args){
List<String> tokens;
try{
//词法分析
tokens=lex("+2* (-2+3*4)+-5");

//中缀转后缀
tokens=toRpn(tokens);

//计算结果
System.out.println(calcRpn(tokens));

}catch(Exception ex){
ex.printStackTrace();
}
}

/**
* 将输入串转换为操作符串
* @param sExpres
* @return
*/
public static List<String> lex(String sExpres){
List<String> tokens=new ArrayList<String>();

//将表达式分割成符号序列
String sRegExp="(((?<=^|\\(|\\+|-|\\*|/|%)(\\+|-))?\\d+(\\.\\d+)?)"
+"|\\(|\\)|\\*|/|\\+|-";
Pattern p=Pattern.compile(sRegExp);
Matcher m=p.matcher(sExpres.replaceAll("\\s+",""));
while(m.find()){
tokens.add(m.group());
}

tokens.add("#");

return tokens;
}

/**
* 将中缀表单时转化为后缀表达式
* @param tokens
* @return
*/
public static List<String> toRpn(List<String> tokens)
throws Exception{
List<String> rpnList=new ArrayList<String>();
Stack<String> optrStack=new Stack<String>();

optrStack.add("^");
for(String token:tokens){
if(token.matches("^(\\+|-)?\\d+(\\.\\d+)?$")){
rpnList.add(token);
}else{
outputOptr(token,optrStack,rpnList);
}
}

if(!optrStack.isEmpty()
&&optrStack.lastElement().equals("#")){
return rpnList;
}else{
throw new Exception("后缀表达式转化错误!");
}
}

/**
* 计算后缀表达式的值
* @param rpnTokens
* @return
* @throws Exception
*/
public static double calcRpn(List<String> rpnTokens)
throws Exception{
NumberFormat nf=NumberFormat.getInstance();
Stack<Double> numStack=new Stack<Double>();

for (String token : rpnTokens) {
if (token.matches("^(\\+|-)?\\d+(.\\d+)?$")) {
token=token.indexOf('+')==0
?token.substring(1)
:token;
numStack.add(nf.parse(token).doubleValue());
} else {
doCalcByOptr(token, numStack);
}
}

if (!numStack.isEmpty() && numStack.size() == 1) {
return numStack.lastElement();
} else {
throw new Exception("计算错误！");
}
}

/**
* 将运算符输出到后缀表达式序列.
* @param optr
* @param optrStack
* @param rpnList
* @throws Exception
*/
public static void outputOptr(String optr,
Stack<String> optrStack,
List<String> rpnList)
throws Exception{
String preOptr;

if(optr.equals("(")){//处理左括号
optrStack.push(optr);
return;
}

if(optr.equals(")")){//处理右括号
while(!optrStack.isEmpty()){
preOptr=optrStack.pop();
if(!preOptr.equals("(")){
rpnList.add(preOptr);
}else{
break;
}
}

if(optrStack.isEmpty()){
throw new Exception("括号未闭合!");
}

return;
}

/*按优先级处理其他运算符，若当前运算符优先级较高
* 直接入栈，否则将栈中运算符出战直至栈顶运算符
* 低于当前运算符
*/
preOptr=optrStack.lastElement();
if(optrCmp(optr,preOptr)<0){
optrStack.push(optr);
}else{
while(!preOptr.equals("(")
&&!optrStack.isEmpty()
&&optrCmp(optr,preOptr)>=0){

preOptr=optrStack.pop();
if(!preOptr.equals("^")){
rpnList.add(preOptr);
}
}
optrStack.push(optr);
}
}

/**
* 运算符优先级比较函数,optr1优先级大于optr2返回小于0值,
* 优先级相等返回0,optr1小于optr2返回大于0值.
* @param optr1
* @param optr2
* @return
*/
public static int optrCmp(String optr1,String optr2){
int order1=optrOrder.get(optr1);
int order2=optrOrder.get(optr2);
return order1-order2;
}

/**
* 根据运算符对数据栈中的内容进行操作.
* @param optr
* @param numStack
*/
public static void doCalcByOptr(String optr,
Stack<Double> numStack){
double n1,n2;
n2=numStack.pop();
n1=numStack.pop();

if(optr.equals("+")){
numStack.push(n1+n2);
}else if(optr.equals("-")){
numStack.push(n1-n2);
}else if(optr.equals("*")){
numStack.push(n1*n2);
}else if(optr.equals("/")){
numStack.push(n1/n2);
}else if(optr.equals("%")){
numStack.push(n1%n2);
}
}
}

⑽ 用JAVA求方程

弄清java的语法就可以了

(1) a * x * x + b * x + c

(2) (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a)

(3) x <= 10 && x >= 0

(4) 4 * x - 7 * y + 2 == a * b

(5) "广东".equals(place) && "男".equals(sex)