Permutations. The nth permutation from an ordered set of permutations.

So, I was doing Euler 24 from Project Euler. I thought of an interesting way of find the nth permutation from a set. Here is my solution:

       

Code Snippet

1. /*A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the
2.         digits 1, 2, 3 and 4.
3.         * If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are:
5.         012   021   102   120   201   210
7.         What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
8.         */
9.         //.01 seconds
10.         static void Main(string[] args)
11.         {
12.             Stopwatch sw = new Stopwatch();
13.             sw.Start();
14.             int[] numbers = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
15.             char[] letters = new char[] {'a','b','c','d','e','f','g','h','i','j'};
17.             Console.WriteLine(findPermutationAtElement<int>(numbers, 999999));
19.             Console.WriteLine(findPermutationAtElement<char>(letters, 999999));
22.             sw.Stop();
23.             Console.WriteLine(sw.Elapsed);
24.             Console.ReadLine();
26.         }
28.         private static string findPermutationAtElement<T>(T[] numbers, int p)
29.         {
30.             string answer = "";
31.             ulong totalPerms;
32.             int position;
33.             ulong section;
34.             T[] temp;
35.             int length = numbers.Length;
37.             //make sure array is ordered
38.             numbers = numbers.OrderBy(n => n).ToArray();
40.             for (int i = 0; i < length; i++)
41.             {
42.                 //find number of permutations left
43.                 totalPerms = factorial(numbers.Length);
45.                 //find what section number will fall into
46.                 section = totalPerms / (ulong)numbers.Length;
48.                 //find whole number index
49.                 position = p / (int)section;
51.                 //change p to reflect sub array position
52.                 p = p % (int)section;
54.                 //put value at the end
55.                 answer = answer.Insert(answer.Length, numbers.ElementAt(position).ToString());
57.                 //remove element from array
58.                 temp = new T[numbers.Length - 1];
60.                 for (int j = 0; j < numbers.Length; j++)
61.                 {
62.                     if (j == position)
63.                     {
65.                     }
66.                     else if (j > position)
67.                     {
68.                         temp[j - 1] = numbers[j];
69.                     }
70.                     else
71.                     {
72.                         temp[j] = numbers[j];
73.                     }
74.                 }
76.                 numbers = temp;
78.             }
80.             return answer;
81.         }
83.         private static ulong factorial(int p)
84.         {
85.             if (p == 0)
86.             {
87.                 return 1;
88.             }
90.             return (ulong)p * factorial(p - 1);
91.         }