Finální zdroják testů zhuffle

java

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ArrayTest
{
    class Program
    {

        public static unsafe void BrisingrShuffle(int[] array)
        {
            Random n = new Random();

            double prevNumber = n.NextDouble();
            double magicNumber = n.NextDouble() * 10;
            int variable;
            int length = array.Length - 1;

            int[] randoms = new int[200];
            int currentRand = 0;

            for (int i = 199; i >= 0; i--)
            {
                prevNumber = (prevNumber * magicNumber) % 1;
                randoms[i] = (int)prevNumber * length;
            }

            fixed (int* arr = array)
            {
                for (int i = length / 2; i >= 0; i--, currentRand--)
                {
                    if (currentRand < 0)
                        currentRand = 199;

                    variable = *(arr + i);
                    *(arr + i) = *(arr + randoms[currentRand]);
                    *(arr + randoms[currentRand]) = variable;
                }
            }
        }

        public static void SdracoShuffle(int[] input)
        {
            Random r = new Random();
            for (int i = 0; i < input.Length / 2; i++)
            {
                int a = r.Next(input.Length);
                int b = r.Next(input.Length);
                var c = input[a];
                input[a] = input[b];
                input[b] = c;
            }            
        }

        private static void P4kooShuffle(int[] input)
        {
            Random r = new Random();
            for (int i = input.Length - 1; i >= 0; i--)
            {
                int a = input[i];
                int b = input[r.Next(input.Length)];

                int t = a;
                a = b;
                b = t;
            }
        }

        static void DavidomilShuffle(int[] input, out int[] Output, ushort b)
        {

            ulong delka = (ulong)input.LongLength;
            ulong a = 0;
            int temp;

            for (a = 0; a < delka / 2; a++)
            {
                temp = input[delka - a - 1];
                input[delka - a - 1] = input[a];
                input[a] = temp;
            }


            for (a = 0; a < delka - b; a += 2)
            {
                temp = input[a + b];
                input[a + b] = input[a];
                input[a] = temp;
            }

            Output = input;
        }

        static void Sidecek123Shuffle(int[] array)
        {
            Random r = new Random();
            for (int i = array.Length - 1; i > 0; i--)
            {
                int index = r.Next(i);
                int tmp = array[index];
                array[index] = array[i];
                array[i] = tmp;
            }
        }

        public static void SilviniosShuffle(int[] input)
        {
            // Fisher–Yates shuffle
            // Linear congruential generator: r = (a * r + c) % m, m = 2^31, a=1103515245, c=12345
            int r = (int)DateTime.Now.Ticks;
            for (int i = input.Length - 1; i > 0; i--)
            {
                r = (1103515245 * r + 12345) & 0x7FFFFFFF;
                int j = r % (i + 1);
                int c = input[j];
                input[j] = input[i];
                input[i] = c;
            }
        }

        // Hází index out of bounds
       /* public static void LibcoShuffle(int[] input)
        {
            Random r = new Random((int)DateTime.Now.Ticks);
            Byte[] b = new Byte[input.Length];
            r.NextBytes(b);
            for (int i = 0; i < input.Length; i += 2)
            {
                int c = input[i];
                input[i] = input[b[i]];
                input[b[i]] = c;
            }
        }
        */
        static void LuckinShuffle(int[] arr)
        {
            Random rnd = new Random();
            int size = arr.Length;
            int num = rnd.Next() % (size / 2 - 1) + 1;
            for (int i = 0; i < size; i++)
            {
                int pos = (arr[i] + num + i * 2) % size;
                int temp = arr[i];
                arr[i] = arr[pos];
                arr[pos] = temp;
            }
        }

        static int[][] GenerateArrays(int len, int count)
        {            
            Random random = new Random();
            int[][] arrays = new int[count][];
            for (int i = 0; i < count; i++)
            {
                int length = len;
                if (length < 0)
                    length = random.Next(-(len + 5)) + 5;
                int[] a = new int[length];
                for (int j = 0; j < a.Length; j++)
                {
                    a[j] = random.Next(length / 2);
                }
                arrays[i] = a;
            }
            return arrays;
        }

        static int[] GenerateOrderedArray(int len)
        {
            int[] array = new int[len];
            for (int i = 0; i < len; i++)
                array[i] = i + 1;
            return array;
        }


        static void TestMethods(int size, int count)
        {
            Stopwatch sw = new Stopwatch();

            if (size > 0)
                Console.WriteLine("Test na polích o velikosti {0}, {1} pokusů", size, count);
            else
                Console.WriteLine("Test na polích o náhodné velikosti do {0}, {1} pokusů", -size, count);

            int[][] arrays;
            
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                BrisingrShuffle(arrays[i]);
            }
            sw.Stop();
            Console.WriteLine("Brisingr: {0}", sw.ElapsedMilliseconds);
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                SdracoShuffle(arrays[i]);
            }
            sw.Stop();
            Console.WriteLine("Sdraco: {0}", sw.ElapsedMilliseconds);
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                P4kooShuffle(arrays[i]);
            }
            sw.Stop();
            Console.WriteLine("P4koo: {0}", sw.ElapsedMilliseconds);
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                int[] cast1Out;
                char[] charArray = DateTime.Now.Ticks.ToString().ToCharArray();
                Array.Reverse(charArray);
                ushort nah = Convert.ToUInt16(DateTime.Now.Ticks / Math.Pow(10, charArray.Length));
                DavidomilShuffle(arrays[i], out cast1Out, nah);
                arrays[i] = cast1Out;
            }
            sw.Stop();
            Console.WriteLine("Davidomil: {0}", sw.ElapsedMilliseconds);
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                Sidecek123Shuffle(arrays[i]);
            }
            sw.Stop();
            Console.WriteLine("Sidecek123: {0}", sw.ElapsedMilliseconds);
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                SilviniosShuffle(arrays[i]);
            }
            sw.Stop();
            Console.WriteLine("Silvinios: {0}", sw.ElapsedMilliseconds);
            
            sw.Reset();
            arrays = GenerateArrays(size, count);
            sw.Start();
            for (int i = 0; i < count; i++)
            {
                LuckinShuffle(arrays[i]);
            }
            sw.Stop();
            Console.WriteLine("Luckin: {0}", sw.ElapsedMilliseconds);
            Console.WriteLine();        
        }

        static void OutputArray(int[] array)
        {
            foreach (int a in array)
                Console.Write(a + " ");
            Console.WriteLine();
        }

        static void TestOutput(int length)
        {            
            Console.WriteLine("Test výstupu na polích o velikosti {0}", length);            

            int[] array;
            
            array = GenerateOrderedArray(length);
            Console.WriteLine("Brisingr:");
            BrisingrShuffle(array);
            OutputArray(array);

            array = GenerateOrderedArray(length);
            Console.WriteLine("sdraco:");
            SdracoShuffle(array);
            OutputArray(array);

            array = GenerateOrderedArray(length);
            Console.WriteLine("P4koo:");
            P4kooShuffle(array);
            OutputArray(array);

            array = GenerateOrderedArray(length);
            Console.WriteLine("Davidomil:");

            int[] cast1Out;
            char[] charArray = DateTime.Now.Ticks.ToString().ToCharArray();
            Array.Reverse(charArray);
            ushort nah = Convert.ToUInt16(DateTime.Now.Ticks / Math.Pow(10, charArray.Length));
            DavidomilShuffle(array, out cast1Out, nah);
            array = cast1Out;

            OutputArray(array);

            array = GenerateOrderedArray(length);
            Console.WriteLine("Sidecek123");
            Sidecek123Shuffle(array);
            OutputArray(array);

            array = GenerateOrderedArray(length);
            Console.WriteLine("Silvinios");
            SilviniosShuffle(array);
            OutputArray(array);

            array = GenerateOrderedArray(length);
            Console.WriteLine("Luckin");
            LuckinShuffle(array);
            OutputArray(array);

            Console.WriteLine();  
            
        }

        static void Main(string[] args)
        {
            // test rychlost
            
           TestMethods(10, 200000);
           TestMethods(1000, 25000);
           TestMethods(50000, 500);
            TestMethods(-100, 50000);
            TestMethods(-1000, 10000);    
            TestMethods(-10000, 5000);            

            TestOutput(10);
            TestOutput(100);
            Console.ReadKey();
        }
    }
}

Neformátovaný

Přidáno: 22.9.2013
Expirace: Neuvedeno

Autor: David Hartinger