überprüfen Sie, ob ein Vektor von Strings ein Teil in eines des Elemente ist

Question

ich einen Vektor von Strings habe wie

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

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

Wie würde ich prüfen, ob armstrong ein Teil starker in a1 ist. mit C++

Ich würde zwei for-Schleifen tun und prüfen, ob eine Zeichenfolge eine Teilzeichenfolge in a2 ist, aber ich möchte einen effizienten Ansatz.

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); 

} 

Gegeben seien zwei Arrays von Strings a1 und a2 ein sortiertes Array r in lexikographischen Reihenfolge der Zeichenketten von a1 zurück, die von Teilzeichenketten a2 sind.

Example 1: 

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

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

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

Answer 1

Erstens: Verwenden Sie Namen für die Variablen und Funktionen, die es leicht machen, den Zweck

Zweiter zu identifizieren: Ein Vektor füllen wird nicht auf magische Weise selbst.

Drittens: Sie sind zur Zeit für die vollen Strings innerhalb des Teils Suche (siehe zuerst)

Viertens: durch konstante Referenz des Wert übergeben, wenn Sie zum Ändern es nicht planen.

Fünftens: Nach Ihrer erwarteten Antwort wollen Sie keine Duplikate. Ich würde vorschlagen, std::set für diesen Zweck zu verwenden, da es keine Duplikate erlaubt.

#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); 
} 

Ein etwas schneller Ansatz könnte sein, entfernen Sie die bereits Teil aus der ersten Liste gefunden, so dass Sie nicht zweimal für diese haben zu überprüfen. In diesem Fall wird das Ergebnis nicht sortiert. Wenn Sie also erneut sortieren müssen, ist dies möglicherweise nicht die beste Wahl.

#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); 

}