groups.cs

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

            int itemData;          //当前项值

            seedNum = 6;
            curNum = 0;
            itemData =0;
            resultNum = formerlyResult.Length;
            tempResult = new int[resultNum][];
            if ( seedNum ==0 || filter==null || filter.Length ==0)
            {
                return formerlyResult;
            }
            for (int i = 0; i < resultNum; i++)
            {
                existNum = 0;
                //验证当前纪录中是否存在筛选数据值
                for (int j = 0; j < seedNum; j++)
                {
                    itemData =int.Parse (formerlyResult[i][j].ToString ());
                    for (int k = 0; k < filter.Length; k++)
                    {

                        if (filter[k] .Equals (itemData ))
                        {
                            existNum = existNum + 1;    
                        }
                    }
                }

                if (existNum >=iSeedNum )
                {
                    //如果当前组合中存在此值,则加入新数组中
                    tempResult[curNum] = new int[seedNum];
                    formerlyResult[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[][] MuchDel(int[][] formerlyResult, int[] del, int iSeedNum)
        {
            int curNum;            //当前索引,在循环中使用
            int seedNum;           //种子数
            int resultNum;         //数组记录数
            int[][] tempResult;    //中间结果
            int[][] result;        //结果数组
            int existNum;          //当前组合中村在删除数据的个数
            int itemData;          //当前项值

            seedNum = 6;
            curNum = 0;
            itemData = 0;
            resultNum = formerlyResult.Length;
            tempResult = new int[resultNum][];
            if (seedNum == 0 || del == null || del.Length == 0)
            {
                return formerlyResult;
            }
            for (int i = 0; i < resultNum; i++)
            {
                existNum = 0;
                //验证当前纪录中是否存在删除数据值
                for (int j = 0; j < seedNum; j++)
                {
                    itemData = int.Parse(formerlyResult[i][j].ToString());
                    for (int k = 0; k < del.Length; k++)
                    {

                        if (del[k].Equals(itemData))
                        {
                            existNum = existNum + 1;
                        }
                    }
                }

                if (existNum < iSeedNum)
                {
                    //如果当前组合中存在此值,则加入新数组中
                    tempResult[curNum] = new int[seedNum];
                    formerlyResult[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="min">区间最小值</param>
        /// <param name="max">区间最大值</param>
        /// <returns>成功返回过滤后的数组</returns>
        public int[][] SubtractFilter(int[][] formerlyResult, int min,int max)
        {
            int MAX_ITEM=6;                 //数组中记录的个数
            int previous;                   //上一个数据
            int next;                       //下一个数据
            int temp;
            Boolean exist;
            int[] tempArray;
            int[][] resultArray;            //结果数组
            ArrayList tempResult;           //临时结果集
            ArrayList contrastArray;        //对比数组
            
            //最外层循环
            exist = false;
            tempResult = new ArrayList();
            contrastArray = new ArrayList();
            tempArray =new int [MAX_ITEM ];

            for (int i = 0; i < formerlyResult.Length; i++)
            {
                contrastArray.Clear();
                //求值循环
                for (int j = 0; j < MAX_ITEM - 1; j++)
                {
                    for (int h = j; h >= 0; h--)
                    {
                        previous = int.Parse(formerlyResult[i][h].ToString());
                        next = int.Parse(formerlyResult[i][j + 1].ToString());
                        if (next > previous)
                        {
                            temp = next - previous;
                        }
                        else
                        {
                            temp =   previous-next ;
                        }
                        
                        if (j == 0)
                        {
                            contrastArray.Add(temp);
                        }
                        else
                        {
                            exist = false;
                            //查找是否已存在此数据
                            for (int k = 0; k < contrastArray.Count; k++)
                            {
                                if (int.Parse(contrastArray[k].ToString()) == temp)
                                {
                                    exist = true;
                                }
                            }
                            if (exist == false)
                            {
                                contrastArray.Add(temp);
                            }
                        }
                    }
                }
                if (contrastArray.Count >= min && contrastArray.Count <= max)
                {
                    tempArray = new int[MAX_ITEM];
                    formerlyResult[i].CopyTo(tempArray, 0);
                    tempResult.Add(tempArray);
                }
            }
            resultArray =new int [tempResult .Count ][];
            //resultArray= (int[][])tempResult.ToArray(typeof(int));
            tempResult.CopyTo(resultArray);
            return resultArray;
        }
        #endregion

        #region//获得预测结果中奖情况（红球）
        /// <summary>
        /// 获得预测结果中奖情况
        /// </summary>
        /// <param name="formerlyResult">预测结果</param>
        /// <param name="awardNo">中奖号码</param>
        /// <returns></returns>
        public WinResult GetWinResult(int[][] finallyResult1,int[] awardNo)
        {
            int iSix;               //数字６
            int GuessNum;           //猜中数
            WinResult winResult;    //中奖结果
            ArrayList awardArray;   //所有中将结果
            
            iSix =6;
            GuessNum = 0;
            winResult.FirstNum = 0;
            winResult.SecondNum = 0;
            winResult.ThirdNum = 0;
            winResult.FourNum = 0;
            winResult.FifthNum = 0;
            winResult.SixthNum = 0;
            winResult.SmallTotalMoney = 0;
            winResult.BigTotalMoney = 0;
            awardArray = new ArrayList();

            for (int i = 0; i < finallyResult1.Length; i++)
            {
                GuessNum = 0;
                for (int j = 0; j < iSix; j++)          //formerlyResult[]数组中的循环
                {
                    for (int k = 0; k < iSix; k++)      //awardno数组中的循环
                    {
                        if (finallyResult1[i][j].ToString() == awardNo[k].ToString())
                        {
                            GuessNum += 1;
                            break; 
                        }
                    }
                }
                //根据中奖号数来赋值
                switch (GuessNum)
                { 
                    case 3:
                        winResult.FifthNum += 1;
                        //awardArray.Add(finallyResult1[i]);
                        break;
                    case 4:
                        winResult.FourNum += 1;
                        awardArray.Add(finallyResult1[i]);
                        break;
                    case 5:
                        winResult.ThirdNum += 1;
                        awardArray.Add(finallyResult1[i]);
                        break;
                    case 6:
                        winResult.FirstNum += 1;
                        awardArray.Add(finallyResult1[i]);
                        break;
                    default:
                        winResult.SixthNum += 1;
                        break;
                }
            }
            winResult.BigTotalMoney = winResult.SixthNum * 5 + winResult.FifthNum * 10 + winResult.FourNum * 200 + winResult.ThirdNum * 3000;
            winResult.SmallTotalMoney = winResult.FourNum * 10 + winResult.ThirdNum * 200;
            Groups.finallyResult = null;
            Groups.finallyResult = new int[awardArray.Count][];
            awardArray.CopyTo(Groups.finallyResult);
            return winResult;
        }
        #endregion

        #region//
        /// <summary>
        /// 
        /// </summary>
        /// <param name="intNum"></param>
        //public void GetFirst(int[] intNum)
        //{
        //    int n;

        //    int[][] temp = new int[intNum.Length * (intNum.Length - 1) * (intNum.Length - 2)][];
        //    int[] temp3 = new int[3];

        //    n = 0;
        //    for (int i = 0; i < intNum.Length; i++)
        //    {
        //        for (int j = 1; j < intNum.Length; j++)
        //        {
        //            for (int k = 2; k < intNum.Length; k++)
        //            {
        //                n = n + 1;
        //                temp3[0] = int.Parse(intNum[i].ToString());
        //                temp3[1] = int.Parse(intNum[j].ToString());
        //                temp3[2] = int.Parse(intNum[k].ToString());
        //                temp[n - 1] = temp3;
        //                //Console.Write("temp[{0}][{1}]={2}  ", n - 1, 0, temp[n - 1][0].ToString());
        //                //Console.Write("temp[{0}][{1}]={2}  ", n - 1, 1, temp[n - 1][1].ToString());
        //                //Console.WriteLine("temp[{0}][{1}]={2}", n-1,2, temp[n-1][2].ToString ());

        //            }
        //        }
        //    }


        //}
        #endregion
    }
}