Example #1
0
        private List <Mu> RetornarListaMuIII(Mu mu, string regla)
        {
            List <Mu> listMuSustituido = new List <Mu>();

            _listaCoordenadasIII.ForEach(x =>
            {
                if (x.YaUtilizada == false)
                {
                    Mu newMu = new Mu(NuevaCadenaReglaTres(x, mu), regla, mu.Historial);
                    listMuSustituido.Add(newMu);
                }
            });

            /*
             * foreach (var coordenada in _listaCoordenadasIII)
             * {
             *  if (coordenada.YaUtilizada == false)
             *  {
             *      Mu newMu = new Mu(NuevaCadenaReglaTres(coordenada, mu), regla, mu.Historial);
             *      listMuSustituido.Add(newMu);
             *  }
             * }
             */
            return(listMuSustituido);
        }
Example #2
0
        private CoordenadasU CrearCoordenadas(Mu mu, int primeraCoordenada)
        {
            int ultimaCoordenada = 0;

            for (int i = primeraCoordenada + 1; i < mu.Cadena.Length; i++)
            {
                // Sé que i es U, pero no que i + 2 es U
                if (mu.Cadena.Length > i + 1)
                {
                    if (mu.Cadena[i + 1].ToString().Equals("U"))
                    {
                        // Nothing
                    }
                    else
                    {
                        ultimaCoordenada = i;
                    }
                }
                else if (!(mu.Cadena.Length > i + 1))
                {
                    ultimaCoordenada = i;
                }
            }

            CoordenadasU coordenadas = new CoordenadasU(primeraCoordenada, ultimaCoordenada);

            return(coordenadas);
        }
Example #3
0
        private List <Mu> RetornarListaMuU(Mu mu, string regla)
        {
            List <Mu> listMuSustituido = new List <Mu>();

            foreach (var coordenada in _listaCoordenadasU)
            {
                if (coordenada.YaUtilizada == false)
                {
                    Mu newMu = new Mu(NuevaCadenaReglaCuatro(coordenada, mu), regla, mu.Historial);
                    listMuSustituido.Add(newMu);
                }
            }

            return(listMuSustituido);
        }
Example #4
0
        private Mu RevisarIII(Mu mu)
        {
            for (int i = 1; i < mu.Cadena.Length; i++)
            {
                if (mu.Cadena.Length > i + 2 &&
                    (mu.Cadena[i].ToString() + mu.Cadena[i + 1].ToString() + mu.Cadena[i + 2].ToString()).Equals("III"))
                {
                    mu.ContieneIII = true;
                    CoordenadasIII coordenadas = new CoordenadasIII(i, i + 1, i + 2);
                    _listaCoordenadasIII.Add(coordenadas);
                }
            }

            return(mu);
        }
Example #5
0
        public List <Mu> AplicarReglaCuatroSiEsPosible(Mu mu)
        {
            string regla = "4";

            var muRevisado = RevisarUU(mu);

            if (muRevisado.ContieneU)
            {
                List <Mu> listaReglaCuatro = RetornarListaMuU(muRevisado, regla);
                _listaCoordenadasU.Clear();
                return(listaReglaCuatro);
            }
            else
            {
                return(null);
            }
        }
Example #6
0
        public List <Mu> AplicarReglaTresSiEsPosible(Mu mu)
        {
            string regla = "3";

            var muRevisado = RevisarIII(mu);

            if (muRevisado.ContieneIII)
            {
                List <Mu> listaReglaTres = RetornarListaMuIII(muRevisado, regla);
                _listaCoordenadasIII.Clear();
                return(listaReglaTres);
            }
            else
            {
                return(null);
            }
        }
Example #7
0
        public Mu AplicarReglaUnoSiEsPosible(Mu mu)
        {
            string regla = "1";
            Mu     newMu = CopiarObjetoCadena(mu, regla);

            int tamaño = newMu.Cadena.Length;

            if (newMu.Cadena[tamaño - 1].Equals('I'))
            {
                string nuevaCadena = newMu.Cadena + "U";
                newMu.Cadena = nuevaCadena;

                return(newMu);
            }
            else
            {
                return(null);
            }
        }
Example #8
0
        private Mu RevisarUU(Mu mu)
        {
            _creadorCoordenadas.CadenaRevisar = mu.Cadena;
            _creadorCoordenadas.CrearCoordenadas();

            foreach (CoordenadasU coordenada in _creadorCoordenadas.DevolverListaCoordenadas())
            {
                if (coordenada != null)
                {
                    _listaCoordenadasU.Add(coordenada);
                }
            }

            if (_listaCoordenadasU.Count > 0)
            {
                mu.ContieneU = true;
            }

            _creadorCoordenadas.LimpiarEnMemoria();
            return(mu);
        }
Example #9
0
        public Mu AplicarReglaDosSiEsPosible(Mu mu)
        {
            string regla = "2";
            Mu     newMu = CopiarObjetoCadena(mu, regla);

            if (newMu.Cadena[0].Equals('M'))
            {
                string x = "";

                for (int i = 1; i < newMu.Cadena.Length; i++)
                {
                    x += newMu.Cadena[i];
                }

                newMu.Cadena = "M" + x + x;

                return(newMu);
            }
            else
            {
                return(null);
            }
        }
Example #10
0
        private string NuevaCadenaReglaCuatro(CoordenadasU coordenada, Mu muRevisado)
        {
            string cadena = "M";

            for (int i = 1; i < muRevisado.Cadena.Length; i++)
            {
                if (i == coordenada.CoordenadaPrimera)
                {
                    cadena += "U";
                }
                else if (i > coordenada.CoordenadaPrimera && i <= coordenada.CoordenadaUltima)
                {
                    // Nothing
                }
                else
                {
                    cadena += muRevisado.Cadena[i].ToString();
                }
            }

            coordenada.YaUtilizada = true;
            return(cadena);
        }
Example #11
0
        private string NuevaCadenaReglaTres(CoordenadasIII coordenada, Mu muRevisado)
        {
            string cadena = "M";

            for (int i = 1; i < muRevisado.Cadena.Length; i++)
            {
                if (i == coordenada.CoordenadaI)
                {
                    cadena += "U";
                }
                else if ((i == coordenada.CoordenadaII) || (i == coordenada.CoordenadaIII))
                {
                    // nothing
                }
                else
                {
                    cadena += muRevisado.Cadena[i].ToString();
                }
            }

            coordenada.YaUtilizada = true;
            return(cadena);
        }
Example #12
0
        private Mu CopiarObjetoCadena(Mu mu, string regla)
        {
            Mu newMu = new Mu(mu.Cadena, regla, mu.Historial);

            return(newMu);
        }