DEV Community: Guillermo

La función atoi y strcat en C

Guillermo — Tue, 02 Jul 2024 05:53:13 +0000

¡Hola! Me encuentro aprendiendo el lenguaje de programación C y como herramienta estoy utilizando el libro de "The C Programming Language" de Kernighan y Ritchie. A lo largo de mi aprendizaje estaré compartiendo todo lo que me parezca interesante o retador. Todos estos posts estarán unidos con la etiqueta #csaga.

Actualmente acabo de concluir el segundo capítulo y de él rescato dos problemas que me parecen interesantes a los cuales daremos solución mediante funciones.

Comencemos con el primer problema: Dada una cadena de dígitos regresar su equivalente numérico.

Vamos a resolver este problema mediante un función que llamaremos atoi, en ella recibiremos una cadena (arreglo de caracteres) que nombraremos s[], también es claro que la función debe retornar un int. De aquí en adelante dividiremos el problema en dos partes:

Es natural asumir que lo primero que debemos hacer es recorrer el arreglo, esto lo podemos hacer con un ciclo for. Podemos inicializar el ciclo for como siempre con un contador i = 0, pero debemos establecer un criterio para salir del ciclo. En este caso los autores decidieron aprovechar el hecho de que en C, los caracteres están representados por sus valores ASCII. Por ejemplo '0' tiene un valor ASCII de 48, '1' tiene el valor 49 y así, hasta el carácter '9' que tiene el valor 57. Entonces los valores ASCII válidos para nuestro ciclo están entre 48 y 57 inclusivos, por lo que podemos formar la sentencia:
for (i=0; s[i] >= '0' && s[i] <= '9'; ++i). La condición de salida del ciclo es clara, ya que si se llega final del arreglo de caracteres este siempre es '\0' que representa el carácter nulo, cuyo valor en ASCII es 0. También, si hubiera un valor que no fuera un dígito se saldría del ciclo, por las razones antes mencionadas.
Una vez que estamos recorriendo el arreglo debemos convertir el digito en el entero que representa. Esto lo podemos hacer con : (s[i] - '0'). La sentencia anterior toma el valor ASCII del arreglo y le resta el valor ASCII de '0', dando como resultado el entero deseado. Ejemplo:
Supongamos s[i]=5, entonces s[i] - 0 es equivalente a 53 - 48 = 5. Por último, queda acomodar el número en su posición pertinente (como unidad, decena, centena, etc.) Lo cual se consigue estableciendo un n = 0 y luego actualizando en cada iteración con n = 10 * n + (s[i] - '0').

Con todo lo anterior, nuestra función deseada queda como:

int atoi(char s[]){

    int i, n;
    n=0;

    for (i=0; s[i] >= '0' && s[i] <= '9'; ++i){
        n = 10 * n + (s[i] - '0');
    }
        return n;
}

Segundo problema: Dadas dos cadenas s[] y t[] concatenar la cadena t al final de la cadena s.

Para hacer el problema más fácil el libro asume que en s hay suficiente espacio para almacenar la combinación. Ahora, debemos comenzar definiendo una función que llamaremos strcat que debe recibir dos cadenas s[] y t[], esta función no necesita regresar un valor. Una manera de resolver el problema es primero posicionaros al final de la primera cadena s[]. A partir del final de la primera cadena debemos de empezar a guardar los elementos de la segunda cadena t[].

Para llegar al final de la primera cadena podemos comenzar con un contador i = 0 e ir aumentando el valor de i hasta el final del arreglo, esto se logra cuando alcanzamos el valor '\0', el cual marca el final de todo arreglo de caracteres. Así podemos tener el siguiente código:

while(s[i] != '\0'){
    i++;
}

Ahora que estamos posicionados en el fin de s debemos de empezar a copiar los valores de t. Para esto necesitamos empezar otro contador j = 0 y asignar s[i] = t[j], recordemos que el valor de i ya esta al final de la primera cadena. Luego debemos incrementar ambos índices y repetir el proceso hasta que encontremos el carácter '\0' que marca el fin de la cadena en t. Todo lo anterior lo podemos lograr mediante la sentencia:

while ((s[i++] = t[j++]) != '\0') {
   ;
}

Sé que me estoy repitiendo, pero con la finalidad de que quede todo claro. El código anterior primero asigna el carácter t[j] a s[i], luego incrementa el valor de i y de j hasta encontrar el final de t.
Teniendo en cuenta lo anterior nuestra función quedaría como:

void strcat(char s[], char t[]) {
    int i = 0, j = 0;

    while (s[i] != '\0') {
        i++;
    }

    while ((s[i++] = t[j++]) != '\0') {
        ;
    }
}

Antes de terminar el post quisiera decir que el lector debe tener en cuenta que ando aprendiendo, en caso de existir algún error, por favor, con toda libertad me lo pueden hacer saber en comentarios.

Gracias por leer!!!!

Iniciando en el mundo de la programación con C

Guillermo — Fri, 28 Jun 2024 00:29:55 +0000

Hace ya bastante tiempo decidí aprender a programar con la finalidad de cambiar de carrera profesional. Las primeras recomendaciones que encontré en internet y en algunas escuelas online fue empezar a estudiar HTML, CSS y JavaScript. Sin embargo, para ser honesto algunos cursos que tomé sobre estos temas se me hicieron algo tediosos y para nada me sentí motivado, incluso llegué a pensar que esto de la programación no era para mí. También debo aclarar que cuando hice los cursos estaba en medio de una fuerte depresión.

Ahora que estoy más estable y feliz he decidido darle una segunda oportunidad a la programación, pero esta vez usaré una ruta y un enfoque diferente. En esta ocasión estoy dispuesto a disfrutar el camino. Hace algunos años me recibí de la carrera de matemáticas por lo que encuentro más divertido estudiar algoritmos, fórmulas y cosas relacionadas. Por lo anterior he decidido aprender a programar pero en C, quiero aprender las bases de la programación, estructuras de datos, implementar algoritmos, arquitectura de computadoras, etc.

Espero este sea el inicio de un gran viaje y al menos aprenda muchas cosas.

Una pequeña intro a las subplots de Matplotlib

Guillermo — Wed, 11 Jan 2023 05:42:36 +0000

En este muy pequeño post nos centraremos en la tarea de crear varios gráficos en una sola imagen con la librería Matplotlib.

La manera más fácil de lograr nuestra tarea es usando matplotlib.pyplot.subplots. Este método retorna una tupla (fig, ax), donde fig hace referencia a Figure el cual es la imagen contenedora de todos los sub-gráficos, y ax hace referencia a un arreglo de Axes, estos se refieren a cada sub-gráfico de manera individual.

Al método anterior le podemos especificar el número de filas y columnas para generar tantos sub-gráficos como nosotros consideremos necesario. Para entender esto de mejor manera pasemos al código:

import matplotlib.pyplot as plt
plt.style.use('ggplot')
fig, ax = plt.subplots(figsize=(12,4) ,nrows=1, ncols=3)

Ahora veamos como graficar en los espacios generados, para esto crearemos unos datos con ayuda de numpy.

import numpy as np
x = np.linspace(0, 2 * np.pi, 400)
y1 = np.cos(x**2)
y2 = np.sin(x**2)
y3 = np.floor(x**2)

Ahora sí grafiquemos estas tres funciones:

fig, ax = plt.subplots(figsize=(16,4) ,nrows=1, ncols=3)
ax[0].plot(x, y1, color='#581845', linestyle='dashed')
ax[0].set_title('Función coseno')
ax[1].plot(x, y2, color='#0C0C0E', linestyle='dashdot')
ax[1].set_title('Función seno')
ax[2].plot(x, y3, color='#D42D2D')
ax[2].set_title('Función piso')
plt.show()

Alternativamente podemos desempacar los Axes como una tupla:

fig, (ax1, ax2, ax3) = plt.subplots(figsize=(16,4) ,nrows=1, ncols=3)
ax1.plot(x, y1, color='#581845', linestyle='dashed')
ax1.set_title('Función coseno')
ax2.plot(x, y2, color='#0C0C0E', linestyle='dashdot')
ax2.set_title('Función seno')
ax3.plot(x, y3, color='#D42D2D')
ax3.set_title('Función piso')
plt.show()

Y el resultado será el mismo. Aquí ya es una cuestión de gustos el cómo manejar a los Axes.

Ahora generemos un arreglo bidimensional de sub-gráficos y veamos que podemos acceder a cada uno de ellos con índices, como si se tratara de una matriz.

Pero antes de graficar necesitamos crear una cuarta función para poder llenar el último espacio, así que creemos dicha función:

y4=np.exp(x)

Ahora si procedamos a hacer nuestras gráficas:

fig, ax = plt.subplots(figsize=(16,8) ,nrows=2, ncols=2)
ax[0, 0].plot(x, y1, color='#581845', linestyle='dashed')
ax[0, 0].set_title('Función coseno')
ax[0, 1].plot(x, y2, color='#0C0C0E', linestyle='dashdot')
ax[0, 1].set_title('Función seno')
ax[1, 0].plot(x, y3, color='#D42D2D')
ax[1, 0].set_title('Función piso')
ax[1, 1].plot(x, y4, color='#0B13BE')
ax[1, 1].set_title('Función exponencial')
plt.show()

Este ejemplo es muy sencillo y todas las funciones las generamos a partir del mismo dominio (eje X). Sin embargo, puede que también en un caso que estemos estudiando los datos compartan algún eje, por lo que resultaría útil que nuestra imagen no muestre el eje dos veces sino que simplemente se comparta. Lo anterior lo podemos lograr con sharex o sharey.

fig, ax = plt.subplots(figsize=(16,8) ,nrows=2, ncols=2, sharex=True)
ax[0, 0].plot(x, y1, color='#581845', linestyle='dashed')
ax[0, 0].set_title('Función coseno')
ax[0, 1].plot(x, y2, color='#0C0C0E', linestyle='dashdot')
ax[0, 1].set_title('Función seno')
ax[1, 0].plot(x, y3, color='#D42D2D')
ax[1, 0].set_title('Función piso')
ax[1, 1].plot(x, y4, color='#0B13BE')
ax[1, 1].set_title('Función exponencial')
plt.show()

Muchas más cosas se pueden personalizar con la finalidad de realizar la visualización que nosotros queramos, pero la idea era hacer este post muy conciso y corto, ya trataremos con mayor profundidad este y otros temas en próximas entradas.

Mil gracias por leer, excelente día :D