编程-统计并输出符合条件的字串组合

public class Stastistics
    {
        /// <summary>
        /// 统计可选数字最小值
        /// </summary>
        private static readonly int MinNum = 0;

        /// <summary>
        /// 统计可选数字最大值
        /// </summary>
        private static readonly int MaxNum = 9;

        /// <summary>
        /// 组合字串中某个数字的最小重复个数
        /// </summary>
        private static readonly int MinRepeatCount = 1;

        /// <summary>
        /// 组合字串中某个数字的最大重复个数
        /// </summary>
        private static readonly int MaxRepeatCount = 5;

        /// <summary>
        /// 符合条件的所有统计结果
        /// </summary>
        static readonly List<string> AllStatisticsResult = new List<string>();

        /*
         * 符合条件，且所有重复次数的统计结果
         * 
         * 数据结构：(可选数字，重复次数，组合字串)
         * 例如：
         * [
         *  (0，
         *      (1, [01117, 01126, ...]),
         *      (2, [00118, 00127, ...]),
         *      .....
         *   )
         * ]
         */
        private static readonly Dictionary<int, Dictionary<int, List<string>>> SpecialStatisticsResult = new Dictionary<int, Dictionary<int, List<string>>>(10);

        /// <summary>
        /// 数字组合格式
        /// </summary>
        private static string sortFormat = "{0}{1}{2}{3}{4}";

        /// <summary>
        /// 输出路径
        /// </summary>
        private static string OutputPath = @"D:\StatisticsResult.txt";

        public static void Run()
        {
            Initialize();

            // 统计并记录所有符合条件的结果
            for (int i = MinNum; i <= MaxNum; i++)
            {
                for (int j = MinNum; j <= MaxNum; j++)
                {
                    for (int k = MinNum; k <= MaxNum; k++)
                    {
                        for (int l = MinNum; l <= MaxNum; l++)
                        {
                            for (int m = MinNum; m <= MaxNum; m++)
                            {
                                var total = i + j + k + l + m;
                                if (total % 10 == 0)
                                {
                                    AllStatisticsResult.Add(string.Format(sortFormat, i, j, k, l, m));
                                }
                            }
                        }
                    }
                }
            }

            // 统计符合条件，不同重复次数的结果
            foreach (var numCombs in AllStatisticsResult)
            {
                CalculateSpecial(numCombs);
            }

            //获取所有分类统计结果的字符串格式
            string statisticsResult = GetStastisticsResult();

            //将统计结果输出并保存到文件中
            Output(statisticsResult);
        }

        /// <summary>
        /// 初始化数据存储结构
        /// </summary>
        private static void Initialize()
        {
            for (int i = MinNum; i <= MaxNum; i++)
            {
                var numRepeatCountDic = new Dictionary<int, List<string>>();
                for (int j = MinRepeatCount; j <= MaxRepeatCount; j++)
                {
                    numRepeatCountDic.Add(j, new List<string>());
                }

                SpecialStatisticsResult.Add(i, numRepeatCountDic);
            }
        }

        /// <summary>
        /// 计算并保存当前组合字串中不同数字的重复个数
        /// </summary>
        /// <param name="numComb">组合子串</param>
        /// <returns></returns>
        private static void CalculateSpecial(string numComb)
        {
            for (int i = MinNum; i <= MaxNum; i++)
            {
                //当前数字对应的字典
                var currentNumRepeatCountDic = SpecialStatisticsResult.FirstOrDefault(s => s.Key == i);

                for (int j = MinRepeatCount; j <= MaxRepeatCount; j++)
                {
                    //当前重复个数对应的字典
                    var currentRepeatCountDic = currentNumRepeatCountDic.Value.FirstOrDefault(s => s.Key == j);
                    if (Regex.Matches(numComb, i.ToString()).Count == j)
                    {
                        currentRepeatCountDic.Value.Add(numComb);
                    }
                }
            }
        }

        /// <summary>
        /// 获取统计结果，并以字符串方式输出
        /// </summary>
        /// <returns>统计结果</returns>
        private static string GetStastisticsResult()
        {
            StringBuilder statisticsResultBuilder = new StringBuilder();

            statisticsResultBuilder.AppendFormat("--------所有样本总数：{0}--------", AllStatisticsResult.Count);
            foreach (var s in AllStatisticsResult)
            {
                statisticsResultBuilder.AppendFormat("{0},", s);
            }

            statisticsResultBuilder.AppendLine().AppendLine();

            for (int i = MinNum; i <= MaxNum; i++)
            {
                var currentValue = SpecialStatisticsResult.FirstOrDefault(s => s.Key == i);
                if (currentValue.Value.Count <= 0)
                {
                    continue;
                }

                for (int j = MinRepeatCount; j <= MaxRepeatCount; j++)
                {
                    var currentNumComb = currentValue.Value.FirstOrDefault(s => s.Key == j);
                    if (currentNumComb.Value.Count <= 0)
                    {
                        continue;
                    }

                    statisticsResultBuilder.AppendFormat("--------{0} 重复 {1} 次的总数：{2}--------", i, j, currentNumComb.Value.Count);

                    foreach (var s in currentNumComb.Value)
                    {
                        statisticsResultBuilder.Append(s + ", ");
                    }

                    statisticsResultBuilder.AppendLine().AppendLine();
                }
            }

            return statisticsResultBuilder.ToString();
        }

        /// <summary>
        /// 将统计结果保存到文件中
        /// </summary>
        /// <param name="statisticsResult">统计结果</param>
        private static void Output(string statisticsResult)
        {
            using (StreamWriter writer = new StreamWriter(OutputPath))
            {
                writer.WriteLine(statisticsResult);
                writer.Flush();
            }
        }
    }