¿Como encontrar la mayor cantidad de numero uno consecutivos?

Digamos que nos proporcionan un array de numeros binarios llamado nums, este devuelve el número máximo de unos consecutivos en el array.

Para resolver este problema voy a utilizar JavaScript. 

Como un ejemplo, el primer array que vamos a ejecutar es el siguiente: 

nums: [1,1,0,1,1,1] y como resultado nuestra funcion deberia devolver el valor: 3. 

 

El siguiente es el codigo para resolver este problema:

var encontrarMaximoNumeroUnosCosecutivos = function(nums) {
    let c = 0;
    let l1 = 0;
    let l2 = 0;
    let maximo = 0;

    for (let i=0; i<nums.length; i++) {
        
        if (nums[i] === 1) {
            c++;
        }  
        
        if (nums[i] === 0 || i === (nums.length - 1)) {
            
            if (l1 !== 0 && l2 < l1) {
                l2 = l1;
            }
            
            l1 = c;
            c = 0;  
 
            if (l1 > l2) {
                maximo = l1;
            } else {
                maximo = l2;
            }
        } 
    }

    return maximo;
    
};

 let nums = [1,1,0,1,1,1];

 console.log(encontrarMaximoNumeroUnosCosecutivos(nums));



Ahora voy a explicar como funciona este codigo.



var encontrarMaximoNumeroUnosCosecutivos = function(nums) {
    let c = 0;
    let l1 = 0;
    let l2 = 0;
    let maximo = 0;
};

Primero, declaramos la funcion "encontrarMaximoNumeroUnosConsecutivos" e iniciamos las variables c, l1, l2, y maximo; todas igual a 0. 


var encontrarMaximoNumeroUnosCosecutivos = function(nums) {
    let c = 0;
    let l1 = 0;
    let l2 = 0;
    let maximo = 0;

    for (let i=0; i<nums.length; i++) {
         if (nums[i] === 1) {
            c++;
        }  
    }
Luego, debemos atravezar cada elemento del array "nums". Para ello utilizamos un for loop, en esete caso.
Al mismo tiempo, cada vez que el valor del indice "i" que estemos atravezando sea igual a "1" incrementaremos el valor de la variable "c".
 

var encontrarMaximoNumeroUnosCosecutivos = function(nums) {
    let c = 0;
    let l1 = 0;
    let l2 = 0;
    let maximo = 0;

    for (let i=0; i<nums.length; i++) {
        
        if (nums[i] === 1) {
            c++;
        }  
        
        if (nums[i] === 0 || i === (nums.length - 1)) {
           
l1 = c;
            c = 0;

        }
};

Ahora preguntamos: si el indice "i" es igual a 0 o el indice "i" indique el final del array entonces debemos especificar q el valor de "l1"ahora sera el valor del acumulador de 1s "c". Y luego resetear el valor de "c" a 0 de nuevo.
 

var encontrarMaximoNumeroUnosCosecutivos = function(nums) {
    let c = 0;
    let l1 = 0;
    let l2 = 0;
    let maximo = 0;

    for (let i=0; i<nums.length; i++) {
        
        if (nums[i] === 1) {
            c++;
        }  
        
        if (nums[i] === 0 || i === (nums.length - 1)) {
            
            if (l1 !== 0 && l2 < l1) {
                l2 = l1;
            }
            
            l1 = c;
            c = 0; 
        } 
    }

};

Digamos que el valor maximo de unos consecutivos en un array es igual a 2 y luego encontramos otro valor consecutivo mas alto, entonces debemos reemplazar este valor. Para ello preguntamos si la variable "l1" no es igual que 0 y tambien "l1" es mayor que el valor de "l2", entonces "l2" tendria el valor de "l1". 


var encontrarMaximoNumeroUnosCosecutivos = function(nums) {
    let c = 0;
    let l1 = 0;
    let l2 = 0;
    let maximo = 0;

    for (let i=0; i<nums.length; i++) {
        
        if (nums[i] === 1) {
            c++;
        }  
        
        if (nums[i] === 0 || i === (nums.length - 1)) {
            
            if (l1 !== 0 && l2 < l1) {
                l2 = l1;
            }
            
            l1 = c;
            c = 0;  
 
            if (l1 > l2) {
                maximo = l1;
            } else {
                maximo = l2;
            }
        } 
    }

    return maximo;
    
};

 let nums = [1,1,0,1,1,1];

 console.log(encontrarMaximoNumeroUnosCosecutivos(nums));

Finalmente preguntamos si el valor del numero maximo de unos consecutivos nuevo (l1) es mayor que el valor de unos consecutivos anterior (l2) entonces la variable "maximo" sera igual al valor de l1; de lo contrario sera igual al valor de l2. Retornamos la variable "maximo" que nos indicara el numero maximo final de unos consecutivos en el array. 

 

 

 

Comparación entre Animaciones Web utilizando JavaScript o CSS


 Las aplicaciones web a veces están equipadas con animaciones. Algunas animaciones son desencadenadas por eventos, como por ejemplo cuando el usuario pasa el mouse sobre un botón y este progresivamente expande su tamaño, o simplemente pueden suceder sin la interacción del usuario, un ejemplo seria un cuadrado parpadeante en la pantalla. Las animaciones proporcionan efectos visuales a las aplicaciones basadas en la web para hacerlas más interactivas y visualmente atractivas. Algunas aplicaciones son más adecuadas a tener elementos animados mas que otras, como en el caso de juegos interactivos.

    Actualmente existen diferentes formas de lograr estos efectos visuales en la web. En este artículo voy a analizar los enfoques de animación web utilizando JavaScript y CSS. ¿Qué método es más eficiente y bajo qué circunstancias? Cuál método es más fácil de implementar y mantener?

    En el pasado, Flash era un método muy popular para crear aplicaciones animadas; sin embargo, llegada la demanda de dispositivos mobiles la utilización de Flash se volvió obsoleta. Esto se debió a que el rendimiento de la animación se convirtió en una aspecto muy importante y Flash no ofrecía las mejores capacidades. Mas adelante se introdujeron librerías de JavaScript, como es el caso de jQuery, que ofrece animaciones basadas en JavaScript. Sin embargo, tan conveniente como jQuery fue para los desarrolladores, este también quedo corto en lograr un alto rendimiento de animación [3]. Luego, la introducción de CSS3 se convirtió una mejor solución para animaciones que no implicaban instalar ninguna librería externa para nuestro proyecto, y por lo tanto era una opción prometedora para animaciones más eficientes.

Hay dos formas diferentes de utilizar CSS para crear animaciones. Estos son Propiedades de animaciones y transiciones CSS:

Transiciones CSS: muestra animaciones entre dos estados. Estos podrían ser, por ejemplo, animando un botón entre su estado de reposo y un hover. El botón podría mostrar un efecto de desvanecimiento mientras el usuario intenta seleccionar este botón. Las transiciones con CSS tienen diferentes propiedades que definen la propiedad de animación de destino, la duración de la animación, suavizado del efecto y retraso del mismo. Tanto la duración como el retraso se miden en segundos.

Animaciones CSS: asigna animaciones entre un conjunto de propiedades iniciales y finales. Esta consta de keyframes clave para la progresión de las animaciones y el estilo de la apariencia de la misma [2].

    Ambos están programados de diferentes formas, pero también comparten deficiencias similares. Las animaciones utilizando CSS no permiten una gran interacción entre el programador/usuario y la animación. Por ejemplo, no hay forma de encontrar un keyframe especifico en una animacion programada solo con CSS, también una vez que la animación ha comenzado no se puede revertir o llevar a ningún punto en particular. Aparte de esto, solo algunos navegadores permiten al usuario pausar y reanudar una animación creada con CSS. Cuando se trata de valores relativos, las animaciones hechas con CSS no ofrecen gran flexibilidad tampoco, lo que significa que si el programador desea instruir a la animación un elemento para mover 50px a la derecha de donde comienzan las animaciones, no sería posible hacerlo simplemente utilizando animaciones con CSS [3].

    Otra alternativa popular para animar elementos de aplicaciones web es utilizando JavaScript. Cómo mencione anteriormente, hay ciertas librerías de JavaScript que se pueden utilizar para producir animaciones de una manera simple para los desarrolladores. jQuery hizo un intento de lograr esto, pero este también se quedo corto con relación al rendimiento. Aparte de jQuery existe otra librería basada en JavaScritpt llamada GSAP (GreenSock Animation Platform) que se construyó específicamente para crear animaciones para la web, teniendo en cuenta la optimización y la eficiencia de estas tareas [3]. Sin embargo, existe un enfoque más estándar para crear animaciones JavaScript, y esto es la API de animaciones web que funciona dirigiéndose a elementos DOM [6].

    JavaScript proporciona ciertas funcionalidades que no son posibles utilizando simplemente animaciones basadas en CSS como son la posibilidad de pausar, reanudar, detener, y revertir una animación. Esto proporciona al usuario la capacidad de tener cierto control sobre la animación.  Esto hace que aplicación sea verdaderamente interactiva, una característica que no es posible con CSS [3]. Las animaciones desarrolladas con JavaScript también puede hacer uso de objetos, lo que hace posible integrar la Programación Orientada a Objetos a nuestras animaciones, permitiendo desarrollar diseños más complejos. Otra ventaja de JavaScript sobre las animaciones con CSS es poder animar otras objetos distintos de los elementos DOM [2].

    Aparte de la interactividad y la facilidad de desarrollo, hay otro, incluso más importante aspecto al comparar dos métodos de programación. Aqui estamos hablando del rendimiento. Primero vamos a discutir qué propiedades y componentes son menos y más costosos de animar. Las propiedades más baratas para animar los navegadores son: posición, escala, rotación, y opacidad [4]. Ahora, las propiedades más caras de animar son las que cambian el diseño completo de la página junto con ellos, así como la pintura en la pantalla. Por ejemplo, si tenemos un elemento de página web con ancho y alto medidos en porcentaje junto a otros elementos, cambiar estas propiedades constantemente hará que el los elementos en el entorno tengan que recalcular sus valores tambien, lo que hace que esta sea una tarea muy costosa. Estos problemas relacionados al  rendimiento se pueden atribuir a ambos tipos: animaciones basadas con JavaScript y también con CSS.

    Cuando se trata de subprocesos de animaciones CSS, así como animaciones web basadas en JavaScript se ejecutan en un hilo llamado "hilo compositor". Este hilo es diferente del hilo donde el navegador hace la mayor parte del trabajo en cuanto a estilo, diseño, pintura y ejecución de JavaScript. El nombre de este hilo es "hilo principal". El hecho de que haya una hilo separado para CSS y animaciones web para ejecutar significa que se ejecutarán independientemente de la carga de trabajo que lleva el navegador de otros tareas. Esto hace que las animaciones basadas en CSS y JavaScript funcionen igualmente bien en eso sentido [2]. Otra ventaja que hace que las animaciones CSS y JavaScript se ejecuten sin problemas es la ventaja que ambos obtienen del hardware. La capa de GPU permite el aislamiento los elementos de las de animaciones que, a su vez, facilitan que la GPU mueva esas capas y las componga mas tarde. Sin embargo, para que JavaScript aproveche esta ventaja del GPU una capas que necesita para hacer uso de transformaciones 3D y matrices. La única desventaja de la estratificación de GPU sería un pequeño retraso al iniciar ambas aplicaciones debido al cálculo de la capa del navegador y la carga a la hora de la GPU [3].

    En conclusión, tanto las animaciones basadas en JavaScript como en CSS funcionan relativamente y casi igualmente bien cuando JavaScript está bien optimizado. La decisión de elegir uno sobre el otro tiene más que ver con la flexibilidad y la complejidad de la animación que quiere ser lograda. Para proyectos más pequeños y simples, se recomienda utilizar animaciones CSS. Vienen con la ventaja de ser más fáciles de escribir. Para animaciones más complejas que requieren pausar, detener, reanudar y ralentizar las animaciones, JavaScript es necesario. La API de animaciones web es la herramienta de referencia para el desarrollo de animaciones JavaScript; sin embargo, hay otras librerías de animación de alto rendimiento como GSAP.



Referencias:

[1] https://developers.google.com/web/fundamentals/design-and-ux/animations/css-vs-javascript
Updated 2019
[2]https://developers.google.com/web/fundamentals/design-and-ux/animations/animations-andperformance#
css-vs-javascript-performance Updated 2019
[3] https://css-tricks.com/myth-busting-css-animations-vs-javascript/ 2014 - Updated 2017
[4] https://www.html5rocks.com/en/tutorials/speed/high-performance-animations/

Como invertir un String con recursividad




Primero que todo ¿Que es recursividad?

Recursividad es el proceso en el que una función se invoca a si misma. La solución de este problema depende de la solución de instancias más pequeñas del mismo problema.

Pasos a tener en cuenta cuando usamos recursividad.

Paso 1. Ten especificaciones específicas

Paso 2. Procura que tu método trabaje en el caso base.

Paso 3. Presta atención al caso recursivo(s). En tu mente reemplaza cada invocación recursiva de acuerdo a las especificaciones y verifica que todo este correcto.

Paso 4. Ten en cuenta no tener un proceso recursivo infinito. Asegúrate de que los argumentos de invocaciones recursivas son en algún caso más pequeñas que las partes de los métodos.

Aquí discutiré el problema de como invertir un String, o una palabra usando JavaScript. Este problema se podría resolver fácilmente utilizando un ciclo for. Sin embargo, quiero utilizar el método de recursividad para resolver el mismo problema.

1. Primero creamos una función llamada: "invertirString", que reciba como argumento un String: "str".

function invertirString(str) {
}

2. Necesitamos saber el tamaño del String, por lo tanto creamos una variable llamada "sLen" que sera igual al str.length.

function invertirString(str) {
       let sLen = str.length;
}

3. ¿Ahora, para que saber el tamano del String? Pues la lógica de las invocaciones recursivas requiere que llamemos la funcion "invocarString()" tantas veces sea necesario, teniendo en cuenta que cada vez que llamemos la función el valor del argumento (str), debe de ser cada vez menor.

Si cada vez que llamemos la funcion "invertirString()" queremos que la entrada sea menor entonces el caso base seria cuando el tamaño del String sea menor o igual que 0. Por lo tanto:

function invertirString(str) {
       let sLen = str.length;
       if (sLen <= 0) {
        return "";
    }
}

Cuando hayamos llamado la función muchas veces hasta agotar el tamano del String debemos retornar la función con un String vacío.

4. La parte más importante de las funciones recursivas es invocarse a si mismas. En este caso para invertir un String debemos primero utilizar el método "chatAt()" para tomar el último caracter en nuestro String y concatenarlo con el resultado de la invocación de nuestra funcion. Como queremos que el String valla eliminando el caracter que vallamos añadiendo a nuestro resultado y así achicando la entrada, entonces utilizamos el método "substring()" para ello. De esta manera nuestro código terminaría así:

function invertirString(str) {
    let sLen = str.length;
    if (sLen <= 0) {
        return '';
    } else {
        return str.charAt(sLen - 1) + invertirString(str.substring(0, sLen -1));
    }
}




Como encontrar el segundo valor mas grande en un array




En este programa usare JavaScript para encontrar el sugundo valor mas alto en un array.

Primero declaramos una variable de nombre "arr" con el array y los valores que queramos intentar.

let arr = [ 8, 6, 4, 12, 10, 2 ];

Luego declaramos la funcion "segundoMasGrande" y pasamos el array "arr" como parametro de la siguiente manera:

let arr = [ 8, 6, 4, 12, 10, 2 ];

function segundoMasGrande(arr) {

}


Para empezar debemos declarar dos variables e inizializarlas en cero:

let arr = [ 8, 6, 4, 12, 10, 2 ];

function segundoMasGrande(arr) {
   let masGrande = 0;
   let segundoMasGrande = 0;
}


Ahora debemos comparar todos los valores en el array para saber cual es el segundo valor mas grande. Para ello tambien debemos saber cual es el valor mas grande y compararlos. Utilizamos un clico for iterar por cada valor y para comparar los valores, uno con otro utilizamos un if.

let arr = [ 8, 6, 4, 12, 10, 2 ];

function segundoMasGrande(arr) {

   let masGrande = 0;
   let segundoMasGrande = 0;

  for (let i = 0; i < arr.length; i++) {
     if (arr[i] > masGrande ) {
            masGrande = arr[i];
     }
  }
}


En el codigo de arriba, "if (arr[i] > masGrande ) {" compara si el "arr[i]" o el valor actual es mayor que el valor actual mas grande que es la variable "masGrande". Cuando el ciclo "for" compare por primera vez que el valor "8" es mas grande que "0" que seria el valor actual de la variable "masGrande" entocese el valor de la variable "masGrande" se igualaria a "8".

Cuando el ciclo "for" compare el segundo valor "6" enconces preguntara: 6 > 8, siendo el resultado falso, entoces deberiamos decir que 8 todavia es el valor mas grande pero 6 es ahora el segundo valor mas grande. Para ello creamos un else y utlizamos la variable del valor "segMasGrande".

let arr = [ 8, 6, 4, 12, 10, 2 ];

function segundoMasGrande(arr) {

   let masGrande = 0;
   let segundoMasGrande = 0;

  for (let i = 0; i < arr.length; i++) {
     if (arr[i] > masGrande ) {
            masGrande = arr[i];
     } else {

             if (arr[i] > segMasGrande) {
                segMasGrande= arr[i];
             }
         }
  }
}


Cuando el ciclo compare el tercer valor "4" entonces preguntaria: 4 > 8, (8 todavia es le valor mas grade) esto tambien seria falso, por lo cual se va al else y el if preguntaria de nuevo: 4 > 6, (6 todavia el segundo valor mas grande), esto seria falso tambien, por lo tanto los valores de ambas variables continuan igual.

Al comparar 12 > 8, esto seria verdadero, ahora el valor de la variable masGrande se iguala a 12. Pero que pasaria con el valor de 8, que ahora seria le segundo valor mas grande? Para resolver esto simplemente igualamos la variable "segMasGrande" igual a el valor que tenia la variable "masGrande".

let arr = [ 8, 6, 4, 12, 10, 2 ];

function segundoMasGrande(arr) {

   let masGrande = 0;
   let segundoMasGrande = 0;

  for (let i = 0; i < arr.length; i++) {
     if (arr[i] > masGrande ) {
            segundoMasGrande = masGrande ;
            masGrande = arr[i];
     } else {

             if (arr[i] > segMasGrande) {
                segMasGrande= arr[i];
             }
         }
    }
}




Finalmente imprimimos el valor de la variable "segMasGrande" y llamamos la funcion al final.

let arr = [ 8, 6, 4, 12, 10, 2 ];

function segundoMasGrande(arr) {

   let masGrande = 0;
   let segundoMasGrande = 0;

  for (let i = 0; i < arr.length; i++) {
     if (arr[i] > masGrande ) {
            segundoMasGrande = masGrande ;
            masGrande = arr[i];
     } else {
             if (arr[i] > segMasGrande) {
                segMasGrande= arr[i];
             }
         }
    }
    console.log(segMasGrande);
}


segundoMasGrande(arr);


El segundo valor mas grande de este array seria 10.

Java: Contar espacios en blanco en una oracion

El siguiente codigo va a retornar el numero de espacios en blanco de una oracion escrita por el usuario en Java.


Primero escribimos el procedimiento llamado contarEspaciosEnBlanco.


public static void contarEspaciosEnBlanco() {

 }


El procedimiento es static porque solo habra una copia del objeto que estamos creando.

Luego creamos un Scanner para que el usuario pueda escribir la oracion e imprimir el mensaje indicando al usuario que escriba alli.

Scanner kb = new Scanner(System.in);
System.out.println("Escriba una oracion...");

En la variable kb vamos a alojar el mensaje que el usuario escriba en la pantalla. Para asegurarnos que se capture la linea debemos crear una variable typo String llamada oracion.

String oracion= kb.nextLine();

Luego necesitamos contar el numero de caracteres en la oracion. Para eso utilizamos la propiedad .lenght().

int oraLen = oracion.length();

Tambien crear una variable llamada espaciosEnBlanco unizializada en zero.

int espaciosEnBlanco = 0;

Crear un bucle que empieze en 0 y llegue hasta el total numero de caracteres de la oracion. Luego un if va a comparar cada uno de los caracteres en la oracion para ver si es un espacion en blanco. Si es asi, entonces espacios en blanco va a incrementar uno a uno.

for (int i = 0; i <  oraLen; i++) {
if (oracion.charAt(i) == ' ') {
espaciosEnBlanco ++;
}
}


Finalmente el programa va a imprimir el resultado.

System.out.println("El numero de espacios en blanco es su oracion es: " + espaciosEnBlanco );

Todo el codigo se vera asi:


import java.util.Scanner;

public class espBlanco {

public static void main(String[] args) {
// TODO Auto-generated method stub
contarEspaciosEnBlanco();
}


public static void contarEspaciosEnBlanco() {

Scanner kb = new Scanner(System.in);
                System.out.println("Escriba una oracion...");

String oracion= kb.nextLine();
int oraLen = oracion.length();
int espaciosEnBlanco = 0;

for (int i = 0; i <  oraLen; i++) {

if (oracion.charAt(i) == ' ') {
espaciosEnBlanco ++;
}

}

System.out.println("El numero de espacios en blanco es su oracion es: " + espaciosEnBlanco );
}

}




Python: Determinar si una grafica tiene un Circuito Euleriano, un Camino Euleriano o ninguno de los dos


Dado el conjunto de vértices y pares de vértices asociados a los bordes de una grafica, encuentre el grado en-grado y fuera-de-grado cada vértice, y indique si el gráfico tiene un circuito Euleriano, un camino Euleriano, o ninguno de los dos. El programa esta dirigido a graficas directas.

Ejemplo de una entrada (desde el teclado):

Conjunto de vértices: a, b, c
Bordes: (a, b), (a, c), (b, a), (b, c)

El codigo siguiente es la solucion a este problema utilizando Python:


def EulerianoCNN():
    print("Introduzca cada entrada separada por coma (,) \n")
    print("Ex: \nConjunto de vértices: a,b,c \nBordes: (a,b),(a,c),(b,a),(b,c) \n")

    sov = input("Conjunto de vértices: ")  # Obtener letras de vértice de entrada
    Ssov = sov.split(",")       # Obtener los vértices de entrada delimitados por comas y ponerlos en el array

    edg = input("Bordes: ")
    edg1 = edg.replace(",", "")     # Borrar todas las comas (,) de la entrada Bordes
    edg2 = edg1.replace("(", "")    # Borrar todos los parentesis de apertura de la entrada Bordes
    edg3 = edg2.replace(")", "")    # Borrar todos los parentesis de cierre de la entrada Bordes
   
    outdeg = []     # Creación de lista de fuera de grado vacía
    indeg = []      # Creación de una lista en grados vacía

    odCounter = 0   # Declarar contador de-grado de salida igual a 0
    idCounter = 0   # Declarar contador fuera-de-grado de salida igual a 0

    equalDegrees = 0     # Variable para acumular cuando los grados en-grado y fuera-de-grado son iguales
    notEqualDegrees = 0

    EPEequalDegrees = 0  # Variable para acumular todos los vértices pares
    EPOequalDegrees = 0

    ECreason = 0        # Variable por la razón de no tener un motivo del circuito Euleriano
    EPreason = 0        # Variable por la razón de no tener una razón Camini Euleriano


    eulerPath = False
    ep1 = 0
    ep2 = 0

    eulerCircuit = False
    ec = 0

    forCounter = 0

    for j in Ssov:  ## Iterar a través de cada vértice

        ## Ver si el vértice es igual a outdegree

        ## Fuera-de-grado
        for i in range(0, len(edg3), 2):
            op, code = edg3[i:i+2]  ## Obtener Bordes 2 por 2 de la lista Bordes y asignar la primera letra a op y la segunda a code
                                    ## op comparará el grado de salida. El código se comparará en grado

            if j == op:  ## Si el vértice actual es igual a los primeros anuncios de ocurrencia de outdegree en el contador
                odCounter = odCounter + 1  ## Añadir un outdegree a un vértice

        outdeg.append(odCounter)  ## Añada la cantidad de ocurrencias de un vértice en la lista de salida
        odCounter = 0; ## Establecer odCounter igual a 0

        ## En-grado
        ## Repetir todos los pasos desde En-grado hasta Fuera-de-grado
        for i in range(0, len(edg3), 2):
            op, code = edg3[i:i+2]

           
            if j == code:
                odCounter = odCounter + 1

        indeg.append(odCounter)
        odCounter = 0;

    for j,o,i in zip(Ssov,outdeg,indeg):
        print(str('deg-('),j,str(')= '),o, str(', deg+('),j,str(')= '),i,  str('\n')) # Printing the values for every vertex letter and corresponding in and out degrees


    ## Chequear por circuito Euleriano
       
        if (o == i):
            equalDegrees = equalDegrees + 1 ## Cada vez que un En-grado y Fuera-de-grado sean iguales, anadir al contador
        else:
            notEqualDegrees = notEqualDegrees + 1   ## Cada vez que un vertice Fuera-de-grado y En-grado no sean iguales, anadir al contador
           
           
        if (notEqualDegrees == 0): ## Si los vertices nunca fueron no iguales, entoces tenemos un circuito Euleriano
            eulerCircuit = True
        else:
            eulerCircuit = False
            ECreason = 2
         

    ## Chequear por un camino Euleriano
        if ((o-i) == 1):
            ep1 = ep1 + 1

        if ((i-o) == 1):
            ep2 = ep2 + 1
       

        ##  Verificar que uno si y uno no de cada vertex tenga En-grado =Fuera-de-grado
        if ((forCounter%2) == 0):
            if (o == i):
                EPEequalDegrees = EPEequalDegrees + 1
        else:
            if (o == i):
                EPOequalDegrees = EPOequalDegrees + 1
        forCounter = forCounter +1

    ## End for

 
   
    if (EPEequalDegrees >= 1 or EPOequalDegrees >= 1):
        if (ep1 == 1 and ep2 == 1):
            eulerPath = True
        else:
            eulerPath = False
            EPreason = 1
    else:
        EPreason = 2

   
    print(str('Circuito Euleriano: '),eulerCircuit)  
    print(str('Camino Euleriano: '),eulerPath)

    if (eulerCircuit == True):
        print("La grafica no tiene un Circuito Euleriano")
    else:
        if (ECreason == 2):
            print("La grafica no tiene un circuito euleriano porque el En-grado y Fuera-de-grado de cada vertice no son iguales")

    if (eulerPath == True):
        print("La grafica tiene un camino Euleriano")
    else:
        if (EPreason == 1):
            print("La grafica no tiene un camino Euleriano porque ni a lo más un vértice tiene (fuera-de-grado) - (en-grado) = 1, tampoco tiene como mucho un vértice que tenga (en-grado) - (fuera-de-grado) = 1")
        elif(EPreason == 2):
            print("La grafica no tiene un camino Euleriano porque cada otro vértice no tiene en-grado = fuera-de-grado")


EulerianoCNN()