Count distinct pairs of strings that contain at least one common character at the same position - c++

Question

Is there a more efficient way to count distinct pairs of strings in an array that have at least one common character at the same position. The strings will always have the same length of 3. For example,
"abc", acb": counts
"bun", "fun": counts
"xyz", "yzx": doesn't count
"one", "two": doesn't count
I've tried writing a function that checks if they match and then count them using for loops, but it doesn't seem to be so efficient, especially when the array is huge.
bool match(std::string a, std::string b) {
for (int i = 0; i < 3; i++) {
if (a.at(i) == b.at(i)) {
return true;
}
}
return false;
}
int main() {
const int count = 100000;
std::string strings[count] = {...};
long long int matches = 0;
for (int i = 0; i < count; i++) {
for (int j = i + 1; j < count; j++) {
if (match(strings[i], strings[j])) {
matches++;
}
}
}
}
So, is there a more efficient way to achieve this?

Answer 1

Heres the list (assuming the strings has 3 chars):
is actual the only one that might not be already done by your compiler: pass the std::string by const&, so that you don't need to copy them every time you call the function
bool match(const std::string& a, const std::string& b){...}
avoid useless branches in your code (can be optimized already by some branch prediction algorithm):
// from
if (match(strings[i], strings[j])) {
matches++;
}
// to
matches = matches + match(strings[i], strings[j];
loop unrolling (which can been done already by your compiler):
bool match(std::string a, std::string b) {
return a.at(0) == b.at(0) || a.at(1) == b.at(1) || a.at(2) == b.at(2);
}
You can also try to parallelize those conditions (depends on architecture, can be done already by the compiler) using | and so all the conditions can be done in parallel by ALU, instead using | must be performed step by step (short circuit evaluation):
bool match(std::string a, std::string b) {
return a.at(0) == b.at(0) | a.at(1) == b.at(1) | a.at(2) == b.at(2);
}
Compile using the highest optimization (can increase the compilation time), using -O3
use pre-increment instead of post-increment (post increment will generate a second variable to return every time you use it, pre-increment no):
for (int i = 0; i < count; ++i) {
for (int j = i + 1; j < count; ++j) {
}
}
by this line std::string strings[count] = {...}; I suppose you are using initializarer list, and so the computation can actually be performed at compile time if you use std::string_view and so at runtime there is no compilation to perform (this works only if the strings are known at compile time)
decrease cache misses, but this depends 100% on architecture
inline the function (so that your program don't have to do a jump every time to call match):
// from:
bool match(const std::string& a, const std::string& b){...}
//to:
inline bool match(const std::string& a, const std::string& b){...}
use operator[] instead of .at() because it does not make any kind of bounds checking
bool match(std::string a, std::string b) {
return a[0] == b[0] | a[1] == b[1] | a[2] == b[2];
}