Question

I’m converting an algorithm from C# to C++. A small part of the algorithm is to calculate average values for certain areas in a dictionary.

The data in the dictionary is stored in the following way:

Index     Value
1         10
3         28
290       78
1110      90

I need to calculate the average value of all values with an index smaller than a certain number and all index values larger than a certain number. In C# I do it the following way:

if (dictionary.Where(x => x.Key < areaWidth).Count() > 0)
{
    avgValue = (int) dictionary.Where(x => x.Key < areaWidth).Average(
        x => x.Value);
}

for (var i = 0; i < line.Length; i++)
{
    if (i == areaWidth)
    {
        avgValue = -1;
        i = line.Length - areaWidth;
        var rightBorder = i - areaWidth;

        if (dictionary.Where(x => x.Key > (rightBorder)).Count() > 0)
        {
            avgValue = (int) dictionary.Where(
                x => x.Key > (rightBorder)).Average(
                                x => x.Value);
        }
    }

    if (line[i] < avgValue * 0.8)
    {
        reallyImportantValue += (avgValue - line[i]);
    }
}

I know that is not very efficient and pretty crappy code, but I knew that I would have to completely rewrite this part of the algorithm in C++ anyway, so I decided to implement it quick and dirty.

Anyway I am now porting this to C++ and because it will run on a mobile platform performance is very important. With my limited C++/STL knowledge I could most likely get the job done, but the result would probably be much worse than the C# code.

So if you know a good and efficient way to accomplish this task in C++, please tell me.

---

EDIT: Thank you for all your answers. As I mentioned in my post my STL knowledge is limited, so it’s really hard for me to pick a solution, especially since there are a lot of different opinions. It would be great if someone could help me with the decision, by comparing the solutions posted here. To give you a little more background information:

The function will be called approximately 500 times with 1000 values in the map. The most important aspect is stability, performance is the second most important.

Answer 1

Key-value pairs in std::map are sorted by keys – it’s easy to sum the values pointed by keys smaller or larger than some value even with a for loop (if you do not want to use or learn to use STL algorithms). For keys lower than some value:

std::map<int, int> map;
map[...] = ...;

int count = 0, sum = 0;
for (std::map<int, int>::const_iterator it = map.begin();
     it != map.end() && it->first < value; ++it, ++count)
{
    sum += it->second;
}
// check for count == 0
int avg = sum / count; // do note integer division, change if appropriate

For average of keys larger than value, use map.rbegin() (of type std::map<...>::const_reverse_iterator), map.rend() and >.

edit: STL algorithms might make the code shorter (where its used, that is). For example, to calculate the average of keys below value.

int ipsum(int p1, const std::pair<int, int>& p2) {
    return p1 + p2.second;
}

...

std::map<int, int> map;
int sum = std::accumulate(map.begin(), map.lower_bound(value), 0, ipsum);