示例#1
0
        static winlose SmartAi(int[] numberArray, int sum)
        {
            int numRows   = numberRows(numberArray);
            int num       = 0;
            int row       = 0;
            int sumSticks = 0;

            for (int i = 0; i < numberArray.Length; i++)
            {
                sumSticks += numberArray[i];
            }

            for (int i = 0; i < numberArray.Length; i++)
            {
                if (numberArray[i] == 0)
                {
                    continue;
                }

                if (numberArray[i] == 1)
                {
                    num++;
                }

                else
                {
                    row = i;
                }
            }
            if (num == numRows && num % 2 == 0)
            {
                for (int i = 0; i < numberArray.Length; i++)
                {
                    if (numberArray[i] > 0)
                    {
                        return(new winlose(i, numberArray[i]));
                    }
                }
                return(new winlose(row, numberArray[row]));
            }

            if (num == numRows - 1)
            {
                if ((numRows) % 2 == 0)
                {
                    return(new winlose(row, numberArray[row]));
                }

                else
                {
                    return(new winlose(row, numberArray[row] - 1));
                }
            }

            else if (numRows % 2 == 0)
            {
                symmetry[] pairArray = new symmetry[2 * numberArray.Length + 1];

                for (int i = 0; i < numberArray.Length; i++)
                {
                    pairArray[numberArray[i]] = new symmetry(1);
                }

                for (int i = 0; i < numberArray.Length; i++)
                {
                    pairArray[numberArray[i]].occurences++;
                    pairArray[numberArray[i]].indexes.Add(i);
                }

                int count        = 0;
                int firstfucked  = 0;
                int secondfucked = 0;

                for (int i = 1; i < pairArray.Length; i++)
                {
                    if (pairArray[i].occurences % 2 == 1)
                    {
                        count++;
                        if (count == 1)
                        {
                            for (int j = 0; j < numberArray.Length; j++)
                            {
                                if (numberArray[j] == i)
                                {
                                    firstfucked = j;
                                    break;
                                }
                            }
                        }

                        else if (count == 2)
                        {
                            for (int j = 0; j < numberArray.Length; j++)
                            {
                                if (numberArray[j] == i)
                                {
                                    secondfucked = j;
                                    break;
                                }
                            }
                        }
                    }

                    if (count > 2)
                    {
                        break;
                    }
                }

                if (count == 2)
                {
                    if (numberArray[firstfucked] > numberArray[secondfucked])
                    {
                        return(new winlose(firstfucked, numberArray[firstfucked] - numberArray[secondfucked]));
                    }

                    else
                    {
                        return(new winlose(secondfucked, numberArray[secondfucked] - numberArray[firstfucked]));
                    }
                }
            }

            if (numRows % 2 == 1)
            {
                symmetry[] pairArray = new symmetry[2 * numberArray.Length + 1];

                for (int i = 0; i < pairArray.Length; i++)
                {
                    pairArray[i] = new symmetry(1);
                }

                for (int i = 0; i < numberArray.Length; i++)
                {
                    pairArray[numberArray[i]].occurences++;
                    pairArray[numberArray[i]].indexes.Add(i);
                }

                int count       = 0;
                int firstfucked = 0;

                for (int i = 1; i < pairArray.Length; i++)
                {
                    if (pairArray[i].occurences % 2 == 1)
                    {
                        count++;
                        if (count == 1)
                        {
                            for (int j = 0; j < numberArray.Length; j++)
                            {
                                if (numberArray[j] == i)
                                {
                                    firstfucked = j;
                                }
                            }
                        }
                    }

                    if (count > 1)
                    {
                        break;
                    }
                }

                if (count == 1)
                {
                    return(new winlose(firstfucked, numberArray[firstfucked]));
                }
            }

            if (numRows == 3 || numRows == 4)
            {
                if (numRows == 3)
                {
                    int [] indexes = new int [3];
                    int    count   = 0;

                    for (int i = 0; i < numberArray.Length; i++)
                    {
                        if (numberArray[i] > 0)
                        {
                            if (count < 3)
                            {
                                indexes[count] = i;
                                count++;
                            }
                        }
                    }

                    int gcd  = 0;
                    int temp = 0;

                    gcd  = GCD(numberArray[indexes[0]], numberArray[indexes[1]]);
                    temp = Math.Abs(numberArray[indexes[0]] / gcd - numberArray[indexes[1]] / gcd);
                    if (temp == 1)
                    {
                        if (numberArray[indexes[0]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[2]] - numberArray[indexes[1]]) > gcd)
                            {
                                return(new winlose(indexes[2], (numberArray[indexes[2]] - (numberArray[indexes[1]] - gcd))));
                            }
                        }
                        else
                        {
                            if (numberArray[indexes[2]] > (numberArray[indexes[0]] - gcd))
                            {
                                return(new winlose(indexes[2], numberArray[indexes[2]] - (numberArray[indexes[0]] - gcd)));
                            }
                        }
                    }

                    gcd  = GCD(numberArray[indexes[1]], numberArray[indexes[2]]);
                    temp = Math.Abs(numberArray[indexes[1]] / gcd - numberArray[indexes[2]] / gcd);
                    if (temp == 1)
                    {
                        if (numberArray[indexes[1]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[0]] - numberArray[indexes[2]]) > gcd)
                            {
                                return(new winlose(indexes[0], (numberArray[indexes[0]] - (numberArray[indexes[2]] - gcd))));
                            }
                        }
                        else
                        {
                            if (numberArray[indexes[0]] > (numberArray[indexes[1]] - gcd))
                            {
                                return(new winlose(indexes[0], numberArray[indexes[0]] - (numberArray[indexes[1]] - gcd)));
                            }
                        }
                    }

                    gcd  = GCD(numberArray[indexes[2]], numberArray[indexes[0]]);
                    temp = Math.Abs(numberArray[indexes[2]] / gcd - numberArray[indexes[0]] / gcd);
                    if (temp == 1)
                    {
                        if (numberArray[indexes[2]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[1]] - numberArray[indexes[0]]) > gcd)
                            {
                                return(new winlose(indexes[1], (numberArray[indexes[1]] - (numberArray[indexes[0]] - gcd))));
                            }
                        }
                        else
                        {
                            if (numberArray[indexes[1]] > (numberArray[indexes[2]] - gcd))
                            {
                                return(new winlose(indexes[1], numberArray[indexes[1]] - (numberArray[indexes[2]] - gcd)));
                            }
                        }
                    }

                    //second time for adding shit in middle instead of on ends

                    gcd  = GCD(numberArray[indexes[0]], numberArray[indexes[1]]);
                    temp = Math.Abs(numberArray[indexes[1]] / gcd - numberArray[indexes[0]] / gcd);
                    if (temp == 2)
                    {
                        if (numberArray[indexes[1]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[2]] - numberArray[indexes[0]]) >= gcd)
                            {
                                return(new winlose(indexes[2], (numberArray[indexes[2]] - numberArray[indexes[0]] - gcd)));
                            }
                        }
                    }

                    gcd  = GCD(numberArray[indexes[1]], numberArray[indexes[2]]);
                    temp = Math.Abs(numberArray[indexes[1]] / gcd - numberArray[indexes[2]] / gcd);
                    if (temp == 2)
                    {
                        if (numberArray[indexes[1]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[0]] - numberArray[indexes[2]]) >= gcd)
                            {
                                return(new winlose(indexes[0], (numberArray[indexes[0]] - numberArray[indexes[2]] - gcd)));
                            }
                        }
                    }

                    gcd  = GCD(numberArray[indexes[2]], numberArray[indexes[0]]);
                    temp = Math.Abs((numberArray[indexes[2]] / gcd) - (numberArray[indexes[0]] / gcd));
                    if (temp == 2)
                    {
                        if (numberArray[indexes[2]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[1]] - numberArray[indexes[0]]) >= gcd)
                            {
                                return(new winlose(indexes[1], (numberArray[indexes[1]] - numberArray[indexes[0]] - gcd)));
                            }
                        }
                    }
                }
                else
                {
                    int [] indexes = new int [4];
                    int    count   = 0;
                    for (int i = 0; i < numberArray.Length; i++)
                    {
                        if (numberArray[i] > 0)
                        {
                            if (count < 4)
                            {
                                indexes[count] = i;
                                count++;
                            }
                        }
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        if (i == 0)
                        {
                            int gcd = GCD(GCD(numberArray[indexes[1]], numberArray[indexes[2]]), numberArray[indexes[3]]);

                            int [] temp = new int[] { numberArray[indexes[1]] / gcd, numberArray[indexes[2]] / gcd, numberArray[indexes[3]] / gcd };
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return(new winlose(indexes[i], numberArray[indexes[i]]));
                            }
                        }
                        else if (i == 1)
                        {
                            int gcd = GCD(GCD(numberArray[indexes[2]], numberArray[indexes[3]]), numberArray[indexes[0]]);

                            int [] temp = new int[] { numberArray[indexes[2]] / gcd, numberArray[indexes[3]] / gcd, numberArray[indexes[0]] / gcd };
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return(new winlose(indexes[i], numberArray[indexes[i]]));
                            }
                        }
                        else if (i == 2)
                        {
                            int gcd = GCD(GCD(numberArray[indexes[3]], numberArray[indexes[0]]), numberArray[indexes[1]]);

                            int [] temp = new int[] { numberArray[indexes[3]] / gcd, numberArray[indexes[0]] / gcd, numberArray[indexes[1]] / gcd };
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return(new winlose(indexes[i], numberArray[indexes[i]]));
                            }
                        }
                        else
                        {
                            int gcd = GCD(GCD(numberArray[indexes[0]], numberArray[indexes[1]]), numberArray[indexes[2]]);

                            int [] temp = new int[] { numberArray[indexes[0]] / gcd, numberArray[indexes[1]] / gcd, numberArray[indexes[2]] / gcd };
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return(new winlose(indexes[i], numberArray[indexes[i]]));
                            }
                        }
                    }
                }
            }

            if (true)
            {
                int [] difs  = new int [numberArray.Length];
                int    bestI = 0;

                for (int i = 0; i < numberArray.Length; i++)
                {
                    difs[i] = 2 * i + 1 - numberArray[i];
                }

                int [] dif1 = new int [difs.Length];
                Array.Copy(difs, dif1, difs.Length);
                int max = dif1[0];

                int count = -1;
                for (int i = 0; i < difs.Length; i++)
                {
                    if (difs[i] == max)
                    {
                        if (count == -1)
                        {
                            bestI = i;
                        }
                        count++;
                    }
                }

                if (count > 0)
                {
                    int temp = 0;
                    for (int i = 0; i < difs.Length; i++)
                    {
                        if (difs[i] == max)
                        {
                            if (numberArray[i] > temp)
                            {
                                temp  = numberArray[i];
                                bestI = i;
                            }
                        }
                    }
                }

                if (sumSticks % 2 == 0)
                {
                    return(new winlose(bestI, 2));
                }
                else
                {
                    return(new winlose(bestI, 1));
                }
            }
        }
示例#2
0
        static winlose SmartAi(int[] numberArray, int sum)
        {
            int numRows = numberRows(numberArray);
            int num = 0;
            int row = 0;
            int sumSticks = 0;

            for (int i = 0; i < numberArray.Length; i++)
            {
                sumSticks += numberArray[i];
            }

            for (int i = 0; i < numberArray.Length; i++)
            {
                if (numberArray[i] == 0)
                {
                    continue;
                }

                if (numberArray[i] == 1)
                {
                    num++;
                }

                else
                {
                    row = i;
                }
            }
            if (num == numRows && num % 2 == 0)
            {
                for (int i = 0; i < numberArray.Length; i++)
                {
                    if (numberArray[i] > 0)
                    {
                        return new winlose(i, numberArray[i]);
                    }
                }
                    return new winlose(row, numberArray[row]);
            }

            if (num == numRows - 1)
            {
                if ((numRows) % 2 == 0)
                {
                    return new winlose(row, numberArray[row]);
                }

                else
                {
                    return new winlose(row, numberArray[row] - 1);
                }
            }

            else if (numRows % 2 == 0)
            {
                symmetry[] pairArray = new symmetry[2*numberArray.Length + 1];

                for(int i = 0; i < numberArray.Length; i++)
                {
                    pairArray[numberArray[i]] = new symmetry(1);
                }

                for (int i = 0; i < numberArray.Length; i++)
                {
                    pairArray[numberArray[i]].occurences++;
                    pairArray[numberArray[i]].indexes.Add(i);
                }

                int count = 0;
                int firstfucked = 0;
                int secondfucked = 0;

                for (int i = 1; i < pairArray.Length; i ++)
                {
                    if (pairArray[i].occurences % 2 == 1)
                    {
                        count++;
                        if (count == 1)
                        {
                            for (int j = 0; j < numberArray.Length; j++)
                            {
                                if (numberArray[j] == i)
                                {
                                    firstfucked = j;
                                    break;
                                }
                            }
                        }

                        else if (count == 2)
                        {
                            for (int j = 0; j < numberArray.Length; j++)
                            {
                                if (numberArray[j] == i)
                                {
                                    secondfucked = j;
                                    break;
                                }
                            }
                        }
                    }

                    if (count > 2)
                    {
                        break;
                    }
                }

                if (count == 2)
                {
                    if (numberArray[firstfucked] > numberArray[secondfucked])
                    {
                        return new winlose(firstfucked, numberArray[firstfucked]-numberArray[secondfucked]);
                    }

                    else
                    {
                        return new winlose(secondfucked, numberArray[secondfucked] - numberArray[firstfucked]);
                    }
                }
            }

            if (numRows % 2 == 1)
            {
                symmetry[] pairArray = new symmetry[2*numberArray.Length + 1];

                for (int i = 0; i < pairArray.Length; i++)
                {
                    pairArray[i] = new symmetry(1);
                }

                    for (int i = 0; i < numberArray.Length; i++)
                    {
                        pairArray[numberArray[i]].occurences++;
                        pairArray[numberArray[i]].indexes.Add(i);
                    }

                int count = 0;
                int firstfucked = 0;

                for (int i = 1; i < pairArray.Length; i ++)
                {
                    if (pairArray[i].occurences % 2 == 1)
                    {
                        count++;
                        if (count == 1)
                        {
                            for (int j = 0; j < numberArray.Length; j++)
                            {
                                if (numberArray[j] == i)
                                {
                                    firstfucked = j;
                                }
                            }
                        }
                    }

                    if (count > 1)
                    {
                        break;
                    }
                }

                if (count == 1)
                {
                    return new winlose(firstfucked, numberArray[firstfucked]);
                }
            }

            if (numRows == 3 || numRows == 4)
            {
                if (numRows == 3)
                {
                    int [] indexes = new int [3];
                    int count = 0;

                    for (int i = 0; i < numberArray.Length; i++)
                    {
                        if (numberArray[i] > 0)
                        {
                            if (count < 3)
                            {
                                indexes[count] = i;
                                count++;
                            }
                        }
                    }

                    int gcd = 0;
                    int temp = 0;

                    gcd = GCD(numberArray[indexes[0]], numberArray[indexes[1]]);
                    temp = Math.Abs(numberArray[indexes[0]] / gcd - numberArray[indexes[1]] / gcd);
                    if (temp == 1)
                    {
                        if (numberArray[indexes[0]]/gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[2]] - numberArray[indexes[1]]) > gcd)
                            {
                                return new winlose (indexes[2], (numberArray[indexes[2]] - (numberArray[indexes[1]] - gcd)));
                            }
                        }
                        else
                        {
                            if (numberArray[indexes[2]] > (numberArray[indexes[0]]-gcd))
                            {
                                return new winlose (indexes[2], numberArray[indexes[2]]-(numberArray[indexes[0]]-gcd));
                            }
                        }
                    }

                    gcd = GCD(numberArray[indexes[1]], numberArray[indexes[2]]);
                    temp = Math.Abs(numberArray[indexes[1]] / gcd - numberArray[indexes[2]] / gcd);
                    if (temp == 1)
                    {
                        if (numberArray[indexes[1]]/gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[0]] - numberArray[indexes[2]]) > gcd)
                            {
                                return new winlose (indexes[0], (numberArray[indexes[0]] - (numberArray[indexes[2]] - gcd)));
                            }
                        }
                        else
                        {
                            if (numberArray[indexes[0]] > (numberArray[indexes[1]]-gcd))
                            {
                                return new winlose (indexes[0], numberArray[indexes[0]]-(numberArray[indexes[1]]-gcd));
                            }
                        }
                    }

                    gcd = GCD(numberArray[indexes[2]], numberArray[indexes[0]]);
                    temp = Math.Abs(numberArray[indexes[2]] / gcd - numberArray[indexes[0]] / gcd);
                    if (temp == 1)
                    {
                        if (numberArray[indexes[2]]/gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[1]] - numberArray[indexes[0]]) > gcd)
                            {
                                return new winlose (indexes[1], (numberArray[indexes[1]] - (numberArray[indexes[0]] - gcd)));
                            }
                        }
                        else
                        {
                            if (numberArray[indexes[1]] > (numberArray[indexes[2]]-gcd))
                            {
                                return new winlose (indexes[1], numberArray[indexes[1]]-(numberArray[indexes[2]]-gcd));
                            }
                        }
                    }

                    //second time for adding shit in middle instead of on ends

                    gcd = GCD(numberArray[indexes[0]], numberArray[indexes[1]]);
                    temp = Math.Abs(numberArray[indexes[1]] / gcd - numberArray[indexes[0]] / gcd);
                    if (temp == 2)
                    {
                        if (numberArray[indexes[1]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[2]] - numberArray[indexes[0]]) >= gcd)
                            {
                                return new winlose(indexes[2], (numberArray[indexes[2]] - numberArray[indexes[0]] - gcd));
                            }
                        }
                    }

                    gcd = GCD(numberArray[indexes[1]], numberArray[indexes[2]]);
                    temp = Math.Abs(numberArray[indexes[1]] / gcd - numberArray[indexes[2]] / gcd);
                    if (temp == 2)
                    {
                        if (numberArray[indexes[1]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[0]] - numberArray[indexes[2]]) >= gcd)
                            {
                                return new winlose(indexes[0], (numberArray[indexes[0]] - numberArray[indexes[2]] - gcd));
                            }
                        }
                    }

                    gcd = GCD(numberArray[indexes[2]], numberArray[indexes[0]]);
                    temp = Math.Abs((numberArray[indexes[2]] / gcd) - (numberArray[indexes[0]] / gcd));
                    if (temp == 2)
                    {
                        if (numberArray[indexes[2]] / gcd % 2 == 1)
                        {
                            if ((numberArray[indexes[1]] - numberArray[indexes[0]]) >= gcd)
                            {
                                return new winlose(indexes[1], (numberArray[indexes[1]] - numberArray[indexes[0]] - gcd));
                            }
                        }
                    }
                }
                else
                {
                    int [] indexes = new int [4];
                    int count = 0;
                    for (int i =0; i < numberArray.Length; i++)
                    {
                        if (numberArray[i] > 0)
                        {
                            if (count < 4)
                            {
                                indexes[count] = i;
                                count++;
                            }
                        }
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        if (i == 0)
                        {
                            int gcd = GCD(GCD(numberArray[indexes[1]], numberArray[indexes[2]]), numberArray[indexes[3]]);

                            int [] temp = new int[] {numberArray[indexes[1]]/gcd, numberArray[indexes[2]]/gcd, numberArray[indexes[3]]/gcd};
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return new winlose(indexes[i], numberArray[indexes[i]]);
                            }
                        }
                        else if (i == 1)
                        {
                            int gcd = GCD(GCD(numberArray[indexes[2]], numberArray[indexes[3]]), numberArray[indexes[0]]);

                            int [] temp = new int[] {numberArray[indexes[2]]/gcd, numberArray[indexes[3]]/gcd, numberArray[indexes[0]]/gcd};
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return new winlose(indexes[i], numberArray[indexes[i]]);
                            }
                        }
                        else if (i == 2)
                        {
                            int gcd = GCD(GCD(numberArray[indexes[3]], numberArray[indexes[0]]), numberArray[indexes[1]]);

                            int [] temp = new int[] {numberArray[indexes[3]]/gcd, numberArray[indexes[0]]/gcd, numberArray[indexes[1]]/gcd};
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return new winlose(indexes[i], numberArray[indexes[i]]);
                            }
                        }
                        else
                        {
                            int gcd = GCD(GCD(numberArray[indexes[0]], numberArray[indexes[1]]), numberArray[indexes[2]]);

                            int [] temp = new int[] {numberArray[indexes[0]]/gcd, numberArray[indexes[1]]/gcd, numberArray[indexes[2]]/gcd};
                            Array.Sort(temp);
                            if (temp[2] - temp[0] == 2 && temp[1] - temp[0] == 1)
                            {
                                return new winlose(indexes[i], numberArray[indexes[i]]);
                            }
                        }

                    }
                }
            }

            if(true)
            {
                int [] difs = new int [numberArray.Length];
                int bestI = 0;

                for (int i = 0; i < numberArray.Length; i++)
                {
                    difs[i] = 2*i + 1 - numberArray[i];
                }

                int [] dif1 = new int [difs.Length];
                Array.Copy(difs, dif1, difs.Length);
                int max = dif1[0];

                int count = -1;
                for (int i = 0; i < difs.Length; i++)
                {
                    if (difs[i] == max)
                    {
                        if (count == -1)
                        {
                            bestI = i;
                        }
                        count++;

                    }
                }

                if (count > 0)
                {
                    int temp = 0;
                    for (int i = 0; i < difs.Length; i++)
                    {
                        if (difs[i] == max)
                        {
                            if (numberArray[i] > temp)
                            {
                                temp = numberArray[i];
                                bestI = i;
                            }
                        }
                    }
                }

                if (sumSticks % 2 == 0)
                {
                    return new winlose(bestI, 2);
                }
                else
                {
                    return new winlose(bestI, 1);
                }
            }
        }