Binario

El lenguaje que entienden los ordenadores es el binario (unos y ceros). Cuando creamos un programa, al compilar y "construir" el ejecutable, lo que hace el compilador es traducir nuestro código en instrucciones en binario (es posible que profundice en este tema más adelante).

Como curiosidad, me ha parecido buena idea comentar un poco cómo pueden expresarse datos en binario.

Como en cualquier lenguaje, disponemos de una serie de signos, en el caso del castellano, los signos son las letras y números. Al combinar estos signos (letras) formamos palabras, a partir de ellas, frases más o menos complejas.

En binario, los signos son 0 y 1 (bits). Podemos combinarlos como queramos para crear nuestro propio lenguaje, pero normalmente, en binario se suelen representar números, vamos a ver cómo.

Vamos poco a poco:

El primer caso es sencillo, pero el segundo tiene más lógica, podemos decir que el 1 a la derecha (el primero) vale 1 y el segundo vale 2, así podemos combinarlos para conseguir 4 valores diferentes.

El tercer bit (contando siempre desde la derecha) valdría 4.

Matemáticamente hablando, el valor de cada bit, se expresa como 2 elevado a n, donde n es la posición (empezando desde 0 por la derecha).

Ahora ya se puede entender el código ASCII, donde con 8 bits se le adjudica un valor a cada letra y número del alfabeto, combinatos estos bytes (conjunto de 8 bits) se puede expresar todo lo que queramos.

Paralizado por mudanza.

En general, supongo que es obvio que hace tiempo que no tengo actividad. De momento debido a una mudanza y que no tengo acceso a una conexión en condiciones.
Aún así, mi objetivo, una vez instalada completamente, es continuar añadiendo cosas pequeñas cosas interesantes.

Un saludo.

Expresiones Regulares I

Aunque no sea exactamente C++, después de tener que pelearme bastante con ellas últimamente, se me ha ocurrido hacer aquí algo básico con ellas.

No quiero asustar a nadie con un ejemplo (a simple vista si no se conocen, son absolutamente abstractas) ni con una tabla de signos igual que las que hay a patadas en internet (sólo hay que poner "expresiones regulares" en google para ver cientos de ejemplos), simplemente voy a empezar contando un poco qué son y para qué sirven.

Las expresiones regulares son, como indica su nombre, expresiones que se utilizan para identificar un patrón de texto, como por ejemplo, si queremos localizar en un texto muy largo los números de teléfono o una dirección de email.

Para probarlas, he decidido utilizar Notepad++ ( https://notepad-plus-plus.org/ ). Es un editor de texto que, entre muchas otras ventajas, permite utilizar expresiones regulares para buscar o reemplazar patrones de texto.

Vamos directamente con los ejemplos prácticos (opción "Buscar" en el Notepad++):

Teléfono básico: XXXXXXXXX (nueve dígitos seguidos tal cual).

Podemos ver cómo a través de la expresión regular ha encontrado el número de teléfono (si fuesen varios los encontraría todos) sin importar el número exacto, sólo con el patrón.
A ver la expresión regular:  [0-9]{0}
[0-9]   Esta expresión indica un dígito entre el 0 y el 9 (ambos inclusive).
{9}     Esta expresión nos dice que la expresión anterior se debe repetir 9 veces.

Teléfono con prefijo separado por espacio: XXX XXXXXX (tres dígitos, un espacio y seis dígitos).

La expresión regular: [0-9]{3}\s[0-9]{6}
Lo nuevo:
\s     Esta expresión nos indica que debe haber un espacio en blanco en esa posición (entre los tres primeros dígitos y los otros seis).

Teléfono con prefijo separado por un guión: XXX-XXXXXX (tres dígitos, un guión y otros seis dígitos).

La expresión regular: [0-9]{3}[-]+[0-9]{6}
Lo nuevo:
[-]+   Ahora la expresión debe buscar un guión y el símbolo "+" indica que debe haber al menos una repetición de esa expresión a la que va ligada.

Teléfono con prefijo separado por paréntesis: (XXX)XXXXXX (paréntesis, tres dígitos, cierra paréntesis y otros seis dígitos).

La expresión regular: \([0-9]{3}\)[0-9]{6}
Lo nuevo:
\(     Abre paréntesis.
\)     Cierra paréntesis.


Para la próxima..... más ejemplos de expresiones regulares.

Juego del ahorcado. Versión 2.

Segunda versión del juego: ahora vamos a obtener las palabras de un fichero de texto.

Abre el fichero y coge la primera palabra, para evitar que se repita siempre, cogeremos cada palabra que ya hayamos utilizado y la colocaremos al final del fichero. Esto vamos a hacerlo a través de un fichero de texto temporal, en el que se colocarán las palabras en el nuevo orden. Después borramos el fichero de texto original y renombramos el nuevo. Este es el aspecto del pequeño fichero que he creado para hacer las pruebas:

Salvo un pequeño cambio en la llamada a la función en Main, sólo se ha tocado la función "Genera_Palabra".

Vamos a ver primero las bibliotecas que se han incluido:

Se ha modificado la llamada a la función "Genera_Palabra", en lugar de devolver ya directamente la palabra, va a devolver una variable del tipo "bool", que nos indicará si ha habido cualquier problema a la hora de abrir los ficheros (por ejemplo si el fichero de palabras no se encuentra en el lugar esperado). Para obtener la palabra que adivinaremos, pasaremos una variable del tipo string como parámetro (se coloca delante el "&" para que se pase la variable por referencia, es decir, los cambios que se realicen dentro de la función, afectarán a la variable de "main" que se le pase de esta forma).

Podemos ver que la llamada ha cambiado y que si el resultado es "false", se muestra un mensaje de error y el programa se detiene.

Vamos ahora a la parte más interesante, la función "Genera_Palabra":

Al trabajar con ficheros hay varias cosas a tener en cuenta, la primera es que es muy común que un fichero no se pueda abrir, ya sea porque no esté donde lo estamos buscando, que otro programa lo esté utilizando y lo tenga bloqueado, etc.... Por eso es importante comprobar primero si se ha abierto correctamente el fichero (función "is_open").
También es muy importante cerrar el fichero cuando terminemos de trabajar con él (función "close").

El resto del código no tiene nada nuevo, aún así, si alguien tiene cualquier duda sobre el código, no dude en comentarlo.

Juego del ahorcado. Parte IV.

Primeras mejoras sobre la versión original. Esta vez, de nuevo he dejado aparcada la generación de palabras, ya que hay que meterse en la gestión de ficheros y prefiero ir paso a paso.

En general las mejoras han sido en la función Main.

Como podemos ver, el primer cambio y más importante es que hemos modificado la variable "palabraResuelta" de estática a dinámica, es decir, en lugar de tener una constante con el máximo y generar un array fijo con ese valor (independientemente del tamaño de la palabra a resolver), ahora se reserva sólo la memoria necesaria para guardar la palabra que vamos a adivinar. Gracias a eso hemos eliminado unas de las inicializaciones (siempre es bueno inicializar todas las palabras). Debido a este cambio también se ha tenido que modificar la función "Pinta_Tablero" y añadirle como parámetro el valor máximo de la palabra original.

También se ha añadido al "Main" algunos ajustes a la hora de mostrar los datos, pero es simplemente estético.

La función "Pinta_Tablero" quedaría así:

Esta vez no voy a poner capturas de las pantallas porque los cambios son mínimos.

La próxima nos metemos con la generación de palabras más currada.


NOTA IMPORTANTE: Siempre que utilicemos memoria dinámica, es de vital importancia que cuando terminemos de usar esas variables, eliminemos la memoria que se ha reservado con ellas (función "delete").

Juego del ahorcado. Parte III.

Ahora vamos a ver el código de la primera versión (muy muy muy mejorable). En las próximas versiones me gustaría optimizar el código y realizar todas las mejoras que se nos ocurran.

 

La función Generar_Palabra:

 

Esta es la primera versión y he preferido hacerlo lo más sencillo posible así que introducimos ya la palabra fija por código.

La función Pinta_Tablero:

Esta función pinta las vidas restantes y la palabra que estamos averiguando, las letras que no hayamos averiguado las coloca como guiones bajos.


La función Procesa_Entrada:

La función para procesar cada letra que introducimos se encarga de ver si esa letra pertenece a la palabra a adivinar. Si no está en la palabra, resta una vida y si aún quedan vidas restantes devuelve "false" (es decir, avisa de que no ha terminado el juego), en cambio si se han terminado las vidas, devuelve "true" indicando que el juego ha terminado. Si la letra está incluida en la palabra y todavía no está averiguada, la sustituye en el array que la almacena y comprueba si ha terminado, si la palabra está completa indica que el juego ha terminado devolviendo "true".


Función main:

En esta primera parte de la función creamos e inicializamos todas las variables. En el caso de la palabra resuelta (donde se irán guardando las letras que vayamos acertando) es un array fijo de tamaño 50 (predefinido en una constante) que inicializamos primero a "1". Después se vuelve a incializar a "0" sólo las posiciones que serán ocupadas por la palabra a adivinar, así sabemos si es un hueco vacío o es una posición que no se debe utilizar (una pista, esto es muy muy mejorable).

En la segunda parte tenemos un bucle do-while que se ejecuta hasta que el jugador decide salir (introduciendo "0") o cuando termina la partida.

Y ahora unos pantallazos de cómo queda el juego (también muy mejorable):

Juego del ahorcado. Parte II.

En este post voy a exponer el primer boceto de la estructura del programa función a función.

Función Genera_Palabra:
Esta función generará una palabra para que el usuario la averigue. Esta función será la que más se modifique según vayamos generando versiones del programa.

Función Pinta_Tablero:
Al ser una aplicación de consola, esta función será la encargada de limpiar la pantalla y pintar el tablero cada vez que la invoquemos.

Función Procesa_Entrada:
Coge la letra que ha seleccionado el usuario y procesa si es una letra válida o no. Si se ha completado la palabra, lo indicará y también notificará cuando el usuario decida dejar de jugar.

Función Main:
Será la función principal del programa e irá llamando al resto de funciones.

Ya con la idea general, se pueden ir desarrollando más en concreto cada una de las funciones.