Question

我有一个像

这样的字符串向量

a1 = ["arp", "live", "strong"]

a2 = ["lively", "alive", "harp", "sharp", "armstrong"]

我如何检查阿姆斯特朗是否是强大的子串。使用C ++

我会做两个for循环并检查字符串是否是a2中的子字符串，但我想要一种有效的方法。

std::vector<std::string> inArray(std::vector<std::string> &array1, std::vector<std::string> &array2)
{
    vector<string> result;
    for (string &s : array1)
    {
        for (string &d : array2)
        {

            if (s.find(d) != string::npos)
            {
                cout << d << endl;
            }
        }

    }

    return result;

}

int main() {

    vector<string> a = { "arp", "live", "strong" };
    vector<string> b = { "lively", "alive", "harp", "sharp", "armstrong" };

    vector<string> result = inArray(a, b);

}

给定两个字符串数组a1和a2以a1的字符串的字典顺序返回一个排序数组r，这些字符串是a2字符串的子串。

Example 1:

a1 = ["arp", "live", "strong"]

a2 = ["lively", "alive", "harp", "sharp", "armstrong"]

returns ["arp", "live", "strong"]

Answer 1

首先：使用变量和函数的名称，以便于识别目的

第二：矢量不会神奇地填充自己。

第三：您正在搜索子字符串中的完整字符串（请参阅第一个）

第四：如果您不打算修改它，请通过const引用传递值。

第五：根据你的预期答案，你不想要重复。我建议将std::set用于此目的，因为它不允许重复。

#include <vector>
#include <set>
#include <string>
#include <iostream>

using std::set;
using std::vector;
using std::string;
using std::cout;

set<string> getMatchingSubstrings(const vector<string> &subStrings, const vector<string> &fullStrings)
{   
    set<string> result;
    for (const string &fullString : fullStrings)
    {
        for (const string &subString : subStrings)
        {
            if (fullString.find(subString) != string::npos)
            {
                result.insert(subString);
            }
        }

    }
    return result;
}

int main() {

    vector<string> a = { "arp", "live", "strong" };
    vector<string> b = { "lively", "alive", "harp", "sharp", "armstrong" };
    set<string> result = getMatchingSubstrings(a, b);
}

稍微快一些的方法可能会从初始列表中删除已经找到的子字符串，因此您不必检查这两个子字符串。在这种情况下，结果不会被排序，因此如果您需要再次排序，这可能不是最佳选择。

#include <vector>
#include <string>
#include <iostream>

using std::vector;
using std::string;
using std::cout;

std::vector<std::string> getMatchingSubstrings(const std::vector<std::string> &subStrings, const std::vector<std::string> &fullStrings)
{   
    vector<string> unmatchedSubStrings = subStrings;
    vector<string> matchedSubStrings;
    for (const string &fullString : fullStrings)
    {
        if (unmatchedSubStrings.empty()) break;
        for (auto subStringIter = unmatchedSubStrings.begin(); subStringIter != unmatchedSubStrings.end();)
        {
            const string& subString = *subStringIter;
            if (fullString.find(subString) != string::npos)
            {
                matchedSubStrings.push_back(subString);
                subStringIter = unmatchedSubStrings.erase(subStringIter);
            }
            else
            {
                ++subStringIter;
            }
        }
    }

    return matchedSubStrings;
}

int main() {

    vector<string> a = { "arp", "live", "strong" };
    vector<string> b = { "lively", "alive", "harp", "sharp", "armstrong" };

    vector<string> result = getMatchingSubstrings(a, b);

}

检查字符串向量是否是其中一个元素中的子字符串

1 个答案: