Buddhism8003
/
AdventOfCode
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor `Permutations` in `EnumerableExtensions`, add `PermutationsWithRepeats` method, and update tests for improved validation and clarity

This commit is contained in:
Sebastian Lindemeier 2025-12-16 07:56:20 +01:00
parent 0665713725
commit 9d4051ece1
2 changed files with 71 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
AdventOfCode.Extensions.Tests/EnumerableExtensionsTest.cs
View File

@ -9,9 +9,8 @@ public class EnumerableExtensionsTest
int[] data = [1, 2]; int[] data = [1, 2];
var actual = data.Combinations(2).ToArray(); var actual = data.Combinations(2).ToArray();
Assert.Contains([1, 2], actual); Assert.Equal([[1, 2]], actual);
Assert.Single(actual);
} }
[Fact] [Fact]
@ -21,10 +20,7 @@ public class EnumerableExtensionsTest
var actual = data.Combinations(2).ToArray(); var actual = data.Combinations(2).ToArray();
Assert.Contains([1, 2], actual); Assert.Equal([[1, 2], [1, 3], [2, 3]], actual);
Assert.Contains([1, 3], actual);
Assert.Contains([2, 3], actual);
Assert.Equal(3, actual.Length);
} }
[Fact] [Fact]
@ -33,9 +29,8 @@ public class EnumerableExtensionsTest
int[] data = [1, 2, 3]; int[] data = [1, 2, 3];
var actual = data.Combinations(3).ToArray(); var actual = data.Combinations(3).ToArray();
Assert.Contains([1, 2, 3], actual); Assert.Equal([[1, 2, 3]], actual);
Assert.Single(actual);
} }
[Fact] [Fact]
@ -69,33 +64,42 @@ public class EnumerableExtensionsTest
} }
[Fact] [Fact]
public void Permutations_12_2_equals_11_12_21_22() public void Permutations_repeated_12_2_equals_11_12_21_22()
{
int[] data = [1, 2];
var actual = data.PermutationsWithRepeats(2).ToArray();
Assert.Equal([[1, 1], [1, 2], [2, 1], [2, 2]], actual);
}
[Fact]
public void Permutations_12_2_equals_12_21()
{ {
int[] data = [1, 2]; int[] data = [1, 2];
var actual = data.Permutations(2).ToArray(); var actual = data.Permutations(2).ToArray();
Assert.Contains([1, 1], actual); Assert.Equal([[1, 2], [2, 1]], actual);
Assert.Contains([1, 2], actual);
Assert.Contains([2, 1], actual);
Assert.Contains([2, 2], actual);
Assert.Equal(4, actual.Length);
} }
[Fact] [Fact]
public void Permutations_123_2_equals_11_12_13_21_22_23_31_32_33() public void Permutations_repeated_123_2_equals_11_12_13_21_22_23_31_32_33()
{
int[] data = [1, 2, 3];
var actual = data.PermutationsWithRepeats(2).ToArray();
Assert.Equal([[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]], actual);
}
[Fact]
public void Permutations_123_2_equals_12_13_21_23_31_32()
{ {
int[] data = [1, 2, 3]; int[] data = [1, 2, 3];
var actual = data.Permutations(2).ToArray(); var actual = data.Permutations(2).ToArray();
Assert.Contains([1, 1], actual); Assert.Equal([[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]], actual);
Assert.Contains([1, 2], actual);
Assert.Contains([2, 1], actual);
Assert.Contains([2, 2], actual);
Assert.Contains([3, 1], actual);
Assert.Contains([3, 2], actual);
Assert.Contains([3, 3], actual);
Assert.Equal(9, actual.Length);
} }
} }

43
AdventOfCode.Extensions/EnumerableExtensions.cs
View File

@ -68,7 +68,7 @@ public static class EnumerableExtensions
} }
} }
public static IEnumerable<TValue[]> Permutations<TValue>(this IEnumerable<TValue> values, int count) public static IEnumerable<TValue[]> PermutationsWithRepeats<TValue>(this IEnumerable<TValue> values, int count)
{ {
var pool = values.ToArray(); var pool = values.ToArray();
if (count > pool.Length) if (count > pool.Length)
@ -96,6 +96,47 @@ public static class EnumerableExtensions
} }
} }
public static IEnumerable<TValue[]> Permutations<TValue>(this IEnumerable<TValue> values, int count)
{
var pool = values.ToArray();
var poolLength = pool.Length;
if (count > poolLength)
yield break;
var indices = Enumerable.Range(0, poolLength).ToArray();
var cycles = Enumerable.Range(0, poolLength + 1)
.Skip(poolLength - count + 1)
.Reverse()
.ToArray();
yield return GetCombination(indices[..count], pool);
var notDone = true;
while (notDone)
{
notDone = false;
for (var i = count - 1; i >= 0; i--)
{
cycles[i] -= 1;
if (cycles[i] == 0)
{
var tmp = indices[i];
for (var j = i; j < indices.Length - 1; j++)
{
indices[j] = indices[j + 1];
}
indices[^1] = tmp;
cycles[i] = poolLength - i;
}
else
{
var j = cycles[i];
(indices[i], indices[^j]) = (indices[^j], indices[i]);
yield return GetCombination(indices[..count], pool);
notDone = true;
break;
}
}
}
}
private static TValue[] GetCombination<TValue>(int[] innerIndices, TValue[] innerPool) => private static TValue[] GetCombination<TValue>(int[] innerIndices, TValue[] innerPool) =>
innerIndices.Select(i => innerPool[i]).ToArray(); innerIndices.Select(i => innerPool[i]).ToArray();
} }