c++primer（第五版） 第十章 泛型算法习题答案

最新推荐文章于 2022-05-09 16:31:52 发布
最新推荐文章于 2022-05-09 16:31:52 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： c/c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axuan_k/article/details/50805240
版权

第五版第九章以后的参考答案在网上很难找,于是就决定自己认真写一份,当做练习吧.

部分答案参考了github上大牛的代码.



10.1,    10.2

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <list>
using namespace std;
int main()
{
    vector<int>v{1,2,3,4,5,6,7,8,9};
    cout<<count(v.cbegin(), v.cend(),6)<<endl;


    list<string>l{"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    cout<< count(l.cbegin(), l.cend(),"the")<<endl;
    return 0;
}



10.3  10.4  10.5

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
int main()
{
    vector<int>v {1,2,3,4,5,6,7,8,9};
    cout<< accumulate(v.cbegin(), v.cend(),0)<<endl;


    vector<double>v_d {1.1,2.2,3,14,5.1};
    cout<< accumulate(v_d.cbegin(), v_d.cend(),0)<< endl;     //错误  初始累加和值为0（整型）  累加过程中会被强制转换为整型
    cout<< accumulate(v_d.cbegin(), v_d.cend(),0.0)<< endl;
    return 0;


//    10.5
//    结果为false
//    c风格字符串equal要满足是同一块内存中的那一条字符串
}






10.6 10.7 10.8

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int> vec {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    fill_n(vec.begin(), vec.size(), 0);
    for (auto i : vec)
        cout << i << " ";
    cout << endl;

//    10.7
//    (a)
//    copy的第三个参数应该是一个插入迭代器
//    (b)
//    reserve是分配内存空间 并没有分配元素 应该使用resize


//    10.8
//    并不是标准库算法改变了容器大小 而是迭代器调用容器操作改变了容器大小
}




10.9  10.10

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

void elimDups(vector<string>& vec){
    for(auto i:vec)
        cout<<i<<" ";
    cout<<endl;
    sort(vec.begin(),vec.end());
    for(auto i:vec)
        cout<<i<<" ";
    cout<<endl;
    vector<string>::iterator it=unique(vec.begin(),vec.end());
    for(auto i:vec)
        cout<<i<<" ";
    cout<<endl;
    vec.erase(it,vec.end());
    for(auto i:vec)
        cout<<i<<" ";
    cout<<endl;
}

int main(){
    vector<string>vec{"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    elimDups(vec);
    return 0;
}




//    10.10
//    @pezy: Cause the library algorithms operate on iterators, not containers. Thus, an algorithm cannot (directly) add or remove elements.
//    标准库算法都是针对迭代器的操作,而不是容器,因此,它不能直接添加或删除元素.



10.11     10.13 

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

bool isShorter(const string&s1,const string& s2){
    return s1.size()<s2.size();
}

bool part(const string& str1){
    return str1.size()>=5?true:false;
}

void elimDups(vector<string>& vec){
    sort(vec.begin(),vec.end());

    vector<string>::iterator it=unique(vec.begin(),vec.end());

    vec.erase(it,vec.end());

}

int main(){
//    10.11
    vector<string>vec{"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    elimDups(vec);
    stable_sort(vec.begin(),vec.end(),isShorter);
    for(auto i:vec)
        cout<<i<<" ";
    cout<<endl;


//    10.13
    vector<string>vec2{"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    partition(vec2.begin(),vec2.end(),part);
    for(auto i:vec2)
        cout<<i<<" ";
    cout<<endl;
    return 0;
}



10.14  10.15   10.17  10.18

#include<iostream>
#include<vector>
#include<algorithm>
#include"Sales_data.h"
using namespace std;

void elimdups(vector<string>& vs)
{
    sort(vs.begin(), vs.end());
    auto new_end = unique(vs.begin(), vs.end());
    vs.erase(new_end, vs.end());
}

void biggies_partition(vector<string>& vs, int sz)
{
    elimdups(vs);

    auto pivot = partition(vs.begin(), vs.end(), [sz](const string& s) {return s.size() >= sz;});

    for (auto it = vs.cbegin(); it != pivot; ++it) cout << *it << " ";
}


void biggies_stable_partition(vector<string>& vs, int sz)
{
    elimdups(vs);

    auto pivot =stable_partition(vs.begin(), vs.end(),[sz](const string& s) { return s.size() >= sz; });

    for (auto it = vs.cbegin(); it != pivot; ++it) cout << *it << " ";
}

int main(){
//    10.14
    auto func=[](int a,int b)->int{return a+b;};


//    10.15
    int a=5;
    auto func2=[a](int b)->int{return a+b;};



//  10.17
    Sales_data d1("aa"), d2("aaaa"), d3("aaa"), d4("z"), d5("aaaaz");
    vector<Sales_data> v{d1, d2, d3, d4, d5};
    sort(v.begin(), v.end(),[](const Sales_data& sd1, const Sales_data& sd2)
         {return sd1.isbn().size() < sd2.isbn().size();});
    for (const auto& element : v) cout << element.isbn() << " ";
    cout << endl;


//    10.18
    vector<string>vec{"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    biggies_partition(vec,5);
    for(auto i:vec)
        cout<<i<<" ";
    cout<<endl;



//    10.19
    vector<string>vec2{"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    biggies_stable_partition(vec2,5);
    for(auto i:vec2)
        cout<<i<<" ";
    cout<<endl;
    return 0;
}




10.20   10.21

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
//    10.20
    vector<string>vec{"the","quick","red","fox","jumps","over","the","slow","red","turtle","ssssssss","ssssssaas"};
    cout<<count_if(vec.cbegin(),vec.cend(),[](const string& str1){return str1.size()>6;})<<endl;

//    10.21
    int s=6;
    int d=3;
    auto f1=[&]()->int{
        if(d<1)
            return 0;
        else
        return --d;};
    while(s--)
        std::cout<<f1()<<" ";
    return 0;
}



10.22   10.23   10.24   10.25

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
using namespace std::placeholders;
bool check_size2(const string& str1,int sz){
    return str1.size()<=sz;
}

void elimdups(std::vector<std::string>& vs)
{
    std::sort(vs.begin(), vs.end());
    auto new_end = std::unique(vs.begin(), vs.end());
    vs.erase(new_end, vs.end());
}

bool check_size(const std::string& str,size_t sz){
    return str.size()>=sz;
}

void biggies(std::vector<std::string>& vs, std::size_t sz)
{
    using std::string;
    elimdups(vs);
    auto wc = std::stable_partition(vs.begin(), vs.end(),bind(check_size,_1,sz));
    std::for_each(vs.begin(),wc, [](const string& s) { std::cout << s << " "; });
}

int main(){
//    10.22
    vector<string>vec{"the","quick","red","fox","aaaaaaa","jumps","over","bbbbbbbb","the","slow","red","turtle"};
    auto it=partition(vec.begin(),vec.end(),bind(check_size2,_1,6));
    for(auto i=vec.begin();i!=it;i++)
        cout<<*i<<" ";
    cout<<endl;


//    10.23
//    原函数有n个参数 则bind后有n+1个参数 第n+1个参数为原函数名


//    10.24
    vector<int>vec2{1,2,3,4,5,6,7,8,9,10};
    string str="sssss";
    auto it2=partition(vec2.begin(),vec2.end(),bind(check_size,str,_1));
    cout<<*it2<<endl;


//    10.25
    std::vector<std::string> v{"1234", "1234", "1234", "hi~",
                               "alan", "alan", "cp"};
    biggies(v, 3);
    cout <<endl;
    return 0;

}



10.27  10.28

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>
using namespace std;
int main()
{
    vector<int>v{1,2,3,4,5,6,7,8,9};


//    10.27
    list<int>lst;
    unique_copy(v.begin(),v.end(),front_inserter(lst));
    for(auto i:lst)
        cout<<i<<" ";
    cout<<endl;

//    10.28
    list<int>v2(20),v3(20),v4(20);
    copy(v.begin(),v.end(),front_inserter(v2));
    copy(v.begin(),v.end(),back_inserter(v3));
    copy(v.begin(),v.end(),inserter(v4,v4.begin()));
    for(auto i:v2)
        cout<<i<<" ";
    cout<<endl;
    for(auto i:v3)
        cout<<i<<" ";
    cout<<endl;
    for(auto i:v4)
        cout<<i<<" ";
    cout<<endl;
    return 0;
}



10.29   10.30   10.31    10.32    10.33

#include<iostream>
#include<cstring>
#include<iterator>
#include<vector>
#include<algorithm>
#include<fstream>
#include"Sales_item"
using namespace std;

void func(ifstream& in,const string& odd,const string& even)
{
    ofstream f1(odd),f2(even);
    ostream_iterator<int>os1(f1," "),os2(f2," ");
    int temp;
    while(in>>temp){
        if(temp%2)
            *os1++=temp;
        else
            *os2++=temp;
    }
}

int main()
{

//    10.29
    ifstream in("in.txt");
    istream_iterator<string>start(in),eof;
    vector<string>vec;
    while(start!=eof)
        cout<<*start++<<" ";


//    10.30
    vector<int>vec2;
    istream_iterator<int>start2(cin),eof2;
    copy(start2,eof2,back_inserter(vec));
    sort(vec2.begin(),vec2.end());
    copy(vec2.cbegin(),vec2.cend(),ostream_iterator<int>(cout," "));


//    10.31
    vector<int>vec3;
    istream_iterator<int>start3(cin),eof3;
    unique_copy(start3,eof3,back_inserter(vec2));
    sort(vec3.begin(),vec3.end());
    copy(vec3.cbegin(),vec3.cend(),ostream_iterator<int>(cout," "));


//    10.32
    istream_iterator<Sales_item> in_iter(cin), in_eof;
    vector<Sales_item> vec4;

    while (in_iter != in_eof) vec.push_back(*in_iter++);
    sort(vec4.begin(), vec4.end(),
         [](Sales_item const& lhs, Sales_item const& rhs) {
             return lhs.isbn() < rhs.isbn();
         });
    for (auto beg = vec4.cbegin(), end = beg; beg != vec4.cend(); beg = end) {
        end = find_if(beg, vec4.cend(), [beg](const Sales_item& item) {
            return item.isbn() != beg->isbn();
        });
        cout << accumulate(beg, end, Sales_item(beg->isbn()))<< endl;
    }


//    10.33
    ifstream is("in2.txt");
    func(is,"f1.txt","f2.txt");
    return 0;
}



10.34   10.35  10.36  10.37

#include <iostream>
#include <string>
#include <list>
#include <algorithm>
using namespace std;

int main()
{
//  10.34
    list<int> v{1,2,3,0,4,5,6,7,8,9};                       
    for(auto i=v.crbegin();i!=v.crend();i++)
        cout<<*i<<" ";
    cout<<endl;


//    10.35
    auto i=--v.end();                                      
    while(i!=v.begin())
        cout<<*i--<<" ";
    cout<<*i<<endl;


//    10.36
    auto ans=find(v.crbegin(),v.crend(),0);                 
    auto loc=ans.base();
    cout<<*loc<<endl;


//    10.37
    vector<int>v2{1,2,3,4,5,6,7,8,9};                       
    list<int>l;
    copy(v2.crbegin()+2,v2.crbegin()+7,back_inserter(l));
    for(auto i:l)
        cout<<i<<" ";
    return 0;
}



10.39  10.40

#include <iostream>
#include <string>
#include <list>
#include <algorithm>
using namespace std;

int main()
{
//    10.39
//    list: 双向迭代器
//    vector: 随机访问迭代器


//    10.40
//    copy: 第一,二个参数为输入迭代器  第三个为输出迭代器
//    reverse:双向访问迭代器
//    unique:前向迭代器
    return 0;
}



10.41

#include <iostream>
#include <string>
#include <list>
#include <algorithm>
using namespace std;
int main()
{
//    10.41
    replace(beg, end, old_val, new_val); // 在迭代器beg 和end 范围内 将old_val 替换成  new_val
    replace_if(beg, end, pred, new_val); // 在迭代器beg 和end 范围内 将满足条件的pred的值替换成  new_val
    replace_copy(beg, end, dest, old_val, new_val); // 将迭代器beg 和end 范围内的值拷贝到dest指向的容器中 并且在新容器中old_val 替换成了 new_val
    replace_copy_if(beg, end, dest, pred, new_val); // 将迭代器beg 和end 范围内的值拷贝到dest指向的容器中 并且在新容器中满足条件的pred的值 替换成了 new_val
    return 0;
}




10.42 

#include<iostream>
#include<algorithm>
#include<list>
#include<string>
using namespace std;
int main()
{
    list<string>lst{"aaa","bbb","ccc","aaa","bb","bbbb","cc","ccc"};
    lst.sort();
    lst.unique();
    for(auto i:lst)
        cout<<i<<" ";
    cout<<endl;
    return 0;
}



Kuro同学
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++ Primer(第五版)|练习题答案与解析(第十章:泛型算法)
01-06
C++ Primer(第五版)|练习题答案与解析(第十章:泛型算法) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++ Primer C++ Primer 练习题10.1 头文件algorithm中定义了一个名为count的函数，它类似find...
C++Primer(第5版） 习题10.9、10.11
Teng_NaoDan的博客
06-07 159
10.9实现elimDups函数，作用为排序并删除重复元素； 10.11对elimpDups进一步处理，作用为首先按元素大小排序，且等长度的元素会保持字典顺序；
C++ lambda 表达式
storm
09-24 732
在看c++ Primer 关于泛型编程的章节中，看到了lambda和bindlia
《C++ Primer》学习笔记（十）：泛型算法
南方以北
05-17 398
《C++ Primer》学习笔记（十）：泛型算法初识泛型算法只读算法写容器元素的算法重排容器元素的算法定制操作向算法传递函数lambda表达式 泛型算法是一组公共接口，可以用于不同类型的元素和多种容器类型。 泛型算法本身不会执行容器的操作，只会运行于特定迭代器上，执行迭代器的操作，即不会改变底层容器的大小。但是标准库定义了一类特殊的迭代器：插入器（inserter)。与普通迭代器只能遍历所绑定的容器相比，插入器能做更多的事情。当给这类迭代器赋值时，它们会在底层的容器上执行插入操作。因此当一个算法操作这样的迭
C++ Primer 5th 第10章 泛型算法
weixin_30323961的博客
08-17 136
练习10.1：头文件algorithm中定义了一个名为count的函数，它类似find，接受一对迭代器和一个值作为参数。count返回给定值在序列中出现的次数。编写程序，读取int序列存入vector中，打印有多少个元素的值等于给定值。 #include <iostream> #include <algorithm> #include <vector>...
C++ 泛型算法（一）初识泛型算法，lambda表达式
强者之路
04-14 674
文章目录概述算法工作原理泛型算法只读算法写容器算法重排容器元素算法指定操作及算法传参lambda表达式谓词lambda介绍lambda传参捕获列表用lambda改写算法lambda捕获和返回值捕获引用捕获隐式捕获显式捕获可变lambda指定lambda返回类型 概述 对于顺序容器的操作，我们前面介绍了添加，删除，大小操作，但是我们还有比如查找，排序等操作，这些操作是基于算法的，C++给我们提供了...
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
10-11
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
C++ Primer习题集(第五版)
12-08
C++ Primer习题集(第五版) , 带目录完整版。 --------------------------------------------------------------------------- 目录 第1章............................................................ 1 练习1.1 ...
C++ Primer第四版【中文高清扫描版】.pdf
03-13
第11章　泛型算法 335 11.1 概述 336 11.2 初窥算法 339 11.2.1 只读算法 339 11.2.2 写容器元素的算法 341 11.2.3 对容器元素重新排序的算法 343 11.3 再谈迭代器 347 11.3.1 插入迭代器 348 11.3.2 iostream迭代器...
java坑爹的笔试题-cpp-primer-5th:C++Primer第五版学习资料
06-13
C++Primer第五版——习题答案+详解(完整版) 作者学习心得 2017年3月23日更新：历时三个月，粗略的算是看完了这本书，简单的进行总结一下： 本书的Part I（C++基础）是C++基础，必须进行通读掌握。这几章有非常多的小...
C ++ Primer（第五版）第五章练习答案.zip
09-07
自己做的第五章的练习答案，一共14个编程题，有问题可以到博客下来讨论-。- https://blog.csdn.net/weixin_43655901/article/details/108363244
c++primer第五版习题答案（第10章）
11-12
c++primer第五版中文版课后答案（第10章）pdf格式，真正的c++primer习题集（第五版），用手机拍的，但是每个字都能看的很清楚
C++ Primer 第五版 课后习题答案（高清无水印PDF）
08-14
C++ Primer 第五版（中文版） 第1~11章课后习题答案（附上代码）
C++Primer 第五版 —— 《第十章 》泛型算法
TAOTAO
01-03 468
目录 目录 Preface 概述（ find 算法） find 算法是如何工作的 只读算法(find、count、accumulate 338P） 使用accumulate 算法将 vector中的 string 元素连接起来 用equal 操作两个序列（339P） 使用 fill 和 fill_n 算法向容器写入元素（340P） 介绍 back_inserter 插入迭代器...
C++Primer第五版 第十章习题答案（1~10）
whjstudy1的博客
10-22 840
1：这个比较简单，类比下 find() 函数也就知道了。 #include&lt;iostream&gt; #include&lt;algorithm&gt; #include&lt;vector&gt; using namespace std; void main() { int number = 0; int arr[] = { 0, 0, 1, 2, 3, 4, 5, 6, 7, 8...
C++ primer(第五版）第10章习题答案
INFINITE POSSIBILITIES
03-27 464
第十章　泛型算法 10.1 10.2 #include <iostream> #include <string> #include <vector> #include <algorithm> #include <list> int main() { //! 10.1 std::vector<int> v...
删除vector中的重复项
weixin_39445116的博客
05-09 835
#include<iostream> #include<vector> #include<string> #include<algorithm> void elimDups(std::vector<std::string>& words) { std::sort(words.begin(), words.end()); auto end_uniques = std::unique(words.begin(), words.end()).
c++ primer第五版（中文）习题答案 第十章第二节第一小节-只读算法
xhxwd的博客
09-18 578
本博客知识记录自己学习中的笔记或者记录，如果有错误欢迎大家纠正。本节初步了解泛型算法。算法不能改变容器大小，切记10.3用accumlate求一个vector中元素的之和代码如下#include <vector> #include <iostream> #include <numeric> #include "stdlib.h" int main3() { std::vector<int>
C++lambda表达式
GUI1259802368的博客
07-02 632
在介绍lambda表达式之前，先来看一下什么是谓词。下面是一个例子 void elimDups(vector&lt;string&gt; &amp;words) { sort(words.begin(),words.end()); //按字典序排序words,以便查找重复单词 //排列在范围的前部，返回指向不重复区域之后一个位置的迭代器 a...
c++ primer 第五版答案
最新发布
08-03
c primer第五版的答案，即书中的示例代码和习题答案，是帮助读者巩固所学知识、深入理解C语言的重要工具。通过阅读书中的答案，读者可以学习到正确的编程思路、解决问题的方法，从而提高自己的编程能力。 c primer...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值