Question

This is my code:

SortedDictionary<int,int> Numbers = new SortedDictionary<int,int>();
List<int> onlyP = new List<int>(Numbers.Keys);
int Inferior = int.Parse(toks[0]);
int Superior = int.Parse(toks[1]);
int count = 0;

int inferiorindex = Array.BinarySearch(Numbers.Keys.ToArray(), Inferior);
if (inferiorindex < 0) inferiorindex = (inferiorindex * -1) - 1;
int superiorindex = Array.BinarySearch(Numbers.Keys.ToArray(), Superior);
if (superiorindex < 0) superiorindex = (superiorindex * -1) - 1;

count = Numbers[onlyP[superiorindex]] - Numbers[onlyP[inferiorindex]];

So what I’m trying to do is this: I’ve got a sorted dictionary with powers as keys, and a normal iteration as values. I’ve to print how many numbers of the keys fit within a specified range.

Example:
Some entries of the dict: [1,1],[4,2],[8,3],[9,4],[16,5],[25,6],[27,7],[32,8]
Limits: 2 and 10
Numbers within 2 – 10 : 4, 8, 9 = 3 numbers.

With BinarySearch I’m trying to quickly find the numbers I want and then substract Potencias[onlyP[superiorindex]] – Potencias[onlyP[inferiorindex]] to find how many numbers are within the range. Unfortunately it’s not working for all the cases, and it sometimes gives less numbers than the actual amount. How can this be fixed? Thanks in advance.

[EDIT] Examples of the problems: If I select limits: 4 and 4… it returns 0, but the answer is 1.
limits: 1 and 10^9 (the whole range) returns 32669… But the answer is 32670.
The algorithm is ignoring powers.

Answer 1

Finally, having read the documentation. Notice the -1 on the upperIndex conversion and the +1 on the return value, these are important.

var numbers = new[] { 1, 4, 8, 9, 16, 25, 27, 32 };

var lowerBound = 4;
var upperBound = 17;

int lowerIndex = Array.BinarySearch(numbers, lowerBound);
if (lowerIndex < 0) lowerIndex = ~lowerIndex;

// - 1 here because we want the index of the item that is <= upper bound.
int upperIndex = Array.BinarySearch(numbers, upperBound);
if (upperIndex < 0) upperIndex = ~upperIndex - 1;

return (upperIndex - lowerIndex) + 1;

Explanation:

For the lower index we just take the complement because the BinarySearch returns the index of the first item >= lowerBound.

For the upper index we additionally minus one from the complement because we want the first item <= upperBound (not >= upperBound which is what BinarySearch returns).