include selection option(r) in permutation

Author: justcoding121

Advanced.Algorithms.Tests/Combinatorics/Permutation_Tests.cs

@@ -12,77 +12,64 @@ namespace Advanced.Algorithms.Tests.Combinatorics
     public class Permutation_Tests
     {
         //for verification
-        readonly Func<int, int> factorial = n => n == 0 ? 1 :
+        static readonly Func<int, int> factorial = n => n == 0 ? 1 :
             Enumerable.Range(1, n).Aggregate((acc, x) => acc * x);
 
-
-        [TestMethod]
-        public void Permutation_Without_Repetitions_Smoke_Test()
-        {
-            var input = "".ToCharArray().ToList();
-            var permuations = Permutation.Find<char>(input);
-            Assert.AreEqual(factorial(input.Count), permuations.Count);
-
-            input = "cookie".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input);
-            Assert.AreEqual(factorial(input.Count), permuations.Count);
-
-            input = "monster".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input);
-            Assert.AreEqual(factorial(input.Count), permuations.Count);
-        }
-
+        //for verification
+        static readonly Func<int, int, int> permutation = (int n, int r)
+            => n == 0 || r == 0 ? 1 : factorial(n) / factorial(n - r);
 
         [TestMethod]
         public void Permutation_With_Repetition_Smoke_Test()
         {
             var input = "".ToCharArray().ToList();
-            var permuations = Permutation.Find<char>(input, true);
+            var permuations = Permutation.Find<char>(input, input.Count, true);
             Assert.AreEqual(Math.Pow(input.Count, input.Count), permuations.Count);
 
             input = "pen".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input, true);
+            permuations = Permutation.Find<char>(input, input.Count, true);
             Assert.AreEqual(Math.Pow(input.Count, input.Count), permuations.Count);
 
             input = "scan".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input, true);
+            permuations = Permutation.Find<char>(input, input.Count, true);
             Assert.AreEqual(Math.Pow(input.Count, input.Count), permuations.Count);
-        }
 
-        [TestMethod]
-        public void Permutation_Without_Repetition_Without_Inversions_Smoke_Test()
-        {
-            var input = "".ToCharArray().ToList();
-            var permuations = Permutation.Find<char>(input, false, false);
-            Assert.AreEqual(factorial(input.Count) / 2, permuations.Count);
+            input = "scan".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, 2, true);
+            Assert.AreEqual(Math.Pow(input.Count, 2), permuations.Count);
 
-            input = "abc".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input, false, false);
-            Assert.AreEqual(factorial(input.Count) / 2, permuations.Count);
+            input = "scan".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, 3, true);
+            Assert.AreEqual(Math.Pow(input.Count, 3), permuations.Count);
 
-            input = "acde".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input, false, false);
-            Assert.AreEqual(factorial(input.Count) / 2, permuations.Count);
+            input = "scaner".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, 4, true);
+            Assert.AreEqual(Math.Pow(input.Count, 4), permuations.Count);
         }
 
 
         [TestMethod]
-        public void Permutation_With_Repetition_Without_Inversions_Smoke_Test()
+        public void Permutation_Without_Repetitions_Smoke_Test()
         {
-
             var input = "".ToCharArray().ToList();
-            var permuations = Permutation.Find<char>(input, true, false);
-            Assert.AreEqual(0, permuations.Count);
+            var permuations = Permutation.Find<char>(input, input.Count);
+            Assert.AreEqual(permutation(input.Count, input.Count), permuations.Count);
 
-            input = "pen".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input, true, false);
-            Assert.AreEqual(9, permuations.Count);
+            input = "cookie".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, input.Count);
+            Assert.AreEqual(permutation(input.Count, input.Count), permuations.Count);
 
-            input = "cool".ToCharArray().ToList();
-            permuations = Permutation.Find<char>(input, true, false);
-            Assert.AreEqual(80, permuations.Count);
-        }
+            input = "monster".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, input.Count);
+            Assert.AreEqual(permutation(input.Count, input.Count), permuations.Count);
 
-       
+            input = "cookie".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, 2);
+            Assert.AreEqual(permutation(input.Count, 2), permuations.Count);
+
+            input = "monster".ToCharArray().ToList();
+            permuations = Permutation.Find<char>(input, 3);
+            Assert.AreEqual(permutation(input.Count, 3), permuations.Count);
+        }
     }
 }

Advanced.Algorithms/Combinatorics/Permutation.cs

@@ -8,20 +8,20 @@ namespace Advanced.Algorithms.Combinatorics
 {
     public class Permutation
     {
-        public static List<List<T>> Find<T>(List<T> input, bool withRepetition = false)
+        public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition = false)
         {
             var result = new List<List<T>>();
 
-            Recurse(input, withRepetition, new List<T>(), new HashSet<int>(), result);
+            Recurse(input, r, withRepetition, new List<T>(), new HashSet<int>(), result);
 
             return result;
         }
 
-        private static void Recurse<T>(List<T> input, bool withRepetition,
+        private static void Recurse<T>(List<T> input, int r, bool withRepetition,
             List<T> prefix, HashSet<int> prefixIndices,
             List<List<T>> result)
         {
-            if (prefix.Count == input.Count)
+            if (prefix.Count == r)
             {
                 result.Add(new List<T>(prefix));
                 return;
@@ -37,53 +37,7 @@ private static void Recurse<T>(List<T> input, bool withRepetition,
                 prefix.Add(input[j]);
                 prefixIndices.Add(j);
 
-                Recurse(input, withRepetition, prefix, prefixIndices, result);
-
-                prefix.RemoveAt(prefix.Count - 1);
-                prefixIndices.Remove(j);
-            }
-        }
-
-        public static List<List<T>> Find<T>(List<T> input, bool withRepetition,
-            bool withInversions) where T : IComparable
-        {
-            var result = new List<List<T>>();
-
-            Recurse(input, withRepetition, withInversions,
-                new List<T>(), new HashSet<int>(), result);
-
-            return result;
-        }
-
-        private static void Recurse<T>(List<T> input,
-            bool withRepetition, bool withInversions,
-            List<T> prefix, HashSet<int> prefixIndices,
-            List<List<T>> result) where T : IComparable
-        {
-            if (prefix.Count == input.Count
-                && (withInversions ||
-                (prefix.Count > 0 && prefix[0].CompareTo(prefix[prefix.Count - 1]) < 0)))
-            {
-                result.Add(new List<T>(prefix));
-                return;
-            }
-
-            if (prefix.Count == input.Count)
-            {
-                return;
-            }
-
-            for (int j = 0; j < input.Count; j++)
-            {
-                if (prefixIndices.Contains(j) && !withRepetition)
-                {
-                    continue;
-                }
-
-                prefix.Add(input[j]);
-                prefixIndices.Add(j);
-
-                Recurse(input, withRepetition, withInversions, prefix, prefixIndices, result);
+                Recurse(input, r, withRepetition, prefix, prefixIndices, result);
 
                 prefix.RemoveAt(prefix.Count - 1);
                 prefixIndices.Remove(j);