collection – VDonC#ev

How to generate Permutations with repetition recursively in C#

// 1: [6, 1, 1, 1, 1, 1, 1, 1, 1]
// 2: [1, 6, 1, 1, 1, 1, 1, 1, 1]
// 3: [1, 1, 6, 1, 1, 1, 1, 1, 1]
// 4: [1, 1, 1, 6, 1, 1, 1, 1, 1]
// 5: [1, 1, 1, 1, 6, 1, 1, 1, 1]
// 6: [1, 1, 1, 1, 1, 6, 1, 1, 1]
// 7: [1, 1, 1, 1, 1, 1, 6, 1, 1]
// 8: [1, 1, 1, 1, 1, 1, 1, 6, 1]
// 9: [1, 1, 1, 1, 1, 1, 1, 1, 6]

using System;

public static class PermutationsWithRep
{
    private static int numberOfCombos;

    public static void Main()
    {
        var collection = new[] { 6, 1, 1, 1, 1, 1, 1, 1, 1 };
        PermuteRep(collection);
    }

    private static void PermuteRep<T>(T[] workArray, int? end = null, int start = 0)
        where T : IComparable<T>
    {
        if (end == null)
        {
            end = workArray.Length - 1;
        }

        PrintPerm(workArray);

        for (int left = end.Value - 1; left >= start; left--)
        {
            for (int right = left + 1; right <= end; right++)
                if (workArray[left].CompareTo(workArray[right]) != 0)
                {
                    Swap(ref workArray[left], ref workArray[right]);
                    PermuteRep(workArray, end, left + 1);
                }

            var firstElement = workArray[left];

            for (int i = left; i <= end.Value - 1; i++)
            {
                workArray[i] = workArray[i + 1];
            }

            workArray[end.Value] = firstElement;
        }
    }

    private static void Swap<T>(ref T a, ref T b)
    {
        var temp = a;
        a = b;
        b = temp;
    }

    private static void PrintPerm<T>(T[] arr)
    {
        Console.WriteLine($"{++numberOfCombos}: [{string.Join(", ", arr)}]");
    }
}

Simple dynamic implementation of generic STACK in C#

using System;

public class LinkedStack<T>
{
	private LinkedStackNode<T> firstNode;

	public int Count { get; private set; }

	public void Push(T element)
	{
		var newNode = new LinkedStackNode<T>(element);

		newNode.NextNode = this.firstNode;
		this.firstNode = newNode;

		this.Count++;
	}

	public T Pop()
	{
		if (this.Count <= 0)
		{
			throw new InvalidOperationException("Stack is empty.");
		}

		var nodeToPop = this.firstNode;
		this.firstNode = this.firstNode.NextNode;
		this.Count--;

		return nodeToPop.Value;
	}

	public T Peek()
	{
		var nodeToPeek = this.firstNode;

		return nodeToPeek.Value;
	}

	public T[] ToArray()
	{
		var arr = new T[this.Count];
		var currentNode = this.firstNode;
		var arrIndex = 0;
		while (currentNode != null)
		{
			arr[arrIndex] = currentNode.Value;
			arrIndex++;
			currentNode = currentNode.NextNode;
		}

		return arr;
	}

	private class LinkedStackNode<T>
	{
		public LinkedStackNode(
			T value,
			LinkedStackNode<T> nextNode = null)
		{
			this.Value = value;
		}

		public T Value { get; private set; }

		public LinkedStackNode<T> NextNode { get; set; }
	}
}

Simple static implementation of generic STACK in C#

using System;

public class ArrayStack<T> : IArrayStack<T>
{
	private const int InitialCapacity = 16;

	private T[] internalStorage;
	private int capacity;

	public ArrayStack(int capacity = InitialCapacity)
	{
		this.Capacity = capacity;
		this.internalStorage = new T[this.Capacity];
	}

	public int Count { get; private set; }

	private int Capacity
	{
		get
		{
			return this.capacity;
		}

		set
		{
			if (value <= 0)
			{
				throw new ArgumentOutOfRangeException(
					nameof(value),
					"Capacity should be positive integer number.");
			}

			this.capacity = value;
		}
	}

	public void Push(T element)
	{
		if (this.GrowNeeded())
		{
			this.Grow();
		}

		this.internalStorage[this.Count] = element;
		this.Count++;
	}

	public T Pop()
	{
		if (this.Count <= 0)
		{
			throw new InvalidOperationException("Stack is empty.");
		}
		
		this.Count--;
		var element = this.internalStorage[this.Count];
		this.internalStorage[this.Count] = default(T);

		return element;
	}

	public T Peek()
	{
		var element = this.internalStorage[this.Count - 1];

		return element;
	}

	public T[] ToArray()
	{
		var arr = new T[this.Count];
		this.FillStorage(arr);
		Array.Reverse(arr);

		return arr;
	}

	private bool GrowNeeded()
	{
		var result = this.Count >= this.Capacity;

		return result;
	}

	private void Grow()
	{
		this.Capacity *= 2;
		var newStorage = new T[this.Capacity];
		this.FillStorage(newStorage);
		this.internalStorage = newStorage;
	}

	private void FillStorage(T[] array)
	{
		Array.Copy(this.internalStorage, array, this.Count);
	}
}