Esempio n. 1
0
 public void AlteraValorCelula(SDMatrizModel matriz, SDCelulaModel celulaAlterada, SDCelulaModel oldCelula)
 {
     using (ISDService sdService = new SDService())
     {
         sdService.AlteraValorCelula(matriz, celulaAlterada, oldCelula);
     }
 }
Esempio n. 2
0
 public void ResolveSudoku(SDMatrizModel matriz)
 {
     using (ISDService sdService = new SDService())
     {
         sdService.ResolveSudoku(matriz);
     }
 }
Esempio n. 3
0
        public void GeraDigitosIniciais(SDMatrizModel matriz, int qtdeDigitosIniciais)
        {
            int digGerados = 0;

            if (qtdeDigitosIniciais > 0)
            {
                List <SDCelulaModel> listaAleatoriaCelulas = new List <SDCelulaModel>();

                matriz.Celulas.ForEach(celula =>
                {
                    listaAleatoriaCelulas.Add(new SDCelulaModel(celula));
                });

                listaAleatoriaCelulas.Shuffle();

                do
                {
                    SDCelulaModel cel = listaAleatoriaCelulas.Where(celula => celula.Valor == 0 || celula.Valor == null).First();

                    do
                    {
                        cel.Valor = rng.Next(1, 10);
                    } while (RetornaListaCelulasInvalidas(matriz, cel).Any());

                    matriz.Celulas.Where(celula => celula.Equals(cel)).First().Valor        = cel.Valor;
                    matriz.Celulas.Where(celula => celula.Equals(cel)).First().isCelulaDica = true;

                    AjustaStatusCelula(matriz, cel);

                    digGerados++;
                } while (digGerados < qtdeDigitosIniciais);
            }
        }
Esempio n. 4
0
 public void GeraDigitosIniciais(SDMatrizModel matriz, int qtdeDigitosIniciais)
 {
     using (ISDService sdService = new SDService())
     {
         sdService.GeraDigitosIniciais(matriz, qtdeDigitosIniciais);
     }
 }
Esempio n. 5
0
        private List <SDCelulaModel> RetornaListaCelulasInvalidas(SDMatrizModel matriz, SDCelulaModel celulaAlterada)
        {
            List <SDCelulaModel> listaCelulasInvalidas = new List <SDCelulaModel>();

            listaCelulasInvalidas.AddRange(matriz.Linhas.
                                           Find(linha => linha.NumeroSequencial == celulaAlterada.PosicaoLinha).
                                           Celulas.Where(celula => celula.PosicaoColuna != celulaAlterada.PosicaoColuna &&
                                                         celula.Valor == celulaAlterada.Valor &&
                                                         (celula.Valor > 0 && celula.Valor != null)).ToList());

            listaCelulasInvalidas.AddRange(matriz.Colunas.
                                           Find(coluna => coluna.NumeroSequencial == celulaAlterada.PosicaoColuna).
                                           Celulas.Where(celula => celula.PosicaoLinha != celulaAlterada.PosicaoLinha &&
                                                         celula.Valor == celulaAlterada.Valor &&
                                                         (celula.Valor > 0 && celula.Valor != null)).ToList());

            listaCelulasInvalidas.AddRange(matriz.Quadrantes.
                                           Find(quadrante => quadrante.Celulas.Contains(celulaAlterada)).
                                           Celulas.Where(celula => celula.PosicaoLinha != celulaAlterada.PosicaoLinha &&
                                                         celula.PosicaoColuna != celulaAlterada.PosicaoColuna &&
                                                         celula.Valor == celulaAlterada.Valor &&
                                                         (celula.Valor > 0 && celula.Valor != null)).ToList());

            return(listaCelulasInvalidas);
        }
Esempio n. 6
0
        private void ResetaMatriz()
        {
            SDMatrizModel matriz = new SDMatrizModel();

            this.sdMatrixGrid.Matriz = matriz;
            this.sdMatrixGrid.AmarraMatrizAoGrid();
        }
Esempio n. 7
0
 public void ValidaAlteracaoCelula(SDMatrizModel matriz, SDCelulaModel celulaAlterada)
 {
     using (ISDService sdService = new SDService())
     {
         sdService.AjustaStatusCelula(matriz, celulaAlterada);
     }
 }
Esempio n. 8
0
 public void AjustaStatusCelula(SDMatrizModel matriz, List <SDCelulaModel> listCelulasInvalidas)
 {
     foreach (var celulaInvalida in listCelulasInvalidas)
     {
         celulaInvalida.isCelulaValida = false;
     }
 }
Esempio n. 9
0
 private void AjustaStatusCelula(SDMatrizModel matriz)
 {
     foreach (var celula in matriz.Celulas)
     {
         AjustaStatusCelula(matriz, celula);
     }
 }
Esempio n. 10
0
        private void GeraPrimeirosNoveDigitos(SDMatrizModel matriz, List <SDCelulaModel> listaAleatoriaCelulas)
        {
            for (int i = 1; i <= 9; i++)
            {
                SDCelulaModel cel = listaAleatoriaCelulas.Where(celula => celula.Valor == 0 || celula.Valor == null).First();
                cel.Valor = i;

                matriz.Celulas.Where(celula => celula.Equals(cel)).First().Valor           = cel.Valor;
                matriz.Celulas.Where(celula => celula.Equals(cel)).First().isCelulaInicial = true;
                matriz.Celulas.Where(celula => celula.Equals(cel)).First().PossiveisValores.Add(cel.Valor);
            }
        }
Esempio n. 11
0
        private List <SDCelulaModel> RetornaListaAleatoriaCelulas(SDMatrizModel matriz)
        {
            List <SDCelulaModel> listaAleatoriaCelulas = new List <SDCelulaModel>();

            matriz.Celulas.ForEach(celula =>
            {
                listaAleatoriaCelulas.Add(new SDCelulaModel(celula));
            });

            listaAleatoriaCelulas.Shuffle();
            return(listaAleatoriaCelulas);
        }
Esempio n. 12
0
        private List <int?> RetornaListaValoresBloqueados(SDMatrizModel matriz, SDCelulaModel celulaVerificada)
        {
            List <int?> listaValoresBloqueados = new List <int?>();

            matriz
            .Linhas
            .Find(linha => linha.NumeroSequencial == celulaVerificada.PosicaoLinha)
            .Celulas
            .Where(celula => celula.PosicaoColuna != celulaVerificada.PosicaoColuna &&
                   celula.Valor > 0 && celula.Valor != null)
            .ToList()
            .ForEach(celulaDaLinha =>
            {
                if (!listaValoresBloqueados.Contains(celulaDaLinha.Valor))
                {
                    listaValoresBloqueados.Add(celulaDaLinha.Valor);
                }
            });

            matriz
            .Colunas
            .Find(coluna => coluna.NumeroSequencial == celulaVerificada.PosicaoColuna)
            .Celulas
            .Where(celula => celula.PosicaoLinha != celulaVerificada.PosicaoLinha &&
                   celula.Valor > 0 && celula.Valor != null)
            .ToList()
            .ForEach(celulaDaColuna =>
            {
                if (!listaValoresBloqueados.Contains(celulaDaColuna.Valor))
                {
                    listaValoresBloqueados.Add(celulaDaColuna.Valor);
                }
            });

            matriz
            .Quadrantes
            .Find(quadrante => quadrante.Celulas.Contains(celulaVerificada))
            .Celulas
            .Where(celula => !celula.Equals(celulaVerificada) &&
                   celula.Valor > 0 && celula.Valor != null)
            .ToList()
            .ForEach(celulaDoQuadrante =>
            {
                if (!listaValoresBloqueados.Contains(celulaDoQuadrante.Valor))
                {
                    listaValoresBloqueados.Add(celulaDoQuadrante.Valor);
                }
            });

            return(listaValoresBloqueados);
        }
Esempio n. 13
0
        private Dictionary <int, SDCelulaModel> RetornaDictCelulasParaPreencher(SDMatrizModel matriz)
        {
            var dictCelulasParaPreencher = new Dictionary <int, SDCelulaModel>();

            int i = 1;

            matriz.Celulas.Where(celula => !celula.isCelulaInicial).OrderBy(celula => celula.PossiveisValores.Count).ToList()
            .ForEach(celula =>
            {
                dictCelulasParaPreencher.Add(i, new SDCelulaModel(celula));
                i++;
            });

            return(dictCelulasParaPreencher);
        }
Esempio n. 14
0
        public void ReavaliaCelulasAposAlteracao(SDMatrizModel matriz, SDCelulaModel oldCelula)
        {
            var listaCelulasParaReavaliar = new List <SDCelulaModel>();

            listaCelulasParaReavaliar.AddRange(matriz.Linhas.Find(linha => linha.NumeroSequencial == oldCelula.PosicaoLinha)
                                               .Celulas.Where(celula => celula.Valor == oldCelula.Valor).ToList());
            listaCelulasParaReavaliar.AddRange(matriz.Colunas.Find(coluna => coluna.NumeroSequencial == oldCelula.PosicaoColuna)
                                               .Celulas.Where(celula => celula.Valor == oldCelula.Valor).ToList());
            listaCelulasParaReavaliar.AddRange(matriz.Quadrantes.Find(quadrante => quadrante.Celulas.Contains(oldCelula))
                                               .Celulas.Where(celula => celula.Valor == oldCelula.Valor).ToList());

            foreach (var celulaParaReavaliar in listaCelulasParaReavaliar)
            {
                AjustaStatusCelula(matriz, celulaParaReavaliar);
            }
        }
Esempio n. 15
0
        private void PreenchePossiveisValores(SDMatrizModel matriz, List <SDCelulaModel> listaCelulas)
        {
            foreach (var celula in listaCelulas)
            {
                var listaValoresBloqueados = RetornaListaValoresBloqueados(matriz, celula);

                if (listaValoresBloqueados.Any())
                {
                    celula.PossiveisValores = ListaValoresSudoku
                                              .Where(valor => !listaValoresBloqueados.Contains(valor))
                                              .ToList();
                }
                else
                {
                    celula.PossiveisValores = ListaValoresSudoku;
                }
            }
        }
Esempio n. 16
0
        public void AjustaStatusCelula(SDMatrizModel matriz, SDCelulaModel celulaAlterada)
        {
            var listaCelulasInvalidas = RetornaListaCelulasInvalidas(matriz, celulaAlterada);

            if (listaCelulasInvalidas.Any())
            {
                celulaAlterada.isCelulaValida = false;
            }
            else
            {
                celulaAlterada.isCelulaValida = true;
            }

            foreach (var celulaInvalida in listaCelulasInvalidas)
            {
                celulaInvalida.isCelulaValida = false;
            }
        }
Esempio n. 17
0
        private void PreencheValorCelula(SDMatrizModel matriz, KeyValuePair <int, SDCelulaModel> parCelulaAtual, Dictionary <int, SDCelulaModel> dictCelulasParaPreencher)
        {
            if (!matriz.Celulas.Any())
            {
                return;
            }

            var celulaReal = matriz.Celulas.Find(cel => cel.Equals(parCelulaAtual.Value));

            if (celulaReal.PossiveisValores.Count == 1 && !matriz.Celulas.Exists(celula => !celula.PossiveisValores.Any()))
            {
                celulaReal.Valor = celulaReal.PossiveisValores.First();
                return;
            }

            foreach (var valor in celulaReal.PossiveisValores)
            {
                if (celulaReal.Valor == valor)
                {
                    continue;
                }

                celulaReal.Valor = valor;
                PreenchePossiveisValores(matriz);

                if (!matriz.Celulas.Exists(celula => !celula.PossiveisValores.Any()))
                {
                    return;
                }
            }

            if (parCelulaAtual.Key - 2 < 0)
            {
                throw new ArgumentOutOfRangeException();
            }

            var parCelulaAnterior = dictCelulasParaPreencher.ElementAt(parCelulaAtual.Key - 2);

            PreencheValorCelula(matriz, parCelulaAnterior, dictCelulasParaPreencher);

            PreencheValorCelula(matriz, parCelulaAtual, dictCelulasParaPreencher);
        }
Esempio n. 18
0
        private SDMatrizModel RetornaGridResolvida()
        {
            SDMatrizModel matriz = new SDMatrizModel();

            while (rollBack)
            {
                matriz = new SDMatrizModel();

                List <SDCelulaModel> listaAleatoriaCelulas = RetornaListaAleatoriaCelulas(matriz);

                GeraPrimeirosNoveDigitos(matriz, listaAleatoriaCelulas);

                PreenchePossiveisValores(matriz);

                Dictionary <int, SDCelulaModel> dictCelulasParaPreencher = RetornaDictCelulasParaPreencher(matriz);

                try
                {
                    foreach (var item in dictCelulasParaPreencher)
                    {
                        PreencheValorCelula(matriz, item, dictCelulasParaPreencher);
                    }
                }
                catch (ArgumentOutOfRangeException ex)
                {
                    continue;
                }

                AjustaStatusCelula(matriz);

                if (matriz.Celulas.Any() && !matriz.Celulas.Exists(celula => !celula.isCelulaValida))
                {
                    rollBack = false;
                }
            }

            return(matriz);
        }
Esempio n. 19
0
        private void PreenchePossiveisValores(SDMatrizModel matriz)
        {
            foreach (var celula in matriz.Celulas)
            {
                if (celula.isCelulaInicial)
                {
                    continue;
                }

                var listaValoresBloqueados = RetornaListaValoresBloqueados(matriz, celula);

                if (listaValoresBloqueados.Any())
                {
                    celula.PossiveisValores = ListaValoresSudoku
                                              .Where(valor => !listaValoresBloqueados.Contains(valor))
                                              .ToList();
                }
                else
                {
                    celula.PossiveisValores = ListaValoresSudoku;
                }
            }
        }
Esempio n. 20
0
 public void ResolveSudoku(SDMatrizModel matriz)
 {
 }
Esempio n. 21
0
 public void AlteraValorCelula(SDMatrizModel matriz, SDCelulaModel celulaAlterada, SDCelulaModel oldCelula)
 {
     AjustaStatusCelula(matriz, celulaAlterada);
     ReavaliaCelulasAposAlteracao(matriz, oldCelula);
 }
Esempio n. 22
0
        public SDMatrizModel MontaGridInicial()
        {
            SDMatrizModel matriz = RetornaGridResolvida();

            return(matriz);
        }