Is There an Efficient Method of Checking Which Letter is Being Used?

Question

Let's say I have a string string str;, and it has any number of letters in it, and I want to count how many of each letter is in the string. For example, the word "Example" has 2 'e', 1 'x', 1 'a', 1 'm', 1 'p', and 1 'l'. Is there a more efficient way of checking for each of these letters than this?

for (int i = 0; i < str.length(); i++)
{
    if (str.at(i) == 'a')
    {
        //variable which keeps track of a ++
    }...
    //25 more of that for each other letter
}

It feels like there has to be a more efficient way of doing this, but I have no idea how. Please enlighten me.

Use array the size of the ascii table and then you can easily count every character. array[character]++ — Wahalez, Jul 30 '21 at 14:01
Or rather `array[(unsigned char)character]`, since `char`s may or may not be signed. — HolyBlackCat, Jul 30 '21 at 14:02
On a side note: using `at()` is overkill in this example, since the `for` loop ensures that it won't go out of bounds of the string, so no need to bounds check each character. Use `str[i]` instead of `str.at(i)` — Remy Lebeau, Jul 30 '21 at 16:22
@Wahalez -- close, but use the number of possible values that `char` can hold, i.e., `1u << CHAR_BIT`. The character encoding doesn't matter during counting. — Pete Becker, Jul 30 '21 at 18:19

Matthias Grün · Answer 1 · 2021-07-30T14:26:34.657

4

You could use a std::map for example:

#include <map>

std::map<char, std::size_t> mCount{};
for (auto ch : str)
{
   ++mCount[ch];
}

Using a std::array (which has the advantage of the data being contiguous in memory, thereby improving cache performance) you can write:

#include <array>
#include <limits>

constexpr auto nNumChars = static_cast<std::size_t>(std::numeric_limits<unsigned char>::max()) + 1;
std::array<std::size_t, nNumChars> arCounts{};

for (auto ch : str) {
   ++arCounts[static_cast<unsigned char>(ch)];
}

edited Jul 30 '21 at 14:26

answered Jul 30 '21 at 14:01

Matthias Grün

1,466
1
7
12

2

You might want to increase array size to `256`. – HolyBlackCat Jul 30 '21 at 14:04
2

Only if `char` are unsigned. Otherwise, there's UB on negative chars – Jeffrey Jul 30 '21 at 14:05
1

You're all correct, of course. Typed it up in a hurry between other things. Adapted accordingly and removed array example. – Matthias Grün Jul 30 '21 at 14:10
@Jeffrey That's why you should cast to `unsigned char` first. – HolyBlackCat Jul 30 '21 at 14:11
2

An array of 256, with `ch` cast to some `unsigned` would have made your array answer excellent. – Drew Dormann Jul 30 '21 at 14:11
@DrewDormann I still think 256 is a bit risky on a system with 64 bit bytes. – Ted Lyngmo Jul 30 '21 at 14:21
2

For portability's sake, I believe the array size need to be `(2 << CHAR_BIT) - 1`. This will cover cases where you have a larger than 8 bit `char`. – NathanOliver Jul 30 '21 at 14:23
2

@NathanOliver Even that will be problematic if `CHAR_BIT` is 64 :-) (btw, you mean `1 << CHAR_BIT` right)? – Ted Lyngmo Jul 30 '21 at 14:24
1

@TedLyngmo Plus a `static_assert` to check for potential overflow ;) – NathanOliver Jul 30 '21 at 14:26

rturrado · Answer 2 · 2021-07-30T14:43:30.623

1

I especially like multisets for this.

Initialization from string is straight away.

Walking the set is not so clean.

https://godbolt.org/z/soccz8Tnn

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

int main()
{
    std::string str{"The quick fox jumped over the green fence"};

    // Easy initialization from string
    std::multiset<char> st(cbegin(str), cend(str));

    // Printing the count for each different key is a bit more difficult
    for (auto it{cbegin(st)}; it != cend(st); it = st.upper_bound(*it))
    {
        std::cout << "st[" << *it << "] = " << st.count(*it) << "\n";
    }
}

edited Jul 30 '21 at 14:43

answered Jul 30 '21 at 14:27

rturrado

7,699
6
42
62

1

Doesn't it perform a heap allocation for each character? (any character, not only unique ones) :( – HolyBlackCat Jul 30 '21 at 15:04
1

@HolyBlackCat I'm not sure, but it could easily be that way, yes. I understood OP's reference to efficiency as avoiding writing 26 `if` blocks; and, in that sense, `multiset` is hardly beatable. But I agree that an `array` solution is not much more complicated, and indeed more efficient (for insertions/lookup/memory usage). – rturrado Jul 30 '21 at 15:24

Is There an Efficient Method of Checking Which Letter is Being Used?

2 Answers2