方程求解给定变量的方程组。支持多项式方程以及含有指数，对数和三角函数的方程。方程计算器可以找到方程的数值解和准确解。方程的解是简化的，所以它可能与你所期望的形式不同。支持复杂的解和复杂的方程组,支持复变函数。
方程计算器如何在线使用
通常我们买的学生用计算器是不能直接计算一元二次方程，一元三次方程的，但是在网上我们却能方便准确的计算出来，而且不用下载就可直接使用的哦…
对于一元一次，一元二次方程，我们可以进入此网址http://www.jiefangcheng.net/，或者输入“在线解方程”即可，界面如下，下侧有使用须知，很简单方便，下面举个简单例子介绍怎么使用。
在框里输入2x+8=20，点击“点我解方程”，计算步骤和结果就在下方显示了,同样输入2X^2+8=26，得出结果是±3。注意“^”是英文状态下按shift+6打出来的。
当然也可以输入2 x^2+x+8 = 18带两个X比较复杂点的式子，总之是很方便使用的。
类似这样的在线计算一元一次，一元二次方程的网站有很多，如：计算器在线网，这里你不用输入x，只需要在前边输入系数即可，相比来说这种方法更简单。那么我们看到这两个工具的计算结果是一样的。
下边再介绍个复杂一些的一元三次方程的计算，叫九九参考计算网，网址如下：http://www.99cankao.com/algebra/cubic-equation.php，界面如下，方法和上一个的基本一样。下边我们来举个例子，我们在4个空白框里分别输入1，看到结果如下，很神奇吧！
其实学生用的计算器的计算也可以在网上在线计算的，网址如下：http://www.jisuanqinet.com/shuxue/bangbang.html，界面简单清晰，相信您也会喜欢的！

一元稀疏多项式计算器
要变得更强。

————更新————

下面同学说的问题我改正啦。

没改之前：

可以看到多了个负号，是因为在这个结构体里面，第一项就是0，因此会跳过打印多项式对fooo[0]的求解，所以会多一项负号。

因此我选择用for循环来找到第一项不是0的就可以啦。

改后：



——————————

这个问题怎么说，一个上午就这么过去了。果然不愧是小白：（

一开始我还想用三个数组，一个存第一个，一个存第二个，再把结果存到另外一个数组里面。

不过很明显，非常麻烦，当给我把代码码出来时，得到的结果也很离谱。然后……然后我就几乎全部重改了。

然后缩减至两个数组，将无论加减都放在一个数组里。

再将结果放进另外一个数组里。

需要考虑的点：
1.关于系数为0 ，1，-1
2.关于幂次为0，1
3.如果和为0（使用count来计数）

问题描述

一元 n 次多项式𝑝0𝑋𝑒0 + 𝑝1𝑋𝑒1 + ⋯ + 𝑝𝑖𝑋𝑒𝑖 + ⋯ + 𝑝𝑛𝑋𝑒𝑛

项数较少时成为一元稀疏多项式， 例如：3 + 6𝑋3 − 2𝑋8 + 12𝑋20是一个一元稀疏多项式。设计一个一元稀疏多项式计算器程

序完成两个一元稀疏多项式的加减法，输出结果多项式的各项系数和指数。

输入说明

输入数据第 1 行为 3 个正整数 n，m，t。

其中 n 表示第一个多项式的项数，m 表示第二个多项式的项数，t 表示运算类型，0为加法，1 为减法。

数据的第 2 行包含 2n 个整数，每两 个整数分别表示第一个多项式每一项的系数和指数；第 3 行包含 2m 个整数，每两个整数分 别表示第二个多项式每一项的系数和指数。两个多项式的每项是按照指数递增的形式给出的， 例如对于多项式3 + 6𝑋3 − 2𝑋8 + 12𝑋20，对应的输入为 3 0 6 3 -2 8 12 20。

输出说明

运算结果按指数从低到高的顺序在以多项式形式（见输出样例）输出结果，注意系数为负数 时输出减号，系数为 0 时不输出该项，指数为 1

时不输出指数。

输入样例

6 2 0 1 0 1 1 1 2 1 3 1 4 1 5

-1 3 -1 4

输出样例

1+x+x^2 +x^5

我的代码
#include<stdio.h>
typedef struct{
	struct{
		int ratio,power;
	}items;
}POLYNOMIA;

int main(){
	POLYNOMIA f[1000],fooo[1000];
	int n,m,t,i,j,temp1,temp2,ra,po;
	int count=1,k=0,sum=0;
	
	scanf("%d %d %d",&n,&m,&t);//输入数字 
	//printf("N:%d M:%d T:%d\n",n,m,t);
	for(i=0;i<n;i++) scanf("%d %d",&f[i].items.ratio,&f[i].items.power);
	for(j=0;j<m;j++,i++) {
		scanf("%d %d",&ra,&po);//在输入时就验证是加法还是减法
		if(t){//t=1是减法
			f[i].items.ratio=-ra;
			f[i].items.power=po;	
		} 
		else{//加法 
			f[i].items.ratio=ra;
			f[i].items.power=po;
		}
	}
	//进行排序
	for(i=0;i<m+n;i++){ 
		for(j=0;j<m+n-i-1;j++){
			if(f[j].items.power>f[j+1].items.power){
				temp1=f[j].items.power;
				f[j].items.power=f[j+1].items.power;
				f[j+1].items.power=temp1;
				
				temp2=f[j].items.ratio;
				f[j].items.ratio=f[j+1].items.ratio;
				f[j+1].items.ratio=temp2;
			}
		}
	}
	//进行计算
	for(i=0;i<m+n;i++){
		if(f[i].items.power!=f[i+1].items.power){
			fooo[k].items.power=f[i].items.power;
			fooo[k].items.ratio=f[i].items.ratio;
		//	printf("fooo%d:%d %d\n",k,fooo[k].items.ratio,fooo[k].items.power);	
			k++;
		}
		if(f[i].items.power==f[i+1].items.power){
			f[i+1].items.ratio+=f[i].items.ratio;
		}		
	} 
	//打印多项式 
	for(i=0;fooo[i].items.ratio==0;i++);
	if(fooo[i].items.ratio!=0){//由于第一位不带加减号。
		count=0; 
		if(fooo[i].items.ratio==1){
			if(fooo[i].items.power==0)
				printf("%d",fooo[0].items.ratio);
			else if(fooo[i].items.power==1) 
				printf("x");
			else 
				printf("x^%d",fooo[i].items.power);
		}
		else if(fooo[i].items.ratio==-1){
			if(fooo[i].items.power==0)
			printf("%d",fooo[i].items.ratio);
			else if(fooo[i].items.power==1) 
			printf("-x");
			else 
			printf("-x^%d",fooo[i].items.power);
		}
		else{
			if(fooo[i].items.power==0)
				printf("%d",fooo[i].items.ratio);
			else if(fooo[i].items.power==1) 
				printf("%dx",fooo[i].items.ratio);
			else 
				printf("%dx^%d",fooo[i].items.ratio,fooo[i].items.power);
		}
	}
	for(i++;i<k;i++){//对后面的数字进行加减 
		if(fooo[i].items.ratio>0){//如果系数是大于0的数字
		count=0;	
			if(fooo[i].items.ratio==1){// 要特别注意1的情况
				if(fooo[i].items.power==0) 
					printf("%d",fooo[i].items.ratio);
				else if(fooo[i].items.power==1) 
					printf("+x");
				else 
					printf("+x^%d",fooo[i].items.power);
			}
			else{
				
				if(fooo[i].items.power==0)
					printf("+%d",fooo[i].items.ratio);
				else if(fooo[i].items.power==1) 
					printf("+%dx",fooo[i].items.ratio);
				else 
					printf("+%dx^%d",fooo[i].items.ratio,fooo[i].items.power);
			}
	}
		else if(fooo[i].items.ratio==0){
			count=1;
			continue;
		}
		else{//如果本身是负数，既有符号，就不需要再加上，多余 
		count=0;
			if(fooo[i].items.ratio==-1){
				
				if(fooo[i].items.power==0)
					printf("%d",fooo[i].items.ratio);
				else if(fooo[i].items.power==1) 
					printf("-x");
				else 
					printf("-x^%d",fooo[i].items.power);
			}
			else{
				if(fooo[i].items.power==0)
					printf("%d",fooo[i].items.ratio);
				else if(fooo[i].items.power==1) 
					printf("%dx",fooo[i].items.ratio);
				else 
					printf("%dx^%d",fooo[i].items.ratio,fooo[i].items.power);
			}	
		}
	}
	if(count)printf("0");
	return 0;
}

130行太多了太多了——

对于一个C的基础题，这就像你写1+1；

写过程用了nnnnnn个方程来解决一样。

哎呀，就是比喻不大确切。

不过，要是能够优化，请扣我！！！

乐意至极，谢谢。

ldo regula
 Regula Falsi方法 (Regula Falsi method)
About the method:
 关于方法： 
We often hear many children and even many adults complaining about the difficulty level that they face while solving complex polynomial equations. It is also difficult for many to follow the steps in a scientific calculator and find the roots of the equations.
 我们经常听到许多儿童甚至许多成人抱怨他们在解决复杂的多项式方程式时面临的困难程度。 对于许多人来说，遵循科学计算器中的步骤并找到方程式的根源也是困难的。 
Therefore, this is a program that would help engineering students and many shopkeepers, vendors to solve complex equations via the False Position method or the Regula Falsi method. It is also handy, easy and calculations need not be done. 
 因此，该程序可以帮助工程专业的学生以及许多店主，供应商通过False Position方法或Regula Falsi方法求解复杂的方程式。 它也方便，容易并且不需要进行计算。 
Though this is an old method and not much used now it can be useful for those students who are willing to work on a complex project and on a difficult topic like this as they can create a better impression on their professors and fetch more marks. The method used is:
 尽管这是一种古老的方法，但现在很少使用，但对于愿意从事复杂项目和类似难题的学生来说，它可能会很有用，因为他们可以给教授留下更好的印象并获得更多的分数。 使用的方法是 ： 
We start this procedure by locating two points x0 and x1 where the function has opposite signs. We now connect the two points f(x0) and f(x1) by a straight line and find where it cuts the x-axis. Let it cut the axis at x2. We find f(x2). If f(x2) and f(x0) are of opposite signs then we replace x1 by x2 and draw a straight line connecting f(x2) to f(x0) to find the new intersection point. If f(x2) and f(x0) are of the same sign then x0 is replaced by x2 and proceed as before. In both cases, the new interval of search is smaller than the initial interval and ultimately it is guaranteed to converge to the root.
 我们通过定位函数具有相反符号的两个点x 0和x 1来开始此过程。 现在，我们通过一条直线连接两个点f(x 0 )和f(x 1 )，并找到它在x轴上的切割位置。 让它在x 2处切割轴。 我们找到f(x 2 )。 如果f(x 2 )和f(x 0 )具有相反的符号，则我们将x 1替换为x 2并绘制一条将f(x 2 )连接到f(x 0 )的直线以找到新的交点。 如果f(x 2 )和f(x 0 )具有相同的符号，则将x 0替换为x 2并像以前一样进行。 在这两种情况下，新的搜索间隔都小于初始间隔，并最终保证了收敛到根。 
We will now get an equation to find the successive approximations to the root:
 现在，我们将得到一个方程式，以求根的逐次逼近： 
Problem:
 问题： 
To find the roots of the given polynomial equation using the Regula Falsi method. Here, we take the equation in the form of f(x) = ax2+ bx+c if the equation is a quadratic equation.
 使用Regula Falsi方法查找给定多项式方程的根。 在这里，如果方程是二次方程，则采用f(x)= a x 2 + b x + c的形式。 
Example: f(x) = x2-25
 例如：f(x)= x 2 -25 
In this method, we need to assume 2 numbers which might be the roots of the equation by equating the equation f(x) to zero {f(x) = 0}. If the actual roots do not lie between or are near to the assumed values, the program will not run. And if the actual roots lie between the assumed values then the program will give the approximate of exact answer.

 在此方法中，我们需要通过将方程f(x)等于零{f(x)= 0}来假设2个数字可能是方程的根。 如果实际根不在假设值之间或附近，则程序将不会运行。 如果实际根位于假设值之间，则程序将给出精确答案的近似值。 






Example/program:
 示例/程序： 
#include <stdio.h>
#include <math.h>
#define ep 0.001

float poly(float ar[], int, float);

int main()
{
	float a[10],y0,y1,y2,x0,x1,x2,s,r;
	int i,n;
	char flag;
	
	printf("\t\t\t*****REGULA FALSI METHOD*****");

	//enter 2 if it is quadratic eq.
	printf ("\n\n Please enter the degree of polynomial equation: "); 
	scanf ("%d", &n);
	
	if (n>1)
	{
		for (i=0;i<=n; i++)
		{
			printf ("Enter the coefficient of x to the power %d: ", i);
			scanf ("%f", &a[i]);
		}
		do
		{
			//enter assumed values of roots
			printf ("\n Enter the initial guesses of x0 and x1: "); 
			scanf ("%f %f",&x0,&x1);
			y0=poly (a, n, x0);
			y1=poly (a, n, x1);
		} while (y0*y1>0);       
		
		printf ("\n x0           x1           x2          y0           y1           y2");

		for (i=0; i<=100; i++)
		{
			s= (x0*y1)-(y0*x1);
			r= y1-y0;
			x2 = s/r;
			y2 = poly (a, n, x2);
							
			if (fabs (y2)<= ep)
			{
				flag ='T';
				break;
			}

			printf("\n %f    %f    %f    %f   %f    %f",x0,x1,x2,y0,y1,y2);
			if ((y2*y0)<0)
			{
				x1=x2;
				y1=y2;
			}
			else
			{
				x0=x2;
				y0=y2;
			}
		}
		if(flag=='T')
			printf("\n\n Convergent solution= %f",x2);
		else
			printf("Does not converge in 100 iterations.");
	}
	else
	{
		printf("\n\tDegree not acceptable!");
	}
	
	return 0;
}

float poly(float ar[],int n,float x)
{
	int i;
	float p;
	p=ar[n];
	for(i=n;i>=1;i--)
	{
		p=ar[i-1]+(x*p);
	}
	return (p);
}

Output:
 输出： 
翻译自: https://www.includehelp.com/algorithms/find-the-roots-of-a-complex-polynomial-equation-using-regula-falsi-method-in-c.aspx
ldo regula

　　费了一番功夫。采取了拆分多项式逐项处理的方法。编写了一个项处理函数，将字符串拆分成一个个项，逐个处理，提取出左式跟右式的系数做差，然后利用求根公式。
Debug记录：
①条件判等写成了赋值
②项处理函数中在使用sum之前忘了初始化
③编写项处理函数时没有考虑到减号的情况
④对系数数组应该采取累加的方式，以应对多个同阶项的情况

题目描述：


设计一个二次方程计算器
输入：


每个案例是关于x的一个二次方程表达式，为了简单，每个系数都是整数形式。
输出：


每个案例输出两个实数（由小到大输出，中间由空格隔开），保留两位小数;如果无解，则输出“No Solution”。
样例输入：

x^2+x=3x+4
样例输出：

-1.24 3.24
来源：
2011年上海交通大学计算机研究生机试真题
答疑：
解题遇到问题?分享解题心得?讨论本题请访问：http://t.jobdu.com/thread-7826-1-1.html
#include <cstdio>
#include <cstring>
#include <cmath>
#define MAXSIZE 50
#define EPS 0.000001
using namespace std;
double a[3],b[3],c[3];
void dealItem(char *str,int order) {//进来的项存储在str中，必须带+-号 
	bool pos; 
	int len=strlen(str);
	int haveX=-1,haveBul=-1;
	double temp,sum;
	//符号处理
	pos=str[0]=='+'?true:false;
	for (int i=1;i<len;i++){
		if (str[i]=='x')/*bug= ==*/
			haveX=i;
		if (str[i]=='^')
			haveBul=i;
	} 
	if (haveX>=0){//一次项或二次项 
		if (haveX==1){//系数为1 
			sum=1; 
		}
		else{//系数不为1 
			sum=0;
			for (int i=1;i<haveX;i++){
				sum*=10;
				sum+=str[i]-'0';
			}
		}
		if (haveBul>0){//二次项 
			a[order]+=pos?sum:-sum;
		}
		else{//一次项 
			b[order]+=pos?sum:-sum;
		}
	}
	else{//常数项 
		sum=0;/*bug忘写*/
		for (int i=1;i<len;i++){
			sum*=10;
			sum+=str[i]-'0';
		}
		c[order]+=pos?sum:-sum;
	}
}

int main(){
	char str[MAXSIZE],strTemp[MAXSIZE];
	double delta;
	double x1,x2;
	int len;
	int p,q;
	
	while (scanf("%s",str)!=EOF){
		//initiate
		for (int i=0;i<3;i++){//初始化系数阵列为0 假设都为0 
			a[i]=b[i]=c[i]=0;
		}
		len=strlen(str);
		strTemp[0]='\0';
		//process
		p=-1;//p在str上走 
		while (p<len) {//处理左式 
			q=0;//q在strTemp上走 
			//该项符号处理 
			if (p==-1||str[p]=='='){//在多项式首部的情况 
				p++;
				if (str[p]=='-'||str[p]=='+'){//若该项自带符号 
					strTemp[q]=str[p];
					p++;q++;
				}
				else{//若该项不带符号 
					strTemp[q]='+';
					q++;
				}
			} 
			else{//不在多项式首部 则录入符号 
				strTemp[q]=str[p];
				p++;q++;
			}
			//处理项的绝对值部分 
			for (;str[p]!='+'&&str[p]!='='&&str[p]!='\0'&&str[p]!='-';p++){//copy a item 
				strTemp[q]=str[p];
				q++;
			}
			strTemp[q]='\0';
			dealItem(strTemp,1);
			if (str[p]=='='){
				break;
			}
		}
		while (p<len){//处理右式 
			q=0;//q在strTemp上走 
			//该项符号处理 
			if (p==-1||str[p]=='='){//在多项式首部的情况 
				p++;
				if (str[p]=='-'||str[p]=='+'){//若该项自带符号 
					strTemp[q]=str[p];
					p++;q++;
				}
				else{//若该项不带符号 
					strTemp[q]='+';
					q++;
				}
			} 
			else{//不在多项式首部 则录入符号 
				strTemp[q]=str[p];
				p++;q++;
			}
			for (;str[p]!='+'&&str[p]!='='&&str[p]!='\0'&&str[p]!='-';p++){//copy a item 
				strTemp[q]=str[p];
				q++;
			}
			strTemp[q]='\0';
			dealItem(strTemp,2);
		}
		//cal
		a[0]=a[1]-a[2];
		b[0]=b[1]-b[2];
		c[0]=c[1]-c[2];
		delta=b[0]*b[0]-4*a[0]*c[0];
		if (delta<0){
			printf("No Solution\n");
		}
		else{
			x1=(-sqrt(delta)-b[0])/2/a[0];
			x2=(sqrt(delta)-b[0])/2/a[0];
			printf("%.2lf %.2lf\n",x1,x2);
		}
	}
	return true;
}
/*bug
1.没考虑减号的情况 
2.系数应该使用+=sum，以防多个同阶项的情况 
*/