8-word anagrams performance

README.md

@@ -50,7 +50,7 @@ Number of words|Time to check all anagrams no longer than that|Time to solve "ea
 5|46s|||1.1s|1,348,876,896
 6|34 minutes|||15s|58,837,302,096
 7|11 hours (?)|45s|6.5s|2 minutes|1,108,328,708,976
-8|||||12,089,249,231,856
+8||4 minutes|27s|11 minutes|12,089,249,231,856
 9|||||88,977,349,731,696
 10|||||482,627,715,786,096
 11|||||2,030,917,440,675,696

dotnet/WhiteRabbit/Flattener.cs

@@ -26,11 +26,8 @@
         private static IEnumerable<T[]> Flatten3<T>(T[][] phrase)
         {
             foreach (var item0 in phrase[0])
-            {
             foreach (var item1 in phrase[1])
-                {
             foreach (var item2 in phrase[2])
-                    {
                 yield return new T[]
                 {
                     item0,
@@ -38,21 +35,14 @@
                     item2,
                 };
         }
-                }
-            }
-        }
 
         // Fast hard-coded implementation for 4 words
         private static IEnumerable<T[]> Flatten4<T>(T[][] phrase)
         {
             foreach (var item0 in phrase[0])
-            {
             foreach (var item1 in phrase[1])
-                {
             foreach (var item2 in phrase[2])
-                    {
             foreach (var item3 in phrase[3])
-                        {
                 yield return new T[]
                 {
                     item0,
@@ -61,24 +51,15 @@
                     item3,
                 };
         }
-                    }
-                }
-            }
-        }
 
         // Fast hard-coded implementation for 5 words
         private static IEnumerable<T[]> Flatten5<T>(T[][] phrase)
         {
             foreach (var item0 in phrase[0])
-            {
             foreach (var item1 in phrase[1])
-                {
             foreach (var item2 in phrase[2])
-                    {
             foreach (var item3 in phrase[3])
-                        {
             foreach (var item4 in phrase[4])
-                            {
                 yield return new T[]
                 {
                     item0,
@@ -88,27 +69,16 @@
                     item4,
                 };
         }
-                        }
-                    }
-                }
-            }
-        }
 
         // Fast hard-coded implementation for 6 words
         private static IEnumerable<T[]> Flatten6<T>(T[][] phrase)
         {
             foreach (var item0 in phrase[0])
-            {
             foreach (var item1 in phrase[1])
-                {
             foreach (var item2 in phrase[2])
-                    {
             foreach (var item3 in phrase[3])
-                        {
             foreach (var item4 in phrase[4])
-                            {
             foreach (var item5 in phrase[5])
-                                {
                 yield return new T[]
                 {
                     item0,
@@ -119,30 +89,17 @@
                     item5,
                 };
         }
-                            }
-                        }
-                    }
-                }
-            }
-        }
 
         // Fast hard-coded implementation for 7 words
         private static IEnumerable<T[]> Flatten7<T>(T[][] phrase)
         {
             foreach (var item0 in phrase[0])
-            {
             foreach (var item1 in phrase[1])
-                {
             foreach (var item2 in phrase[2])
-                    {
             foreach (var item3 in phrase[3])
-                        {
             foreach (var item4 in phrase[4])
-                            {
             foreach (var item5 in phrase[5])
-                                {
             foreach (var item6 in phrase[6])
-                                    {
                 yield return new T[]
                 {
                     item0,
@@ -154,12 +111,29 @@
                     item6,
                 };
         }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+
+        // Fast hard-coded implementation for 7 words
+        private static IEnumerable<T[]> Flatten8<T>(T[][] phrase)
+        {
+            foreach (var item0 in phrase[0])
+            foreach (var item1 in phrase[1])
+            foreach (var item2 in phrase[2])
+            foreach (var item3 in phrase[3])
+            foreach (var item4 in phrase[4])
+            foreach (var item5 in phrase[5])
+            foreach (var item6 in phrase[6])
+            foreach (var item7 in phrase[7])
+                yield return new T[]
+                {
+                    item0,
+                    item1,
+                    item2,
+                    item3,
+                    item4,
+                    item5,
+                    item6,
+                    item7,
+                };
         }
 
         public static IEnumerable<T[]> Flatten<T>(T[][] wordVariants)
@@ -176,6 +150,8 @@
                     return Flatten6(wordVariants);
                 case 7:
                     return Flatten7(wordVariants);
+                case 8:
+                    return Flatten8(wordVariants);
                 default:
                     return FlattenAny(ImmutableStack.Create(wordVariants)).Select(words => words.ToArray());
             }

dotnet/WhiteRabbit/PrecomputedPermutationsGenerator.cs

@@ -5,7 +5,7 @@
 
     internal static class PrecomputedPermutationsGenerator
     {
-        private static int[][][] Permutations { get; } = Enumerable.Range(0, 8).Select(GeneratePermutations).ToArray();
+        private static int[][][] Permutations { get; } = Enumerable.Range(0, 9).Select(GeneratePermutations).ToArray();
 
         private static long[] PermutationsNumbers { get; } = GeneratePermutationsNumbers().Take(19).ToArray();