(Creado por el analista de sistemas y docente Leonel Iván Saafigueroa)

---

CORTANDO CADENAS

Hablar con la computadora es algo que se viene ensayando hace tiempo, en esta sección vamos a crear un programa para poder chatear y mantener un diálogo con la máquina.

Aunque conversar con computadoras parece algo reciente, esto fue posible hace más de 50 años gracias a Joseph Weizenbaum, profesor de informática del MIT (Instituto Tecnológico de Massachusetts). Al igual que Siri, Alexa, Google Assistant, Cortana y otros asistentes digitales que se utilizan en la actualidad, este primer programa conversacional de inteligencia artificial tenía nombre de mujer, se llamaba Eliza.

El programa realizaba las preguntas que hacían los psicoterapeutas que seguían los lineamientos del psicólogo Carl Rogers, creador de la llamada “terapia centrada en el cliente“, fue tan eficiente que muchos usuarios le contaban sus intimidades.

A continuación, vamos a comenzar con un programa sencillo, que nos ayudará a entender las complicaciones que surgen al desarrollar esta clase de proyectos.

Diseñamos un programa que permita el ingreso de texto por parte del usuario:

En esta primera versión se podrá ingresar una cadena de texto, si la cadena coincide con “hola“, el programa responderá: “Hola!“.

Analizamos el código

Algoritmo dialogo
	Escribir '?'
	Leer entrada // Guardamos en la variable "entrada" lo que ingresó el usuario.
	Si entrada='hola' Entonces // Buscamos una palabra.
		Escribir 'Hola!'
	FinSi
FinAlgoritmo

Ejecutamos el programa

Veamos el código en C++:

// dialogo

#include <iostream>

using namespace std;

string entrada;

int main()
{
    cout << "? ";
    cin >> entrada;
    if(entrada == "hola") // buscamos la palabra "hola".
    {
        cout << endl << "Hola!" << endl;
    }
    return 0;
}

Vamos a analizar línea por línea este código en C++:

Línea 1: // dialogo
Esta es una línea de comentario, que se ignora completamente por el compilador. La sintaxis // indica que todo lo que sigue hasta el final de la línea es un comentario.

Línea 3: #include <iostream>
Esta línea incluye la biblioteca iostream en el programa. La biblioteca iostream permite leer y escribir datos desde/para la salida estándar (pantalla) del sistema operativo.

Línea 5: using namespace std;
Esta línea importa todas las clases y funciones de la biblioteca iostream al espacio de nombres actual, lo que significa que no necesitamos especificar el nombre completo de cada clase o función para usarla. En este caso, se utiliza la clase cout para escribir en la pantalla.

Línea 7: string entrada;
Esta línea declara una variable llamada entrada del tipo string, que es un conjunto de caracteres (como cadenas de texto). Esta variable será utilizada para almacenar la entrada del usuario.

Línea 9: int main()
Esta función es el punto de entrada principal del programa. La palabra clave main indica que esta función se ejecutará automáticamente cuando se ejecute el programa.

Líneas 11-12: cout << "? "; cin >> entrada;
La primera línea imprime en la pantalla un signo de interrogación (?) seguido de un espacio en blanco. La segunda línea utiliza la clase cin para leer una cadena de texto desde la entrada estándar (pantalla) y almacenarla en la variable entrada.

Línea 13: if(entrada == "hola")
Esta línea comienza una condición IF que comprueba si el contenido de la variable entrada es igual a la cadena de texto "hola". Si se cumple esta condición, entonces…

Líneas 15: cout << endl << "Hola!" << endl;
…se imprime en la pantalla una línea vacía (endl) seguida de la cadena de texto "Hola! " y otra línea vacía.
La secuencia de comandos << es utilizada para concatenar los valores.

Línea 17: return 0;
Esta línea indica que el programa ha terminado ejecutarse correctamente y devuelve un código de salida igual a cero, lo que indica que todo salió bien.

En resumen, este programa espera una entrada del usuario (una cadena de texto), compara si la entrada es igual a “hola” y, si lo es, imprime “Hola!” en la pantalla. Si no se cumple esta condición, el programa simplemente termina sin hacer nada.

Ahora el código en PYTHON:

# dialogo

entrada = input("? ")

if entrada == "hola":
    print("Hola!")

Vamos a analizar línea por línea este código en PYTHON:

Línea 1: # dialogo
Esta línea es un comentario, que se ignora completamente por el intérprete. La sintaxis # indica que todo lo que sigue hasta el final de la línea es un comentario.

Línea 3: entrada = input("? ")
Esta línea lee una cadena de texto desde la entrada estándar (pantalla) y la almacena en la variable entrada. La función input() devuelve como cadena de texto lo que el usuario introduce. El parámetro "?" es simplemente un mensaje que se imprime en la pantalla para pedir al usuario que introduzca algo.

Línea 5: if entrada == "hola":
Esta línea comienza una condición IF que comprueba si el contenido de la variable entrada es igual a la cadena de texto "hola". Si se cumple esta condición, entonces…

Línea 6: print("Hola!")
…se imprime en la pantalla la cadena de texto "Hola! ". La función print() es utilizada para imprimir valores en la salida estándar (pantalla).

Modificamos el programa para que no tenga problemas con las mayúsculas o minúsculas:

Con la función minusculas convertimos la cadena de texto contenida en la variable entrada toda a minúsculas. Lo hacemos llamando a la función minuscula con la variable entrada como argumento y asignando el resultado a la misma variable.
Además, agregamos una segunda palabra al vocabulario, se trata de “chau” que responderá “chau!“, cuando pueda ser identificada.

Analizamos el código

Algoritmo dialogo2
	Escribir "?"
	// Guardamos en la variable "entrada" lo que ingrese el usuario.
	Leer entrada
	// Convertimos la cadena de texto a minúsculas.
	entrada <- minusculas(entrada)
	// Búsqueda de palabra.
	Si entrada="hola" Entonces
		Escribir "Hola!"
	FinSi
	// Búsqueda de palabra.
	Si entrada="chau" Entonces
		Escribir "chau!"
	FinSi
FinAlgoritmo

Ejecutamos el programa

Veamos el código en C++:

// dialogo2. CONVERTIMOS TEXTO A MINÚSCULAS.

#include <iostream>

using namespace std;

string entrada;
int largo;

int main()
{
    cout << "? ";
    cin >> entrada;
    // Transformamos la entrada a minúsculas.
    
    largo = entrada.size(); // Primero contamos la cantidad de caracteres que tiene nuestra variable entrada.
    
    // La variable letra hará que nuestra función tolower case se ejecute tantas veces como el largo de nuestro texto.
    
    for (int letra = 0; letra < largo; ++letra)
        {   
        // Guardamos en la variable de texto una a una de las letras ahora en minúscula con la función tolower().
        entrada[letra] = tolower(entrada[letra]); 
        }
    
    // Ahora sí analizamos las palabras todas en minúsculas.
         
    if(entrada == "hola") // buscamos la palabra "hola".
    {
        cout << endl << "Hola!" << endl;
    }
    if(entrada == "chau") // buscamos la palabra "chau".
    {
        cout << endl << "chau!" << endl;
    }
    return 0;
}

Vamos a analizar línea por línea este código en C++:

Línea 1: // dialogo2. CONVERTIMOS TEXTO A MINÚSCULAS.

Esta línea es un comentario, es decir, una nota para nosotros mismos que no se ejecuta como código. En este caso, indica que el programa está destinado a convertir texto a minúsculas.

Línea 3: #include <iostream>
Esta línea incluye la biblioteca iostream en el programa. La biblioteca iostream permite leer y escribir datos desde/para la salida estándar (pantalla) del sistema operativo.

Línea 5: using namespace std;

Estas dos líneas son parte de la cabecera del programa. La primera línea incluye la biblioteca iostream, que permite leer y escribir datos en el flujo de entrada/output estándar (es decir, la consola). La segunda línea utiliza la librería iostream con el alias “std“, lo que significa que podemos utilizar los objetos y funciones de la biblioteca sin tener que especificar su espacio de nombres.

Línea 7: string entrada;

Esta línea declara una variable llamada entrada del tipo string. Un string es un objeto que almacena texto. En este caso, la variable entrada se utilizará para almacenar el texto ingresado por el usuario.

Línea 8: int largo;

Esta línea declara otra variable llamada largo del tipo entero (int). Esta variable se utilizará para almacenar el número de caracteres en el texto almacenado en la variable entrada.

Línea 10: int main()

La función principal del programa, main(), es donde comienza la ejecución del programa. La función main() devuelve un valor entero que indica si el programa se ejecutó con éxito o no.

Líneas 12-13: cout << "? "; cin >> entrada;

Estas dos líneas son parte de la secuencia de comando para leer texto del usuario. La primera línea imprime en la consola un signo de interrogación (?), y la segunda línea lee el texto ingresado por el usuario y lo almacena en la variable entrada.

Línea 14: // Transformamos la entrada a minúsculas.

Esta línea es otro comentario que indica que a partir de aquí se comienza a convertir el texto a minúsculas.

Líneas 16-18:

largo = entrada.size(); // Primero contamos la cantidad de caracteres que tiene nuestra variable entrada.
// La variable letra hará que nuestra función tolower case se ejecute tantas veces como el largo de nuestro texto.

Estas dos líneas son parte del proceso de conversión a minúsculas. La primera línea cuenta el número de caracteres en el texto almacenado en la variable entrada y lo almacena en la variable largo. La segunda línea explica que la variable letra se utilizará para iterar sobre cada carácter del texto, ejecutando la función tolower() tantas veces como sea necesario.

Línea 20: for (int letra = 0; letra < largo; ++letra)

La instrucción for es un bucle que se utiliza para repetir una serie de acciones varias veces. En este caso, el bucle se ejecutará mientras la variable letra sea menor que el número de caracteres en el texto (largo). La variable letra se inicializa a 0 y se incrementa después de cada iteración.

Línea 23: entrada[letra] = tolower(entrada[letra]);

Esta línea es la acción principal del bucle. Almacena en la posición letra del texto almacenado en la variable entrada el resultado de aplicar la función tolower() al carácter correspondiente.

Línea 28: if (entrada == "hola")

La instrucción if es una condición que se evalúa para decidir qué acciones realizar. En este caso, si la variable entrada contiene la cadena "hola", entonces se ejecutará el código dentro del bloque de código asociado a la condición.

Línea 30: cout << endl << "Hola!" << endl;

Si la condición es cierta (es decir, si la entrada coincide con la palabra “hola“), entonces se imprime en la consola un mensaje con el texto "Hola!".

Línea 32: if (entrada == "chau")

La instrucción if es otra condición que se evalúa para decidir qué acciones realizar. En este caso, si la variable entrada contiene la cadena "chau", entonces se ejecutará el código dentro del bloque de código asociado a la condición.

Línea 34: cout << endl << "chau!" << endl;

Si la condición es cierta (es decir, si la entrada coincide con la palabra “chau“), entonces se imprime en la consola un mensaje con el texto "chau!".

Línea 36: return 0;

La instrucción return indica que la función principal del programa (main()) ha terminado de ejecutarse y devuelve un valor entero (0) para indicar que todo salió bien.

Ahora el código en PYTHON:

# dialogo2

entrada = input("? ")

# Convertimos la entrada ingresada a minúsculas.
entrada = entrada.lower()

if entrada == "hola":
    print("Hola!")

Vamos a analizar línea por línea este código en PYTHON:

Línea 3: entrada = input("? ")

• Esta es la primera línea del programa y se utiliza para obtener una entrada de texto desde el usuario.
• La función input() es una función en Python que muestra un mensaje de texto al usuario y espera a que ingrese algo, luego devuelve lo que ingresó como una cadena de texto.
• El mensaje "?" es el mensaje que se muestra al usuario antes de esperar su entrada.
• La variable entrada es donde se almacena la respuesta ingresada por el usuario. En este caso, se le asigna lo que el usuario ingresó.

Línea 6: entrada = entrada.lower()

• Esta línea convierte todo lo ingresado en minúsculas.
• La función lower() devuelve una copia de la cadena de texto ingresada pero con todas las letras convertidas a minúscula.
• Esto es útil porque si el usuario ingresa algo como “Hola” o “hola”, queremos que el programa reconozca ambos casos.

Línea 8: if entrada == "hola":

• Esta línea comienza un condicional. Un condicional es una estructura de control en la cual se verifica si una condición es verdadera o falsa.
• En este caso, la condición es que la variable entrada sea igual a "hola".
• Si esta condición es verdadera (es decir, si el usuario ingresó “hola” o cualquier otra cosa que se convierta en “hola” con lower()), entonces se ejecuta lo dentro del bloque de código después de la coma.

Línea 9: print("Hola!")

• Esta línea imprime un mensaje en la pantalla. En este caso, el mensaje es "Hola!".
• El mensaje se mostrará en la pantalla solo si la condición en la línea anterior (if entrada == "hola") es verdadera.

En resumen, este programa pide al usuario que ingrese algo con input(), convierte su entrada a minúsculas, y luego verifica si la entrada ingresada fue "hola". Si es así, entonces imprime un mensaje en la pantalla.

Creamos una nueva versión que analice la cadena ingresada en busca de palabras claves:

Analizamos el código

Algoritmo dialogo3
	Escribir "?"
	// Guardamos en la variable "entrada" lo que ingrese el usuario.
	Leer entrada
	// Convertimos la cadena de texto a minúsculas.
	entrada <- minusculas(entrada)
	// Guardamos en una variable "t" el tamaño de la entrada.
	t <- longitud(entrada)
	// Creamos una variable "i" para cortar la entrada.
	Para i<-1 Hasta t Hacer
		// Creamos una variable j para cortar la entrada.
		Para j<-i hasta t Hacer
			// creamos la variable "fragmento".
			fragmento <- subcadena(entrada,i,j)
			// Búsqueda de palabras claves por cada fragmento creado.
			Si fragmento="hola" Entonces
				Escribir "Hola!"
			FinSi
			Si fragmento="chau" Entonces
				Escribir "Adios!"
			FinSi
		FinPara
	FinPara
FinAlgoritmo

Ejecutamos el programa

Analizamos esta última ejecución de una forma más gráfica:

Estos fragmentos se construyen gracias al primer bucle de la estructura para, que genera una sub cadena de la variable entrada, que va desde el valor 1 entregado por la variable i, a los valores que tomará j, que van gracias a un segundo bucle para, desde el valor de la variable i (en este caso 1), hasta el valor de la variable t, que representa el total de la longitud de la cadena entrada (en este caso con el valor 11).

En esta primera vuelta del bucle, en el cuarto fragmento, se encuentra la palabra clave “hola“, con la que puede dar una posible respuesta.

En esta segunda vuelta del bucle, el valor de la variable i es 2, por lo tanto, los valores que asignará a j irán desde el 2 hasta el 11, entregando diez sub cadenas.

Sin encontrar resultados.

En la tercera vuelta del bucle, el valor de la variable i es 3, por lo tanto, los valores que asignará a j irán desde el 3 hasta el 11, entregando nueve sub cadenas.

Sin encontrar resultados.

En la cuarta vuelta del bucle, el valor de la variable i es 4, por lo tanto, j tomará valores que van desde el 4 hasta el 11.

Sin encontrar resultados.

En la quinta vuelta del bucle, el valor de la variable i es 5, por lo tanto, j tomará valores que van desde el 5 hasta el 11.

Sin encontrar resultados.

En la sexta vuelta el valor de la variable i es
6, j tomará valores que van desde el 6 hasta el 11, entregando seis sub cadenas.

Sin encontrar resultados.

En la séptima vuelta el valor de la variable i es 7, j tomará valores que van desde el 7 hasta el 11, entregando cinco sub cadenas.

Sin encontrar resultados.

En la octava vuelta del bucle, el valor de la variable i es 8, por lo tanto, los valores que asignará a j irán desde el 8 hasta el 11, entregando cuatro sub cadenas.

Se encuentra un fragmento con la palabra clave “chau“, con la que puede dar otra posible respuesta.

En la novena vuelta del bucle, el valor de la variable i es 9, por lo tanto, los valores que asignará a j irán desde el 9 hasta el 11, entregando tres sub cadenas.

Sin encontrar resultados.

En la décima vuelta del bucle, el valor de la variable i es 10, por lo tanto, los valores que asignará a j irán desde el 10 hasta el 11, entregando dos sub cadenas.

Sin encontrar resultados.

En la décima primera vuelta del bucle, el valor de la variable i es 11, por lo tanto, el valor que asignará a j será 11, entregando solo una sub cadena.

Sin encontrar resultados.

Finaliza la ejecución del programa, haciendo todos los procesos anteriores prácticamente al instante.

Con esto podremos mantener una conversación con nuestra PC.
El objetivo es que pueda responder a casi todo, para eso necesitamos dejar programado un vocabulario amplio.

Veamos el código en C++:

// dialogo3. UTILIZAMOS SUBCADENAS.

#include <iostream>

using namespace std;

string entrada;
string fragmento;
int largo;

int main()
{
    cout << "? ";
    getline(cin,entrada);
    // Transformamos la entrada a minúsculas.

    largo = entrada.size(); // Primero contamos la cantidad de caracteres que tiene nuestra variable entrada.

    // La variable letra hará que nuestra función toupper case se ejecute tantas veces como el largo de nuestro texto.

    for (int letra = 0; letra < largo; ++letra)
        {
        // Guardamos en la variable de texto una a una de las letras ahora en minúscula con la función tolower().
        entrada[letra] = tolower(entrada[letra]);
        }

    // Vamos a cortar en trocitos a la entrada.

        for(int i = 0; i <= largo; i++)
        {
            for(int o = 1; o <= largo-i; o++)
            {
            fragmento=entrada.substr(i, o);
            // cout << fragmento << " " << "i=" << i << " o=" << o << endl;   // Esto muestra como corta la entrada en pedazos más chicos y el valor de la variables (i,o).

            // Ahora sí analizamos las palabras todas en minúsculas.
               if(fragmento == "hola") // buscamos la palabra "hola".
                {
                    cout << endl << "Hola!" << endl;
                }
                if(fragmento == "chau") // buscamos la palabra "chau".
                {
                    cout << endl << "Adios!" << endl;
                }
            }
        }
return 0;
}

Vamos a analizar línea por línea este código en C++:

Línea 1: // dialogo3. UTILIZAMOS SUBCADENAS.

• Esta es una comentario de línea que describe el propósito del programa.

Líneas 5-9:

#include <iostream>
using namespace std;
string entrada;
string fragmento;
int largo;

• La primera línea incluye la biblioteca iostream, que permite leer y escribir datos en la consola.
• La segunda línea utiliza el alias std para acceder a las funciones de la biblioteca estándar de C++.
• Las siguientes tres líneas declaran variables:
  + entrada: una cadena de texto que almacenará la entrada del usuario.
  + subcadena: otra cadena de texto que se utilizará para extraer sub cadenas de entrada.
  + largo: un entero que almacena la longitud de la cadena entrada.

Línea 11: int main()

• La función principal del programa, donde comienza la ejecución.

Línea 13: cout << "? ";

• Imprime el mensaje “?” en la consola y espera a que el usuario ingrese algo.

Línea 14: getline(cin, entrada);

• Lee una línea de texto desde la consola y la almacena en la variable entrada.

Líneas 17-19:

largo = entrada.size(); // Primero contamos la cantidad de caracteres que tiene nuestra variable entrada.

// La variable letra hará que nuestra función toupper case se ejecute tantas veces como el largo de nuestro texto.

• La primera línea cuenta la longitud de la cadena entrada y la almacena en la variable largo.
• La segunda línea es un comentario que describe el propósito de la variable letra.

Línea 21: for (int letra = 0; letra < largo; ++letra)

• Inicia un bucle for que itera sobre los caracteres de la cadena entrada.
• El bucle se ejecutará desde el carácter con índice 0 hasta el carácter con índice largo-1.

Línea 24: entrada[letra] = tolower(entrada[letra]);

• En cada iteración del bucle, convierte el carácter en la posición actual de letra a minúscula utilizando la función tolower().

Líneas 27-31:

// Vamos a cortar en trocitos a la entrada.

for(int i = 0; i <= largo; i++)
{
    for(int o = 1; o <= largo-i; o++)

• La primera línea es un comentario que describe el propósito de los siguientes bloques de código.
• El primer bucle itera sobre las posiciones de inicio de las sub cadenas, desde la posición 0 hasta largo.
• El segundo bucle itera sobre la longitud de cada sub cadena, desde 1 hasta largo-i.

Línea 33: fragmento = entrada.substr(i, o);

• En cada iteración del bucle, extrae una sub cadena de entrada empezando en la posición i y con longitud o. La sub cadena se almacena en la variable fragmento.

Líneas 36-44:

// Ahora sí analizamos las palabras todas en minúsculas.
if(fragmento == "hola") // buscamos la palabra "hola".
{
    cout << endl << "Hola!" << endl;
}
if(fragmento == "chau") // buscamos la palabra "chau".
{
    cout << endl << "Adios!" << endl;
}

• En cada iteración del bucle, se comprueba si la sub cadena coincide con la palabra “hola” o “chau“. Si es así, se imprime un mensaje correspondiente.

Línea 20: return 0;

Finaliza la función principal y devuelve el código de salida 0.

Ahora el código en PYTHON:

# dialogo3

entrada = input("? ")

# Convertimos la entrada ingresada a minúsculas.
entrada = entrada.lower()

t = len (entrada)

for i in range(0, t+1):
	for j in range(i+1, t+1):
		fragmento=entrada[i:j]
		if fragmento == "hola":
			print("Hola!")
		if fragmento == "chau":
			print("Adios!")

Vamos a analizar línea por línea este código en PYTHON:

Línea 1: # dialogo3

• Esta es una comentario de línea que describe el propósito del programa.

Línea 3: entrada = input("? ")

• La función input() permite al usuario ingresar un valor y lo asigna a la variable entrada. El parámetro "?" es el mensaje que se muestra al usuario para que ingrese su respuesta.

Línea 6: entrada = entrada.lower()

• La función lower() convierte todas las letras de la cadena entrada a minúsculas. Esto se hace porque en el código posterior se compararán las sub cadenas con las palabras “hola” y “chau“, que están en minúscula.

Línea 8: t = len(entrada)

• La función len() devuelve la longitud de la cadena entrada, que es almacenada en la variable t.

Líneas 10-11:

for i in range(0, t+1):
        for j in range(i+1, t+1):

• Estos dos bucles son anidados entre sí. El primer bucle itera sobre las posiciones de inicio de las sub cadenas, desde la posición 0 hasta t. El segundo bucle itera sobre las posiciones finales de las sub cadenas, desde la posición i+1 hasta t.

Línea 12: fragmento = entrada[i:j]

• En cada iteración del bucle, se extrae una sub cadena de entrada empezando en la posición i y terminando en la posición j. La sub cadena se almacena en la variable fragmento.

Líneas 13-16:

if fragmento == "hola":
        print("Hola!")
if fragmento == "chau":
        print("Adios!")

• En cada iteración del bucle, se comprueba si la sub cadena coincide con la palabra “hola” o “chau“. Si es así, se imprime un mensaje correspondiente.

Nota importante: El código utiliza la función range() para generar los números de índice para las posiciones de inicio y fin de las sub cadenas. Sin embargo, esto puede causar problemas si la longitud de la cadena entrada es cero o muy grande, ya que se pueden generar índices fuera del rango permitido. En este caso, el código funciona correctamente porque se utiliza el operador +1 para garantizar que los bucles no intenten acceder a índices fuera del rango.

En resumen, el código busca todas las sub cadenas de la entrada ingresada por el usuario y comprueba si cada una coincide con la palabra “hola” o “chau“. Si es así, imprime un mensaje con la respuesta correspondiente.