Минимизация строк комбинаций в списке <int>

Question

У меня есть список List<int> (List<List<int>>). Список состоит из игровых ставок стартовых номеров в гонках. Допустим, я выбрал три варианта в первой гонке, затем один вариант в оставшихся 6 гонках. Это добавляет до трех комбинаций ставок.

A List<List<int>> из трех уникальных строк (ставок) будет выглядеть следующим образом:

[0] 1  [0] 2  [0] 3
[1] 1  [1] 1  [1] 1
[2] 1  [2] 1  [2] 1
[3] 1  [3] 1  [3] 1
[4] 1  [4] 1  [4] 1
[5] 1  [5] 1  [5] 1
[6] 1  [6] 1  [6] 1

Когда я отправляю ставку, я хочу группироватьотдельные ставки в меньшие сгруппированные ставки (возможно, List<List<string>>?), которые математически представляют список выше, поэтому согласно приведенному выше примеру:

[0] "1,2,3"
[1] "1"
[2] "1"
[3] "1"
[4] "1"
[5] "1"
[6] "1"

Я нашел похожие решения, связанные с темой Декартово произведение,Но никто не кажется подходящим для этой проблемы. Любые идеи?

Я нашел этот Обратный декартовой продукт , который описывает мою проблему, но я не могу действительно перевести этот ответ в c # из Java.

РЕДАКТИРОВАТЬ: Просто чтобы уточнитьна вопросы в комментариях каждая ставка всегда состоит из 7 гонок, поэтому, если я выбрал ставку № 1 в гонке 2-7, а затем поставил на № 1, № 2, № 3 в первой гонке. Моя функция создает три строки List с .Count == 7. Я просто пытался проиллюстрировать содержимое списка. В c # можно было бы создать новый список следующим образом:

List<List<int>> list = new List<List<int>> { new List<int> { 1, 1, 1, 1, 1, 1, 1 }, new List<int> { 2, 1, 1, 1, 1, 1, 1 }, new List<int> { 3, 1, 1, 1, 1, 1, 1 } };

Answer 1

Кажется, что вы хотите удалить дубликаты значений int в каждой строке (= элемент верхнего списка), но сохранить сами строки, даже если они являются дубликатами друг друга.

Это может быть достигнуто с помощьюиспользование Select() и Distinct():

var bets = new List<List<int>>()
{
    new List<int>() { 1 , 2 , 3 },
    new List<int>() { 1 , 1 , 1 },
    new List<int>() { 1 , 1 , 1 },
    new List<int>() { 1 , 1 , 1 },
    new List<int>() { 1 , 1 , 1 },
    new List<int>() { 1 , 1 , 1 },
    new List<int>() { 1 , 1 , 1 },
}

var reducedBets = bets.Select(bet => bet.Distinct());

reducedBets теперь фактически равняется:

new List<List<int>>()
{
    new List<int>() { 1 , 2 , 3 },
    new List<int>() { 1 },
    new List<int>() { 1 },
    new List<int>() { 1 },
    new List<int>() { 1 },
    new List<int>() { 1 },
    new List<int>() { 1 },
}

Обозначение, которое вы использовали в своем ответе, неясно дляменя (странное использование индекса), но я предполагаю, что это то, что вы хотите, чтобы это было?

Answer 2

То, что вы хотите, может быть сделано с помощью LINQ:

var lists = new List<List<int>>()
{
    new List<int> { 1, 1, 1, 1, 1, 1, 1 },
    new List<int> { 2, 1, 1, 1, 1, 1, 1 },
    new List<int> { 3, 1, 1, 1, 1, 1, 1 }
};

var result = lists
    .SelectMany(i => i.Select((value, index) => new { value, index }), (list, value) => value)
    .GroupBy(tuple => tuple.index)
    .Select(grouping => grouping.Select(tuple => tuple.value).Distinct().ToList()).ToList();

Сначала мы преобразуем каждое значение в объект, содержащий значение и его индекс (Select), затем мы сглаживаем этот список, чтобы получитьодин огромный список со всеми записями (SelectMany). После этого мы группируем их по их индексам (GroupBy), и из этих групп мы выбираем значения (Select), при этом мы убеждаемся, что все дубликаты удаляются (Distinct), и все эти отдельные значения помещаются вlist (ToList) и все эти списки затем помещаются в список результатов (ToList)

Answer 3

Вместо 0,1,2,3,4,5, ... вы можете использовать 1,2,4,8,16, ... таким образом, вы можете комбинировать ставки с помощью побитового или оператора (илипросто сложите их):

[0] 1 | 2 | 4 (equals 7)
[1] 1 | 1 | 1 (equals 1)

и знать, что если он содержит элемент, вы можете просто использовать его побитово и (&), так что

if(bet & 4 == 4) it contains 4;
if(bet & 8 == 8) it contains 8;

и так далее.

Таким образом, ставка, содержащая 1,8,16, будет (1 + 8 + 16 или 1 | 8 | 16 = 25);

0 означает, что ставки не сделаны.

Таким образом, вы можете иметь все комбинации ставок в одном целом.