C++编程【问题描述】根据泰勒公式，求sinx的值。

C++语言，需要增加头文件，cmath库函数包含数学函数。#include （1） sqrt(pow(sin(x), 5));（2） (a * x + (a + x) / (4 * a)) / 2;（3）const double PI = 3.1415926;pow(pow(c, x), 2) / sqrt(2 * PI);...

#include
void main()
{
int A,B,C,D,E,F,J,H;
coutB>>C>>D>>E>>F>>J>>H;
cout

已测试，结果正确，但是n不能设的太大，给点辛苦分吧亲。。
#include
using namespace std;
int main()
{
unsigned int a,n,i;
unsigned long sum=0,total=0;
cin>>a>>n;
while(!cin)
{
couta>>n;
}
cout

这要看你想用什么方法解了,高斯消去的话程序效率太低,建议用迭代.你可以去看看Matlab的代码库,里面有,太长了我搬不过来,里面分了几种不同的迭代法

程序一为：
#include
void main()
{
int a,b,c,s;
couta>>b;
s=a+b;
cout

complex complex::operator ! ()
{im = -im;return *this;}
那个这个代码把调用这个函数的对象的本身的值给该了呀!
{
return complex(re,-im);
}
这样简单又不给改本身的值.
那个重载+时,友元和成员函数用一个不就行了吗?
再说了,如果都有,同样是+,系统识别时会不知道调用哪一个的!同样两个参数,同样的运算符!不过要是那个第一个数不是你自定义的数据类型时,可以再重载友元函数,形参就不一样了!其实对同一类型的用一个就行了,要想调试,一个一个来呗.
还有你那个输出复数的值时,会出现+-xx现象,可以在输出前加一个判断的!对不同情形进行讨论,这样结果会更好看的!

比较复杂,给个简单思路:
1. 成员函数: 获取算式
2. 成员变量: 较大的数组,当然如果你认为算式长度可能非常大,则最好使用向量
3. 成员函数:检查算式,主要进行括号匹配的校验,方法是从前往后,遇到'('则+1,遇到')'则-1,如果值小于0则报错
4.成员函数:分析算式,每遇到'(',则将其匹配的')'中间的算式作为一个子算式;如果遇到*或/也将其作为一个子算式,如此递归分解直到算式的符号全为+和-;
5.成员函数:计算算式,将每个子算式的结果算出,并按顺序进行加减
--- 话说分那么重要吗?

首先是方程式怎样表示的问题,在“数据规模”中提到方程长度不会超过255,即方程可用大小为256的字符数组来保存,既然是C++,当然也能用string来保存.为体现C++的优越,就用string吧.
主要思路就是跟据这个字符串,读出每个X的系数以及常数项；对于一元一次方程,常数项除以系数就是未知数的根了,最主要的就是设计算法读出每个项及其符号了.
我的具体思路就是读取每个字符,如果读到数字,就将其放入一个字符串n中,一旦读出的字符不是数字,转换n为整数,并结合符号位得出正负；如果读出符号,保存给符号位；如果数字之后读出X,就认为刚才读到的数字是X的系数,而应该加到系数中,如果是+-号就是常数项,加到常数中；如果+-号之后就是X,那么系数就为1.一旦碰到=号,就说明正负的计算应颠倒了……
总而言之就是解方程中的移项合并同类项,要是看不懂,我明天就追加一段代码来具体说明.

int c=2,d=2,m=0,n=1;//默认的矩阵是两行两列且均是(0,1)之间myrandom ran; int panduan=0; cout

横线6：j>=i
横线7:a[i][j]
横线8：NULL
横线9：*str2++
横线10：(i+j)%2!=0
横线11：0
横线12：a[i]

int sushu(int N)
{
int i;
int flag=1;
if (N==1) return false;//1既不是素数也不是质数
if (N==2) return true;
for (i=2;i

#include "stdio.h"
#include "math.h"
#define N 100
void main()
{
double delta=1.0/N;
double x=1;
double y1,y2;
double s=0;
y1=0;
while(x

#include
using namespace std;
int main()
{
int x,i,y;

for(x=1;x

//#include "stdafx.h"//vc++6.0加上这一行.
#include
using namespace std;
typedef struct abc{
char p;
unsigned x;
int n;
abc *next;
}*NODE,node;
void freenode(NODE p){
if(p->next) freenode(p->next);
else delete p;
}
NODE CreateLink(void){
char ch;
NODE head,p;
if((p=head=new node)==NULL){
cout ch;
if(ch=='#') break;
if((p->next=new node)==NULL){
cout next->p=ch;
cin >> p->next->x >> p->next->n;
p=p->next;
}
p->next=NULL;
p=head;
head=head->next;
delete p;
return head;
}
void Processing(NODE p){
for(;p;p=p->next){
switch(p->p){
case 'L':
cout x & ((1

class Complex{
public:
friend ostream& operato

#include
using namespace std;

void main()
{
char chs[]={1,3,5,7,11,13,15,16,21,23,24,29,31,32,33,35,37,41,45,47,48,52,61,63,65,67,68,81};
for (int x = 1-11; x < 81-11; ++x) {//因为没有说是整数,所以最新从1-11开始,最大是81-11,按条件2,3来取的
for (int y = 1-11; y < 81-11; ++y) {
string str = chs;//因为没有0,所以取巧,用string就搞定了
if(str.find(x+y)!=-1 str.find(x+11)!=-1 &
str.find(y+11)!=-1 &str.find(x+y+12)!=-1)
cout<}
}
}

像你说的那样，在输入完153之后的回车和100之后的回车系统是不会自动判断结束的，通常是输入一个文件结束字符，^Z也就是ctrl+Z。
#include
void main()
{
int number[100],i=0,a,b,c;
do
{ scanf("%d",&number[i]);
i++;
}while(number[i-1]!=EOF);
i=0;
while(number[i]!=EOF)
{ a=number[i]/100;
b=(number[i]-a*100)/10;
c=number[i]-a*100-b*10;
if(number[i]==a*a*a+b*b*b+c*c*c)
printf("YESn");
else
printf("NOn");
i++;
}
}

这个题目用递归就行了。一个目标值总的可行方案数量等于应用某种面值钱币后剩下的钱的方案数加上不用这种面值钱币的方案数。我简单写了个针对第一个测试用例的代码，供参考（代码输出是2）。#include
#define NMAX 100000
int v[6] = {2,5,10,20,50,100};
int min(int a,int b) { return aint solve(int t,int i=0){
if(t==0) return 0;
if(i>=6 || t return min(solve(t,i+1),solve(t-v[i],i)+1);
}
int main() {
int n = solve(15);
printf("%dn",n);
return 0;
}solve返回值为最少的钱币数量，大于NMAX表示无解。

C++中,引用变量之前必须对其初始化,看了你这段代码,发现你的变量r在for循环判断之前并没有初始化而直接对其判断是否为0,这是一种错误的引用.而且对於输入的两个数m、n,在处理的时候最好不要改变它们本身的值,而将其拷贝给另外俩个变量（自己重新声明两个变量）,这是一种很好的编程习惯.

额
假设只使用标准c++(不用boost,qt之类的)
假设输入数据格式为
number 3
data 100 90
data 100 96
data 100 80

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
#include
#include
std::wstring s2ws(const std::string& s)
{
setlocale(LC_ALL, "chs");
const char* _Source = s.c_str();
size_t _Dsize = s.size() + 1;
wchar_t *_Dest = new wchar_t[_Dsize];
wmemset(_Dest, 0, _Dsize);
mbstowcs(_Dest,_Source,_Dsize);
std::wstring result = _Dest;
delete []_Dest;
setlocale(LC_ALL, "C");
return result;
}
std::string ws2s(const std::wstring& ws)
{
std::string curLocale = setlocale(LC_ALL, NULL); // curLocale = "C";
setlocale(LC_ALL, "chs");
const wchar_t* _Source = ws.c_str();
size_t _Dsize = 2 * ws.size() + 1;
char *_Dest = new char[_Dsize];
memset(_Dest,0,_Dsize);
wcstombs(_Dest,_Source,_Dsize);
std::string result = _Dest;
delete []_Dest;
setlocale(LC_ALL, curLocale.c_str());
return result;
}
class Judge
{
public:
Judge():number(0)
{
std::wcout.imbue(std::locale("chs"));
}
~Judge(){}
bool read(const std::wstring & filePathName);
bool write(void);
private:
enum show
{
better,
worse,
same
};
std::list allNum;
std::list expNum;
std::list per;
std::list result;
int number;
std::wifstream fin;
std::wofstream fout;
};
bool Judge::read(const std::wstring & filePathName)
{
fin.close();
fout.close();
fin.open(filePathName);
if(fin.is_open())
{
fout.open(filePathName+std::wstring(L".txt"));
allNum.clear();
expNum.clear();
per.clear();
number=0;
std::wstring lineTemp;
while( std::getline(fin,lineTemp) )
{
std::wstringstream ilineTemp(lineTemp);
if( std::getline(ilineTemp,lineTemp,L' ') )
{
if(lineTemp==std::wstring(L"data"))
{
if(std::getline(ilineTemp,lineTemp,L' '))
{
allNum.push_back( atoi(ws2s(lineTemp).c_str()) );
ilineTemp>>lineTemp;
expNum.push_back( atoi(ws2s(lineTemp).c_str()) );
}
else
{
std::wcout

1、bool IsShuiXian(int n)//利用这个水仙花数判断函数，可以求出任意区间的
{
char szText[32] = {0};
itoa(n,szText,10);
int iLen = strlen(szText);
int iAry[32] = {0};
int iSum = 0;
for ( int i=0; i n )
{
return false;
}
}
if ( iSum == n )
{
return true;
}
return false;
}
4、
bool IsPrime(int n)//利用这个函数，可以判断出任意区间的素数
{
if ( n

你这样是因为少了if
其实你这样的编码习惯很有问题,在多个if和else嵌套的时候加上大括号是很必要的,方便检查也代码美观
例如
if(){
if(){
.
}else{
.
}
}else{
.
}
只是帮你解决问题是不够的 望君注意下编码习惯 然后自己再看一下 就知问题何在

哥们,你的错误很多啊,出不了结果主要在于你取abcde的各个位数时错了,你可以再看看你的程序,在第二次循环结束时,也就是10001时,abcde已经变成了原来万位上的数,也就是1,进行判断,永远小于100000,成了死循环,所以程序没结果了,你再读读你的程序,看看是不是这个道理.我给你修改了一下,如下程序：
#include
using namespace std;
//一个5位数字ABCDE*4=EDCBA
int main()
{
int a,b,c,d,e,edcba,abcde,i;
cout

要使效率高,那就不能用递归函数,而要自己去迭代.
#include "stdio.h"
void main()
{
//设一个查找表,可以快速地判断某数是否为素数
bool prime[40]={
0,0,1,1,0,1,0,1,0,0,
0,1,0,1,0,0,0,1,0,1,
0,0,0,1,0,0,0,0,0,1,
0,1,0,0,0,0,0,1,0,0
};
//快速判断哪些数已经被选中
bool used[21]=;
//a[0]无用,a[1]到a[20]分别存放选出的数
//因为考虑到题目要求的循环性
//所有的解都可以位移使得1出现在a[1]位置
//所以我们就直接规定1放在a[1]
int a[21]=;
//已经选中的数的个数,
int cnt=1;
//当发生无数可选的情况时,需要回退一步
//此变量用来表示是否发生了回退
bool tag=false;
int i;
while(cnt<20)
{
//如果发生了回退,则直接从上次选的数的后面开始查找
//不是回退的话,则从2开始查找
for(i=(tag?a[cnt+1]+1:2);i<21;i++)
if(!used[i] && prime[i+a[cnt]])
{
//找到符合条件的数
a[++cnt]=i;
used[i]=true;
tag=false;
break;
}
//找到解
if(cnt==20 && prime[a[1]+a[20]])
{
for(i=1;i<21;i++)
printf("%d ",a[i]);
return;
}
//如果发生了无数可选的情况,则回退一步
else if(cnt==20 || i==21)
{
used[a[cnt--]]=false;
tag=true;
}
}
}

如下：
#include
using namespace std;
int main()
{
int num1=0;
int num2=0;
int num3=0;
int number=0;
for(int i=100;i

#include
using namespace std;

void sortNum(int * numArray, int num)
{
for (int i = 0; i < num;i++)
{
for (int j = 0; j < num -i -1; j++)
{
if (numArray[j] > numArray[j + 1])
{
int tmp = numArray[j];
numArray[j] = numArray[j+1];
numArray[j+1] = tmp ;
}
}
}
}

int main()
{
// 四个数
int numArray[] = {2, 10, 8, 9};

sortNum(numArray, 4);

for (int i = 0; i < 4; i++)
{
cout << numArray[i] << " ";
}
cout<return 0;
}

#include
#include
#include
using namespace std;
char map[4][4];
int main()
{
int x,y;
couty;
coutx;
map[0][0]=map[0][1]=map[1][0]='B';
map[0][2]=map[0][3]=map[1][3]='C';
map[2][0]=map[3][0]=map[3][1]='E';
map[3][2]=map[2][3]=map[3][3]='D';
map[1][1]=map[1][2]=map[2][1]=map[2][2]='A';
if((x==0||x==1)&&y==0)map[1][1]='B';
if((x==0||x==1)&&y==3)map[1][2]='C';
if((x==3||x==2)&&y==0)map[2][1]='E';
if((x==3||x==2)&&y==3)map[2][2]='D';
for(int i=0;i

#include

int real_number_print(float x)
{
int integer_part = (int)x;
float fractional_part = x-integet_part;
printf("%d %f", integer_part, fractional_part);
return 0;
}

int sum(int x, int y, int z)
{
return (x+y+z);
}

float average(int x, int y, int z)
{
return (x+y+z)/3;
}

1.大概是这样的算法
void search(int *a,int n int *max,int *min){
max=a[0];
min=a[0];
for(int i=0; imax) max = a[i];
if(a[i]

根据数学排列组合 那么 第一位有4种选择 第二位有三种选择 第三位 两种选择
则有 4X3X2 =24 种
[123][124][132][134][142][143]
[213][214][231][234][241][243]
[312][314][321][324][341][342]
[412][413][421][423][431][432]
Press any key to continue
#include
using namespace std;
int main()
{
x09int aa,bb,cc;
x09for (aa=1;aa

#include
int main(void)
{
int x,a,b,c;
printf("请输入一个三位数："）;
a=x/100;
b=x%100/10;
c=x%10;
printf("逆顺序输出：%d%d%dn",a,b,a);
return();
}

你没有重新计算你定义的 a
循环最后加一条语句
while(a>10e-6)
{
.
.
a=fabs(x0-x1);
}

for(int i=0;i

#include
int main()
{
char cypher[4]="Love"，code[4];
const int N=26;
int i=0,n;
printf("please input the keys :n");
scanf("%d",&n);
printf("The original word is %s n", cypher);
for(;i'Z')
cypher[i] =((cypher[i] - 'a')+n)%N+'a';
else
cypher[i]=((cypher[i] - 'A')+n)%N+'A';
}
printf(("The encrypted word is %s , cypher);
return 0;
}

#include
#include
using namespace std;
double triangel_area(double a,double b,double c);
int main()
{
double a,b,c;
x09cin>>a>>b>>c;
x09cout<x09return 0;
}
double triangel_area(double a,double b,double c)
{
x09if(a+b>c || a+c>b || b+c>a)
x09{
x09double p = (a+b+c)/2;
x09x09return sqrt(p*(p-a)*(p-b)*(p-c));
x09}
x09return 0.0;
}

　　//main.cpp _______used for testing
　　#include
　　#include
　　#include "matrix.h"
　　#include "time.h"
　　#include "stdlib.h"
　　using namespace std;
　　int main(int argc,char *argv[])
　　{
　　srand(time(NULL));
　　double data[ROW][COLUMN];
　　Matrix *pm1,*pm2;
　　int k=0;
　　while(k

#include "iostream.h"
#include "math.h"
class point
{
public:
float x;
float y;
//构造函数
point(float x,float y)
{
this->x=x;
this->y=y;
}
};
class line
{
float a;
float b;
float c;
public:
//构造函数
line(float a,float b,float c)
{
this->a=a;
this->b=b;
this->c=c;
}
float getDistance(point p)
{
float x,y;
x=p.x;
y=p.y;
return fabs(a*x+b*y+c)/sqrt(a*a+b*b);
}
};
void main()
{
float x,y;
coutx;
couty;
point p(x,y);

float a,b,c;
couta;
coutb;
coutc;
line l(a,b,c);
cout

#include
class digital
{
private:
int m_num;
public:
digital(int num=0)
{
this->m_num=num;
}
digital(){};
int GetNum()
{
return m_num;
}
digital operator + (digital x)
{
digital y;
y.m_num=this->m_num+x.m_num;
return y;
}
digital operator * (digital x)
{
digital y;
y.m_num=this->m_num*x.m_num;
return y;
}
digital operator / (digital x)
{
digital y;
y.m_num=this->m_num / x.m_num;
return y;
}
digital operator - (digital x)
{
digital y;
y.m_num = this->m_num - x.m_num;
return y;
}
};
void main()
{
digital a(3);
digital b(3);
cout<<(a+b).GetNum()<cout<<(a*b).GetNum()<cout<<(a/b).GetNum()<cout<<(a-b).GetNum()<}