---
# System prepended metadata

title: DESAFIO BCI

---

# DESAFIO BCI

## EJERCICIO 2

> De un *string* binario (conformado por ceros y unos) y retornar la cantidad de todos los *substrings* que tengan la misma cantidad de ceros y de unos, con la condición de que tanto los ceros como los unos de los *substrings* sean consecutivos

1. **ANÁLISIS**
    - Lo primero es entender lo que se pide. Básicamente es tomar todos los posibles *substrings* dado un *string* de entrada
    - Si consideramos el hecho de que los *substrings* que cumplen la condición debe tener la misma cantidad de ceros que de unos, entonces podemos **descartar** todos los ***substrings* impares**
    - Teniendo ya *substrings* pares dentro de nuestro grupo de "posibles candidatos", ahora debemos evaluar si cumplen la condición de tener la **misma cantidad** de **ceros y unos consecutivos**. Para ello, debemos tomar cada *substring* y evaluar su primer mitad. Si en esa primer mitad sólo tenemos unos, en la segunda mitad sólo debemos tener ceros, y viceversa
2. **EJEMPLO**
    - Supongamos que recibimos el *string* `011001`, acá todos los posibles *substrings* **pares** son:
        - `01`
        - `11`
        - `10`
        - `01`
        - `0110`
        - `1100`
        - `1001`
    - Notar que hay otros *substrings*, pero estos no nos sirven por ser impares y, en consecuencia, nunca tendrán la misma cantidad de ceros que de unos. Lo siguiente es tomar cada *substring* y analizar su primer mitad y su segunda mitad, de manera que si la primer mitad sólo tiene unos, la segunda sólo debe tener ceros. De esta forma evaluamos las dos condiciones: (a) que tengan la misma cantidad de ceros que de unos y (b) que los ceros y unos sean consecutivos. Para cada *substring* que cumpla, tendremos un contador para finalmente tener el total de *substrings* que cumplen lo solicitado
        - `01`. Primer mitad `0` ¿sólo unos/ceros? **Sí, sólo ceros**. Segunda mitad `1` ¿sólo unos? **Sí, sólo unos**. **Contador = 1**
        - `11` Primer mitad `1` ¿sólo unos/ceros? **Sí, sólo unos**. Segunda mitad `1` ¿sólo ceros? **No**
        - `10` Primer mitad `1` ¿sólo unos/ceros? **Sí, sólo unos**. Segunda mitad `0` ¿sólo ceros? **Sí, sólo ceros**. **Contador = 2**
        - `01` Primer mitad `0` ¿sólo unos/ceros? **Sí, sólo ceros**. Segunda mitad `1` ¿sólo unos? **Sí, sólo unos**. **Contador = 3**
        - `0110` Primer mitad `01` ¿sólo unos/ceros? **No**
        - `1100` Primer mitad `11` ¿sólo unos/ceros? **Sí, sólo unos**. Segunda mitad `00` ¿sólo ceros? **Sí, sólo ceros**. **Contador = 4**
        - `1001` Primer mitad `10` ¿sólo unos/ceros? **No**
        - **Contador final = 4**
3. **VB.NET C#**
```java=
using System;
using System.Collections.Generic;

namespace test_BCI
{
    public class Funciones
    {
        public int ContarSubstrings(string entrada)
        {
            string subString;
            List<string> LstsubString = new List<string>();

            //Recorrer string enviado {entrada}
            for (int i = 0; i < entrada.Length; i++)
            {
                for (int j = i; j < entrada.Length; j++)
                {
               
                    subString = entrada.Substring(i, j - i + 1);
                    //dividir en 2 para ver si son pares
                    if (subString.Length % 2 == 0)
                        LstsubString.Add(subString);
                }
            }
           
            //variable para contar los ceros del string
            int ceros;
            //variable para contar los unos del string
            int unos;
           //variable para contar cadenas correctas
            int contador = 0;
            //vatiable para recorrer string en caso de true
            bool resultado = true;

            //variables para sub dividir string
            char primerCaracter;
            char[] arregloDeChar;
           
            foreach (string aEvaluar in LstsubString)
            {
                unos = 0;
                ceros = 0;
                //contamos los ceros
                foreach (char cero in aEvaluar) if (cero == '0') ceros++;
                //contamos los unos
                foreach (char uno in aEvaluar) if (uno == '1') unos++;
                //si los unos y ceros son iguales, avanzamos
                if (ceros == unos)
                {
                    //re-seteamos las variables anteriores
                    ceros = 0;
                    unos = 0;
                    //tomamos el primer caracter
                    primerCaracter = Convert.ToChar(aEvaluar.Substring(0, 1));
                    arregloDeChar = aEvaluar.ToCharArray();
                    int largoMitad = (aEvaluar.Length / 2) ;

                    resultado = true;

                    if (primerCaracter == '0')
                    {

                        //evaluamos la primer mitad
                        for (int k = 1; k < largoMitad; k++)
                        {
                            //Siempre que sea verdadero se cumple la condicion
                            if (resultado)
                            {
                                if (arregloDeChar[k] == '0')
                                {
                                    resultado = true;
                                }
                                else
                                {
                                    resultado = false;
                                    break; //salimos del for
                                }
                            }
                        }
                        //Se evalua la segunda mitad
                        for (int l = largoMitad; l < aEvaluar.Length; l++)
                        {
                            //Siempre que sea verdadero se cumple la condicion
                            if (resultado)
                            {
                                if (arregloDeChar[l] == '1')
                                {
                                    resultado = true;
                                }
                                else
                                {
                                    resultado = false;
                                    break; //salimos del for
                                }
                            }
                        }
                        
                    }
                    //repetimos el proceso, pero considerando que el primer caracter del substring es uno
                    else
                    {
                        //evaluamos la primer mitad
                        for (int k = 1; k < largoMitad; k++)
                        {
                            //Siempre que sea verdadero se cumple la condicion
                            if (resultado)
                            {
                                if (arregloDeChar[k] == '1')
                                {
                                    resultado = true;
                                }
                                else
                                {
                                    resultado = false;
                                    break; //salimos del for
                                }
                            }
                        }
                        //evaluamos la segunda mitad
                        for (int l = largoMitad; l < aEvaluar.Length; l++)
                        {
                            //Siempre que sea verdadero se cumple la condicion
                            if (resultado)
                            {
                                if (arregloDeChar[l] == '0')
                                {
                                    resultado = true;
                                }
                                else
                                {
                                    resultado = false;
                                    break; //salimos del for
                                }
                            }
                        }
                    }
                }
                //Si se cumplen las condiciones sumas ++ al contador
                if (resultado) contador++;
            }
            return contador;
        }
    }
    class Program
    {
        static void Main(string[] args)
        { 

           Funciones ClsFunciones = new Funciones();
           int cont = ClsFunciones.ContarSubstrings("011001");


            Console.WriteLine(cont);
        }
    }
}
```