Efficient way of finding item at index in array with joined count array

Question

I have an object that contains two arrays, the first is a slope array:

double[] Slopes = new double[capacity];

The next is an array containing the counts of various slopes:

int[] Counts = new int[capacity];

The arrays are related, in that when I add a slope to the object, if the last element entered in the slope array is the same slope as the new item, instead of adding it as a new element the count gets incremented.

i.e. If I have slopes 15 15 15 12 4 15 15, I get:

Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }

Is there a better way of finding the i_th item in slopes than iterating over the Counts with the index and finding the corresponding index in Slopes?

edit: Not sure if maybe my question wasn't clear. I need to be able to access the i_th Slope that occurred, so from the example the zero indexed i = 3 slope that occurs is 12, the question is whether a more efficient solution exists for finding the corresponding slope in the new structure.

Maybe this will help better understand the question: here is how I get the i_th element now:

public double GetSlope(int index)
        int countIndex = 0;
        int countAccum = 0;
        foreach (int count in Counts)
        {
            countAccum += count;
            if (index - countAccum < 0)
            {
                return Slopes[countIndex];
            }
            else
            {
                countIndex++;
            }
        }
        return Slopes[Index];
}

I am wondering if there is a more efficient way?

Answer 1

If you are loading the slopes at one time and doing many of these "i-th item" lookups, it may help to have a third (or instead of Counts, depending on what that is used for) array with the totals. This would be { 0, 3, 4, 5 } for your example. Then you don't need to add them up for each look up, it's just a matter of "is i between Totals[x] and Totals[x + 1]". If you expect to have few slope buckets, or if slopes are added throughout processing, or if you don't do many of these look-ups, it probably will buy you nothing, though. Essentially, this is just doing all those additions at one time up front.

Answer 2

You could use a third array in order to store the first index of a repeated slope

double[] Slopes = new double[capacity];
int[] Counts = new int[capacity]; 
int[] Indexes = new int[capacity]; 

With

Slopes  = { 15, 12, 4, 15 }
Counts  = {  3,  1, 1,  2 } 
Indexes = {  0,  3, 4,  5 } 

Now you can apply a binary search in Indexes to serach for an index which is less or equal to the one you are looking for.

Instead of having an O(n) search performance, you have now O(log(n)).

Answer 3

you can always wrap your existing arrays, and another array (call it OriginalSlopes), into a class. When you add to Slopes, you also add to OriginalSlopes like you would a normal array (i.e. always append). If you need the i_th slope, look it up in OriginalSlopes. O(1) operations all around.

edit adding your example data:

Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }
OriginalSlopes = { 15, 15, 15, 12, 4, 15, 15 }

Answer 4

In counts object (or array in your base), you add a variable that has the cumulative count that you have found so far.

Using the binary search with comparator method comparing the cumulative count you would be able to find the slope in O(log N) time.

edit

`Data = 15 15 15 12 4 15 15`
Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }
Cumulative count = { 3, 4, 5, 7}

For instance, if you are looking for element at 6th position, when you search into the Cumulative count dataset and find value 5, and know next value is 7, you can be sure that element at that index will have 6th position element as well.

Use binary search to find element in log(N) time.

Answer 5

EDIT: You could use a dictionary where the key is the slope and each key's value is a list of corresponding indexes and counts. Something like:

class IndexCount
{
    public int Index { get; set; }
    public int Count { get; set; }
}

Your collection declaration would look something like:

var slopes = new Dictionary<double, List<IndexCount>>();

You could then look up the dictionary by value and see from the associated collection what the count is at each index. This might make your code pretty interesting though. I would go with the list approach below if performance is not a primary concern.

---

You could use a single List<> of a type that associates the Slopes and Counts, something like:

class SlopeCount
{
    public int Slope { get; set; }
    public int Count { get; set; }
}

then:

var slopeCounts = new List<SlopeCount>();

// fill the list

Answer 6

Why not a Dictionary<double, double> with the key being Slopes and the value being counts?

Hmm, double double? Now I need a coffee...