Question

Good day all,

I have a class and a property, and I have three instances of that class.

public class myclass {
  public int myproperty;
}

...

myclass inst1, inst2, inst3;

...

Now at a certain point I need to compare those three property values, and verify that they be equal or not, to end up with the least amount of values.

So if I have

inst1.myproperty = 3;
inst2.myproperty = 5;
inst3.myproperty = 3;

after the magic_function_call, I should get 3 and 5.

And if I have

inst1.myproperty = 2;
inst2.myproperty = 2;
inst3.myproperty = 2;

after the magic_function_call, I should get 2.

Albeit this is trivial per se, and can be solved with as many IF checks as needed, I was wondering which is the fastest, or more efficient way to do it, especially in light of the fact that I might need to add another variable to the check in the future.

I am in fact wondering if there is a bitwise operation that can be performed that can solve this elegantly and quickly.

Alternatively, is there an array operation that can be used to achieve the same goal? I’ve tried looking for ‘reduction’ or ‘compression’ but those keywords don’t seem to lead in the right direction.

Thanks in advance.

Answer 1

Here’s a quick function which doesn’t require any extra libraries and avoids the setup costs and overheads associated with LINQ:

    static int[] Reduce(IEnumerable<myclass> items)
    {
        HashSet<int> uniqueValues = new HashSet<int>();

        foreach (var item in items)
        {
            uniqueValues.Add(item.myproperty);
        }

        return uniqueValues.ToArray();
    }

Pass it a collection of your myclass instances and it will return an array of unique myproperty values.