练习11

1

//-------------------------------------
// EX1101.cpp
// 解方程
//-------------------------------------
#include"Root.h"
#include<iostream>
using namespace std;
//-------------------------------------
int main(){
  for(double a,b,c; cin>>a>>b>>c; )
    Root(a,b,c).solve();
}//------------------------------------

//-------------------------------------
// Root.h
//-------------------------------------
#ifndef HEADER_ROOT
#define HEADER_ROOT
//-------------------------------------
class Root{
  double aa,bb,cc;
public:
  Root(double a, double b, double c):aa(a), bb(b), cc(c){}
  void solve()const;
};//-----------------------------------
#endif   // HEADER_ROOT

/*
#ifndef HEADER_ROOT
#define HEARDER_ROOT


#endif HEADER_ROOT
*/

//-------------------------------------
// Root.cpp
//-------------------------------------
#include"Root.h"
#include"Complex.h"
#include<cmath>  // for sqrt()
//-------------------------------------
void Root::solve()const{
  Complex x1(-bb/(2*aa)), x2(-bb/(2*aa));
  double delta = bb*bb - 4*aa*cc;
  if(delta){
    bool flag=delta<0;
    delta = (flag?-1:1)*delta;//三目运算符,-1乘以负的delta得正数
    delta = std::sqrt(delta)/(2*aa);
    if(flag)
        x1.im = delta, x2.im = -delta;//imag
    else   
        x1.re += delta, x2.re -= delta;//real
  }
  cout<<"The solution is
";
  cout<<"  x1 = "<<x1<<"
";
  cout<<"  x2 = "<<x2<<"
";
}//------------------------------------

//-------------------------------------
// Real.h
//-------------------------------------
#ifndef HEADER_REAL
#define HEADER_REAL
#include<iostream>
using namespace std;
//-------------------------------------
class Real{
protected:
  double real;
public:
  Real(double r=0):real(r){}
   double(const Real& a){ return a.real; }
  friend Real operator+(const Real& a, const Real& b){ return a.real+b.real; }
  friend Real operator-(const Real& a, const Real& b){ return a.real-b.real; }
  friend Real operator*(const Real& a, const Real& b){ return a.real*b.real; }
  friend Real operator/(const Real& a, const Real& b){ return a.real/b.real; }
  friend bool operator==(const Real& a, const Real& b){ return a.real==b.real; }
  friend ostream& operator<<(ostream& cout, const Real& a){ return cout<<a.real; }
  //friend class Root;
};//-----------------------------------
#endif   // HEADER_REAL
     

 

//-------------------------------------
// Real.cpp
//-------------------------------------
#ifndef HEADER_COMPLEX
#define HEADER_COMPLEX
#include<iostream>
using namespace std;
//-------------------------------------
class Complex{
  double real, virt;
public:
  Complex(double r=0, double v=0):real(r),virt(v){}
  friend Complex operator+(const Complex& a, const Complex& b);
  friend ostream& operator<<(ostream& out, const Complex& a);
};//-----------------------------------
#endif   // HEADER_COMPLEX
     

 

//-------------------------------------
// Complex.h
//-------------------------------------
#ifndef HEADER_COMPLEX
#define HEADER_COMPLEX
#include<iostream>
using namespace std;
//-------------------------------------
class Complex{
protected:
  double re, im;
public:
  Complex(double r=0, double v=0):re(r),im(v){}
  friend Complex operator+(const Complex& a, const Complex& b);
  friend ostream& operator<<(ostream& out, const Complex& a);
  friend class Root;
};//-----------------------------------
#endif   // HEADER_COMPLEX
     

//-------------------------------------
// Complex.cpp
//-------------------------------------
#include"Complex.h"
#include<iostream>
using namespace std;
//-------------------------------------
ostream& operator<<(ostream& cout, const Complex& a){
  return (a.im ? cout<<a.re<<" + "<<a.im<<"i" : cout<<a.re);
}//------------------------------------
Complex operator+(const Complex& a, const Complex& b){
  return Complex(a.re+b.re, a.im+b.im);
}//--------------------------

 2

//=====================================
// EX1102_2.cpp
// 大数A+B (对象版)
//=====================================
#include"Number.h"
#include<fstream>
#include<iostream>
using namespace std;
//-------------------------------------
int main(){
  ifstream cin("aplusb.in");
  for(Number a,b; cin>>a>>b; )
    cout<<a+b<<"
";
}//====================================
 

//=====================================
// Number.cpp
//=====================================
#include"Number.h"
#include<iostream>
#include<string>
#include<vector>
using namespace std;
//-------------------------------------
void Number::add(const Number& a){
  for(int i=s.length()-1,tmp=0; i>=0; --i, tmp/=10){
    tmp += a.s[i]-'0'+ s[i]-'0';
    s[i] = tmp%10 + '0';
  }
}//------------------------------------
void Number::comple(string& t){                 // 十进数取补
  for(int i=0; i<t.length(); ++i) //取反
    t[i] = 105 - t[i];  // '0'+'9'=105
  int i=t.length()-1;
  while(i>=0 && t[i]=='9')        //+1
    t[i--]='0';
  t[i]++;
}//------------------------------------
void Number::stretch(){               // 伸展至Num位
  if(s[0]!='-')
    s = string(Num-s.length(),'0')+s;
  else{
    s[0]='0';
    comple(s);
    s = string(Num-s.length(),'9')+s;
  }
}//------------------------------------
string Number::shrink()const{                // 按有效位压缩
  string t(s);
  if(t[0]=='9')
    comple(t);
  int pos = t.find_first_not_of('0');
  if(pos<0) return string("0");
  return (s[0]=='9'? "-":"")+t.substr(pos);
}//------------------------------------
Number operator+(const Number& a, const Number& b){
  Number w(a);
  w.add(b);  // w+=t
  return w;
}//------------------------------------
istream& operator>>(istream& cin, Number& a){
  cin>>a.s;
  a.stretch();
  return cin;
}//------------------------------------
ostream& operator<<(ostream& cout, const Number& a){
  return cout<<a.shrink();
}//------------------------------------

//=====================================
// Number.h
// 大数类
//=====================================
#ifndef HEADER_NUMBER
#define HEADER_NUMBER
#include<iostream>
#include<string>
using namespace std;
//-------------------------------------
class Number{
  string s;
  void comple(string& s);     //s取补
  void stretch();             //s伸展,用于初始化
  string shrink()const;       //s压缩
  enum { Num=80 };
public:
  Number():s(Num,'0'){}
  Number(const string& a):s(a){ stretch(); }
  void add(const Number& a);  //s+=a
  friend Number operator+(const Number& a, const Number& b);
  friend istream& operator>>(istream& cin, Number& a);
  friend ostream& operator<<(ostream& cout, const Number& a);
};//-----------------------------------
#endif  // HEADER_NUMBER

字串是从零开始的 下标0表示第一个字符
length 返回的实际内容的长度 不包括０
3

//=====================================
// Number.cpp
//=====================================
#include"Number.h"
#include<iostream>
#include<string>
using namespace std;
//-------------------------------------
static void sub(string& x, const string& k);
//-------------------------------------
string Number::div(int n)const{
  string p(s), res=(p[0]=='9'?"-":"");
  if(p[0]=='9') comple(p);
  int pos=p.find_first_not_of('0');
  if(pos<0) return string();
  p=p.substr(pos);

  string k;
  for( ; n; n/=10) k = char(n%10+'0')+k;

  if(k.length()>p.length()) return string();

  int m = k.length()-(p.substr(0,k.length())>=k);
  string x(p.substr(0, m));
  for(int i=m; i<p.length(); ++i){
    x += p[i];
    int count=0;
    for( ; x.length()>=k.length() && x>=k; count++)
      sub(x,k);
    res += char(count+'0');
  }
  return res;  // x abandoned
}//------------------------------------
void sub(string& x, const string& k){
  int tmp=0,h=x.length()-k.length();
  for(int i=k.length()-1; i>=0; --i){
    tmp=x[i+h]-k[i]-tmp;
    if(tmp>=0) x[i+h]=tmp+'0', tmp=0;
    else x[i+h]=10+tmp+'0', tmp=1;
  }
  if(tmp) x[0]--;
  int pos = x.find_first_not_of('0');
  x = (pos<0 ? string() : x.substr(pos));
}//------------------------------------
void Number::operator()(const Number& a){
  add(a);
  cout<<a.shrink()<<"
";
}//------------------------------------
bool operator<(const Number& a, const Number& b){
  if(a.s[0]=='9' && b.s[0]!='9') return true;
  if(a.s[0]!='9' && b.s[0]=='9') return false;
  return a.s<b.s;
}//------------------------------------
void Number::add(const Number& a){
  for(int i=s.length()-1,tmp=0; i>=0; --i, tmp/=10){
    tmp += a.s[i]-'0'+ s[i]-'0';
    s[i] = tmp%10 + '0';
  }
}//------------------------------------
void Number::comple(string& t){                 // 十进数取补
  for(int i=0; i<t.length(); ++i) //取反
    t[i] = 105 - t[i];  // '0'+'9'=105
  int i=t.length()-1;
  while(i>=0 && t[i]=='9')        //+1
    t[i--]='0';
  t[i]++;
}//------------------------------------
void Number::stretch(){               // 伸展至Num位
  if(s[0]!='-')
    s = string(Num-s.length(),'0')+s;
  else{
    s[0]='0';
    comple(s);
    s = string(Num-s.length(),'9')+s;
  }
}//------------------------------------
string Number::shrink()const{                // 按有效位压缩
  string t(s);
  if(t[0]=='9')
    comple(t);
  int pos = t.find_first_not_of('0');
  if(pos<0) return string("0");
  return (s[0]=='9'? "-":"")+t.substr(pos);
}//------------------------------------
Number operator+(const Number& a, const Number& b){
  Number w(a);
  w.add(b);  // s+=t
  return w;
}//------------------------------------
istream& operator>>(istream& cin, Number& a){
  cin>>a.s;
  a.stretch();
  return cin;
}//------------------------------------
ostream& operator<<(ostream& cout, const Number& a){
  return cout<<a.shrink();
}//------------------------------------

//=====================================
// Number.h
// 大数类
//=====================================
#ifndef HEADER_NUMBER
#define HEADER_NUMBER
#include<iostream>
#include<string>
using namespace std;
//-------------------------------------
class Number{
  string s;
  void comple(string& s);     //s取补
  void stretch();             //s伸展,用于初始化
  string shrink()const;       //s压缩
  enum { Num=100 };
public:
  Number():s(string(Num,'0')){}
  Number(const string& a):s(a){ stretch(); }
  string div(int n)const;
  void add(const Number& a);  //s+=a
  void operator()(const Number& a);
  friend bool operator<(const Number& a, const Number& b);
  friend Number operator+(const Number& a, const Number& b);
  friend istream& operator>>(istream& cin, Number& a);
  friend ostream& operator<<(ostream& cout, const Number& a);
};//-----------------------------------
#endif  // HEADER_NUMBER

//=====================================
// EX1102_2.cpp
// 大数排序+求平均数
//=====================================
#include"Number.h"
#include<fstream>
#include<iostream>
#include<vector>
#include<algorithm>  // sort, for_each
using namespace std;
//-------------------------------------
int main(){
  ifstream cin("aplusb.in");
  vector<Number> x;
  for(Number a; cin>>a; )
    x.push_back(a);
  sort(x.begin(), x.end());
  Number sum = for_each(x.begin(), x.end(), Number());
  cout<<"Average: "<<sum.div(x.size())<<"
";
}//====================================

//=====================================
// EX1102_1.cpp
// 大数排序+求平均数
//=====================================
#include"Number.h"
#include<fstream>
#include<iostream>
#include<vector>
#include<algorithm>  // sort
using namespace std;
//-------------------------------------
int main(){
  ifstream cin("aplusb.in");
  vector<Number> x;
  for(Number a; cin>>a; )
    x.push_back(a);
  sort(x.begin(), x.end());
  Number sum;
  for(int i=0; i<x.size(); i++){
    sum.add(x[i]);
    cout<<x[i]<<"
";
  }
  cout<<"Average: "<<sum.div(x.size())<<"
";
}//====================================