rn

justcoding121 · justcoding121 · commit 4baca7d5187b · 2017-10-16T20:34:08.000-04:00
diff --git a/Algorithm.Sandbox/Combinatorics/Combination.cs b/Algorithm.Sandbox/Combinatorics/Combination.cs
@@ -8,16 +8,16 @@ namespace Algorithm.Sandbox.Combinatorics
 {
     public class Combination
     {
-        public static List<List<T>> Find<T>(List<T> input, int r, bool enableRepetition)
+        public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition)
         {
             var result = new List<List<T>>();
 
-            Recurse(input, r, enableRepetition, 0, new List<T>(), new HashSet<int>(), result);
+            Recurse(input, r, withRepetition, 0, new List<T>(), new HashSet<int>(), result);
 
             return result;
         }
 
-        private static void Recurse<T>(List<T> input, int r, bool enableRepetition,
+        private static void Recurse<T>(List<T> input, int r, bool withRepetition,
             int k, List<T> prefix, HashSet<int> prefixIndices,
             List<List<T>> result)
         {
@@ -29,15 +29,15 @@ private static void Recurse<T>(List<T> input, int r, bool enableRepetition,
 
             for (int j = k; j < input.Count; j++)
             {
-                if (prefixIndices.Contains(j) && !enableRepetition)
+                if (prefixIndices.Contains(j) && !withRepetition)
                 {
                     continue;
                 }
 
                 prefix.Add(input[j]);
                 prefixIndices.Add(j);
 
-                Recurse(input, r, enableRepetition, j, prefix, prefixIndices, result);
+                Recurse(input, r, withRepetition, j, prefix, prefixIndices, result);
 
                 prefix.RemoveAt(prefix.Count - 1);
                 prefixIndices.Remove(j);
diff --git a/Algorithm.Sandbox/Combinatorics/Permutation.cs b/Algorithm.Sandbox/Combinatorics/Permutation.cs
@@ -8,16 +8,16 @@ namespace Algorithm.Sandbox.Combinatorics
 {
     public class Permutation
     {
-        public static List<List<T>> Find<T>(List<T> input, bool enableRepetition = false)
+        public static List<List<T>> Find<T>(List<T> input, bool withRepetition = false)
         {
             var result = new List<List<T>>();
 
-            Recurse(input, enableRepetition, new List<T>(), new HashSet<int>(), result);
+            Recurse(input, withRepetition, new List<T>(), new HashSet<int>(), result);
 
             return result;
         }
 
-        private static void Recurse<T>(List<T> input, bool enableRepetition,
+        private static void Recurse<T>(List<T> input, bool withRepetition,
             List<T> prefix, HashSet<int> prefixIndices,
             List<List<T>> result)
         {
@@ -29,39 +29,39 @@ private static void Recurse<T>(List<T> input, bool enableRepetition,
 
             for (int j = 0; j < input.Count; j++)
             {
-                if (prefixIndices.Contains(j) && !enableRepetition)
+                if (prefixIndices.Contains(j) && !withRepetition)
                 {
                     continue;
                 }
 
                 prefix.Add(input[j]);
                 prefixIndices.Add(j);
 
-                Recurse(input, enableRepetition, prefix, prefixIndices, result);
+                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 enableRepetition,
-            bool enableInversions) where T : IComparable
+        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, enableRepetition, enableInversions,
+            Recurse(input, withRepetition, withInversions,
                 new List<T>(), new HashSet<int>(), result);
 
             return result;
         }
 
         private static void Recurse<T>(List<T> input,
-            bool enableRepetition, bool enableInversions,
+            bool withRepetition, bool withInversions,
             List<T> prefix, HashSet<int> prefixIndices,
             List<List<T>> result) where T : IComparable
         {
             if (prefix.Count == input.Count
-                && (enableInversions ||
+                && (withInversions ||
                 (prefix.Count > 0 && prefix[0].CompareTo(prefix[prefix.Count - 1]) < 0)))
             {
                 result.Add(new List<T>(prefix));
@@ -75,15 +75,15 @@ private static void Recurse<T>(List<T> input,
 
             for (int j = 0; j < input.Count; j++)
             {
-                if (prefixIndices.Contains(j) && !enableRepetition)
+                if (prefixIndices.Contains(j) && !withRepetition)
                 {
                     continue;
                 }
 
                 prefix.Add(input[j]);
                 prefixIndices.Add(j);
 
-                Recurse(input, enableRepetition, enableInversions, prefix, prefixIndices, result);
+                Recurse(input, withRepetition, withInversions, prefix, prefixIndices, result);
 
                 prefix.RemoveAt(prefix.Count - 1);
                 prefixIndices.Remove(j);
diff --git a/Algorithm.Sandbox/Combinatorics/Variation.cs b/Algorithm.Sandbox/Combinatorics/Variation.cs
@@ -18,16 +18,16 @@ receives at most one element. */
 
         //With repetition
         /* It is the number of all ways of putting r distinct balls into input.Count distinct boxes */
-        public static List<List<T>> Find<T>(List<T> input, int r, bool enableRepetition)
+        public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition)
         {
             var result = new List<List<T>>();
 
-            Recurse(input, r, enableRepetition, 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, int r, bool enableRepetition,
+        private static void Recurse<T>(List<T> input, int r, bool withRepetition,
          List<T> prefix, HashSet<int> prefixIndices,
          List<List<T>> result)
         {
@@ -39,15 +39,15 @@ private static void Recurse<T>(List<T> input, int r, bool enableRepetition,
 
             for (int j = 0; j < input.Count; j++)
             {
-                if (prefixIndices.Contains(j) && !enableRepetition)
+                if (prefixIndices.Contains(j) && !withRepetition)
                 {
                     continue;
                 }
 
                 prefix.Add(input[j]);
                 prefixIndices.Add(j);
 
-                Recurse(input, r, enableRepetition, prefix, prefixIndices, result);
+                Recurse(input, r, withRepetition, prefix, prefixIndices, result);
 
                 prefix.RemoveAt(prefix.Count - 1);
                 prefixIndices.Remove(j);

Original file line number	Diff line number	Diff line change
`@@ -8,16 +8,16 @@ namespace Algorithm.Sandbox.Combinatorics`
`8`	`8`	`{`
`9`	`9`	`public class Combination`
`10`	`10`	`{`
`11`		`- public static List<List<T>> Find<T>(List<T> input, int r, bool enableRepetition)`
	`11`	`+ public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition)`
`12`	`12`	`{`
`13`	`13`	`var result = new List<List<T>>();`
`14`	`14`
`15`		`- Recurse(input, r, enableRepetition, 0, new List<T>(), new HashSet<int>(), result);`
	`15`	`+ Recurse(input, r, withRepetition, 0, new List<T>(), new HashSet<int>(), result);`
`16`	`16`
`17`	`17`	`return result;`
`18`	`18`	`}`
`19`	`19`
`20`		`- private static void Recurse<T>(List<T> input, int r, bool enableRepetition,`
	`20`	`+ private static void Recurse<T>(List<T> input, int r, bool withRepetition,`
`21`	`21`	`int k, List<T> prefix, HashSet<int> prefixIndices,`
`22`	`22`	`List<List<T>> result)`
`23`	`23`	`{`
`@@ -29,15 +29,15 @@ private static void Recurse<T>(List<T> input, int r, bool enableRepetition,`
`29`	`29`
`30`	`30`	`for (int j = k; j < input.Count; j++)`
`31`	`31`	`{`
`32`		`- if (prefixIndices.Contains(j) && !enableRepetition)`
	`32`	`+ if (prefixIndices.Contains(j) && !withRepetition)`
`33`	`33`	`{`
`34`	`34`	`continue;`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`prefix.Add(input[j]);`
`38`	`38`	`prefixIndices.Add(j);`
`39`	`39`
`40`		`- Recurse(input, r, enableRepetition, j, prefix, prefixIndices, result);`
	`40`	`+ Recurse(input, r, withRepetition, j, prefix, prefixIndices, result);`
`41`	`41`
`42`	`42`	`prefix.RemoveAt(prefix.Count - 1);`
`43`	`43`	`prefixIndices.Remove(j);`
Original file line number	Diff line number	Diff line change
`@@ -8,16 +8,16 @@ namespace Algorithm.Sandbox.Combinatorics`
`8`	`8`	`{`
`9`	`9`	`public class Permutation`
`10`	`10`	`{`
`11`		`- public static List<List<T>> Find<T>(List<T> input, bool enableRepetition = false)`
	`11`	`+ public static List<List<T>> Find<T>(List<T> input, bool withRepetition = false)`
`12`	`12`	`{`
`13`	`13`	`var result = new List<List<T>>();`
`14`	`14`
`15`		`- Recurse(input, enableRepetition, new List<T>(), new HashSet<int>(), result);`
	`15`	`+ Recurse(input, withRepetition, new List<T>(), new HashSet<int>(), result);`
`16`	`16`
`17`	`17`	`return result;`
`18`	`18`	`}`
`19`	`19`
`20`		`- private static void Recurse<T>(List<T> input, bool enableRepetition,`
	`20`	`+ private static void Recurse<T>(List<T> input, bool withRepetition,`
`21`	`21`	`List<T> prefix, HashSet<int> prefixIndices,`
`22`	`22`	`List<List<T>> result)`
`23`	`23`	`{`
`@@ -29,39 +29,39 @@ private static void Recurse<T>(List<T> input, bool enableRepetition,`
`29`	`29`
`30`	`30`	`for (int j = 0; j < input.Count; j++)`
`31`	`31`	`{`
`32`		`- if (prefixIndices.Contains(j) && !enableRepetition)`
	`32`	`+ if (prefixIndices.Contains(j) && !withRepetition)`
`33`	`33`	`{`
`34`	`34`	`continue;`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`prefix.Add(input[j]);`
`38`	`38`	`prefixIndices.Add(j);`
`39`	`39`
`40`		`- Recurse(input, enableRepetition, prefix, prefixIndices, result);`
	`40`	`+ Recurse(input, withRepetition, prefix, prefixIndices, result);`
`41`	`41`
`42`	`42`	`prefix.RemoveAt(prefix.Count - 1);`
`43`	`43`	`prefixIndices.Remove(j);`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- public static List<List<T>> Find<T>(List<T> input, bool enableRepetition,`
`48`		`- bool enableInversions) where T : IComparable`
	`47`	`+ public static List<List<T>> Find<T>(List<T> input, bool withRepetition,`
	`48`	`+ bool withInversions) where T : IComparable`
`49`	`49`	`{`
`50`	`50`	`var result = new List<List<T>>();`
`51`	`51`
`52`		`- Recurse(input, enableRepetition, enableInversions,`
	`52`	`+ Recurse(input, withRepetition, withInversions,`
`53`	`53`	`new List<T>(), new HashSet<int>(), result);`
`54`	`54`
`55`	`55`	`return result;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`private static void Recurse<T>(List<T> input,`
`59`		`- bool enableRepetition, bool enableInversions,`
	`59`	`+ bool withRepetition, bool withInversions,`
`60`	`60`	`List<T> prefix, HashSet<int> prefixIndices,`
`61`	`61`	`List<List<T>> result) where T : IComparable`
`62`	`62`	`{`
`63`	`63`	`if (prefix.Count == input.Count`
`64`		`- && (enableInversions \|\|`
	`64`	`+ && (withInversions \|\|`
`65`	`65`	`(prefix.Count > 0 && prefix[0].CompareTo(prefix[prefix.Count - 1]) < 0)))`
`66`	`66`	`{`
`67`	`67`	`result.Add(new List<T>(prefix));`
`@@ -75,15 +75,15 @@ private static void Recurse<T>(List<T> input,`
`75`	`75`
`76`	`76`	`for (int j = 0; j < input.Count; j++)`
`77`	`77`	`{`
`78`		`- if (prefixIndices.Contains(j) && !enableRepetition)`
	`78`	`+ if (prefixIndices.Contains(j) && !withRepetition)`
`79`	`79`	`{`
`80`	`80`	`continue;`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`prefix.Add(input[j]);`
`84`	`84`	`prefixIndices.Add(j);`
`85`	`85`
`86`		`- Recurse(input, enableRepetition, enableInversions, prefix, prefixIndices, result);`
	`86`	`+ Recurse(input, withRepetition, withInversions, prefix, prefixIndices, result);`
`87`	`87`
`88`	`88`	`prefix.RemoveAt(prefix.Count - 1);`
`89`	`89`	`prefixIndices.Remove(j);`
Original file line number	Diff line number	Diff line change
`@@ -18,16 +18,16 @@ receives at most one element. */`
`18`	`18`
`19`	`19`	`//With repetition`
`20`	`20`	`/* It is the number of all ways of putting r distinct balls into input.Count distinct boxes */`
`21`		`- public static List<List<T>> Find<T>(List<T> input, int r, bool enableRepetition)`
	`21`	`+ public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition)`
`22`	`22`	`{`
`23`	`23`	`var result = new List<List<T>>();`
`24`	`24`
`25`		`- Recurse(input, r, enableRepetition, new List<T>(), new HashSet<int>(), result);`
	`25`	`+ Recurse(input, r, withRepetition, new List<T>(), new HashSet<int>(), result);`
`26`	`26`
`27`	`27`	`return result;`
`28`	`28`	`}`
`29`	`29`
`30`		`- private static void Recurse<T>(List<T> input, int r, bool enableRepetition,`
	`30`	`+ private static void Recurse<T>(List<T> input, int r, bool withRepetition,`
`31`	`31`	`List<T> prefix, HashSet<int> prefixIndices,`
`32`	`32`	`List<List<T>> result)`
`33`	`33`	`{`
`@@ -39,15 +39,15 @@ private static void Recurse<T>(List<T> input, int r, bool enableRepetition,`
`39`	`39`
`40`	`40`	`for (int j = 0; j < input.Count; j++)`
`41`	`41`	`{`
`42`		`- if (prefixIndices.Contains(j) && !enableRepetition)`
	`42`	`+ if (prefixIndices.Contains(j) && !withRepetition)`
`43`	`43`	`{`
`44`	`44`	`continue;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`prefix.Add(input[j]);`
`48`	`48`	`prefixIndices.Add(j);`
`49`	`49`
`50`		`- Recurse(input, r, enableRepetition, prefix, prefixIndices, result);`
	`50`	`+ Recurse(input, r, withRepetition, prefix, prefixIndices, result);`
`51`	`51`
`52`	`52`	`prefix.RemoveAt(prefix.Count - 1);`
`53`	`53`	`prefixIndices.Remove(j);`