Навигация Форума
Вы должны войти, чтобы создавать сообщения и темы.
Вывод списка массивов [Решено]
#1 · 13.09.2022, 14:34
Pro
#2 · 13.09.2022, 14:45
#3 · 13.09.2022, 14:55
Pro
#4 · 13.09.2022, 15:12
#5 · 13.09.2022, 17:30
Лайкнул Владислав
Владислав
#6 · 13.09.2022, 19:11
#7 · 13.09.2022, 23:02
Я плоховат в LINQ, но это вроде работает.
Код
.Select(x =>
{
int[] ar = x.ToArray();
return ($"{ar[0]}{ar[1]}", $"{ar[2]}{ar[3]}");
});
IEnumerable<(string, string)> resDistinc = res2.DistinctBy(x => x.Item1).DistinctBy(x => x.Item2);
var res1 = (resDistinc.Select(x => x.Item1.ToCharArray().Select(x => int.Parse(x.ToString()))), resDistinc.Select(x=> x.Item2.ToCharArray().Select(x => int.Parse(x.ToString()))));
var retRes = new List<int[]>();
for (int i = 0; i < res1.Item1.Count(); i++)
{
retRes.Add(new int[] { res1.Item1.ToArray()[i].ToArray()[0], res1.Item1.ToArray()[i].ToArray()[1], res1.Item2.ToArray()[i].ToArray()[0], res1.Item2.ToArray()[i].ToArray()[1] });
}
P.S. А почему нету кнопки со спойлером?
Pro
#8 · 14.09.2022, 08:06
Голова дана человеку не для того, чтобы кушать, а для того, чтобы думать.
#9 · 14.09.2022, 08:38
#10 · 14.09.2022, 12:40
[/spoiler]Это результат прошлой сортировки из прошлого поста, только тут строчку почистил т.к фигню написал. Логика тут такая. ↓
Картинка
Просто есть методы в LINQ, которые позволяют это сделать проще. Я пока мало знаю.
Pro
#11 · 14.09.2022, 17:06
#12 · 14.09.2022, 20:46
Pro
#13 · 14.09.2022, 22:44
Привет!
Генерацию входной последовательности (двумерного массива для тестирования) и фильтрацию с условиями сделал через методы расширения:
Методы расширения
using System;
using System.Collections.Generic;
using System.Linq;
using static System.Linq.Enumerable;
namespace ConsoleApp
{
public static class ExtendedEnumerable
{
/// <summary>
/// Разбивает последовательность на равные по количеству подпоследовательности.
/// </summary>
/// <param name="numberOfSubSequences">Количество подпоследовательностей</param>
/// <exception cref="ArgumentException"></exception>
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int numberOfSubSequences)
{
var sourceCount = source.Count();
if (numberOfSubSequences < 1)
{
throw new ArgumentException($"Не возможно разбить последовательность на {numberOfSubSequences} равных подпоследовательностей!");
}
if (sourceCount % numberOfSubSequences != 0)
{
throw new ArgumentException($"Не возможно разбить последовательность размером {sourceCount} на {numberOfSubSequences} равных подпоследовательностей!");
}
var subSequences = new T[numberOfSubSequences][];
var sequenceCount = sourceCount / numberOfSubSequences;
var sourceEnumerator = source.GetEnumerator();
while (sourceEnumerator.MoveNext())
{
for (var i = 0; i < numberOfSubSequences; i++)
{
var part = new T[sequenceCount];
for (var j = 0; j < sequenceCount; j++)
{
part[j] = sourceEnumerator.Current;
sourceEnumerator.MoveNext();
}
subSequences[i] = part;
}
}
return subSequences;
}
/// <summary>
/// Фильтрует последовательность по заданным условиям.
/// </summary>
/// <param name="conditions">Последовательность условий фильтрации</param>
/// <returns></returns>
public static IEnumerable<T> Filter<T>(this IEnumerable<T> source, IEnumerable<Predicate<T>> conditions)
{
return source.Where((item) => conditions.Aggregate(true, (result, condition) => result && condition(item)));
}
/// <summary>
/// Генерирует все возможные перестановки элементов последовательности с повторениями.
/// </summary>
/// <param name="selectionCount">Количество элементов выборки</param>
/// <exception cref="ArgumentException"></exception>
public static IEnumerable<IEnumerable<T>> PermutationsWithRepetition<T>(this IEnumerable<T> source, int selectionCount)
{
var sourceCount = source.Count();
if (selectionCount < 0)
{
throw new ArgumentException("Количество элементов не может быть меньше нуля!");
}
if (selectionCount == 0)
{
return Empty<IEnumerable<T>>();
}
if (selectionCount == 1)
{
return source.Split(sourceCount);
}
var permutationsCount = (int)Math.Pow(sourceCount, selectionCount);
var permutations = new List<IEnumerable<T>>(permutationsCount);
foreach (var item in source)
{
foreach (var placement in PermutationsWithRepetition(source, selectionCount - 1))
{
permutations.Add(placement.Prepend(item));
}
}
return permutations;
}
/// <summary>
/// Генерирует все возможные перестановки элементов последовательности без повторений.
/// </summary>
/// <param name="selectionCount">Количество элементов выборки</param>
/// <exception cref="ArgumentException"></exception>
public static IEnumerable<IEnumerable<T>> PermutationsWithoutRepetition<T>(this IEnumerable<T> source, int selectionCount)
{
return PermutationsWithRepetition(source, selectionCount).Where((sequence) => sequence.Distinct().Count() == sequence.Count());
}
}
}
Для отсеивания дубликатов сделал Comparer, только не уверен насчёт метода генерации хеш кода, но с задачей вроде справляется.
IntSequenceComparer
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApp
{
public class IntSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
/// <summary>
/// Сравнивает последовательности без учёта порядка элементов.
/// </summary>
public bool Equals(IEnumerable<int> first, IEnumerable<int> second)
{
return first.Except(second).SequenceEqual(Enumerable.Empty<int>());
}
/// <summary>
/// Генерирует уникальное значение последовательности без учёта порядка элементов.
/// </summary>
public int GetHashCode(IEnumerable<int> sequence)
{
return sequence.Sum() * sequence.Count();
}
}
}
Ну и, собственно, использование этого всего:
Main метод
using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
namespace ConsoleApp
{
internal class Program
{
public static void Main(string[] args)
{
const int numberOfParts = 2;
const int selectionCount = 4;
const int min = 1;
const int max = 9;
// Условия фильтрации
var conditions = new Predicate<IEnumerable<int>>[]
{
// Элементы не повторяются.
(collection) => collection.Distinct().Count() == collection.Count(),
// Суммы всех (в нашем случае двух) частей равны
(collection) => collection.Split(numberOfParts).GroupBy((item) => item.Sum()).Count() == 1,
};
// Генерация входной последовательности
var inputSequence = Enumerable.Range(min, max - min).PermutationsWithRepetition(selectionCount);
// Фильтрация входной последовательности
var outputSequence = inputSequence.Filter(conditions).Distinct(new IntSequenceComparer());
Print(outputSequence);
ReadKey();
}
private static void Print<T>(IEnumerable<T> collection)
{
foreach (var item in collection)
{
Write($"{item} ");
}
WriteLine();
}
private static void Print<T>(IEnumerable<IEnumerable<T>> collection)
{
foreach (var item in collection)
{
Print(item);
}
}
}
}
Результат
Лайкнули Arman и BlendLog
ArmanBlendLog
#14 · 15.09.2022, 09:06