En este post de algoritmos y programación en Python vamos a resolver un ejercicio que cuenta los caracteres sucesivos que encuentra en una cadena.

Es decir, contar cuántas veces seguidas aparece una letra y cuando se encuentre una distinta entonces colocamos el número de veces que se repite y empezamos a contar de nuevo.

Por ejemplo, para la cadena EEEEEDEEDCCEEBEEAEAEGEGEFE debería salir algo como lo siguiente:

E D E D C E B E A E A E G E G E F E
5 1 2 1 2 2 1 2 1 1 1 1 1 1 1 1 1 1

Puede que la descripción del ejercicio cambie dependiendo de tu profesor, pero al final la solicitud es la misma. Veamos entonces cómo resolverlo usando Python.

Descripción del ejercicio

En este caso la solicitud decía así:

La entidad financiera “un banco”, está implementando un sistema de contraseñas, con el fin de aumentar la seguridad de su portal, para las transacciones virtuales.

Este sistema exige que la contraseña de registro e ingreso al portal del banco este formada por una secuencia letras ya sea en mayúsculas o minúsculas, separadas por comas.

Usted debe realizar un programa que valide la contraseña ingresada y verifique si esta contraseña contiene caracteres seguidos que se repitan. El programa debe mostrar la cantidad de caracteres iguales contiguos.

Entrada

La entrada consta de una sucesión de caracteres separados por coma que corresponden a la contraseña para registro al banco

Salida

La salida consta de dos líneas: la primera es la sucesión de caracteres que conforman la contraseña sin repeticiones, en mayúscula y separadas por espacio.

La segunda es la cantidad de veces que se repitió cada carácter de la contraseña cuerda de manera consecutiva, separado también por espacio.

Entrada
E,E,e,E,E,d,E,E,D,c,C,E,E,B,E,E,a,E,A,E,g,E,G,E,f,E

Salida

E D E D C E B E A E A E G E G E F E
5 1 2 1 2 2 1 2 1 1 1 1 1 1 1 1 1 1

Explicación del algoritmo

En este caso nuestra cadena de inicio va a venir sucia, ya que vendrán algunas mayúsculas, minúsculas y comas.

Lo primero que haremos será separar la cadena por comas usando split, luego unirla con join y finalmente convertirla a mayúscula con upper; de modo que al final tendremos solo mayúsculas sin separadores.

Luego vamos a asignar la primera letra a una variable llamada ultima_letra, que guardará, como su nombre lo dice, la última letra recorrida. También inicializamos un conteo.

Comenzamos a recorrer la cadena y en caso de que la letra actual sea distinta a la última entonces registramos la letra y cuántas veces aparece, pues hemos encontrado una letra distinta (es decir, ya no hay consecutivos).

También en ese paso asignamos la letra actual como la última letra, y así seguimos hasta terminar de recorrer la cadena.

En caso de que la letra sea igual, simplemente aumentamos el contador.

Y para el caso de que estemos en la última letra, forzamos que se escriba la letra y cuántas veces aparece ya que hemos terminado de recorrer la cadena.

Contar caracteres iguales contiguos

Ya expliqué el algoritmo para contar caracteres sucesivos con Python. Ahora veamos el código:

def contar(entrada):
    entrada = "".join(entrada.split(",")).upper()
    ultima_letra = entrada[0]
    conteo = 0
    letras = ""
    conteos = ""
    indice = 0
    for letra in entrada:
        if letra != ultima_letra:
            letras += ultima_letra + " "
            conteos += str(conteo) + " "
            conteo = 1
            ultima_letra = letra
        else:
            conteo += 1
        if indice+1 >= len(entrada):
            letras += ultima_letra+" "
            conteos += str(conteo) + " "
        indice += 1
    return letras, conteos

Por cierto, en este caso el conteo se lleva en una cadena y la letra en otra. Tú podrías usar listas, diccionarios, concatenar el conteo junto a la letra o cualquier otra cosa; eres libre.

Poniendo todo junto

Es momento de probar nuestro ejercicio. Pondré la cadena de entrada y veremos lo que pasa:

Como puedes ver funciona perfectamente, y así lo hará para cualquier cantidad de letras. El código completo queda así:

def contar(entrada):
    entrada = "".join(entrada.split(",")).upper()
    ultima_letra = entrada[0]
    conteo = 0
    letras = ""
    conteos = ""
    indice = 0
    for letra in entrada:
        if letra != ultima_letra:
            letras += ultima_letra + " "
            conteos += str(conteo) + " "
            conteo = 1
            ultima_letra = letra
        else:
            conteo += 1
        if indice+1 >= len(entrada):
            letras += ultima_letra+" "
            conteos += str(conteo) + " "
        indice += 1
    return letras, conteos


entrada = "E,E,e,E,E,d,E,E,D,c,C,E,E,B,E,E,a,E,A,E,g,E,G,E,f,E,f"
letras, conteos = contar(entrada)
print(letras)
print(conteos)

Para terminar te dejo con más tutoriales de Python y Ejercicios resueltos en mi blog.