groups.cs

我自己开发的双色球预测软件

                        }
                    }
                    break;
                //default:
                //    Console.WriteLine("Default case");
                //    break;
            }

            return tempGroup;
        }
        #endregion

        #region//获得当前组的所有组合
        ///// <summary>
        ///// 获得当前组的所有组合
        ///// </summary>
        ///// <param name="group">当前组</param>
        ///// <param name="seedNum">当前组中的种子数</param>
        ///// <returns>返回一个所有组合的二维数组</returns>
        //public int[][] GetGroupResult(int[] group, int seedNum)
        //{
        //    int groupLength;    //原始数组长度
        //    int resultToTal;    //结果数组长度
        //    int n;              //临时变量
        //    //int m;              //临时变量

        //    int[] temp;         //中间临时数组
        //    int[] tempSeed;     //临时种子数组
        //    int[][] tempResult; //结果数组
        //    int[][] initGroup;  //初始化数组

        //    temp = new int[2];
            
        //    groupLength =group .Length ;
        //    resultToTal=GetGroupItemTotal(groupLength ,seedNum );
        //    initGroup = new int[groupLength][];
        //    tempSeed =new int [seedNum ];
        //    tempResult=new int[resultToTal][];
        //    //生成带标志的数组
        //    for (int i = 0; i < groupLength; i++)
        //    {
        //        initGroup[i] = new int[2];
        //        if (i < seedNum)
        //        {
        //            initGroup[i][0] = 1;
        //        }
        //        else
        //        {
        //            initGroup[i][0] = 0;
        //        }
        //        initGroup[i][1] = int.Parse(group[i].ToString());
        //    }

        //    //生成结果数组
        //    for (int i = 0; i < resultToTal; i++)
        //    {
        //        n=0;

        //        tempResult[i] = new int[seedNum];
        //        for (int j=0;j<groupLength ;j++)
        //        {
        //            if (initGroup[j][0].ToString()=="1")
        //            {
        //                tempResult[i][n] = int.Parse(initGroup[j][1].ToString());
        //                //tempSeed[j]=int.Parse ( initGroup[j][1].ToString ());
        //                //Console.Write("{0}    ", tempResult[i][n].ToString());
        //                n = n + 1;
        //                if (n >= seedNum)
        //                {
        //                    break;
        //                }
        //            }
        //        }
        //        //把元素数组添加到临时结果数组中
        //        //Console.WriteLine("");
        //        //tempResult[i] = tempSeed;
        //        //交换1 0位置
        //        for (int j = groupLength - 1; j > 1; j--)
        //        {
        //            if (initGroup[j][0].ToString() == "0" && initGroup[j - 1][0].ToString() == "1")
        //            { 
        //                initGroup [j][0]=1;
        //                initGroup [j-1][0]=0;
        //                break;
        //            }
        //        }
        //        //if (i < groupLength - 1)
        //        //{
        //        //    for (int j = 0; j < groupLength-1; j++)
        //        //    {
        //        //        if (initGroup[j][0].ToString ()=="1" && initGroup [j+1][0].ToString()=="0")
        //        //        {
        //        //            initGroup[j][0] = 0;
        //        //            initGroup[j][1] = 1;
        //        //            break;
        //        //        }
        //        //    }
        //        //}
        //    }
        //    return tempResult;
        //}
        #endregion

        #region//获得结果组的总纪录数
        /// <summary>
        /// 获得结果组的总纪录数
        /// </summary>
        /// <param name="groupItemNum">原始组中的记录数</param>
        /// <param name="seedNum">原始组中的种子数</param>
        /// <returns>结果组的总纪录数</returns>
        private int GetGroupItemTotal(int groupItemNum, int seedNum)
        {
            int total;
            
            //组合公式: 从m中取n个 = m!/n!*(m-n)!
            switch (seedNum)
            {
                case 1:
                    total = groupItemNum;
                    break;
                case 2:
                    total = (groupItemNum * (groupItemNum - 1))/2;
                    break;
                case 3:
                    total = (groupItemNum * (groupItemNum - 1) * (groupItemNum - 2))/( 2 * 3);
                    break;
                case 4:
                    total = (groupItemNum * (groupItemNum - 1) * (groupItemNum - 2) * (groupItemNum - 3))/(4*3*2);
                    break;
                case 5:
                    total = (groupItemNum * (groupItemNum - 1) * (groupItemNum - 2) * (groupItemNum - 3) * (groupItemNum - 4))/(5*4*3*2);
                    break;
                case 6:
                    total = (groupItemNum * (groupItemNum - 1) * (groupItemNum - 2) * (groupItemNum - 3) * (groupItemNum - 4) * (groupItemNum - 5))/(6*5*4*3*2);
                    break;
                default:
                    total = 0;
                    break;
            }
            return total;

        }
        #endregion

        #region//初始化ComboBox
        /// <summary>
        /// 初始化ComboBox
        /// </summary>
        /// <param name="cb">cb控件名称</param>
        /// <param name="seed">种子数</param>
        public void FillCB(System.Windows.Forms.ComboBox cb, int seed)
        {
            cb.Items.Clear();
            for (int i = 1; i < seed + 1; i++)
            {
                cb.Items.Add(i);
            }
            cb.SelectedIndex = 0;
        }
        #endregion

        #region//删除数组记录中包含当前值得所有记录
        /// <summary>
        /// 单一删除数组记录
        /// </summary>
        /// <param name="finallyResult">需要筛选的数组</param>
        /// <param name="singleData">需要筛选的数据</param>
        /// <returns></returns>
        public int[][] SingleDel(int[][] finallyResult,int singleData)
        {
            int curNum;         //当前索引,在循环中使用
            //int newResultNum;    //新数组记录数
            Boolean bExist;     //当前组合中是否存在需要删除的数据
            int seedNum;        //种子数
            int resultNum;      //数组记录数
            int[][] tempResult;  //中间结果
            int[][] result;     //结果数组

            seedNum =6;
            curNum = 0;
            //newResultNum = 0;
            resultNum = finallyResult.Length;
            tempResult =new int[resultNum][];
            if (singleData == -1)
            {
                return finallyResult;
            }
            for(int i=0; i<resultNum ;i++)
            {
                bExist = false;
                //验证当前纪录中是否存在筛选数据值
                for(int j=0;j<seedNum ;j++)
                {
                    if (finallyResult[i][j].Equals(singleData))
                    {
                        bExist = true;
                        break;
                    }
                }

                if (!bExist)
                { 
                    //如果当前组合中不存在此值,则加入新数组中
                    tempResult[curNum] = new int[seedNum];
                    //for (int j = 0; j < seedNum; j++)
                    //{
                    //    tempResult[curNum][j] = int.Parse(finallyResult[i][j].ToString());
                    //}
                    finallyResult[i].CopyTo(tempResult[curNum], 0);
                    curNum = curNum + 1;
                }
            }

            //去掉数组中的空值
            result =new int [curNum ][];
            for (int i = 0; i < curNum; i++)
            {
                result[i] = new int[seedNum];
                for (int j = 0; j < seedNum; j++)
                { 
                    result[i][j]=int.Parse ( tempResult [i][j].ToString ());
                }
            }
            //返回最终结果数组
            return result;
        }

        #endregion

        #region//删除数组记录中不包含当前值得所有记录
        /// <summary>
        /// 删除数组记录中不包含当前值得所有记录
        /// </summary>
        /// <param name="finallyResult">原始数组</param>
        /// <param name="singleData">需要检测的值</param>
        /// <returns>成功返回过滤后的数组,失败返回原始数组</returns>
        public int[][] SingleFilter(int[][] finallyResult, int singleData)
        {
            int curNum;            //当前索引,在循环中使用
            //int newResultNum;    //新数组记录数
            Boolean bExist;        //当前组合中是否存在需要删除的数据
            int seedNum;           //种子数
            int resultNum;         //数组记录数
            int[][] tempResult;    //中间结果
            int[][] result;        //结果数组

            seedNum =6;
            curNum = 0;
            //newResultNum = 0;
            resultNum = finallyResult.Length;
            tempResult =new int[resultNum][];
            if (singleData == -1)
            {
                return finallyResult;
            }
            for(int i=0; i<resultNum ;i++)
            {
                bExist = false;
                //验证当前纪录中是否存在筛选数据值
                for(int j=0;j<seedNum ;j++)
                {
                    if (finallyResult[i][j].Equals(singleData))
                    {
                        bExist = true;
                        break;
                    }
                }

                if (bExist)
                { 
                    //如果当前组合中存在此值,则加入新数组中
                    tempResult[curNum] = new int[seedNum];
                    //for (int j = 0; j < seedNum; j++)
                    //{
                    //    tempResult[curNum][j] = int.Parse(finallyResult[i][j].ToString());
                    //}
                    finallyResult[i].CopyTo(tempResult[curNum], 0);
                    curNum = curNum + 1;
                }
            }

            //去掉数组中的空值
            result =new int [curNum ][];
            for (int i = 0; i < curNum; i++)
            {
                result[i] = new int[seedNum];
                for (int j = 0; j < seedNum; j++)
                { 
                    result[i][j]=int.Parse ( tempResult [i][j].ToString ());
                }
            }
            //返回最终结果数组
            return result;
        }
        #endregion

        #region//批量筛选数据
        /// <summary>
        /// 批量筛选数据
        /// </summary>
        /// <param name="formerlyResult">原始数组</param>
        /// <param name="filter">过滤数组</param>
        /// <param name="seedNum">种子数</param>
        /// <returns>成功返回筛选后的新数组，失败返回原始数组</returns>
        public int[][] MuchFilter(int[][] formerlyResult, int[] filter, int iSeedNum)
        {
            int curNum;            //当前索引,在循环中使用
            int seedNum;           //种子数
            int resultNum;         //数组记录数
            int[][] tempResult;    //中间结果
            int[][] result;        //结果数组
            int existNum;          //当前组合中村在筛选数据的个数