collection | C# Online Compiler

collection by ekardon

#nullable enable
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace Combinatorics.Collections
{
	/// <summary>
	/// Indicates whether a permutation, combination or variation generates equivalent result sets.  
	/// </summary>
	public enum GenerateOption
	{
		/// <summary>
		/// Do not generate equivalent result sets.
		/// </summary>
		WithoutRepetition,
		/// <summary>
		/// Generate equivalent result sets.
		/// </summary>
		WithRepetition,
	}
}

namespace Combinatorics.Collections
{
	/// <summary>
	/// Utility class that maintains a small table of prime numbers and provides
	/// simple implementations of Prime Factorization algorithms.  
	/// This is a quick and dirty utility class to support calculations of permutation
	/// sets with indexes under 2^31.
	/// The prime table contains all primes up to Sqrt(2^31) which are all of the primes
	/// requires to factorize any Int32 positive integer.
	/// </summary>
	internal static class SmallPrimeUtility
	{
		/// <summary>
		/// Performs a prime factorization of a given integer using the table of primes in PrimeTable.
		/// Since this will only factor Int32 sized integers, a simple list of factors is returned instead
		/// of the more scalable, but more difficult to consume, list of primes and associated exponents.
		/// </summary>
		/// <param name = "i">The number to factorize, must be positive.</param>
		/// <returns>A simple list of factors.</returns>
		public static List<int> Factor(int i)
		{
			var primeIndex = 0;
			var prime = PrimeTable[primeIndex];
			var factors = new List<int>();
			while (i > 1)
			{
#if NETSTANDARD1_1
                var remainder = i % prime;
                var divResult = remainder == 0 ? i / prime : 0;
#else
				var divResult = Math.DivRem(i, prime, out var remainder);
#endif
				if (remainder == 0)
				{
					factors.Add(prime);
					i = divResult;
				}
				else
				{
					++primeIndex;
					prime = PrimeTable[primeIndex];
				}
			}

			return factors;
		}

		/// <summary>
		/// Given two integers expressed as a list of prime factors, divides these numbers
		/// and returns an integer also expressed as a set of prime factors.
		/// If the result is not a integer, then the result is undefined.  That is, 11 / 5
		/// when divided by this function will not yield a correct result.
		/// As such, this function is ONLY useful for division with combinatorial results where 
		/// the result is known to be an integer AND the division occurs as the last operation(s).
		/// </summary>
		/// <param name = "numerator">Numerator argument, expressed as list of prime factors.</param>
		/// <param name = "denominator">Denominator argument, expressed as list of prime factors.</param>
		/// <returns>Resultant, expressed as list of prime factors.</returns>
		public static List<int> DividePrimeFactors(IEnumerable<int> numerator, IEnumerable<int> denominator)
		{
			_ = numerator ?? throw new ArgumentNullException(nameof(numerator));
			_ = denominator ?? throw new ArgumentNullException(nameof(denominator));
			var product = numerator.ToList();
			foreach (var prime in denominator)
				product.Remove(prime);
			return product;
		}

		/// <summary>
		/// Given a list of prime factors returns the long representation.
		/// </summary>
		/// <param name = "value">Integer, expressed as list of prime factors.</param>
		/// <returns>Standard long representation.</returns>
		public static BigInteger EvaluatePrimeFactors(IEnumerable<int> value)
		{
			_ = value ?? throw new ArgumentNullException(nameof(value));
			BigInteger result = 1;
			foreach (var prime in value)
				result *= prime;
			return result;
		}

		/// <summary>
		/// Static initializer, set up prime table.
		/// </summary>
		static SmallPrimeUtility()
		{
			PrimeTable = CalculatePrimes();
		}

		/// <summary>
		/// Calculate all primes up to Sqrt(2^32) = 2^16.  
		/// This table will be large enough for all factorizations for Int32's.
		/// Small tables are best built using the Sieve Of Eratosthenes,
		/// Reference: http://primes.utm.edu/glossary/page.php?sort=SieveOfEratosthenes
		/// </summary>
		private static IReadOnlyList<int> CalculatePrimes()
		{
			// Build Sieve Of Eratosthenes
			var sieve = new BitArray(65536, true);
			for (var possiblePrime = 2; possiblePrime <= 256; ++possiblePrime)
			{
				if (!sieve[possiblePrime])
					continue;
				// It is prime, so remove all future factors...
				for (var nonPrime = 2 * possiblePrime; nonPrime < 65536; nonPrime += possiblePrime)
					sieve[nonPrime] = false;
			}

			// Scan sieve for primes...
			var primes = new List<int>();
			for (var i = 2; i < 65536; ++i)
			{
				if (sieve[i])
					primes.Add(i);
			}

			return primes;
		}

		/// <summary>
		/// A List of all primes from 2 to 2^16.
		/// </summary>
		public static IReadOnlyList<int> PrimeTable { get; }
	}
}

namespace Combinatorics.Collections
{
	/// <summary>
	/// Variations defines a sequence of all possible ordered subsets of a particular size from the set of values.  
	/// </summary>
	/// <remarks>
	/// The MetaCollectionType parameter of the constructor allows for the creation of
	/// normal Variations and Variations with Repetition.
	/// 
	/// When given an input collect {A B C} and lower index of 2, the following sets are generated:
	/// MetaCollectionType.WithoutRepetition generates 6 sets: =>
	///     {A B}, {A B}, {B A}, {B C}, {C A}, {C B}
	/// MetaCollectionType.WithRepetition generates 9 sets:
	///     {A A}, {A B}, {A B}, {B A}, {B B }, {B C}, {C A}, {C B}, {C C}
	/// 
	/// The equality of multiple inputs is not considered when generating variations.
	/// </remarks>
	/// <typeparam name = "T">The type of the values within the list.</typeparam>
	public sealed class Variations<T> : IEnumerable<IReadOnlyList<T>>
	{
		/// <summary>
		/// Create a variation set from the indicated list of values.
		/// The upper index is calculated as values.Count, the lower index is specified.
		/// Collection type defaults to MetaCollectionType.WithoutRepetition
		/// </summary>
		/// <param name = "values">List of values to select Variations from.</param>
		/// <param name = "lowerIndex">The size of each variation set to return.</param>
		public Variations(IEnumerable<T> values, int lowerIndex) : this(values, lowerIndex, GenerateOption.WithoutRepetition)
		{
		}

		/// <summary>
		/// Create a variation set from the indicated list of values.
		/// The upper index is calculated as values.Count, the lower index is specified.
		/// </summary>
		/// <param name = "values">List of values to select variations from.</param>
		/// <param name = "lowerIndex">The size of each variation set to return.</param>
		/// <param name = "type">Type indicates whether to use repetition in set generation.</param>
		public Variations(IEnumerable<T> values, int lowerIndex, GenerateOption type)
		{
			Type = type;
			LowerIndex = lowerIndex;
			_myValues = values.ToList();
			if (type != GenerateOption.WithoutRepetition)
			{
				return;
			}

			var myMap = new List<int>(_myValues.Count);
			var index = 0;
			for (var i = 0; i < _myValues.Count; ++i)
				myMap.Add(i >= _myValues.Count - LowerIndex ? index++ : int.MaxValue);
			_myPermutations = new Permutations<int>(myMap);
		}

		/// <summary>
		/// Gets an enumerator for the collection of Variations.
		/// </summary>
		/// <returns>The enumerator.</returns>
		public IEnumerator<IReadOnlyList<T>> GetEnumerator() => Type == GenerateOption.WithRepetition ? (IEnumerator<IReadOnlyList<T>>)new EnumeratorWithRepetition(this) : new EnumeratorWithoutRepetition(this);
		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
		/// <summary>
		/// An enumerator for Variations when the type is set to WithRepetition.
		/// </summary>
		public sealed class EnumeratorWithRepetition : IEnumerator<IReadOnlyList<T>>
		{
			/// <summary>
			/// Construct a enumerator with the parent object.
			/// </summary>
			/// <param name = "source">The source Variations object.</param>
			public EnumeratorWithRepetition(Variations<T> source)
			{
				_myParent = source;
				_myCurrentList = null;
				_myListIndexes = null;
			}

			void IEnumerator.Reset() => throw new NotSupportedException();
			/// <summary>
			/// Advances to the next variation.
			/// </summary>
			/// <returns>True if successfully moved to next variation, False if no more variations exist.</returns>
			/// <remarks>
			/// Increments the internal myListIndexes collection by incrementing the last index
			/// and overflow/carrying into others just like grade-school arithmetic.  If the 
			/// final carry flag is set, then we would wrap around and are therefore done.
			/// </remarks>
			public bool MoveNext()
			{
				var carry = 1;
				if (_myListIndexes == null)
				{
					_myListIndexes = new List<int>(_myParent.LowerIndex);
					for (var i = 0; i < _myParent.LowerIndex; ++i)
					{
						_myListIndexes.Add(0);
					}

					carry = 0;
				}
				else
				{
					for (var i = _myListIndexes.Count - 1; i >= 0 && carry > 0; --i)
					{
						_myListIndexes[i] += carry;
						carry = 0;
						if (_myListIndexes[i] < _myParent.UpperIndex)
						{
							continue;
						}

						_myListIndexes[i] = 0;
						carry = 1;
					}
				}

				_myCurrentList = null;
				return carry != 1;
			}

			/// <summary>
			/// The current variation
			/// </summary>
			public IReadOnlyList<T> Current
			{
				get
				{
					ComputeCurrent();
					return _myCurrentList!;
				}
			}

			object IEnumerator.Current => Current;
			/// <inheritdoc/>
			public void Dispose()
			{
			}

			/// <summary>
			/// Computes the current list based on the internal list index.
			/// </summary>
			private void ComputeCurrent()
			{
				if (_myCurrentList != null)
				{
					return;
				}

				_ = _myListIndexes ?? throw new InvalidOperationException($"Cannot call {nameof(Current)} before calling {nameof(MoveNext)}.");
				_myCurrentList = new List<T>(_myListIndexes.Count);
				foreach (var index in _myListIndexes)
					_myCurrentList.Add(_myParent._myValues[index]);
			}

			/// <summary>
			/// Parent object this is an enumerator for.
			/// </summary>
			private readonly Variations<T> _myParent;
			/// <summary>
			/// The current list of values, this is lazy evaluated by the Current property.
			/// </summary>
			private List<T>? _myCurrentList;
			/// <summary>
			/// An enumerator of the parents list of lexicographic orderings.
			/// </summary>
			private List<int>? _myListIndexes;
		}

		/// <summary>
		/// An enumerator for Variations when the type is set to WithoutRepetition.
		/// </summary>
		public sealed class EnumeratorWithoutRepetition : IEnumerator<IReadOnlyList<T>>
		{
			/// <summary>
			/// Construct a enumerator with the parent object.
			/// </summary>
			/// <param name = "source">The source Variations object.</param>
			public EnumeratorWithoutRepetition(Variations<T> source)
			{
				_myParent = source;
				_myPermutationsEnumerator = (Permutations<int>.Enumerator)_myParent._myPermutations!.GetEnumerator();
			}

			void IEnumerator.Reset() => throw new NotSupportedException();
			/// <summary>
			/// Advances to the next variation.
			/// </summary>
			/// <returns>True if successfully moved to next variation, False if no more variations exist.</returns>
			public bool MoveNext()
			{
				var ret = _myPermutationsEnumerator.MoveNext();
				_myCurrentList = null;
				return ret;
			}

			/// <summary>
			/// The current variation.
			/// </summary>
			public IReadOnlyList<T> Current
			{
				get
				{
					ComputeCurrent();
					return _myCurrentList!;
				}
			}

			object IEnumerator.Current => Current;
			/// <inheritdoc/>
			public void Dispose() => _myPermutationsEnumerator.Dispose();
			/// <summary>
			/// Creates a list of original values from the int permutation provided.  
			/// The exception for accessing current (InvalidOperationException) is generated
			/// by the call to .Current on the underlying enumeration.
			/// </summary>
			/// <remarks>
			/// To compute the current list of values, the element to use is determined by 
			/// a permutation position with a non-MaxValue value.  It is placed at the position in the
			/// output that the index value indicates.
			/// 
			/// E.g. Variations of 6 choose 3 without repetition
			/// Input array:   {A B C D E F}
			/// Permutations:  {- 1 - - 3 2} (- is Int32.MaxValue)
			/// Generates set: {B F E}
			/// </remarks>
			private void ComputeCurrent()
			{
				if (_myCurrentList != null)
				{
					return;
				}

				_myCurrentList = new List<T>(_myParent.LowerIndex);
				var index = 0;
				var currentPermutation = _myPermutationsEnumerator.Current;
				for (var i = 0; i < _myParent.LowerIndex; ++i)
				{
					_myCurrentList.Add(_myParent._myValues[0]);
				}

				foreach (var position in currentPermutation)
				{
					if (position != int.MaxValue)
					{
						_myCurrentList[position] = _myParent._myValues[index];
						if (_myParent.Type == GenerateOption.WithoutRepetition)
						{
							++index;
						}
					}
					else
					{
						++index;
					}
				}
			}

			/// <summary>
			/// Parent object this is an enumerator for.
			/// </summary>
			private readonly Variations<T> _myParent;
			/// <summary>
			/// The current list of values, this is lazy evaluated by the Current property.
			/// </summary>
			private List<T>? _myCurrentList;
			/// <summary>
			/// An enumerator of the parents list of lexicographic orderings.
			/// </summary>
			private readonly Permutations<int>.Enumerator _myPermutationsEnumerator;
		}

		/// <summary>
		/// The number of unique variations that are defined in this meta-collection.
		/// </summary>
		/// <remarks>
		/// Variations with repetitions does not behave like other meta-collections and it's
		/// count is equal to N^P, where N is the upper index and P is the lower index.
		/// </remarks>
		public BigInteger Count => Type == GenerateOption.WithoutRepetition ? _myPermutations!.Count : BigInteger.Pow(UpperIndex, LowerIndex);
		/// <summary>
		/// The type of Variations set that is generated.
		/// </summary>
		public GenerateOption Type { get; }

		/// <summary>
		/// The upper index of the meta-collection, equal to the number of items in the initial set.
		/// </summary>
		public int UpperIndex => _myValues.Count;
		/// <summary>
		/// The lower index of the meta-collection, equal to the number of items returned each iteration.
		/// </summary>
		public int LowerIndex { get; }

		/// <summary>
		/// Copy of values object is initialized with, required for enumerator reset.
		/// </summary>
		private readonly List<T> _myValues;
		/// <summary>
		/// Permutations object that handles permutations on int for variation inclusion and ordering.
		/// </summary>
		private readonly Permutations<int>? _myPermutations;
	}
}

namespace Combinatorics.Collections
{
	/// <summary>
	/// Permutations defines a sequence of all possible orderings of a set of values.
	/// </summary>
	/// <remarks>
	/// When given a input collect {A A B}, the following sets are generated:
	/// MetaCollectionType.WithRepetition =>
	/// {A A B}, {A B A}, {A A B}, {A B A}, {B A A}, {B A A}
	/// MetaCollectionType.WithoutRepetition =>
	/// {A A B}, {A B A}, {B A A}
	/// 
	/// When generating non-repetition sets, ordering is based on the lexicographic 
	/// ordering of the lists based on the provided Comparer.  
	/// If no comparer is provided, then T must be IComparable on T.
	/// 
	/// When generating repetition sets, no comparisons are performed and therefore
	/// no comparer is required and T does not need to be IComparable.
	/// </remarks>
	/// <typeparam name = "T">The type of the values within the list.</typeparam>
	public sealed class Permutations<T> : IEnumerable<IReadOnlyList<T>>
	{
		/// <summary>
		/// Create a permutation set from the provided list of values.  
		/// The values (T) must implement IComparable.  
		/// If T does not implement IComparable use a constructor with an explicit IComparer.
		/// The repetition type defaults to MetaCollectionType.WithholdRepetitionSets
		/// </summary>
		/// <param name = "values">List of values to permute.</param>
		public Permutations(IEnumerable<T> values) : this(values, GenerateOption.WithoutRepetition, null)
		{
		}

		/// <summary>
		/// Create a permutation set from the provided list of values.  
		/// If type is MetaCollectionType.WithholdRepetitionSets, then values (T) must implement IComparable.  
		/// If T does not implement IComparable use a constructor with an explicit IComparer.
		/// </summary>
		/// <param name = "values">List of values to permute.</param>
		/// <param name = "type">The type of permutation set to calculate.</param>
		public Permutations(IEnumerable<T> values, GenerateOption type) : this(values, type, null)
		{
		}

		/// <summary>
		/// Create a permutation set from the provided list of values.  
		/// The values will be compared using the supplied IComparer.
		/// The repetition type defaults to MetaCollectionType.WithholdRepetitionSets
		/// </summary>
		/// <param name = "values">List of values to permute.</param>
		/// <param name = "comparer">Comparer used for defining the lexicographic order.</param>
		public Permutations(IEnumerable<T> values, IComparer<T>? comparer) : this(values, GenerateOption.WithoutRepetition, comparer)
		{
		}

		/// <summary>
		/// Create a permutation set from the provided list of values.  
		/// If type is MetaCollectionType.WithholdRepetitionSets, then the values will be compared using the supplied IComparer.
		/// </summary>
		/// <param name = "values">List of values to permute.</param>
		/// <param name = "type">The type of permutation set to calculate.</param>
		/// <param name = "comparer">Comparer used for defining the lexicographic order.</param>
		public Permutations(IEnumerable<T> values, GenerateOption type, IComparer<T>? comparer)
		{
			_ = values ?? throw new ArgumentNullException(nameof(values));
			// Copy information provided and then create a parallel int array of lexicographic
			// orders that will be used for the actual permutation algorithm.  
			// The input array is first sorted as required for WithoutRepetition and always just for consistency.
			// This array is constructed one of two way depending on the type of the collection.
			//
			// When type is MetaCollectionType.WithRepetition, then all N! permutations are returned
			// and the lexicographic orders are simply generated as 1, 2, ... N.  
			// E.g.
			// Input array:          {A A B C D E E}
			// Lexicographic Orders: {1 2 3 4 5 6 7}
			// 
			// When type is MetaCollectionType.WithoutRepetition, then fewer are generated, with each
			// identical element in the input array not repeated.  The lexicographic sort algorithm
			// handles this natively as long as the repetition is repeated.
			// E.g.
			// Input array:          {A A B C D E E}
			// Lexicographic Orders: {1 1 2 3 4 5 5}
			Type = type;
			_myValues = values.ToList();
			_myLexicographicOrders = new int[_myValues.Count];
			if (type == GenerateOption.WithRepetition)
			{
				for (var i = 0; i < _myLexicographicOrders.Length; ++i)
				{
					_myLexicographicOrders[i] = i;
				}
			}
			else
			{
				comparer ??= Comparer<T>.Default;
				_myValues.Sort(comparer);
				var j = 1;
				if (_myLexicographicOrders.Length > 0)
				{
					_myLexicographicOrders[0] = j;
				}

				for (var i = 1; i < _myLexicographicOrders.Length; ++i)
				{
					if (comparer.Compare(_myValues[i - 1], _myValues[i]) != 0)
					{
						++j;
					}

					_myLexicographicOrders[i] = j;
				}
			}

			Count = GetCount();
		}

		/// <summary>
		/// Gets an enumerator for collecting the list of permutations.
		/// </summary>
		/// <returns>The enumerator.</returns>
		public IEnumerator<IReadOnlyList<T>> GetEnumerator() => new Enumerator(this);
		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
		/// <summary>
		/// The enumerator that enumerates each meta-collection of the enclosing Permutations class.
		/// </summary>
		public sealed class Enumerator : IEnumerator<IReadOnlyList<T>>
		{
			/// <summary>
			/// Construct a enumerator with the parent object.
			/// </summary>
			/// <param name = "source">The source Permutations object.</param>
			public Enumerator(Permutations<T> source)
			{
				_ = source ?? throw new ArgumentNullException(nameof(source));
				_myParent = source;
				_myLexicographicalOrders = new int[source._myLexicographicOrders.Length];
				_myValues = new List<T>(source._myValues.Count);
				source._myLexicographicOrders.CopyTo(_myLexicographicalOrders, 0);
				_myPosition = Position.BeforeFirst;
			}

			void IEnumerator.Reset() => throw new NotSupportedException();
			/// <summary>
			/// Advances to the next permutation.
			/// </summary>
			/// <returns>True if successfully moved to next permutation, False if no more permutations exist.</returns>
			/// <remarks>
			/// Continuation was tried (i.e. yield return) by was not nearly as efficient.
			/// Performance is further increased by using value types and removing generics, that is, the LexicographicOrder parellel array.
			/// This is a issue with the .NET CLR not optimizing as well as it could in this infrequently used scenario.
			/// </remarks>
			public bool MoveNext()
			{
				switch (_myPosition)
				{
					case Position.BeforeFirst:
						_myValues.AddRange(_myParent._myValues);
						_myPosition = Position.InSet;
						break;
					case Position.InSet:
						if (_myValues.Count < 2)
						{
							_myPosition = Position.AfterLast;
						}
						else if (!NextPermutation())
						{
							_myPosition = Position.AfterLast;
						}

						break;
					case Position.AfterLast:
						break;
					default:
						throw new ArgumentOutOfRangeException();
				}

				return _myPosition != Position.AfterLast;
			}

			object IEnumerator.Current => Current;
			/// <summary>
			/// The current permutation.
			/// </summary>
			public IReadOnlyList<T> Current
			{
				get
				{
					if (_myPosition == Position.InSet)
						return new List<T>(_myValues);
					throw new InvalidOperationException();
				}
			}

			/// <inheritdoc/>
			public void Dispose()
			{
			}

			/// <summary>
			/// Calculates the next lexicographical permutation of the set.
			/// This is a permutation with repetition where values that compare as equal will not 
			/// swap positions to create a new permutation.
			/// http://www.cut-the-knot.org/do_you_know/AllPerm.shtml
			/// E. W. Dijkstra, A Discipline of Programming, Prentice-Hall, 1997  
			/// </summary>
			/// <returns>True if a new permutation has been returned, false if not.</returns>
			/// <remarks>
			/// This uses the integers of the lexicographical order of the values so that any
			/// comparison of values are only performed during initialization. 
			/// </remarks>
			private bool NextPermutation()
			{
				var i = _myLexicographicalOrders.Length - 1;
				while (_myLexicographicalOrders[i - 1] >= _myLexicographicalOrders[i])
				{
					--i;
					if (i == 0)
					{
						return false;
					}
				}

				var j = _myLexicographicalOrders.Length;
				while (_myLexicographicalOrders[j - 1] <= _myLexicographicalOrders[i - 1])
				{
					--j;
				}

				Swap(i - 1, j - 1);
				++i;
				j = _myLexicographicalOrders.Length;
				while (i < j)
				{
					Swap(i - 1, j - 1);
					++i;
					--j;
				}

				return true;
			}

			/// <summary>
			/// Helper function for swapping two elements within the internal collection.
			/// This swaps both the lexicographical order and the values, maintaining the parallel array.
			/// </summary>
			private void Swap(int i, int j)
			{
				var temp = _myValues[i];
				_myValues[i] = _myValues[j];
				_myValues[j] = temp;
				_myKviTemp = _myLexicographicalOrders[i];
				_myLexicographicalOrders[i] = _myLexicographicalOrders[j];
				_myLexicographicalOrders[j] = _myKviTemp;
			}

			/// <summary>
			/// Single instance of swap variable for int, small performance improvement over declaring in Swap function scope.
			/// </summary>
			private int _myKviTemp;
			/// <summary>
			/// Flag indicating the position of the enumerator.
			/// </summary>
			private Position _myPosition = Position.BeforeFirst;
			/// <summary>
			/// Parallel array of integers that represent the location of items in the myValues array.
			/// This is generated at Initialization and is used as a performance speed up rather that
			/// comparing T each time, much faster to let the CLR optimize around integers.
			/// </summary>
			private readonly int[] _myLexicographicalOrders;
			/// <summary>
			/// The list of values that are current to the enumerator.
			/// </summary>
			private readonly List<T> _myValues;
			/// <summary>
			/// The set of permutations that this enumerator enumerates.
			/// </summary>
			private readonly Permutations<T> _myParent;
			/// <summary>
			/// Internal position type for tracking enumerator position.
			/// </summary>
			private enum Position
			{
				BeforeFirst,
				InSet,
				AfterLast
			}
		}

		/// <summary>
		/// The count of all permutations that will be returned.
		/// If <see cref = "Type"/> is <see cref = "GenerateOption.WithoutRepetition"/>, then this does not count equivalent result sets.  
		/// I.e., count of permutations of "AAB" will be 3 instead of 6.  
		/// If <see cref = "Type"/> is <see cref = "GenerateOption.WithRepetition"/>, then this is all combinations and is therefore N!, where N is the number of values in the input set.
		/// </summary>
		public BigInteger Count { get; }

		/// <summary>
		/// The type of permutations set that is generated.
		/// </summary>
		public GenerateOption Type { get; }

		/// <summary>
		/// The upper index of the meta-collection, equal to the number of items in the input set.
		/// </summary>
		public int UpperIndex => _myValues.Count;
		/// <summary>
		/// The lower index of the meta-collection, equal to the number of items returned each iteration.
		/// This is always equal to <see cref = "UpperIndex"/>.
		/// </summary>
		public int LowerIndex => _myValues.Count;
		/// <summary>
		/// Calculates the total number of permutations that will be returned.  
		/// As this can grow very large, extra effort is taken to avoid overflowing the accumulator.  
		/// While the algorithm looks complex, it really is just collecting numerator and denominator terms
		/// and cancelling out all of the denominator terms before taking the product of the numerator terms.  
		/// </summary>
		/// <returns>The number of permutations.</returns>
		private BigInteger GetCount()
		{
			var runCount = 1;
			var divisors = Enumerable.Empty<int>();
			var numerators = Enumerable.Empty<int>();
			for (var i = 1; i < _myLexicographicOrders.Length; ++i)
			{
				numerators = numerators.Concat(SmallPrimeUtility.Factor(i + 1));
				if (_myLexicographicOrders[i] == _myLexicographicOrders[i - 1])
				{
					++runCount;
				}
				else
				{
					for (var f = 2; f <= runCount; ++f)
						divisors = divisors.Concat(SmallPrimeUtility.Factor(f));
					runCount = 1;
				}
			}

			for (var f = 2; f <= runCount; ++f)
				divisors = divisors.Concat(SmallPrimeUtility.Factor(f));
			return SmallPrimeUtility.EvaluatePrimeFactors(SmallPrimeUtility.DividePrimeFactors(numerators, divisors));
		}

		/// <summary>
		/// A list of T that represents the order of elements as originally provided.
		/// </summary>
		private readonly List<T> _myValues;
		/// <summary>
		/// Parallel array of integers that represent the location of items in the myValues array.
		/// This is generated at Initialization and is used as a performance speed up rather that
		/// comparing T each time, much faster to let the CLR optimize around integers.
		/// </summary>
		private readonly int[] _myLexicographicOrders;
	}
}

namespace Combinatorics.Collections
{
	/// <summary>
	/// Combinations defines a sequence of all possible subsets of a particular size from the set of values.
	/// Within the returned set, there is no prescribed order.
	/// This follows the mathematical concept of choose.
	/// For example, put <c>10</c> dominoes in a hat and pick <c>5</c>.
	/// The number of possible combinations is defined as "10 choose 5", which is calculated as <c>(10!) / ((10 - 5)! * 5!)</c>.
	/// </summary>
	/// <remarks>
	/// The MetaCollectionType parameter of the constructor allows for the creation of
	/// two types of sets,  those with and without repetition in the output set when 
	/// presented with repetition in the input set.
	/// 
	/// When given a input collect {A B C} and lower index of 2, the following sets are generated:
	/// MetaCollectionType.WithRepetition =>
	/// {A A}, {A B}, {A C}, {B B}, {B C}, {C C}
	/// MetaCollectionType.WithoutRepetition =>
	/// {A B}, {A C}, {B C}
	/// 
	/// Input sets with multiple equal values will generate redundant combinations in proportion
	/// to the likelihood of outcome.  For example, {A A B B} and a lower index of 3 will generate:
	/// {A A B} {A A B} {A B B} {A B B}
	/// </remarks>
	/// <typeparam name = "T">The type of the values within the list.</typeparam>
	public sealed class Combinations<T> : IEnumerable<IReadOnlyList<T>>
	{
		/// <summary>
		/// Create a combination set from the provided list of values.
		/// The upper index is calculated as values.Count, the lower index is specified.
		/// Collection type defaults to MetaCollectionType.WithoutRepetition
		/// </summary>
		/// <param name = "values">List of values to select combinations from.</param>
		/// <param name = "lowerIndex">The size of each combination set to return.</param>
		public Combinations(IEnumerable<T> values, int lowerIndex) : this(values, lowerIndex, GenerateOption.WithoutRepetition)
		{
		}

		/// <summary>
		/// Create a combination set from the provided list of values.
		/// The upper index is calculated as values.Count, the lower index is specified.
		/// </summary>
		/// <param name = "values">List of values to select combinations from.</param>
		/// <param name = "lowerIndex">The size of each combination set to return.</param>
		/// <param name = "type">The type of Combinations set to generate.</param>
		public Combinations(IEnumerable<T> values, int lowerIndex, GenerateOption type)
		{
			_ = values ?? throw new ArgumentNullException(nameof(values));
			// Copy the array and parameters and then create a map of booleans that will 
			// be used by a permutations object to reference the subset.  This map is slightly
			// different based on whether the type is with or without repetition.
			// 
			// When the type is WithoutRepetition, then a map of upper index elements is
			// created with lower index false's.  
			// E.g. 8 choose 3 generates:
			// Map: {1 1 1 1 1 0 0 0}
			// Note: For sorting reasons, false denotes inclusion in output.
			// 
			// When the type is WithRepetition, then a map of upper index - 1 + lower index
			// elements is created with the falses indicating that the 'current' element should
			// be included and the trues meaning to advance the 'current' element by one.
			// E.g. 8 choose 3 generates:
			// Map: {1 1 1 1 1 1 1 1 0 0 0} (7 trues, 3 falses).
			Type = type;
			LowerIndex = lowerIndex;
			_myValues = values.ToList();
			List<bool> myMap;
			if (type == GenerateOption.WithoutRepetition)
			{
				myMap = new List<bool>(_myValues.Count);
				myMap.AddRange(_myValues.Select((t, i) => i < _myValues.Count - LowerIndex));
			}
			else
			{
				myMap = new List<bool>(_myValues.Count + LowerIndex - 1);
				for (var i = 0; i < _myValues.Count - 1; ++i)
					myMap.Add(true);
				for (var i = 0; i < LowerIndex; ++i)
					myMap.Add(false);
			}

			_myPermutations = new Permutations<bool>(myMap);
		}

		/// <summary>
		/// Gets an enumerator for collecting the list of combinations.
		/// </summary>
		/// <returns>The enumerator.</returns>
		public IEnumerator<IReadOnlyList<T>> GetEnumerator() => new Enumerator(this);
		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
		/// <summary>
		/// The enumerator that enumerates each meta-collection of the enclosing Combinations class.
		/// </summary>
		public sealed class Enumerator : IEnumerator<IReadOnlyList<T>>
		{
			/// <summary>
			/// Construct a enumerator with the parent object.
			/// </summary>
			/// <param name = "source">The source combinations object.</param>
			public Enumerator(Combinations<T> source)
			{
				_myParent = source;
				_myPermutationsEnumerator = (Permutations<bool>.Enumerator)_myParent._myPermutations.GetEnumerator();
			}

			void IEnumerator.Reset() => throw new NotSupportedException();
			/// <summary>
			/// Advances to the next combination of items from the set.
			/// </summary>
			/// <returns>True if successfully moved to next combination, False if no more unique combinations exist.</returns>
			/// <remarks>
			/// The heavy lifting is done by the permutations object, the combination is generated
			/// by creating a new list of those items that have a true in the permutation parallel array.
			/// </remarks>
			public bool MoveNext()
			{
				var ret = _myPermutationsEnumerator.MoveNext();
				_myCurrentList = null;
				return ret;
			}

			/// <summary>
			/// The current combination
			/// </summary>
			public IReadOnlyList<T> Current
			{
				get
				{
					ComputeCurrent();
					return _myCurrentList!;
				}
			}

			object IEnumerator.Current => Current;
			/// <inheritdoc/>
			public void Dispose() => _myPermutationsEnumerator.Dispose();
			/// <summary>
			/// The only complex function of this entire wrapper, ComputeCurrent() creates
			/// a list of original values from the bool permutation provided.  
			/// The exception for accessing current (InvalidOperationException) is generated
			/// by the call to .Current on the underlying enumeration.
			/// </summary>
			/// <remarks>
			/// To compute the current list of values, the underlying permutation object
			/// which moves with this enumerator, is scanned differently based on the type.
			/// The items have only two values, true and false, which have different meanings:
			/// 
			/// For type WithoutRepetition, the output is a straightforward subset of the input array.  
			/// E.g. 6 choose 3 without repetition
			/// Input array:   {A B C D E F}
			/// Permutations:  {0 1 0 0 1 1}
			/// Generates set: {A   C D    }
			/// Note: size of permutation is equal to upper index.
			/// 
			/// For type WithRepetition, the output is defined by runs of characters and when to 
			/// move to the next element.
			/// E.g. 6 choose 5 with repetition
			/// Input array:   {A B C D E F}
			/// Permutations:  {0 1 0 0 1 1 0 0 1 1}
			/// Generates set: {A   B B     D D    }
			/// Note: size of permutation is equal to upper index - 1 + lower index.
			/// </remarks>
			private void ComputeCurrent()
			{
				if (_myCurrentList != null)
					return;
				_myCurrentList = new List<T>(_myParent.LowerIndex);
				var index = 0;
				var currentPermutation = _myPermutationsEnumerator.Current;
				foreach (var p in currentPermutation)
				{
					if (!p)
					{
						_myCurrentList.Add(_myParent._myValues[index]);
						if (_myParent.Type == GenerateOption.WithoutRepetition)
							++index;
					}
					else
					{
						++index;
					}
				}
			}

			/// <summary>
			/// Parent object this is an enumerator for.
			/// </summary>
			private readonly Combinations<T> _myParent;
			/// <summary>
			/// The current list of values, this is lazy evaluated by the Current property.
			/// </summary>
			private List<T>? _myCurrentList;
			/// <summary>
			/// An enumerator of the parents list of lexicographic orderings.
			/// </summary>
			private readonly Permutations<bool>.Enumerator _myPermutationsEnumerator;
		}

		/// <summary>
		/// The number of unique combinations that are defined in this meta-collection.
		/// This value is mathematically defined as Choose(M, N) where M is the set size
		/// and N is the subset size.  This is M! / (N! * (M-N)!).
		/// </summary>
		public BigInteger Count => _myPermutations.Count;
		/// <summary>
		/// The type of Combinations set that is generated.
		/// </summary>
		public GenerateOption Type { get; }

		/// <summary>
		/// The upper index of the meta-collection, equal to the number of items in the initial set.
		/// </summary>
		public int UpperIndex => _myValues.Count;
		/// <summary>
		/// The lower index of the meta-collection, equal to the number of items returned each iteration.
		/// </summary>
		public int LowerIndex { get; }

		/// <summary>
		/// Copy of values object is initialized with, required for enumerator reset.
		/// </summary>
		private readonly List<T> _myValues;
		/// <summary>
		/// Permutations object that handles permutations on booleans for combination inclusion.
		/// </summary>
		private readonly Permutations<bool> _myPermutations;
	}
}

namespace HelloWorld
{
	static class Program
	{
		public static string replaceAt(this string str, int index, int length, string replace)
		{
			return str.Remove(index, Math.Min(length, str.Length - index)).Insert(index, replace);
		}

		static void Main(string[] args)
		{
			//char[] inputSet = { 'U', 'D', 'L', 'R', 'S', 's', 'A', 'B' };
			string[] inputSet = {"U", "D", "L", "R", "S", "s", "A", "B"};
			int size = 5;
			Combinatorics.Collections.Combinations<string> combinations = new Combinatorics.Collections.Combinations<string>(inputSet, size);
			string cformat = $"Combinations of {{A B C D}} choose {size}: size = {combinations.Count}";
			Console.WriteLine(cformat);
			List<string> allInput = new List<string>();
			foreach (IList<string> c in combinations)
			{
				string xx = "........";
				for (int i = 0; i < size; i++)
				{
					xx = replaceAt(xx, Array.IndexOf(inputSet, c[i]), 1, c[i]);
				}

				//Console.WriteLine(xx);
				allInput.Add(xx);
			}

			int size2 = 3;
			
			Combinatorics.Collections.Combinations<string> combinations2 = new Combinatorics.Collections.Combinations<string>(allInput, size2, Combinatorics.Collections.GenerateOption.WithRepetition);
			//foreach(IList<string> c in combinations2) {
			//	string xx = "";
			//	for (int i = 0; i < size2; i++){
			//		xx  = xx + $"{c[i]} ";
			//	}
			//Console.WriteLine(xx);
			//}
			
			// instead of foreach loop the following method can be used where
			// more than one element is used in one loop
			IEnumerator allGood = combinations2.GetEnumerator();
			allGood.MoveNext();
			allGood.MoveNext();
			allGood.MoveNext();
			allGood.MoveNext();
			
			// IEnumerator.Current returns "object" type element so it needs to be 
			// casted into known type which in this case is "List<string>"
			List<string> nana = (List<string>)allGood.Current;
			
			allGood.MoveNext();
			allGood.MoveNext();
			
			// To be able to print "current" with type casting following can be used
			Console.WriteLine(
			$"{((List<string>)allGood.Current)[2]}");
			
			
		}
	}
}

​x
 
#nullable enable
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
​
namespace Combinatorics.Collections
{
    /// <summary>
    /// Indicates whether a permutation, combination or variation generates equivalent result sets.  
    /// </summary>
    public enum GenerateOption
    {
        /// <summary>
        /// Do not generate equivalent result sets.
        /// </summary>
        WithoutRepetition,
        /// <summary>
        /// Generate equivalent result sets.
        /// </summary>
        WithRepetition,
    }
}
​
namespace Combinatorics.Collections
{
    /// <summary>
    /// Utility class that maintains a small table of prime numbers and provides
    /// simple implementations of Prime Factorization algorithms.  
    /// This is a quick and dirty utility class to support calculations of permutation
    /// sets with indexes under 2^31.
    /// The prime table contains all primes up to Sqrt(2^31) which are all of the primes
    /// requires to factorize any Int32 positive integer.
    /// </summary>
    internal static class SmallPrimeUtility
    {
        /// <summary>
        /// Performs a prime factorization of a given integer using the table of primes in PrimeTable.
        /// Since this will only factor Int32 sized integers, a simple list of factors is returned instead
        /// of the more scalable, but more difficult to consume, list of primes and associated exponents.
        /// </summary>
        /// <param name = "i">The number to factorize, must be positive.</param>
        /// <returns>A simple list of factors.</returns>
        public static List<int> Factor(int i)
        {
            var primeIndex = 0;
            var prime = PrimeTable[primeIndex];
            var factors = new List<int>();
            while (i > 1)
            {
#if NETSTANDARD1_1
                var remainder = i % prime;
                var divResult = remainder == 0 ? i / prime : 0;
#else
                var divResult = Math.DivRem(i, prime, out var remainder);
#endif
                if (remainder == 0)
                {
                    factors.Add(prime);
                    i = divResult;
                }
                else
                {
                    ++primeIndex;
                    prime = PrimeTable[primeIndex];
                }
            }
​
            return factors;
        }
​
        /// <summary>
        /// Given two integers expressed as a list of prime factors, divides these numbers
        /// and returns an integer also expressed as a set of prime factors.
        /// If the result is not a integer, then the result is undefined.  That is, 11 / 5
        /// when divided by this function will not yield a correct result.
        /// As such, this function is ONLY useful for division with combinatorial results where 
        /// the result is known to be an integer AND the division occurs as the last operation(s).
        /// </summary>
        /// <param name = "numerator">Numerator argument, expressed as list of prime factors.</param>
        /// <param name = "denominator">Denominator argument, expressed as list of prime factors.</param>
        /// <returns>Resultant, expressed as list of prime factors.</returns>
        public static List<int> DividePrimeFactors(IEnumerable<int> numerator, IEnumerable<int> denominator)
        {
            _ = numerator ?? throw new ArgumentNullException(nameof(numerator));
            _ = denominator ?? throw new ArgumentNullException(nameof(denominator));
            var product = numerator.ToList();
            foreach (var prime in denominator)
                product.Remove(prime);
            return product;
        }
​
        /// <summary>
        /// Given a list of prime factors returns the long representation.
        /// </summary>
        /// <param name = "value">Integer, expressed as list of prime factors.</param>
        /// <returns>Standard long representation.</returns>
        public static BigInteger EvaluatePrimeFactors(IEnumerable<int> value)
        {
            _ = value ?? throw new ArgumentNullException(nameof(value));
            BigInteger result = 1;
            foreach (var prime in value)
                result *= prime;
            return result;
        }
​
        /// <summary>
        /// Static initializer, set up prime table.
        /// </summary>
        static SmallPrimeUtility()
        {
            PrimeTable = CalculatePrimes();
        }
​
        /// <summary>
        /// Calculate all primes up to Sqrt(2^32) = 2^16.  
        /// This table will be large enough for all factorizations for Int32's.
        /// Small tables are best built using the Sieve Of Eratosthenes,
        /// Reference: http://primes.utm.edu/glossary/page.php?sort=SieveOfEratosthenes
        /// </summary>
        private static IReadOnlyList<int> CalculatePrimes()
        {
            // Build Sieve Of Eratosthenes
            var sieve = new BitArray(65536, true);
            for (var possiblePrime = 2; possiblePrime <= 256; ++possiblePrime)
            {
                if (!sieve[possiblePrime])
                    continue;
                // It is prime, so remove all future factors...
                for (var nonPrime = 2 * possiblePrime; nonPrime < 65536; nonPrime += possiblePrime)
                    sieve[nonPrime] = false;
            }
​
            // Scan sieve for primes...
            var primes = new List<int>();
            for (var i = 2; i < 65536; ++i)
            {
                if (sieve[i])
                    primes.Add(i);
            }
​
            return primes;
        }
​
        /// <summary>
        /// A List of all primes from 2 to 2^16.
        /// </summary>
        public static IReadOnlyList<int> PrimeTable { get; }
    }
}
​
namespace Combinatorics.Collections
{
    /// <summary>
    /// Variations defines a sequence of all possible ordered subsets of a particular size from the set of values.  
    /// </summary>
    /// <remarks>
    /// The MetaCollectionType parameter of the constructor allows for the creation of
    /// normal Variations and Variations with Repetition.
    /// 
    /// When given an input collect {A B C} and lower index of 2, the following sets are generated:
    /// MetaCollectionType.WithoutRepetition generates 6 sets: =>
    ///     {A B}, {A B}, {B A}, {B C}, {C A}, {C B}
    /// MetaCollectionType.WithRepetition generates 9 sets:
    ///     {A A}, {A B}, {A B}, {B A}, {B B }, {B C}, {C A}, {C B}, {C C}
    /// 
    /// The equality of multiple inputs is not considered when generating variations.
    /// </remarks>
    /// <typeparam name = "T">The type of the values within the list.</typeparam>
    public sealed class Variations<T> : IEnumerable<IReadOnlyList<T>>
    {
        /// <summary>
        /// Create a variation set from the indicated list of values.
        /// The upper index is calculated as values.Count, the lower index is specified.
        /// Collection type defaults to MetaCollectionType.WithoutRepetition
        /// </summary>
        /// <param name = "values">List of values to select Variations from.</param>
        /// <param name = "lowerIndex">The size of each variation set to return.</param>
        public Variations(IEnumerable<T> values, int lowerIndex) : this(values, lowerIndex, GenerateOption.WithoutRepetition)
        {
        }
​
        /// <summary>
        /// Create a variation set from the indicated list of values.
        /// The upper index is calculated as values.Count, the lower index is specified.
        /// </summary>
        /// <param name = "values">List of values to select variations from.</param>
        /// <param name = "lowerIndex">The size of each variation set to return.</param>
        /// <param name = "type">Type indicates whether to use repetition in set generation.</param>
        public Variations(IEnumerable<T> values, int lowerIndex, GenerateOption type)
        {
            Type = type;
            LowerIndex = lowerIndex;
            _myValues = values.ToList();
            if (type != GenerateOption.WithoutRepetition)
            {
                return;
            }
​
            var myMap = new List<int>(_myValues.Count);
            var index = 0;
            for (var i = 0; i < _myValues.Count; ++i)
                myMap.Add(i >= _myValues.Count - LowerIndex ? index++ : int.MaxValue);
            _myPermutations = new Permutations<int>(myMap);
        }
​
        /// <summary>
        /// Gets an enumerator for the collection of Variations.
        /// </summary>
        /// <returns>The enumerator.</returns>
        public IEnumerator<IReadOnlyList<T>> GetEnumerator() => Type == GenerateOption.WithRepetition ? (IEnumerator<IReadOnlyList<T>>)new EnumeratorWithRepetition(this) : new EnumeratorWithoutRepetition(this);
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        /// <summary>
        /// An enumerator for Variations when the type is set to WithRepetition.
        /// </summary>
        public sealed class EnumeratorWithRepetition : IEnumerator<IReadOnlyList<T>>
        {
            /// <summary>
            /// Construct a enumerator with the parent object.
            /// </summary>
            /// <param name = "source">The source Variations object.</param>
            public EnumeratorWithRepetition(Variations<T> source)
            {
                _myParent = source;
                _myCurrentList = null;
                _myListIndexes = null;
            }
​
            void IEnumerator.Reset() => throw new NotSupportedException();
            /// <summary>
            /// Advances to the next variation.
            /// </summary>
            /// <returns>True if successfully moved to next variation, False if no more variations exist.</returns>
            /// <remarks>
            /// Increments the internal myListIndexes collection by incrementing the last index
            /// and overflow/carrying into others just like grade-school arithmetic.  If the 
            /// final carry flag is set, then we would wrap around and are therefore done.
            /// </remarks>
            public bool MoveNext()
            {
                var carry = 1;
                if (_myListIndexes == null)
                {
                    _myListIndexes = new List<int>(_myParent.LowerIndex);
                    for (var i = 0; i < _myParent.LowerIndex; ++i)
                    {
                        _myListIndexes.Add(0);
                    }
​
                    carry = 0;
                }
                else
                {
                    for (var i = _myListIndexes.Count - 1; i >= 0 && carry > 0; --i)
                    {
                        _myListIndexes[i] += carry;
                        carry = 0;
                        if (_myListIndexes[i] < _myParent.UpperIndex)
                        {
                            continue;
                        }
​
                        _myListIndexes[i] = 0;
                        carry = 1;
                    }
                }
​
                _myCurrentList = null;
                return carry != 1;
            }
​
            /// <summary>
            /// The current variation
            /// </summary>
            public IReadOnlyList<T> Current
            {
                get
                {
                    ComputeCurrent();
                    return _myCurrentList!;
                }
            }
​
            object IEnumerator.Current => Current;
            /// <inheritdoc/>
            public void Dispose()
            {
            }
​
            /// <summary>
            /// Computes the current list based on the internal list index.
            /// </summary>
            private void ComputeCurrent()
            {
                if (_myCurrentList != null)
                {
                    return;
                }
​
                _ = _myListIndexes ?? throw new InvalidOperationException($"Cannot call {nameof(Current)} before calling {nameof(MoveNext)}.");
                _myCurrentList = new List<T>(_myListIndexes.Count);
                foreach (var index in _myListIndexes)
                    _myCurrentList.Add(_myParent._myValues[index]);
            }
​
            /// <summary>
            /// Parent object this is an enumerator for.
            /// </summary>
            private readonly Variations<T> _myParent;
            /// <summary>
            /// The current list of values, this is lazy evaluated by the Current property.
            /// </summary>
            private List<T>? _myCurrentList;
            /// <summary>
            /// An enumerator of the parents list of lexicographic orderings.
            /// </summary>
            private List<int>? _myListIndexes;
        }
​
        /// <summary>
        /// An enumerator for Variations when the type is set to WithoutRepetition.
        /// </summary>
        public sealed class EnumeratorWithoutRepetition : IEnumerator<IReadOnlyList<T>>
        {
            /// <summary>
            /// Construct a enumerator with the parent object.
            /// </summary>
            /// <param name = "source">The source Variations object.</param>
            public EnumeratorWithoutRepetition(Variations<T> source)
            {
                _myParent = source;
                _myPermutationsEnumerator = (Permutations<int>.Enumerator)_myParent._myPermutations!.GetEnumerator();
            }
​
            void IEnumerator.Reset() => throw new NotSupportedException();
            /// <summary>
            /// Advances to the next variation.
            /// </summary>
            /// <returns>True if successfully moved to next variation, False if no more variations exist.</returns>
            public bool MoveNext()
            {
                var ret = _myPermutationsEnumerator.MoveNext();
                _myCurrentList = null;
                return ret;
            }
​
            /// <summary>
            /// The current variation.
            /// </summary>
            public IReadOnlyList<T> Current
            {
                get
                {
                    ComputeCurrent();
                    return _myCurrentList!;
                }
            }
​
            object IEnumerator.Current => Current;
            /// <inheritdoc/>
            public void Dispose() => _myPermutationsEnumerator.Dispose();
            /// <summary>
            /// Creates a list of original values from the int permutation provided.  
            /// The exception for accessing current (InvalidOperationException) is generated
            /// by the call to .Current on the underlying enumeration.
            /// </summary>
            /// <remarks>
            /// To compute the current list of values, the element to use is determined by 
            /// a permutation position with a non-MaxValue value.  It is placed at the position in the
            /// output that the index value indicates.
            /// 
            /// E.g. Variations of 6 choose 3 without repetition
            /// Input array:   {A B C D E F}
            /// Permutations:  {- 1 - - 3 2} (- is Int32.MaxValue)
            /// Generates set: {B F E}
            /// </remarks>
            private void ComputeCurrent()
            {
                if (_myCurrentList != null)
                {
                    return;
                }
​
                _myCurrentList = new List<T>(_myParent.LowerIndex);
                var index = 0;
                var currentPermutation = _myPermutationsEnumerator.Current;
                for (var i = 0; i < _myParent.LowerIndex; ++i)
                {
                    _myCurrentList.Add(_myParent._myValues[0]);
                }
​
                foreach (var position in currentPermutation)
                {
                    if (position != int.MaxValue)
                    {
                        _myCurrentList[position] = _myParent._myValues[index];
                        if (_myParent.Type == GenerateOption.WithoutRepetition)
                        {
                            ++index;
                        }
                    }
                    else
                    {
                        ++index;
                    }
                }
            }
​
            /// <summary>
            /// Parent object this is an enumerator for.
            /// </summary>
            private readonly Variations<T> _myParent;
            /// <summary>
            /// The current list of values, this is lazy evaluated by the Current property.
            /// </summary>
            private List<T>? _myCurrentList;
            /// <summary>
            /// An enumerator of the parents list of lexicographic orderings.
            /// </summary>
            private readonly Permutations<int>.Enumerator _myPermutationsEnumerator;
        }
​
        /// <summary>
        /// The number of unique variations that are defined in this meta-collection.
        /// </summary>
        /// <remarks>
        /// Variations with repetitions does not behave like other meta-collections and it's
        /// count is equal to N^P, where N is the upper index and P is the lower index.
        /// </remarks>
        public BigInteger Count => Type == GenerateOption.WithoutRepetition ? _myPermutations!.Count : BigInteger.Pow(UpperIndex, LowerIndex);
        /// <summary>
        /// The type of Variations set that is generated.
        /// </summary>
        public GenerateOption Type { get; }
​
        /// <summary>
        /// The upper index of the meta-collection, equal to the number of items in the initial set.
        /// </summary>
        public int UpperIndex => _myValues.Count;
        /// <summary>
        /// The lower index of the meta-collection, equal to the number of items returned each iteration.
        /// </summary>
        public int LowerIndex { get; }
​
        /// <summary>
        /// Copy of values object is initialized with, required for enumerator reset.
        /// </summary>
        private readonly List<T> _myValues;
        /// <summary>
        /// Permutations object that handles permutations on int for variation inclusion and ordering.
        /// </summary>
        private readonly Permutations<int>? _myPermutations;
    }
}
​
namespace Combinatorics.Collections
{
    /// <summary>
    /// Permutations defines a sequence of all possible orderings of a set of values.
    /// </summary>
    /// <remarks>
    /// When given a input collect {A A B}, the following sets are generated:
    /// MetaCollectionType.WithRepetition =>
    /// {A A B}, {A B A}, {A A B}, {A B A}, {B A A}, {B A A}
    /// MetaCollectionType.WithoutRepetition =>
    /// {A A B}, {A B A}, {B A A}
    /// 
    /// When generating non-repetition sets, ordering is based on the lexicographic 
    /// ordering of the lists based on the provided Comparer.  
    /// If no comparer is provided, then T must be IComparable on T.
    /// 
    /// When generating repetition sets, no comparisons are performed and therefore
    /// no comparer is required and T does not need to be IComparable.
    /// </remarks>
    /// <typeparam name = "T">The type of the values within the list.</typeparam>
    public sealed class Permutations<T> : IEnumerable<IReadOnlyList<T>>
    {
        /// <summary>
        /// Create a permutation set from the provided list of values.  
        /// The values (T) must implement IComparable.  
        /// If T does not implement IComparable use a constructor with an explicit IComparer.
        /// The repetition type defaults to MetaCollectionType.WithholdRepetitionSets
        /// </summary>
        /// <param name = "values">List of values to permute.</param>
        public Permutations(IEnumerable<T> values) : this(values, GenerateOption.WithoutRepetition, null)
        {
        }
​
        /// <summary>
        /// Create a permutation set from the provided list of values.  
        /// If type is MetaCollectionType.WithholdRepetitionSets, then values (T) must implement IComparable.  
        /// If T does not implement IComparable use a constructor with an explicit IComparer.
        /// </summary>
        /// <param name = "values">List of values to permute.</param>
        /// <param name = "type">The type of permutation set to calculate.</param>
        public Permutations(IEnumerable<T> values, GenerateOption type) : this(values, type, null)
        {
        }
​
        /// <summary>
        /// Create a permutation set from the provided list of values.  
        /// The values will be compared using the supplied IComparer.
        /// The repetition type defaults to MetaCollectionType.WithholdRepetitionSets
        /// </summary>
        /// <param name = "values">List of values to permute.</param>
        /// <param name = "comparer">Comparer used for defining the lexicographic order.</param>
        public Permutations(IEnumerable<T> values, IComparer<T>? comparer) : this(values, GenerateOption.WithoutRepetition, comparer)
        {
        }
​
        /// <summary>
        /// Create a permutation set from the provided list of values.  
        /// If type is MetaCollectionType.WithholdRepetitionSets, then the values will be compared using the supplied IComparer.
        /// </summary>
        /// <param name = "values">List of values to permute.</param>
        /// <param name = "type">The type of permutation set to calculate.</param>
        /// <param name = "comparer">Comparer used for defining the lexicographic order.</param>
        public Permutations(IEnumerable<T> values, GenerateOption type, IComparer<T>? comparer)
        {
            _ = values ?? throw new ArgumentNullException(nameof(values));
            // Copy information provided and then create a parallel int array of lexicographic
            // orders that will be used for the actual permutation algorithm.  
            // The input array is first sorted as required for WithoutRepetition and always just for consistency.
            // This array is constructed one of two way depending on the type of the collection.
            //
            // When type is MetaCollectionType.WithRepetition, then all N! permutations are returned
            // and the lexicographic orders are simply generated as 1, 2, ... N.  
            // E.g.
            // Input array:          {A A B C D E E}
            // Lexicographic Orders: {1 2 3 4 5 6 7}
            // 
            // When type is MetaCollectionType.WithoutRepetition, then fewer are generated, with each
            // identical element in the input array not repeated.  The lexicographic sort algorithm
            // handles this natively as long as the repetition is repeated.
            // E.g.
            // Input array:          {A A B C D E E}
            // Lexicographic Orders: {1 1 2 3 4 5 5}
            Type = type;
            _myValues = values.ToList();
            _myLexicographicOrders = new int[_myValues.Count];
            if (type == GenerateOption.WithRepetition)
            {
                for (var i = 0; i < _myLexicographicOrders.Length; ++i)
                {
                    _myLexicographicOrders[i] = i;
                }
            }
            else
            {
                comparer ??= Comparer<T>.Default;
                _myValues.Sort(comparer);
                var j = 1;
                if (_myLexicographicOrders.Length > 0)
                {
                    _myLexicographicOrders[0] = j;
                }
​
                for (var i = 1; i < _myLexicographicOrders.Length; ++i)
                {
                    if (comparer.Compare(_myValues[i - 1], _myValues[i]) != 0)
                    {
                        ++j;
                    }
​
                    _myLexicographicOrders[i] = j;
                }
            }
​
            Count = GetCount();
        }
​
        /// <summary>
        /// Gets an enumerator for collecting the list of permutations.
        /// </summary>
        /// <returns>The enumerator.</returns>
        public IEnumerator<IReadOnlyList<T>> GetEnumerator() => new Enumerator(this);
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        /// <summary>
        /// The enumerator that enumerates each meta-collection of the enclosing Permutations class.
        /// </summary>
        public sealed class Enumerator : IEnumerator<IReadOnlyList<T>>
        {
            /// <summary>
            /// Construct a enumerator with the parent object.
            /// </summary>
            /// <param name = "source">The source Permutations object.</param>
            public Enumerator(Permutations<T> source)
            {
                _ = source ?? throw new ArgumentNullException(nameof(source));
                _myParent = source;
                _myLexicographicalOrders = new int[source._myLexicographicOrders.Length];
                _myValues = new List<T>(source._myValues.Count);
                source._myLexicographicOrders.CopyTo(_myLexicographicalOrders, 0);
                _myPosition = Position.BeforeFirst;
            }
​
            void IEnumerator.Reset() => throw new NotSupportedException();
            /// <summary>
            /// Advances to the next permutation.
            /// </summary>
            /// <returns>True if successfully moved to next permutation, False if no more permutations exist.</returns>
            /// <remarks>
            /// Continuation was tried (i.e. yield return) by was not nearly as efficient.
            /// Performance is further increased by using value types and removing generics, that is, the LexicographicOrder parellel array.
            /// This is a issue with the .NET CLR not optimizing as well as it could in this infrequently used scenario.
            /// </remarks>
            public bool MoveNext()
            {
                switch (_myPosition)
                {
                    case Position.BeforeFirst:
                        _myValues.AddRange(_myParent._myValues);
                        _myPosition = Position.InSet;
                        break;
                    case Position.InSet:
                        if (_myValues.Count < 2)
                        {
                            _myPosition = Position.AfterLast;
                        }
                        else if (!NextPermutation())
                        {
                            _myPosition = Position.AfterLast;
                        }
​
                        break;
                    case Position.AfterLast:
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
​
                return _myPosition != Position.AfterLast;
            }
​
            object IEnumerator.Current => Current;
            /// <summary>
            /// The current permutation.
            /// </summary>
            public IReadOnlyList<T> Current
            {
                get
                {
                    if (_myPosition == Position.InSet)
                        return new List<T>(_myValues);
                    throw new InvalidOperationException();
                }
            }
​
            /// <inheritdoc/>
            public void Dispose()
            {
            }
​
            /// <summary>
            /// Calculates the next lexicographical permutation of the set.
            /// This is a permutation with repetition where values that compare as equal will not 
            /// swap positions to create a new permutation.
            /// http://www.cut-the-knot.org/do_you_know/AllPerm.shtml
            /// E. W. Dijkstra, A Discipline of Programming, Prentice-Hall, 1997  
            /// </summary>
            /// <returns>True if a new permutation has been returned, false if not.</returns>
            /// <remarks>
            /// This uses the integers of the lexicographical order of the values so that any
            /// comparison of values are only performed during initialization. 
            /// </remarks>
            private bool NextPermutation()
            {
                var i = _myLexicographicalOrders.Length - 1;
                while (_myLexicographicalOrders[i - 1] >= _myLexicographicalOrders[i])
                {
                    --i;
                    if (i == 0)
                    {
                        return false;
                    }
                }
​
                var j = _myLexicographicalOrders.Length;
                while (_myLexicographicalOrders[j - 1] <= _myLexicographicalOrders[i - 1])
                {
                    --j;
                }
​
                Swap(i - 1, j - 1);
                ++i;
                j = _myLexicographicalOrders.Length;
                while (i < j)
                {
                    Swap(i - 1, j - 1);
                    ++i;
                    --j;
                }
​
                return true;
            }
​
            /// <summary>
            /// Helper function for swapping two elements within the internal collection.
            /// This swaps both the lexicographical order and the values, maintaining the parallel array.
            /// </summary>
            private void Swap(int i, int j)
            {
                var temp = _myValues[i];
                _myValues[i] = _myValues[j];
                _myValues[j] = temp;
                _myKviTemp = _myLexicographicalOrders[i];
                _myLexicographicalOrders[i] = _myLexicographicalOrders[j];
                _myLexicographicalOrders[j] = _myKviTemp;
            }
​
            /// <summary>
            /// Single instance of swap variable for int, small performance improvement over declaring in Swap function scope.
            /// </summary>
            private int _myKviTemp;
            /// <summary>
            /// Flag indicating the position of the enumerator.
            /// </summary>
            private Position _myPosition = Position.BeforeFirst;
            /// <summary>
            /// Parallel array of integers that represent the location of items in the myValues array.
            /// This is generated at Initialization and is used as a performance speed up rather that
            /// comparing T each time, much faster to let the CLR optimize around integers.
            /// </summary>
            private readonly int[] _myLexicographicalOrders;
            /// <summary>
            /// The list of values that are current to the enumerator.
            /// </summary>
            private readonly List<T> _myValues;
            /// <summary>
            /// The set of permutations that this enumerator enumerates.
            /// </summary>
            private readonly Permutations<T> _myParent;
            /// <summary>
            /// Internal position type for tracking enumerator position.
            /// </summary>
            private enum Position
            {
                BeforeFirst,
                InSet,
                AfterLast
            }
        }
​
        /// <summary>
        /// The count of all permutations that will be returned.
        /// If <see cref = "Type"/> is <see cref = "GenerateOption.WithoutRepetition"/>, then this does not count equivalent result sets.  
        /// I.e., count of permutations of "AAB" will be 3 instead of 6.  
        /// If <see cref = "Type"/> is <see cref = "GenerateOption.WithRepetition"/>, then this is all combinations and is therefore N!, where N is the number of values in the input set.
        /// </summary>
        public BigInteger Count { get; }
​
        /// <summary>
        /// The type of permutations set that is generated.
        /// </summary>
        public GenerateOption Type { get; }
​
        /// <summary>
        /// The upper index of the meta-collection, equal to the number of items in the input set.
        /// </summary>
        public int UpperIndex => _myValues.Count;
        /// <summary>
        /// The lower index of the meta-collection, equal to the number of items returned each iteration.
        /// This is always equal to <see cref = "UpperIndex"/>.
        /// </summary>
        public int LowerIndex => _myValues.Count;
        /// <summary>
        /// Calculates the total number of permutations that will be returned.  
        /// As this can grow very large, extra effort is taken to avoid overflowing the accumulator.  
        /// While the algorithm looks complex, it really is just collecting numerator and denominator terms
        /// and cancelling out all of the denominator terms before taking the product of the numerator terms.  
        /// </summary>
        /// <returns>The number of permutations.</returns>
        private BigInteger GetCount()
        {
            var runCount = 1;
            var divisors = Enumerable.Empty<int>();
            var numerators = Enumerable.Empty<int>();
            for (var i = 1; i < _myLexicographicOrders.Length; ++i)
            {
                numerators = numerators.Concat(SmallPrimeUtility.Factor(i + 1));
                if (_myLexicographicOrders[i] == _myLexicographicOrders[i - 1])
                {
                    ++runCount;
                }
                else
                {
                    for (var f = 2; f <= runCount; ++f)
                        divisors = divisors.Concat(SmallPrimeUtility.Factor(f));
                    runCount = 1;
                }
            }
​
            for (var f = 2; f <= runCount; ++f)
                divisors = divisors.Concat(SmallPrimeUtility.Factor(f));
            return SmallPrimeUtility.EvaluatePrimeFactors(SmallPrimeUtility.DividePrimeFactors(numerators, divisors));
        }
​
        /// <summary>
        /// A list of T that represents the order of elements as originally provided.
        /// </summary>
        private readonly List<T> _myValues;
        /// <summary>
        /// Parallel array of integers that represent the location of items in the myValues array.
        /// This is generated at Initialization and is used as a performance speed up rather that
        /// comparing T each time, much faster to let the CLR optimize around integers.
        /// </summary>
        private readonly int[] _myLexicographicOrders;
    }
}
​
namespace Combinatorics.Collections
{
    /// <summary>
    /// Combinations defines a sequence of all possible subsets of a particular size from the set of values.
    /// Within the returned set, there is no prescribed order.
    /// This follows the mathematical concept of choose.
    /// For example, put <c>10</c> dominoes in a hat and pick <c>5</c>.
    /// The number of possible combinations is defined as "10 choose 5", which is calculated as <c>(10!) / ((10 - 5)! * 5!)</c>.
    /// </summary>
    /// <remarks>
    /// The MetaCollectionType parameter of the constructor allows for the creation of
    /// two types of sets,  those with and without repetition in the output set when 
    /// presented with repetition in the input set.
    /// 
    /// When given a input collect {A B C} and lower index of 2, the following sets are generated:
    /// MetaCollectionType.WithRepetition =>
    /// {A A}, {A B}, {A C}, {B B}, {B C}, {C C}
    /// MetaCollectionType.WithoutRepetition =>
    /// {A B}, {A C}, {B C}
    /// 
    /// Input sets with multiple equal values will generate redundant combinations in proportion
    /// to the likelihood of outcome.  For example, {A A B B} and a lower index of 3 will generate:
    /// {A A B} {A A B} {A B B} {A B B}
    /// </remarks>
    /// <typeparam name = "T">The type of the values within the list.</typeparam>
    public sealed class Combinations<T> : IEnumerable<IReadOnlyList<T>>
    {
        /// <summary>
        /// Create a combination set from the provided list of values.
        /// The upper index is calculated as values.Count, the lower index is specified.
        /// Collection type defaults to MetaCollectionType.WithoutRepetition
        /// </summary>
        /// <param name = "values">List of values to select combinations from.</param>
        /// <param name = "lowerIndex">The size of each combination set to return.</param>
        public Combinations(IEnumerable<T> values, int lowerIndex) : this(values, lowerIndex, GenerateOption.WithoutRepetition)
        {
        }
​
        /// <summary>
        /// Create a combination set from the provided list of values.
        /// The upper index is calculated as values.Count, the lower index is specified.
        /// </summary>
        /// <param name = "values">List of values to select combinations from.</param>
        /// <param name = "lowerIndex">The size of each combination set to return.</param>
        /// <param name = "type">The type of Combinations set to generate.</param>
        public Combinations(IEnumerable<T> values, int lowerIndex, GenerateOption type)
        {
            _ = values ?? throw new ArgumentNullException(nameof(values));
            // Copy the array and parameters and then create a map of booleans that will 
            // be used by a permutations object to reference the subset.  This map is slightly
            // different based on whether the type is with or without repetition.
            // 
            // When the type is WithoutRepetition, then a map of upper index elements is
            // created with lower index false's.  
            // E.g. 8 choose 3 generates:
            // Map: {1 1 1 1 1 0 0 0}
            // Note: For sorting reasons, false denotes inclusion in output.
            // 
            // When the type is WithRepetition, then a map of upper index - 1 + lower index
            // elements is created with the falses indicating that the 'current' element should
            // be included and the trues meaning to advance the 'current' element by one.
            // E.g. 8 choose 3 generates:
            // Map: {1 1 1 1 1 1 1 1 0 0 0} (7 trues, 3 falses).
            Type = type;
            LowerIndex = lowerIndex;
            _myValues = values.ToList();
            List<bool> myMap;
            if (type == GenerateOption.WithoutRepetition)
            {
                myMap = new List<bool>(_myValues.Count);
                myMap.AddRange(_myValues.Select((t, i) => i < _myValues.Count - LowerIndex));
            }
            else
            {
                myMap = new List<bool>(_myValues.Count + LowerIndex - 1);
                for (var i = 0; i < _myValues.Count - 1; ++i)
                    myMap.Add(true);
                for (var i = 0; i < LowerIndex; ++i)
                    myMap.Add(false);
            }
​
            _myPermutations = new Permutations<bool>(myMap);
        }
​
        /// <summary>
        /// Gets an enumerator for collecting the list of combinations.
        /// </summary>
        /// <returns>The enumerator.</returns>
        public IEnumerator<IReadOnlyList<T>> GetEnumerator() => new Enumerator(this);
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        /// <summary>
        /// The enumerator that enumerates each meta-collection of the enclosing Combinations class.
        /// </summary>
        public sealed class Enumerator : IEnumerator<IReadOnlyList<T>>
        {
            /// <summary>
            /// Construct a enumerator with the parent object.
            /// </summary>
            /// <param name = "source">The source combinations object.</param>
            public Enumerator(Combinations<T> source)
            {
                _myParent = source;
                _myPermutationsEnumerator = (Permutations<bool>.Enumerator)_myParent._myPermutations.GetEnumerator();
            }
​
            void IEnumerator.Reset() => throw new NotSupportedException();
            /// <summary>
            /// Advances to the next combination of items from the set.
            /// </summary>
            /// <returns>True if successfully moved to next combination, False if no more unique combinations exist.</returns>
            /// <remarks>
            /// The heavy lifting is done by the permutations object, the combination is generated
            /// by creating a new list of those items that have a true in the permutation parallel array.
            /// </remarks>
            public bool MoveNext()
            {
                var ret = _myPermutationsEnumerator.MoveNext();
                _myCurrentList = null;
                return ret;
            }
​
            /// <summary>
            /// The current combination
            /// </summary>
            public IReadOnlyList<T> Current
            {
                get
                {
                    ComputeCurrent();
                    return _myCurrentList!;
                }
            }
​
            object IEnumerator.Current => Current;
            /// <inheritdoc/>
            public void Dispose() => _myPermutationsEnumerator.Dispose();
            /// <summary>
            /// The only complex function of this entire wrapper, ComputeCurrent() creates
            /// a list of original values from the bool permutation provided.  
            /// The exception for accessing current (InvalidOperationException) is generated
            /// by the call to .Current on the underlying enumeration.
            /// </summary>
            /// <remarks>
            /// To compute the current list of values, the underlying permutation object
            /// which moves with this enumerator, is scanned differently based on the type.
            /// The items have only two values, true and false, which have different meanings:
            /// 
            /// For type WithoutRepetition, the output is a straightforward subset of the input array.  
            /// E.g. 6 choose 3 without repetition
            /// Input array:   {A B C D E F}
            /// Permutations:  {0 1 0 0 1 1}
            /// Generates set: {A   C D    }
            /// Note: size of permutation is equal to upper index.
            /// 
            /// For type WithRepetition, the output is defined by runs of characters and when to 
            /// move to the next element.
            /// E.g. 6 choose 5 with repetition
            /// Input array:   {A B C D E F}
            /// Permutations:  {0 1 0 0 1 1 0 0 1 1}
            /// Generates set: {A   B B     D D    }
            /// Note: size of permutation is equal to upper index - 1 + lower index.
            /// </remarks>
            private void ComputeCurrent()
            {
                if (_myCurrentList != null)
                    return;
                _myCurrentList = new List<T>(_myParent.LowerIndex);
                var index = 0;
                var currentPermutation = _myPermutationsEnumerator.Current;
                foreach (var p in currentPermutation)
                {
                    if (!p)
                    {
                        _myCurrentList.Add(_myParent._myValues[index]);
                        if (_myParent.Type == GenerateOption.WithoutRepetition)
                            ++index;
                    }
                    else
                    {
                        ++index;
                    }
                }
            }
​
            /// <summary>
            /// Parent object this is an enumerator for.
            /// </summary>
            private readonly Combinations<T> _myParent;
            /// <summary>
            /// The current list of values, this is lazy evaluated by the Current property.
            /// </summary>
            private List<T>? _myCurrentList;
            /// <summary>
            /// An enumerator of the parents list of lexicographic orderings.
            /// </summary>
            private readonly Permutations<bool>.Enumerator _myPermutationsEnumerator;
        }
​
        /// <summary>
        /// The number of unique combinations that are defined in this meta-collection.
        /// This value is mathematically defined as Choose(M, N) where M is the set size
        /// and N is the subset size.  This is M! / (N! * (M-N)!).
        /// </summary>
        public BigInteger Count => _myPermutations.Count;
        /// <summary>
        /// The type of Combinations set that is generated.
        /// </summary>
        public GenerateOption Type { get; }
​
        /// <summary>
        /// The upper index of the meta-collection, equal to the number of items in the initial set.
        /// </summary>
        public int UpperIndex => _myValues.Count;
        /// <summary>
        /// The lower index of the meta-collection, equal to the number of items returned each iteration.
        /// </summary>
        public int LowerIndex { get; }
​
        /// <summary>
        /// Copy of values object is initialized with, required for enumerator reset.
        /// </summary>
        private readonly List<T> _myValues;
        /// <summary>
        /// Permutations object that handles permutations on booleans for combination inclusion.
        /// </summary>
        private readonly Permutations<bool> _myPermutations;
    }
}
​
namespace HelloWorld
{
    static class Program
    {
        public static string replaceAt(this string str, int index, int length, string replace)
        {
            return str.Remove(index, Math.Min(length, str.Length - index)).Insert(index, replace);
        }
​
        static void Main(string[] args)
        {
            //char[] inputSet = { 'U', 'D', 'L', 'R', 'S', 's', 'A', 'B' };
            string[] inputSet = {"U", "D", "L", "R", "S", "s", "A", "B"};
            int size = 5;
            Combinatorics.Collections.Combinations<string> combinations = new Combinatorics.Collections.Combinations<string>(inputSet, size);
            string cformat = $"Combinations of {{A B C D}} choose {size}: size = {combinations.Count}";
            Console.WriteLine(cformat);
            List<string> allInput = new List<string>();
            foreach (IList<string> c in combinations)
            {
                string xx = "........";
                for (int i = 0; i < size; i++)
                {
                    xx = replaceAt(xx, Array.IndexOf(inputSet, c[i]), 1, c[i]);
                }
​
                //Console.WriteLine(xx);
                allInput.Add(xx);
            }
​
            int size2 = 3;
            
            Combinatorics.Collections.Combinations<string> combinations2 = new Combinatorics.Collections.Combinations<string>(allInput, size2, Combinatorics.Collections.GenerateOption.WithRepetition);
            //foreach(IList<string> c in combinations2) {
            //  string xx = "";
            //  for (int i = 0; i < size2; i++){
            //      xx  = xx + $"{c[i]} ";
            //  }
            //Console.WriteLine(xx);
            //}
            
            // instead of foreach loop the following method can be used where
            // more than one element is used in one loop
            IEnumerator allGood = combinations2.GetEnumerator();
            allGood.MoveNext();
            allGood.MoveNext();
            allGood.MoveNext();
            allGood.MoveNext();
            
            // IEnumerator.Current returns "object" type element so it needs to be 
            // casted into known type which in this case is "List<string>"
            List<string> nana = (List<string>)allGood.Current;
            
            allGood.MoveNext();
            allGood.MoveNext();
            
            // To be able to print "current" with type casting following can be used
            Console.WriteLine(
            $"{((List<string>)allGood.Current)[2]}");
            
            
        }
    }
}

0
10
3
2

Cached Result
Last Run:	8:14:41 am
Compile:	0.126s
Execute:	0s
Memory:	0b
CPU:	0.031s

View IL Code