将对象列表按C＃分组

Question

I have a list of 'tickets' and each 'ticket' contains three numbers. I would to sort all the tickets into groups so each group contains tickets which share at least one number in common. How do I sort this data into a final list of grouped tickets?

In short here is the initial list of tickets:

ticketA = { 1, 2, 3 }
ticketB = { 3, 4, 1 }
ticketC = { 5, 6, 7 }
ticketD = { 7, 8, 5 }
ticketE = { 9, 10, 11 }
ticketF = { 11, 1, 9 }

The resulting output would be (broken into seperate lines for ease of reading visually:

GroupedTickets = {
    <List>( ticketA, ticketB, ticketF ticketE )
    <List>( ticketC, ticketD )
}

Below is the snippet of code I've been using to figure out a solution for...

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace CrowdTool
{
    class Ticket
    {
        public string Name { get; set; }
        public List<int> Numbers { get; set; }
    }

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            Sort();
        }

        public void Sort()
        {
            List<Ticket> allTickets = new List<Ticket>();
            Ticket ticketA = new Ticket();
            ticketA.Numbers = new List<int> { 1, 2, 3 };
            allTickets.Add(ticketA);
            Ticket ticketB = new Ticket();
            ticketB.Numbers = new List<int> { 3, 4, 1 };
            allTickets.Add(ticketB);
            Ticket ticketC = new Ticket();
            ticketC.Numbers = new List<int> { 5, 6, 7 };
            allTickets.Add(ticketC);
            Ticket ticketD = new Ticket();
            ticketD.Numbers = new List<int> { 7, 8, 5 };
            allTickets.Add(ticketD);
            Ticket ticketE = new Ticket();
            ticketE.Numbers = new List<int> { 9, 10, 11 };
            allTickets.Add(ticketE);
            Ticket ticketF = new Ticket();
            ticketF.Numbers = new List<int> { 11, 1, 9 };
            allTickets.Add(ticketF);

            // variable to store groups of tickets
            List <List<Ticket>> GroupedTickets = new List<List<Ticket>>();
            foreach (var ticket in allTickets)
            {
                Console.WriteLine(ticket);
            }

        }
    }
}

Answer 1

So, I've taken the approach of making all the groups - for all ticket numbers. The final results can then be queried to get you what you want.

I had to change the data into a form that suited the processing. I started with this:

var tickets = new Dictionary<string, int[]>()
{
    { "TicketA", new [] { 1, 2, 3 } },
    { "TicketB", new [] { 3, 4, 1 } },
    { "TicketC", new [] { 5, 6, 7 } },
    { "TicketD", new [] { 7, 8, 5 } },
    { "TicketE", new [] { 9, 10, 11 } },
    { "TicketF", new [] { 11, 1, 9 } },
};

Now I can do this query:

var groupedTickets =
    tickets
        .SelectMany(t => t.Value, (t, n) => new { t, n })
        .ToLookup(x => x.n, x => x.t)
        .OrderBy(x => x.Key)
        .Select(x => new
        {
            number = x.Key,
            tickets = x.Select(y => new
            {
                ticket = y.Key,
                numbers = y.Value
            }).ToList()
        })
        .ToList();

Now that gave me the results like this:

But that's not terribly easy to see the whole thing, so I reformatted like this:

1: TicketA = {1, 2, 3}, TicketB = {3, 4, 1}, TicketF = {11, 1, 9} 
2: TicketA = {1, 2, 3} 
3: TicketA = {1, 2, 3}, TicketB = {3, 4, 1} 
4: TicketB = {3, 4, 1} 
5: TicketC = {5, 6, 7}, TicketD = {7, 8, 5} 
6: TicketC = {5, 6, 7} 
7: TicketC = {5, 6, 7}, TicketD = {7, 8, 5} 
8: TicketD = {7, 8, 5} 
9: TicketE = {9, 10, 11}, TicketF = {11, 1, 9} 
10: TicketE = {9, 10, 11} 
11: TicketE = {9, 10, 11}, TicketF = {11, 1, 9} 

You should be able to query against groupedTickets to get precisely what you want.

For example, you could do this:

var output =
    groupedTickets
        .Where(x => x.tickets.Skip(1).Any())
        .Select(x => String.Join(", ", x.tickets.Select(y => y.ticket)))
        .OrderBy(x => x)
        .Distinct();

Which will give you this output:

TicketA, TicketB 
TicketA, TicketB, TicketF 
TicketC, TicketD 
TicketE, TicketF 

And this is quite similar to the output requested, but formatted for display purposes.

---

Based on the question edit and the comments below here is an updated solution.

var lookup =
    tickets
        .SelectMany(t => t.Value, (t, n) => new { t, n })
        .ToLookup(x => x.n, x => x.t.Value);

var groupedTickets =
    tickets
        .SelectMany(t => t.Value, (t, n) => new { t, n })
        .OrderBy(x => x.n)
        .ToLookup(x => x.n, x => x.t)
        .SelectMany(
            x => x.SelectMany(y => y.Value),
            (x, y) => new []
            {
                Tuple.Create(x.Key, y), 
                Tuple.Create(y, x.Key)
            })
        .SelectMany(t => t)
        .Where(t => t.Item1 != t.Item2)
        .Distinct();

Func<
    IEnumerable<Tuple<int, int>>,
    IEnumerable<Tuple<int, int>>,
    int,
    IEnumerable<Tuple<int, int>>> fold = null;
fold = (ts0, ts1, n) =>
    n == 0
        ? ts0
        : ts0
            .Concat(fold(
                ts0.Join(
                    ts1,
                    t0 => t0.Item2,
                    t1 => t1.Item1,
                    (t0, t1) => Tuple.Create(t0.Item1, t1.Item2)),
                ts1,
                n - 1))
            .Distinct()
            .ToArray();

var pairs = tickets.SelectMany(t => t.Value).Distinct().Count();

var final =
    fold(groupedTickets, groupedTickets, pairs)
        .OrderBy(x => x.Item1)
        .ThenBy(x => x.Item2)
        .GroupBy(x => x.Item1, x => x.Item2)
        .GroupBy(x => String.Join(",", x), x => x.Key)
        .Select(x => x.SelectMany(y => lookup[y]).Distinct());

This produces the two distinct sets:

{ { 1, 2, 3 }, { 3, 4, 1 }, { 11, 1, 9 }, { 9, 10, 11 } }

{ { 5, 6, 7 }, { 7, 8, 5 } }

Answer 2

Not very optimized, but this will do the job and you can improve upon it for efficiency (most obviously with the .Clear() and .AddRange()).

var tickets = new Dictionary<string, List<int>>()
{
    { "TicketA", new List<int> { 1, 2, 3 } },
    { "TicketB", new List<int> { 3, 4, 1 } },
    { "TicketC", new List<int> { 5, 6, 7 } },
    { "TicketD", new List<int> { 7, 8, 5 } },
    { "TicketE", new List<int> { 9, 10, 11 } },
    { "TicketF", new List<int> { 11, 1, 9 } },
};

var newDict = new Dictionary<string, List<int>>(tickets);
foreach(var ticket in newDict)
{
    bool madeChange = true;
    while(madeChange)
    {
        var groupTickets = newDict.Where(t => t.Key != ticket.Key && t.Value.Intersect(ticket.Value).Any() && t.Value.Except(ticket.Value).Any()).ToList();
        madeChange = false;
        if (groupTickets.Any())
        {
            var newSet = groupTickets.SelectMany (t => t.Value).Union(ticket.Value).Distinct().ToList();                
            ticket.Value.Clear();
            ticket.Value.AddRange(newSet);
            foreach(var groupTicket in groupTickets)
            {
                groupTicket.Value.Clear();
                groupTicket.Value.AddRange(newSet);
            }
            madeChange = true;
        }
    }
}

newDict.GroupBy (t => String.Join(",", t.Value)).Dump();

Essentially, it will look for all tickets with a matching number. It will then insert the numbers into all tickets which match. It repeats this until no new numbers are found.