HJ2 计算某字符出现次数

---

1 题目

题源链接

描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）

---

2 解法

---

2.1 count_if 本题代码

#include <algorithm>
#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s;
    getline(cin, s);
    char c = tolower(getchar());
    cout << count_if(s.begin(), s.end(), [c](char i) { return towlower(i) == c; }) << endl;
}

[c](char i) { return towlower(i) == c; }
是C++中的Lambda表达式：（也称为lambda函数）是在调用或作为函数参数传递的位置处定义匿名函数对象的便捷方法。通常，lambda用于封装传递给算法或异步方法的几行代码 。
Lambda表达式详解

---

2.1.1 C++ STL非更易型算法–count_if介绍

定义于头文件 < algorithm >

算法库提供大量用途的函数（例如查找、排序、计数、操作），它们在元素范围上操作。注意范围定义为 [first, last) ，其中 last 指代要查询或修改的最后元素的后一个元素。(即前闭后开）

count_if 返回区间中满足指定条件的元素数目。
函数是自定义的，返回值是true就是表示符合要求。

template<class InputIterator, class Predicate>

   typename iterator_traits<InputIterator>::difference_type count_if(

      InputIterator _First,

      InputIterator _Last,

      Predicate _Pred

   );

_First 输入迭代器，指向将被搜索的区间第一个元素的位置。

_Last 输入迭代器，指向将被搜索的区间最后一个元素后面的。

_Pred ，用户自定义的 predicate function object ，定义了元素被计数需满足的条件。 predicate 只带一个参数，返回 true 或 false.

简单来说：
count_if (first,last,value,comp);
first为首迭代器，last为末迭代器，value为要查询的元素，comp为比较函数。

示例代码：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool IsOdd(int i) {
    return ((i % 2) == 1); 
}
int main() { // 找出[v.begin(), v.end())范围内奇数的个数
    int cnt;
    vector<int> v;
    for (int i = 1; i < 10; i++)
        v.push_back(i); // v: 1 2 3 4 5 6 7 8 9
    cnt = (int) count_if(v.begin(), v.end(), IsOdd);
    cout << "v contains " << cnt << " odd values.\n"; // v contains 5 odd values.
    return 0;
}

---

2.1.2 C++中cin(),cin.get(),cin.getline(),getline()总结：

• cin的读取字符规则：
  cin遇到回车、空格、tab键 结束，但是缓冲区还存在这三个字符，并没有将这三个字符丢弃，且指针光标在这三个字符之前，也就是说，下一次通过其他输入函数读取时，是可以读到这三个字符的。

• cin.get 的读取字符规则：

  1. cin.get(字符变量名) 可以用来接收字符:

char  ch;
ch = cin.get();
//cin.get(ch);

2. cin.get(字符数组名,接收字符数目) 用来接收一行字符串，可以接收空格

//输入abcdfg
//输出abcd
char ch[10];
cin.get (ch, 5);
cout << ch << endl;//只接收4个字符，第5个的内容是'\0'

3. cin.get(无参数): 没有参数主要是用于舍弃输入流中的不需要的字符,或者舍弃回车。

	string a;
	cin>>a;
	cout<<a<<endl;
	/*此时的第一个cin.get()获取的是cin中最后的'\n'，也就是消除缓冲区的'\n'第二个的作用在于在程序结束时输入一个字符，
让程序停留在运行界面*/
	cin.get();
	cin.get();
	system("pause");

• cin.getline() : 接受一个字符串，可以接收空格并输出。 cin.getline()实际上有三个参数,当第三个参数省略时，系统默认为’\0’

#include <iostream>
using namespace std;
int main() 
{  
	char ch[5];
	cin.getline(ch, 5);
	//cin.getline(ch, 5,'s'); 
	//输入：asd
	//输出：a
	cout << ch << endl;
	system("pause");
	return 0;
}

• getline() : 接受一个字符串，可以接收空格并输出，需包含 #include< string > ，丢弃换行符

	string s;
	getline(cin, s);
	cout << s << endl;
	//输入：I Love You
	//输出：I Love You

• gets() : 接受一个字符串，可以接收空格并输出，需包含“#include< string >”

	string s;
	getline(cin, s);
	cout << s << endl;
	//输入：I Love You
	//输出：I Love You

• cin.getline()、cin.get()的区别：
  cin.getline()与cin.get()都能接收输入的带有空格的字符串直到遇到换行符停止接收。
  但是二者稍有区别：
  cin.getline() 丢弃换行符，而cin.get() 将其保留在输入队列中。

---

2.2 一般做法

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s;
    getline(cin, s);

    char c = tolower(getchar());

    int n = 0;
    for (char i : s) {
        if (tolower(i) == c) {
            ++n;
        }
    }
    cout << n << endl;
}

---

3 【扩展】C++ STL–非更易型算法

adjacent_find：
是 STL 算法组件中的算法，adjacent_find 的默认作用：搜查相邻重复的元素。

函数原型：

• adjacent_find(iterator beg, iterator end);
  // 用于查找范围内相等的相邻元素，并返回到这两个元素中第一个的迭代器，如果没有找到这样的对，则返回last的值
  // beg 开始迭代器
  // end 结束迭代器

实例：

#include <iostream>
#include <vector>
#include <algorithm>//algorithm头文件是必不可少的 

using namespace std;
int main() {
    //初始化一个vector类型的容器作为查找的对象 
    vector<int> vec;
    vec.push_back(5);
    vec.push_back(2);
    vec.push_back(2);
    vec.push_back(0);
    vec.push_back(0);
    //vec = {5, 2, 2, 0, 0} 

    //定义一个迭代器first（名称不固定，此处便于理解所以命名为first） 
    vector<int>::iterator first;
    //再定义一个迭代器last 
    vector<int>::iterator last;
    //两个迭代器分别对应查找区间的第一个位置和最后一个位置 

    vector<int>::iterator result;
    //定义一个迭代器result存储adjacent_find函数返回的结果 

    first = vec.begin();
    last = vec.end();
    //将first对应到容器的开头元素，将last对应到元素的末尾位置

    result = adjacent_find(first, last);
    //用result存储对整个容器搜索的结果
    //此条语句等价于：
    result = adjacent_find(vec.begin(), vec.end());

    cout << "对整个容器进行搜索的结果为：";

    if (result == last) { //如果搜索函数的返回值为搜索区间的末尾迭代器，即last，表明在搜索区间内不存在相等的相邻元素 
        cout << "Not find." << endl;
    } else { //否则表示存在 相等的相邻元素 
        cout << *result << endl;
        //输出result所对应的元素值，即相等的相邻元素中前一个元素的值 
        //因为vec = {5, 2, 2, 0, 0} 
        //所以最终的输出是2 （不是0，输出第一对相等的相邻元素） 
    }
    return 0;
}

count：返回目标元素在指定序列中出现了多少次

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main () {
    int mycount;
    // counting elements in array:
    int myints[] = {10,20,30,30,20,10,10,20};   // 8 elements
    mycount = (int) count (myints, myints+8, 10);
    cout << "10 appears " << mycount << " times.\n";
    // counting elements in container:
    vector<int> myvector (myints, myints+8);
    mycount = (int) count (myvector.begin(), myvector.end(), 20);
    cout << "20 appears " << mycount  << " times.\n";
    return 0;
    /* 【打印结果】
        10 appears 3 times.  // 数字10出现了3次
        20 appears 3 times.  // 数字20出现了3次
     */
}

---

By–Suki 2023/1/9