在C＃中，如何识别不同的对，并计算一长对对中它发生了多少次？

Question

I am using Visual C# 2010 Express. I have an array of students that tells me which pair of students have worked together in the past. So, arrStudents(0,0) might contain Joe and arrStudents(0,1) contains Bob, and sometimes vice versa. The order in which the names are recorded doesn't matter, it's just the pairing information that I care about.

Example:

Joe - Bob
Mary - Bob
Bob - Joe
Mary - Joe
Jack - Mary
Joe - Bob

What method should I use to identify all distinct pairs and to count how many times it occurred?

So, since (Joe - Bob) and (Bob - Joe) are the same pair the results should yield:

Joe - Bob, 3
Mary - Bob, 1
Mary - Joe, 1
Jack - Mary, 1

Answer 1

I'd create a Dictionary , where the key is a student-pair and the value is the count. Then iterate through all the pairs and add them to the dictionary. For each pair, sort the names alphabetically (or whatever) so that both "Joe-Bob" and "Bob-Joe" end up as "Bob-Joe". If the pair already exists in the dictionary, increment the corressponding value by 1. If it doesn't, add it and set the value to 1. In the end, just iterate through the dictionary and you'll have your results.

Answer 2

List<Tuple<string, string>> list = new List<Tuple<string, string>>()
{
    //Joe - Bob Mary - Bob Bob - Joe Mary - Joe Jack - Mary Joe - Bob
    new Tuple<string,string>("Joe","Bob"),
    new Tuple<string,string>("Mary","Bob"),
    new Tuple<string,string>("Bob","Joe"),
    new Tuple<string,string>("Mary","Joe"),
    new Tuple<string,string>("Jack","Mary"),
    new Tuple<string,string>("Joe","Bob")
};

var result = list.GroupBy(x=>x, new MyComparer())
    .Select(g=>new {Count = g.Count(),Pair = g.First()})
    .ToArray();

--

public class MyComparer : IEqualityComparer<Tuple<string, string>>
{
    public bool Equals(Tuple<string, string> x, Tuple<string, string> y)
    {
        return (x.Item1 == y.Item1 && x.Item2 == y.Item2) ||
            (x.Item2 == y.Item1 && x.Item1 == y.Item2);
    }

    public int GetHashCode(Tuple<string, string> obj)
    {
        return obj.Item1.GetHashCode() ^ obj.Item2.GetHashCode();
    }
}

Answer 3

Easiest way I can think of is a little Linq. First, get all the pairs of students as a list of pairs of strings, similar to what you show. A List<Tuple<string, string>> should work. The tricky bit is that you're using a rectangular array, which has some weird access behavior if you treat it as an IEnumerable.

Then, you need a way to compare two pairs for equality. I have a generic class that allows you to specify a lambda statement to use for the comparison, so you don't have to implement a single-purpose IEqualityComparer for each custom comparison:

public class GenericEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, T, bool> equalityComparer;
    private readonly Func<T, int> hashFunc;

    public GenericEqualityComparer(Func<T, T, bool> compareFunc, Func<T,int> hashFunc)
        :this(compareFunc)
    {
        this.equalityComparer = compareFunc;
        this.hashFunc = hashFunc;
    }

    public GenericEqualityComparer(Func<T, T, bool> compareFunc)
    {
        this.equalityComparer = compareFunc;
        this.hashFunc = o => o.GetHashCode();
    }

    public bool Equals(T x, T y)
    {
        return equalityComparer(x, y);
    }

    public int GetHashCode(T obj)
    {
        return hashFunc(obj);
    }
}

Then, you simply run the List of values through Linq's GroupBy() method, specifying the GenericEqualityComparer to compare the values in your custom order-independent way:

var pairCounts = pairList
                    .GroupBy(p=>p, //key selector; we want the Tuple itself
                       new GenericEqualityComparer<Tuple<string,string>>(
                          (a,b)=>(a.Item1 == b.Item1 && a.Item2 == b.Item2) 
                             || (a.Item1 == b.Item2 && a.Item2 == b.Item1))
                    .Select(g=>new Tuple<string, int>(g.Key.Item1 + " - " + g.Key.Item2,
                                                      g.Count());

The end result will be a List<Tuple<string,int>> containing the first permutation of each pair of names found, and how many either permutation of that pair was found in the list.