C++ 如何根据一个特定字母的出现来确定两个字符串是否相等？
对于此项目，如果两个字符串的字符“X”的出现次数相同，并且字符“X”在每个字符串中的位置相同，则两个字符串相等。请注意，这允许使用不同长度的字符串，只要较长的字符串末尾的额外字符中没有任何“X”。我需要用函数原型实现这个equals函数C++ 如何根据一个特定字母的出现来确定两个字符串是否相等？,c++,c++14,C++,C++14,对于此项目，如果两个字符串的字符“X”的出现次数相同，并且字符“X”在每个字符串中的位置相同，则两个字符串相等。请注意，这允许使用不同长度的字符串，只要较长的字符串末尾的额外字符中没有任何“X”。我需要用函数原型实现这个equals函数 bool equalsChar（常量字符串和strA，常量字符串和strB，字符ch） 示例 equalsChar（“X”、“X”、“X”）为真 equalsChar（“aaaXaaaX”、“abcXcbaX”、“X”）为真 equalsChar（“XaXbX
bool equalsChar（常量字符串和strA，常量字符串和strB，字符ch）
为真equalsChar（“X”、“X”、“X”）
为真equalsChar（“aaaXaaaX”、“abcXcbaX”、“X”）
为真equalsChar（“XaXbXcX”、“XtXoXpXdef”、“X”）
为falseequalsChar（“XaXbXcX”、“XtXoXpXdXf”、“X”）
为falseequalsChar（“XXXX”，“XX”，“X”）equalsChar（“axbxcx”、“XtXoXpX”、“X”）为false
bool equalsChar(const string& strA, const string& strB, char ch){
int low1=0;
int low2=0;
int high1=strA.length()-1;
int high2=strB.length()-1;
return equalsChar(strA, low1, high1, strB, low2, high2, ch);
}
bool equalsChar(const string& strA, int low1, int high1, const string& strB, int low2, int high2, char ch){
int count1=0;
int count2=0;
for(int i=low1; i<=high1; i++){
if(strA[i]==ch)
count1++;
}
for(int j=low2; j<=high2; j++){
if(strB[j]==ch)
count2++;
}
if(count1==0 && count2==0)
return false;
else if(count1!=count2)
return false;
else{
for(int i=low1; i<=high1; i++){
if(strA[i]==ch){
for(int j=low2; j<=high2; j++){
if(strB[j]==ch){
if(i==j)
return true;
}
}
}
}
}
return false;
}
bool equalsChar（常量字符串和strA、int low1、int high1、常量字符串和strB、int low2、int high2、char ch）{
int count1=0；
int count2=0；
对于（inti=low1；i理想情况下，您必须
1. iterate through first string `str1` by i
2. if you encounter `str1[i] == ch`,and
3 if `i <= str2.length()`
4. check if `str2[i] == ch`.
5. if false then strings are not equal
6. else if `i > str2.length()` you would cut the iteration
7. else if `str2[i] == ch` then strings are not equal
8. continue to iterate through string str2 by i,
9. if `str2[i] == ch` strings are not equal
A. if end reached , strings are equal.
这样称呼：
bool equalsChar(const string& strA, const string& strB, char ch)
{
// maybe do checks if strings are empty to shortcut the function?
auto it1 = strA.begin(), it2 = strB.begin();
return equalsChar(it1, it2, ch, strA.end(), strB.end() );
}
并在调用自身时增加迭代器
第二个是
bool equalsChar(string::iterator& at,
const char& ch, const string::iterator& end);
从第一个的尾箱中调用
// assuming we checked that it2 not equal to end2 before
if(it1 == end1) return equalsChar(it2 , ch, end2 );
现在，cherry.By必需的行为，它可以是具有交换参数的相同函数
if(it1 == end1) return equalsChar(it2 , it1, ch, end2, end1 );
我们可以从一开始就这样做，通过检查哪个字符串更长，调用它，所以第一个字符串总是更长的
非理想版本，假设两个不包含X的字符串相等）
#包括
#包括
#包括
使用std:：string；
bool equalsChar（字符串：：常量迭代器&at1，
字符串：：常量迭代器&at2，
康斯特·查尔和切赫，
字符串：：常量迭代器&end1，
字符串：：常量（迭代器&end2）
{
如果（at2==end2）{
如果（at1==end1）
return true；//两个空字符串相等，对吗？
如果（*at1==ch）
返回false；
}
其他的
{
如果（*at1！=*at2）和（*at1==ch | |*at2==ch））返回false；
++at2；
}
++at1；
返回EqualChar（at1、at2、ch、end1、end2）；
}
bool equalsChar（常量字符串和strA、常量字符串和strB、字符ch）
{
//可能会检查字符串是否为空以缩短函数的快捷方式？
自动it1=strA.begin（），it2=strB.begin（）；
decltype（it1）end1=strA.end（），end2=strB.end（）；
if（strA.length（）// Does s contains given char?
bool hasChar(const char* s, char c)
{
if (*s == '\0') {
return false;
}
if (*s == c) {
return true;
}
return hasChar(s + 1, c);
}
bool equalsChar(const char* strA, const char* strB, char ch)
{
// one string is finished, check the other one.
if (*strA == '\0') {
return !hasChar(strB, ch);
} else if (*strB == '\0') {
return !hasChar(strA, ch);
}
// Are strings compare different?
if (*strA != *strB && (*strA == ch || *strB == ch)) {
return false;
}
// next index
return equalsChar(strA + 1, strB + 1, ch);
}
首先确保较长的字符串是strB
。如果需要，我们使用递归交换参数
然后测试公共长度。我们用==ch
将每个字母投影到bool，并比较那些bool
s
最后，我们测试ch
是否发生在strA.size（）
之后
或者使用C++17的string\u视图
和要整理的范围库
bool equalsChar(string_view strA, string_view strB, char ch) {
if (strA.size() > strB.size()) { return equalsChar(strB, strA, ch); }
auto common = [ch](char a, char b) { return (a == ch) == (b == ch); };
string_view prefix = strB.substr(0, strA.size());
string_view suffix = strB.substr(strA.size());
return ranges::equal(strA, prefix, common)
&& !ranges::contains(suffix, ch);
}
请展示你的努力。你在试图解决这个问题时遇到了什么问题？嘿@Fureeish，我已经根据到目前为止所取得的成果更新了我的代码，现在请看一看。既然要求你使用递归性，最简单的方法就是比较一个字符。如果相等，那么递归地调用它自己hlow1
和low2
增加1。开始使代码使用长度相等的字符串工作，然后当它工作时，改进它以处理第一个字符串短于第二个字符串。工作时，为比第一个字符串短的第二个字符串添加大小写（类似代码）你说你有两个问题。哪一个是你需要帮助的？你能重新设计你的问题的框架，把重点放在这个问题上吗？理想情况下，你应该能够足够抽象地设计问题的框架，这样就不必像这样更详细地描述你的作业了“奇怪的限制是家庭作业的一部分。”。您的解决方案过于复杂。您的任务是一个经过修改的strcmp
函数，可以递归编写（但效率很低），这将假定任何不是ch
的字符都是相等的。嗯，这看起来会有更高的复杂性。而且他们可能不允许通过'std:：find'@Swift FridayPie做快捷方式。怎么会呢？它访问每个char
，如果足够的话，我就丢失在括号中了。但是关于使用的说明仍然存在。这让我们来展示一下算法应该如何工作，所以它很好，并且通过了测试“我们使用递归来交换参数”，这并不是我所说的递归函数。即使我不明白为什么要对这样的函数使用递归解。
// Does s contains given char?
bool hasChar(const char* s, char c)
{
if (*s == '\0') {
return false;
}
if (*s == c) {
return true;
}
return hasChar(s + 1, c);
}
bool equalsChar(const char* strA, const char* strB, char ch)
{
// one string is finished, check the other one.
if (*strA == '\0') {
return !hasChar(strB, ch);
} else if (*strB == '\0') {
return !hasChar(strA, ch);
}
// Are strings compare different?
if (*strA != *strB && (*strA == ch || *strB == ch)) {
return false;
}
// next index
return equalsChar(strA + 1, strB + 1, ch);
}
bool equalsChar(const string& strA, const string& strB, char ch) {
if (strA.size() > strB.size()) { return equalsChar(strB, strA, ch); }
auto common = [ch](char a, char b) { return (a == ch) == (b == ch); };
return std::equal(strA.begin(), strA.end(), strB.begin(), common)
&& (std::find(strB.begin() + strA.size(), strB.end(), ch) == strB.end());
}
bool equalsChar(string_view strA, string_view strB, char ch) {
if (strA.size() > strB.size()) { return equalsChar(strB, strA, ch); }
auto common = [ch](char a, char b) { return (a == ch) == (b == ch); };
string_view prefix = strB.substr(0, strA.size());
string_view suffix = strB.substr(strA.size());
return ranges::equal(strA, prefix, common)
&& !ranges::contains(suffix, ch);
}