Ejemplo n.º 1
0
        private static bool CheckSeveralMissingColumn(GridSquareScript selection, GridSquareScript[] gridSquares)
        {
            int col = GridMaths.ColumnForSquare(selection.Index);

            GridSquareScript[] emptyColSquares = EmptyGridsAtIndexes(GridMaths.GridColumnIndices(col), gridSquares, selection);
            int[] emptyIndices     = emptyColSquares.Select(x => x.Index).Distinct().ToArray();
            int[] bigSquareIndices = emptyColSquares.Select(x => GridMaths.BigSquareForSquare(x.Index)).Distinct().ToArray();

            List <int> usableSquares = new List <int>();

            for (int i = 0; i < bigSquareIndices.Length; i++)
            {
                int box = bigSquareIndices[i];
                if (!DoesBigSquareContainNumber(box, selection, gridSquares))
                {
                    int[] checks = emptyIndices.Intersect(GridMaths.GridColumnInSquare(col, box)).ToArray();
                    if (checks.Length > 0)
                    {
                        usableSquares.AddRange(checks);
                    }
                }
            }
            if (usableSquares.Count > 0)
            {
                return(usableSquares.All(x => DoesRowContainNumber(GridMaths.RowForSquare(x), selection, gridSquares)));
            }
            return(true);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Naked single check, if all numbers except one are accounted for in the square for index
        /// </summary>
        /// <param name="index"></param>
        /// <param name="gridSquares"></param>
        /// <returns>True if all numbers are accounted for with selection entry</returns>
        private static GridSolutionType CheckForNakedSingle(int index, GridSquareScript[] gridSquares)
        {
            int[] rowExisting = ExistingNumbersInRow(gridSquares, GridMaths.RowForSquare(index)).ToArray();
            int[] colExisting = ExistingNumbersInColumn(gridSquares, GridMaths.ColumnForSquare(index)).ToArray();
            int[] bigExisting = ExistingNumbersInBigSquare(gridSquares, GridMaths.BigSquareForSquare(index)).ToArray();
            int[] allExisting = rowExisting.Concat(colExisting).Concat(bigExisting).Distinct().ToArray(); //.Where(x => x != number)

            bool countCheck = allExisting.Length == GridMaths.gridSize;

            print($"[CHECK] Naked single check - count: {countCheck}");
            return(countCheck ? GridSolutionType.NakedSingle : GridSolutionType.None); //allExisting.Length == GridMaths.gridSize;
        }
Ejemplo n.º 3
0
        private static int[] GridEmptyIntersectIndices(GridSquareScript[] gridSquares, GridSquareScript selection)
        {
            int square = GridMaths.BigSquareForSquare(selection.Index);

            GridSquareScript[] emptySquares = EmptyGridsAtIndexes(GridMaths.GridBigSquareIndices(square), gridSquares, selection);
            int[] emptyIndices = EmptyGridsAtIndexes(GridMaths.GridBigSquareIndices(square), gridSquares, selection).Select(x => x.Index).Distinct().ToArray();

            //check how many row are in the empty indicies
            int[] emptyCols        = emptyIndices.Where(x => !DoesColumnContainNumber(GridMaths.ColumnForSquare(x), selection, gridSquares)).ToArray();
            int[] emptyRows        = emptyIndices.Where(x => !DoesRowContainNumber(GridMaths.RowForSquare(x), selection, gridSquares)).ToArray();
            int[] intersectIndices = emptyCols.Intersect(emptyRows).ToArray();
            print($"GridEmptyIntersectIndices: ({string.Join(",", emptyIndices)}) empty rows: {string.Join(",", emptyRows)} cols: {string.Join(",", emptyCols)} intersect: {string.Join(",", intersectIndices)}");
            return(emptyCols.Intersect(emptyRows).ToArray());
        }
Ejemplo n.º 4
0
        private static bool DoesSquareForceColumnNumber(int big, GridSquareScript selection, int col, GridSquareScript[] gridSquares)
        {
            print($"DoesSquare {big} ForceColumn {col} Number: {selection.Number}");
            bool numberCheck = DoesBigSquareContainNumber(big, selection, gridSquares);

            if (DoesBigSquareContainNumber(big, selection, gridSquares))
            {
                return(false);
            }
            int[] emptyIndices  = EmptyGridsAtIndexes(GridMaths.GridBigSquareIndices(big), gridSquares, selection).Select(x => x.Index).Distinct().ToArray();
            int[] noColIndices  = emptyIndices.Where(x => !DoesColumnContainNumber(GridMaths.ColumnForSquare(x), selection, gridSquares)).ToArray();
            int[] noRowIndices  = emptyIndices.Where(x => !DoesRowContainNumber(GridMaths.RowForSquare(x), selection, gridSquares)).ToArray();
            int[] forcedColumns = noColIndices.Intersect(noRowIndices).Select(GridMaths.ColumnForSquare).Distinct().ToArray();

            print($"Empty indices in square {big} = {string.Join(",", emptyIndices)} - no col indices ({string.Join(",", noColIndices)})  no row indices ({string.Join(",", noRowIndices)}) = {string.Join(",", forcedColumns)} =  {col}");
            return(forcedColumns.Length == 1 && forcedColumns[0] == col);
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Simple completion check to see if hte row, column or square has all nine numbers in them.
 /// WARNING Doesn't check for duplicates!!
 /// </summary>
 /// <param name="index"></param>
 /// <param name="gridSquares"></param>
 /// <returns>True if any of the checks are true</returns>
 private static GridSolutionType SimpleCompletionCheck(int index, GridSquareScript[] gridSquares) //TODO can be simplified
 {
     if (RowCompleteCheck(gridSquares, GridMaths.RowForSquare(index)))
     {
         print("[CHECK] Simple completion test - Row complete");
         return(GridSolutionType.CompleteRule);
     }
     else if (ColumnCompleteCheck(gridSquares, GridMaths.ColumnForSquare(index)))
     {
         print("[CHECK] Simple completion test - Column complete");
         return(GridSolutionType.CompleteRule);
     }
     else if (BigSquareCompleteCheck(gridSquares, GridMaths.BigSquareForSquare(index)))
     {
         print("[CHECK] Simple completion test - Big Square complete");
         return(GridSolutionType.CompleteRule);
     }
     return(GridSolutionType.None);
 }
Ejemplo n.º 6
0
        /// <summary>
        /// Simple overlap check to duplicate numbers in the same row, column or big square
        /// </summary>
        /// <param name="number"></param>
        /// <param name="index"></param>
        /// <param name="gridSquares"></param>
        /// <returns>True if no duplicate numbers for the selected index</returns>
        private static bool SingleRuleCheck(GridSquareScript selection, GridSquareScript[] gridSquares)
        {
            int row       = GridMaths.RowForSquare(selection.Index);
            int col       = GridMaths.ColumnForSquare(selection.Index);
            int bigSquare = GridMaths.BigSquareForSquare(selection.Index);
            //print($"Grid - keyboard number: {number} on square: {index}");
            bool existsInRow = DoesRowContainNumber(row, selection, gridSquares);
            bool existsInCol = DoesColumnContainNumber(col, selection, gridSquares);
            bool existsInBig = DoesBigSquareContainNumber(bigSquare, selection, gridSquares);
            bool failed      = existsInRow || existsInCol || existsInBig;

            if (!existsInRow &&
                !existsInCol &&
                !existsInBig)
            {
                //TODO add check for only number
            }
            print($"[CHECK] Simple overlap test: row: {existsInRow} col: {existsInCol} big: {existsInBig} => {failed}");
            return(failed);
        }
Ejemplo n.º 7
0
        private static GridSolutionType CheckDoubleDeduction(GridSquareScript[] gridSquares, GridSquareScript selection)
        {
            int[] intersectIndices = GridEmptyIntersectIndices(gridSquares, selection);
            int[] missingRows      = intersectIndices.Select(GridMaths.RowForSquare).Where(x => x != GridMaths.RowForSquare(selection.Index)).Distinct().ToArray();
            int[] missingCols      = intersectIndices.Select(GridMaths.ColumnForSquare).Where(x => x != GridMaths.ColumnForSquare(selection.Index)).Distinct().ToArray();
            print($"Intersect indices: {string.Join(", ", intersectIndices)} Missing rows: {string.Join(", ", missingRows)} cols: {string.Join(", ", missingCols)}");

            int forceRowCount = 0;
            int big           = GridMaths.BigSquareForSquare(selection.Index);

            for (int i = 0; i < missingRows.Length; i++)
            {
                int[] otherBigRows = GridMaths.OtherBigSquaresForRow(missingRows[i], big);
                for (int j = 0; j < otherBigRows.Length; j++)
                {
                    if (DoesSquareForceRowNumber(otherBigRows[j], selection, missingRows[i], gridSquares))
                    {
                        forceRowCount += 1;
                    }
                }
            }

            int forceColCount = 0;

            for (int i = 0; i < missingCols.Length; i++)
            {
                int[] otherBigCols = GridMaths.OtherBigSquaresForColumn(missingCols[i], big);
                for (int j = 0; j < otherBigCols.Length; j++)
                {
                    if (DoesSquareForceColumnNumber(otherBigCols[j], selection, missingCols[i], gridSquares))
                    {
                        forceColCount += 1;
                    }
                }
            }
            print($"[CHECK] Double deduction: Forced rows: {missingRows.Length} = {forceRowCount} && cols: {missingCols.Length} = {forceColCount} check: {forceColCount == missingCols.Length && forceRowCount == missingRows.Length}");
            return((forceColCount == missingCols.Length && forceRowCount == missingRows.Length) ? GridSolutionType.DoubleDeduction : GridSolutionType.None);
        }