using BenchmarkDotNet.Attributes;

using BenchmarkDotNet.Running;

using System;

using System.Collections.Generic;

​

namespace ConsoleCoreBenchmarkSandbox

{

    class Program

    {

        static void Main(string[] args)

        {

            BenchmarkRunner.Run<Benchmarks>();

        }

    }

​

    public class Benchmarks

    {

        [Params(10, 1000, 10000)]

        public int N;

​

        object blah;

​

        [Benchmark] public void RandomUniqueIntsList() => blah = RandomUniqueIntsList(5, 0..N);

​

        [Benchmark] public void RandomUniqueInts() => blah = RandomUniqueInts(5, 0..N);

​

        [Benchmark] public void RandomUniqueInts2() => blah = RandomUniqueInts2(5, 0..N);

​

        [Benchmark] public void RandomUniqueInts3() => blah = RandomUniqueInts3(5, 0..N);

​

        [Benchmark] public void RandomUniqueInts4() => blah = RandomUniqueInts4(5, 0..N);

​

        [GlobalCleanup] public void CleanUp()

        {

            Console.WriteLine(blah);

        }

​

        internal static void Validate(int count, Range range, out int a, out int b)

        {

            (a, b) = range.End.Value < range.Start.Value

                ? (range.End.Value, range.Start.Value)

                : (range.Start.Value, range.End.Value);

            if (count < 0)

                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");

            if (b - a < count)

                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(range));

        }

​

        public static IEnumerable<int> RandomUniqueInts(int count, Range range)

        {

            Validate(count, range, out int a, out int b);

            var rolled = new SortedSet<int>();

            var random = new Random();

            for (int i = 0; i < count; i++)

            {

                int roll = random.Next(a, b - i);

                foreach (int j in rolled)

                {

                    if (j > roll)

                        break;

                    roll++;

                }

                yield return roll;

                rolled.Add(roll);

            }

        }

​

        internal class Node

        {

            internal int Value;

            internal Node Next;

        }

​

        public static IEnumerable<int> RandomUniqueInts2(int count, Range range)

        {

            Validate(count, range, out int a, out int b);

            Node head = null;

            var random = new Random();

            for (int i = 0; i < count; i++)

            {

                int roll = random.Next(a, b - i);

                Node node = head;

                Node previous = null;

                while (!(node is null))

                {

                    if (node.Value > roll)

                        break;

                    roll++;

                    previous = node;

                    node = node.Next;

                }

                yield return roll;

                if (previous is null)

                    head = new Node() { Value = roll, Next = head, };

                else

                    previous.Next = new Node() { Value = roll, Next = previous.Next };

            }

        }

​

        public static IEnumerable<int> RandomUniqueInts3(int count, Range range)

        {

            Validate(count, range, out int a, out int b);

            var rolled = new int[count];

            var random = new Random();

            for (int i = 0; i < count; i++)

            {

                int roll = random.Next(a, b - i);

                int index = 0;

                foreach (int j in rolled)

                {

                    if (index == i)

                        break;

                    if (j > roll)

                        break;

                    roll++;

                    index++;

                }

                yield return roll;

                for (int j = i; j > index; j--)

                    rolled[j] = rolled[j - 1];

                rolled[index] = roll;

            }

        }

​

        public static IEnumerable<int> RandomUniqueInts4(int count, Range range)

        {

            Validate(count, range, out int a, out int b);

            var rolled = new SortedList<int, int>(count);

            var random = new Random();

            for (int i = 0; i < count; i++)

            {

                int roll = random.Next(a, b - i);

                foreach (var j in rolled)

                {

                    if (j.Key > roll)

                        break;

                    roll++;

                }

                yield return roll;

                rolled.Add(roll, roll);

            }

        }

​

        public static IEnumerable<int> RandomUniqueIntsList(int count, Range range)

        {

            Validate(count, range, out int a, out int b);

            var possibleRolls = new List<int>();

            for (int i = a; i < b; i++)

                possibleRolls.Add(i);

            var random = new Random();

            for (int i = 0; i < count; i++)

            {

                int rollIndex = random.Next(0, possibleRolls.Count);

                int roll = possibleRolls[rollIndex];

                possibleRolls.RemoveAt(rollIndex);

                yield return roll;

            }

        }

    }

}

​