Accelerated C++ 习题解答 第5章

习题解答部分来自网上已有解答

EX.5-0

1)

#include <iostream>
#include <vector>
#include <string>
#include <cctype>
#include <conio.h>
 
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::string;
 
vector<string> split (conststring& s)
{
   vector<string>ret;
   typedef string::size_type string_size;
   string_size i = 0;
 
   while (i != s.size()) {
      while (i != s.size() && isspace(s[i]))
        ++i;
 
      string_size j = i;
 
      while (j != s.size() && !isspace(s[j]))
        ++j;
 
      if (i != j) {
        ret.push_back(s.substr(i,j-i));
        i = j;
      }
   }
   return ret;
}
 
int main()
{
   string s;
   while (getline (cin, s)) {
      vector<string>v = split(s);
 
      for (vector<string>::size_type i = 0; i !=v.size(); ++i) {
        cout <<v[i] << endl;
      }
   }
   getch();
   return 0;
}

2)

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <conio.h>
 
using namespace std;
 
string::size_type width(constvector<string>& v)
{
   string::size_typemaxlen = 0;
   for (vector<string>::size_type i = 0; i !=v.size(); ++i)
      maxlen =max(maxlen, v[i].size());
   return maxlen;
}
 
vector<string> frame(constvector<string>& v)
{
   vector<string>ret;
   string::size_typemaxlen = width(v);
   string border(maxlen+ 4, '*');
 
   ret.push_back(border);
   for (vector<string>::size_type i = 0; i != v.size();++i) {
      ret.push_back("* " + v[i] + string(maxlen-v[i].size(),' ') +"*");
   }
   ret.push_back(border);
   return ret;
}
 
int main()
{
   vector<string>content, output;
 
   string s;
   while (getline(cin, s)) {
      content.push_back(s);
   }
   output = frame(content);
   for (vector<string>::size_type i = 0; i !=output.size(); ++i) {
      cout <<output[i] << endl;
   }
   getch();
   return 0;
}

3)

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <conio.h>
 
using namespace std;
 
string::size_type width(constvector<string>& v)
{
   string::size_typemaxlen = 0;
   for (vector<string>::size_type i = 0; i !=v.size(); ++i)
      maxlen =max(maxlen, v[i].size());
   return maxlen;
}
 
vector<string> frame(constvector<string>& v)
{
   vector<string>ret;
   string::size_typemaxlen = width(v);
   string border(maxlen+ 4, '*');
 
   ret.push_back(border);
   for (vector<string>::size_type i = 0; i !=v.size(); ++i) {
      ret.push_back("* " + v[i] + string(maxlen-v[i].size(),' ') +"*");
   }
   ret.push_back(border);
   return ret;
}
 
vector<string> vcat(constvector<string>& top,constvector<string>& bottom)
{
   vector<string>ret = top;
   ret.insert(ret.end(),bottom.begin(), bottom.end());
   return ret;
}
 
int main()
{
   vector<string>content, output;
 
   string s;
   while (getline(cin, s)) {
      content.push_back(s);
   }
   output =vcat(content, frame(content));
   for (vector<string>::size_type i = 0; i !=output.size(); ++i) {
      cout <<output[i] << endl;
   }
   getch();
   return 0;
}

4)

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <conio.h>
 
using namespace std;
 
string::size_type width(constvector<string>& v)
{
   string::size_typemaxlen = 0;
   for (vector<string>::size_type i = 0; i !=v.size(); ++i)
      maxlen =max(maxlen, v[i].size());
   return maxlen;
}
 
vector<string> frame(constvector<string>& v)
{
   vector<string>ret;
   string::size_typemaxlen = width(v);
   string border(maxlen+ 4, '*');
 
   ret.push_back(border);
   for (vector<string>::size_type i = 0; i !=v.size(); ++i) {
      ret.push_back("* " + v[i] + string(maxlen-v[i].size(),' ') +"*");
   }
   ret.push_back(border);
   return ret;
}
 
 
vector<string> hcat(constvector<string>& left,constvector<string>& right)
{
   vector<string>ret;
   string::size_type  width1 = width(left) + 1;
   vector<string>::size_typei = 0, j = 0;
   while (i != left.size() || j != right.size()) {
      string s;
 
      if (i != left.size()) {
        s = left[i++];
      }
 
      s += string(width1- s.size(), ' ');
 
      if (j != right.size()) {
        s += right[j++];
      }
     
      ret.push_back(s);
   }
   return ret;
}
 
int main()
{
   vector<string>content, output;
 
   string s;
   while (getline(cin, s)) {
      content.push_back(s);
   }
   output =hcat(content, frame(content));
   for (vector<string>::size_type i = 0; i !=output.size(); ++i) {
      cout <<output[i] << endl;
   }
   getch();
   return 0;
}

EX.5-1

 

EX.5-2

1)      vector版本

#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
#include <fstream>
#include <ctime>
#include <conio.h>
 
#include "Student_info.h"
#include "grade.h"
 
//driver program for grade partitioning examples
 
using std::cin;
using std::cout;
using std::endl;
using std::sort;
using std::string;
using std::vector;
using std::max;
using std::ifstream;
using std::ofstream;
 
vector<Student_info> extract_fails(vector<Student_info>&students) {
 vector<Student_info> fail;
#ifdef _MSC_VER
 std::vector<Student_info>::iterator iter = students.begin();
#else
 vector<Student_info>::iterator iter = students.begin();
#endif
 
  while (iter != students.end()) {
    if (fgrade(*iter)) {
     fail.push_back(*iter);
      iter =students.erase(iter);
    } else
      ++iter;
  }
 
  return fail;
}
 
int main() {
 vector<Student_info> vs;
  Student_info s;
  string::size_typemaxlen = 0;
 
  ifstream infile; 
  infile.open("100.txt"); //Elapsed:15 
  //infile.open("1000.txt"); //Elapsed:484 
  //infile.open("10000.txt"); //Elapsed:43297 
  if(!infile.is_open()){ 
      cout<<"can not open the file..."<<std::endl; 
      getch(); 
      exit(1); 
  } 
 
  while (read(infile, s)) {
    maxlen =max(maxlen, s.name.size());
    vs.push_back(s);
  }
 
  sort(vs.begin(),vs.end(), compare);
 
  clock_t start =clock();
 vector<Student_info> fails = extract_fails(vs);
  clock_t elapsed =clock() - start;
 
  cout << "Elapsed: " << elapsed <<endl;
 
  //  for (int i = 0; i< fails.size(); ++i)
  //    cout <<fails[i].name << " " << grade(fails[i]) << endl;
 
  getch();
  return 0;
}

 

2) list版本

#include <algorithm>
#include <list>
#include <iostream>
#include <string>
#include <fstream>
#include <ctime>
#include <conio.h>
 
#include "Student_info.h"
#include "grade.h"
using std::cin;
using std::cout;
using std::endl;
using std::sort;
using std::string;
using std::list;
using std::max;
using std::ifstream;
using std::ofstream;
 
list<Student_info>extract_fails(list<Student_info>& students) {
 list<Student_info> fail;
#ifdef _MSC_VER
  std::list<Student_info>::iteratoriter = students.begin();
#else
 vector<Student_info>::iterator iter = students.begin();
#endif
 
  while (iter != students.end()) {
    if (fgrade(*iter)) {
     fail.push_back(*iter);
      iter =students.erase(iter);
    } else
      ++iter;
  }
 
  return fail;
}
 
int main() {
 list<Student_info> vs;
  Student_info s;
  string::size_typemaxlen = 0;
 
  ifstream infile; 
  //infile.open("100.txt"); //Elapsed:16 
  //infile.open("1000.txt"); //Elapsed:31 
  infile.open("10000.txt"); //Elapsed:453
  if(!infile.is_open()){ 
      cout<<"can not open the file..."<<std::endl; 
      getch(); 
      exit(1); 
  } 
 
  while (read(infile, s)) {
    maxlen =max(maxlen, s.name.size());
    vs.push_back(s);
  }
 
  vs.sort(compare);
 
  clock_t start =clock();
 list<Student_info> fails = extract_fails(vs);
  clock_t elapsed =clock() - start;
 
  cout << "Elapsed: " << elapsed <<endl;
 
  //  for (int i = 0; i< fails.size(); ++i)
  //    cout <<fails[i].name << " " << grade(fails[i]) << endl;
 
  getch();
  return 0;
}

 

EX.5-3(5-4)

#include <algorithm>
#include <list>
#include <vector>
#include <iostream>
#include <string>
#include <ctime>
#include <conio.h>
#include "Student_info.h"
#include "grade.h"
 
using std::cin;
using std::cout;
using std::endl;
using std::sort;
using std::string;
using std::list;
using std::vector;
using std::max;
 
typedef list<Student_info> Student_infos;
//typedef vector<Student_info> Student_infos;
 
Student_infos extract_fails(Student_infos& students) {
  Student_infos fail;
#ifdef _MSC_VER
 Student_infos::iterator iter = students.begin();
#else
 Student_infos::iterator iter = students.begin();
#endif
 
  while (iter != students.end()) {
    if (fgrade(*iter)) {
     fail.push_back(*iter);
      iter = students.erase(iter);
    } else
      ++iter;
  }
 
  return fail;
}
 
int main() {
  Student_infos vs;
  Student_info s;
  string::size_typemaxlen = 0;
  while (read(cin, s)) {
    maxlen =max(maxlen, s.name.size());
    vs.push_back(s);
  }
 
  //vs.sort(compare);
 
  Student_infos fails =extract_fails(vs);
 
  for (Student_infos::const_iterator i = fails.begin();i != fails.end(); ++i)
    cout <<i->name << " " <<grade(*i) << endl;
 
  getch();
  return 0;
}

EX.5-5

#include <iostream>
#include <string>
#include <vector>
#include <conio.h>
 
using namespace std;
 
vector<string> center(constvector<string>& picture) {
  vector<string>new_picture;
 vector<string>::size_type max_length = 0;
 
  for (vector<string>::const_iterator i =picture.begin();
       i !=picture.end(); ++i)
    if (i->size() > max_length)
      max_length =i->size();
 
  for (vector<string>::const_iterator i =picture.begin();
       i !=picture.end(); ++i) {
   vector<string>::size_type padding = (max_length - i->size()) /2;
    stringnew_line(padding, ' ');
    new_line += *i;
   new_picture.push_back(new_line);
  }
 
  return new_picture;
}
 
int main() {
  vector<string>picture;
 
  picture.push_back("*");
  picture.push_back("***");
  picture.push_back("*****");
 
  vector<string>new_picture = center(picture);
 
  for (vector<string>::const_iterator i =new_picture.begin();
       i !=new_picture.end(); ++i)
    cout << *i<< endl;
 
  getch();
  return 0;
}
 

EX.5-6

#include <algorithm>
#include <vector>
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
#include <conio.h>
 
#include "Student_info.h"
#include "grade.h"
 
//driver program for grade partitioning examples
 
using std::cin;
using std::cout;
using std::endl;
using std::sort;
using std::string;
using std::vector;
using std::max;
using std::ifstream;
using std::ofstream;
 
vector<Student_info>extract_fails(vector<Student_info>& students) {
 vector<Student_info> fail;
#ifdef _MSC_VER
 std::vector<Student_info>::size_type i = 0;
#else
 vector<Student_info>::size_type i = 0;
#endif
 
  while (i != students.size()) {
    if (fgrade(students[i])) {
     fail.push_back(students[i]);
     students.insert(students.begin(), students[i]);
      ++i;
    }
    ++i;
  }
   
 students.resize(students.size() - fail.size());
 
  return fail;
}
 
int main() {
 vector<Student_info> vs;
  Student_info s;
  string::size_typemaxlen = 0;
 
 
  ifstream infile; 
  //infile.open("100.txt"); //Elapsed:16 
  infile.open("1000.txt"); //Elapsed:1125 
  //infile.open("10000.txt"); //Elapsed:108297
  if(!infile.is_open()){ 
      cout<<"can not open the file..."<<std::endl; 
      getch(); 
      exit(1); 
  } 
 
 
  while (read(infile, s)) {
    maxlen =max(maxlen, s.name.size());
    vs.push_back(s);
  }
 
  //  sort(vs.begin(),vs.end(), compare);
 
  clock_t start =clock();
 vector<Student_info> fails = extract_fails(vs);
  clock_t elapsed =clock() - start;
 
  cout << "Elapsed: " << elapsed <<endl;
  getch();
  return 0;
}

EX.5-7

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <conio.h>
 
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::string;
using std::max;
 
string::size_type width(constvector<string>& v)
{
   string::size_typemaxlen = 0;
   for (vector<string>::size_type i = 0; i !=v.size(); ++i)
      maxlen =max(maxlen, v[i].size());
   return maxlen;
}
 
vector<string> frame(constvector<string>& v)
{
   vector<string>ret;
   string::size_typemaxlen = width(v);
   string border(maxlen+ 4, '*');
 
   ret.push_back(border);
 
   for (vector<string>::size_type i = 0; i !=v.size(); ++i) {
      ret.push_back("* " + v[i] + string(maxlen -v[i].size(),' ') + "*");
   }
 
   ret.push_back(border);
   return ret;
}
 
int main()
{
   vector<string>v, ret;
   string s;
   string::size_typemaxlen;
 
   while (getline(cin, s)) {
      v.push_back(s);
   }
 
   ret = frame(v);
 
   for (vector<string>::const_iterator it =ret.begin(); it != ret.end(); ++it) {
      cout << *it<< endl;
   }
 
   getch();
   return 0;
}

EX.5-9

#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
bool has_uppercase(conststring& word) {
  for (string::size_type i = 0; i != word.size(); ++i)
    if (isupper(word[i]))
      return true;
 
  return false;
}
 
void print_string_vector(constvector<string>& v) {
  for (vector<string>::const_iterator i =v.begin(); i != v.end(); ++i)
    cout << *i<< endl;
}
 
int main() {
  string s;
  vector<string>no_uppercase;
  vector<string>uppercase;
 
  while (cin >> s)
    if (has_uppercase(s))
     uppercase.push_back(s);
    else
     no_uppercase.push_back(s);
 
  cout << "\nNo uppercase letters:" << endl;
 print_string_vector(no_uppercase);
 
  cout << "Has uppercase letters:" << endl;
 print_string_vector(uppercase);
 
  return 0;
}

EX.5-10

#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <conio.h>
 
using namespace std;
 
bool is_palindrome(conststring& word) {
  string reversed;
 reverse_copy(word.begin(), word.end(), back_inserter(reversed));
  return (word == reversed);
}
 
int main() {
  vector<string>palindromes;
  stringlongest_palindrome;
  string s;
 
  while (cin >> s)
    if (is_palindrome(s)) {
     palindromes.push_back(s);
 
      if (s.length() > longest_palindrome.length())
   longest_palindrome =s;
    }
 
  cout << "\nPalindromes:" << endl;
 
  for (vector<string>::const_iterator it =palindromes.begin();
       it !=palindromes.end(); ++it)
    cout << *it<< endl;
  cout << endl;
 
  cout << "Longest: " << longest_palindrome<< endl;
 
  getch();
  return 0;
}

EX.5-11

#include <iostream>
#include <string>
#include <vector>
#include <conio.h>
 
using namespace std;
 
const string ascenders = "bdfhklt";
const string descenders = "gjpqy";
 
bool has_chars(conststring& word,const string& chars) {
  for (string::size_type i = 0; i != word.length();i++)
    for (string::size_type j = 0; j != chars.length();j++)
      if (word[i] == chars[j])
   return true;
 
  return false;
}
 
int main() {
  vector<string>has_asc_or_dsc;
  stringlongest_word_without_asc_or_dsc;
  string s;
 
  while (cin >> s)
    if (has_chars(s, ascenders) || has_chars(s,descenders))
     has_asc_or_dsc.push_back(s);
    else if (s.length()> longest_word_without_asc_or_dsc.length())
      longest_word_without_asc_or_dsc= s;
 
  cout << "\nHas ascenders or descenders: "<< endl;
 
  for (vector<string>::const_iterator it =has_asc_or_dsc.begin();
       it !=has_asc_or_dsc.end(); ++it)
    cout << *it<< endl;
 
  cout << "Longest word without ascenders or descenders:"
       <<longest_word_without_asc_or_dsc << endl;
 
  getch();
  return 0;
}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值