Пример #1
0
        public void EmbedSecretData(byte[] containerBytes, byte[] secretBytes, SudokuMatrix <byte> sudokuKey)
        {
            if (containerBytes == null || containerBytes.Length == 0 || secretBytes == null || secretBytes.Length == 0)
            {
                throw new ArgumentException();
            }

            if (secretBytes.Length * 2 >= containerBytes.Length)
            {
                throw new InvalidOperationException("Cannot encrypt secret data because container image is too small");
            }

            ValidateSudoku(sudokuKey);

            for (int i = 0, secretDataIterator = 0;
                 i + 1 < containerBytes.Length && secretDataIterator < secretBytes.Length;
                 i += 2, secretDataIterator++)
            {
                byte currentByte = secretBytes[secretDataIterator];
                SudokuCoordinates initialCoordinates = new SudokuCoordinates(containerBytes[i], containerBytes[i + 1]);
                SudokuCoordinates nearestCoordinates = sudokuKey.FindNearestCoordinates(currentByte, initialCoordinates);

                if (initialCoordinates != nearestCoordinates)
                {
                    containerBytes[i]     = nearestCoordinates.X;
                    containerBytes[i + 1] = nearestCoordinates.Y;
                }
            }
        }
        public SudokuCoordinates Find(T valueToFind, SudokuCoordinates initialCoordinates, T[,] sudokuMatrix)
        {
            int sudokoSize = sudokuMatrix.GetLength(0);

            if (!(//valueToFind >= 0 && valueToFind < sudokoSize &&
                    initialCoordinates.X >= 0 && initialCoordinates.X < sudokoSize &&
                    initialCoordinates.Y >= 0 && initialCoordinates.Y < sudokoSize))
            {
                throw new ArgumentException("Wrong initialCoordinates or valueToFind");
            }

            int sudokoBlockSize = (int)Math.Sqrt(sudokoSize);

            //depth 0
            if (CheckValue(initialCoordinates.X, initialCoordinates.Y, valueToFind, sudokoSize, sudokuMatrix))
            {
                return(initialCoordinates);
            }

            for (int depth = 1; depth <= sudokoBlockSize * 2 + 2; depth++)
            {
                for (int i = 0; i < depth + 1; i++)
                {
                    int offset = (depth - i);

                    int x1 = initialCoordinates.X + i;
                    int y1 = initialCoordinates.Y + offset;
                    if (CheckValue(x1, y1, valueToFind, sudokoSize, sudokuMatrix))
                    {
                        return(new SudokuCoordinates((byte)x1, (byte)y1));
                    }

                    int x2 = initialCoordinates.X + i;
                    int y2 = initialCoordinates.Y - offset;
                    if (CheckValue(x2, y2, valueToFind, sudokoSize, sudokuMatrix))
                    {
                        return(new SudokuCoordinates((byte)x2, (byte)y2));
                    }

                    int x3 = initialCoordinates.X - i;
                    int y3 = initialCoordinates.Y + offset;
                    if (CheckValue(x3, y3, valueToFind, sudokoSize, sudokuMatrix))
                    {
                        return(new SudokuCoordinates((byte)x3, (byte)y3));
                    }

                    int x4 = initialCoordinates.X - i;
                    int y4 = initialCoordinates.Y - offset;
                    if (CheckValue(x4, y4, valueToFind, sudokoSize, sudokuMatrix))
                    {
                        return(new SudokuCoordinates((byte)x4, (byte)y4));
                    }
                }
            }

            throw new Exception($"Cannot find requested value: {valueToFind} in the sudoku matrix.");
        }