HPC09_PunterosC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Computación de Alto Desempeño</h1>\n",
    "<h1 align=\"center\">Punteros en C</h1>\n",
    "<h1 align=\"center\">2024</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "|[![Outlook](https://img.shields.io/badge/Microsoft_Outlook-0078D4?style=plastic&logo=microsoft-outlook&logoColor=white)](mailto:calvarezh@udemedellin.edu.co)||[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/HPC/blob/main/HPC09_PunterosC.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Conceptos de Punteros en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Objetivo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introducir el concepto de punteros y su importancia en la manipulación de memoria en C, estableciendo las bases para su uso en computación paralela. Este módulo cubre qué son los punteros, cómo funcionan y por qué son fundamentales para el manejo eficiente de memoria y recursos en C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **¿Qué es un puntero?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un puntero es una variable que **almacena la dirección de memoria** de otra variable. En lugar de contener un valor directo, como lo hacen las variables comunes, un puntero contiene una referencia a una ubicación en la memoria donde se encuentra almacenado el valor real. \n",
    "\n",
    "Esto permite que los punteros puedan:\n",
    "- **Acceder y modificar datos** ubicados en diferentes partes de la memoria.\n",
    "- **Manipular estructuras dinámicas** como listas enlazadas, pilas y árboles.\n",
    "- **Optimizar el uso de memoria** al pasar referencias a funciones, en lugar de copiar grandes cantidades de datos.\n",
    "\n",
    "**Ejemplo básico de puntero:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main() {\n",
    "    int variable = 10;\n",
    "    int *puntero;  // Declaración de un puntero a un entero\n",
    "    puntero = &variable;  // El puntero almacena la dirección de 'variable'\n",
    "\n",
    "    printf(\"Valor de la variable: %d\\n\", variable);\n",
    "    printf(\"Dirección de la variable: %p\\n\", &variable);\n",
    "    printf(\"Valor almacenado en puntero: %p\\n\", puntero);\n",
    "    printf(\"Valor al que apunta el puntero: %d\\n\", *puntero);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Declaración y uso de punteros:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Declaración:** Un puntero se declara especificando el tipo de datos al que apunta seguido por un asterisco `*`. \n",
    "  ```c\n",
    "  int *p;  // 'p' es un puntero a un entero\n",
    "  ```\n",
    "- **Asignación:** Para asignar la dirección de una variable a un puntero, se usa el operador de dirección `&`.\n",
    "  ```c\n",
    "  p = &variable;  // 'p' ahora apunta a la dirección de 'variable'\n",
    "  ```\n",
    "- **Acceso al valor:** Para acceder al valor al que apunta un puntero, se usa el operador de dereferencia `*`.\n",
    "  ```c\n",
    "  int valor = *p;  // 'valor' ahora contiene el valor almacenado en la dirección a la que apunta 'p'\n",
    "  ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Operador de dirección (`&`) y operador de dereferencia (`*`):**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Operador de dirección (`&`)**: Obtiene la dirección de memoria de una variable.\n",
    "  ```c\n",
    "  int *ptr = &variable;  // Almacena la dirección de 'variable' en el puntero 'ptr'\n",
    "  ```\n",
    "- **Operador de dereferencia (`*`)**: Obtiene el valor almacenado en la dirección de memoria a la que apunta el puntero.\n",
    "  ```c\n",
    "  int valor = *ptr;  // Obtiene el valor al que apunta el puntero 'ptr'\n",
    "  ```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Punteros y Arrays**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En C, los arrays y los punteros están estrechamente relacionados. De hecho, un array es esencialmente un bloque continuo de memoria y su nombre actúa como un puntero al primer elemento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Relación entre punteros y arrays:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El nombre de un array en C es un puntero constante al primer elemento del array. Por ejemplo:\n",
    "```c\n",
    "int array[5] = {1, 2, 3, 4, 5};\n",
    "int *p = array;  // 'p' apunta al primer elemento del array\n",
    "```\n",
    "\n",
    "Esto significa que `array` es equivalente a `&array[0]` y se puede acceder a los elementos del array de dos maneras:\n",
    "1. Usando índices: `array[i]`.\n",
    "2. Usando punteros: `*(array + i)`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Indexación y acceso mediante punteros:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un puntero puede utilizarse para recorrer un array accediendo a cada elemento mediante aritmética de punteros. Aquí un ejemplo que demuestra el acceso a un array mediante punteros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main() {\n",
    "    int array[5] = {1, 2, 3, 4, 5};\n",
    "    int *p = array;\n",
    "\n",
    "    for (int i = 0; i < 5; i++) {\n",
    "        printf(\"array[%d] = %d, *(p + %d) = %d\\n\", i, array[i], i, *(p + i));\n",
    "    }\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo:\n",
    "- `array[i]` accede al elemento usando el índice.\n",
    "- `*(p + i)` accede al mismo elemento usando el puntero `p`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Paso de Punteros a Funciones**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En C, las funciones pasan argumentos de dos maneras: por valor y por referencia (mediante punteros). Comprender esta diferencia es crucial al trabajar con funciones que necesitan modificar variables fuera de su propio ámbito."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso por valor vs. paso por referencia:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Paso por valor:**\n",
    "   Al pasar un valor a una función, se crea una **copia** de la variable original. Las modificaciones hechas a la copia dentro de la función no afectan a la variable original.\n",
    "   ```c\n",
    "   void cambiarValor(int x) {\n",
    "       x = 10;  // Solo se cambia la copia\n",
    "   }\n",
    "   ```\n",
    "\n",
    "2. **Paso por referencia (usando punteros):**\n",
    "   Al pasar un puntero, se pasa la **dirección** de la variable, lo que permite modificar la variable original desde la función.\n",
    "   ```c\n",
    "   void cambiarValor(int *p) {\n",
    "       *p = 10;  // Modifica el valor de la variable original\n",
    "   }\n",
    "   ```\n",
    "\n",
    "**Ejemplo de paso por valor y por referencia:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "void pasoPorValor(int x) {\n",
    "    x = 20;  // Solo modifica la copia local\n",
    "}\n",
    "\n",
    "void pasoPorReferencia(int *p) {\n",
    "    *p = 20;  // Modifica el valor original\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    int a = 10;\n",
    "    int b = 10;\n",
    "\n",
    "    pasoPorValor(a);\n",
    "    pasoPorReferencia(&b);\n",
    "\n",
    "    printf(\"Valor de 'a' después de paso por valor: %d\\n\", a);  // No cambia\n",
    "    printf(\"Valor de 'b' después de paso por referencia: %d\\n\", b);  // Cambia\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo:\n",
    "- `a` no cambia porque se pasó por valor.\n",
    "- `b` cambia porque se pasó por referencia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejemplo práctico: Intercambio de dos variables usando punteros**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enunciado:** Escribir un programa que intercambie el valor de dos variables utilizando punteros.\n",
    "\n",
    "El intercambio se puede realizar eficientemente pasando las direcciones de las variables a una función y usando punteros para intercambiar los valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "void intercambiar(int *x, int *y) {\n",
    "    int temporal = *x;\n",
    "    *x = *y;\n",
    "    *y = temporal;\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    int a = 5;\n",
    "    int b = 10;\n",
    "\n",
    "    printf(\"Antes del intercambio: a = %d, b = %d\\n\", a, b);\n",
    "    intercambiar(&a, &b);  // Pasamos las direcciones de 'a' y 'b'\n",
    "    printf(\"Después del intercambio: a = %d, b = %d\\n\", a, b);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explicación del código:**\n",
    "- La función `intercambiar` recibe dos punteros, `x` y `y`, que almacenan las direcciones de las variables a y b.\n",
    "- Utilizando `*x` y `*y`, se accede a los valores de las variables a y b directamente, y se intercambian usando una variable temporal.\n",
    "\n",
    "Este enfoque muestra cómo los punteros pueden manipular directamente los valores originales sin tener que devolver resultados, simplemente alterando los datos en la memoria."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Implementación de una función que modifique una estructura de datos a través de punteros**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enunciado:** Escribir un programa que modifique los elementos de un array utilizando punteros y funciones. La función deberá recibir un puntero al array y modificar sus valores.\n",
    "\n",
    "#### **Ejemplo:**\n",
    "Vamos a crear un programa que incremente cada elemento de un array en 10 usando una función y punteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "void incrementarArray(int *arr, int size) {\n",
    "    for (int i = 0; i < size; i++) {\n",
    "        *(arr + i) += 10;  // Incrementa cada elemento en 10\n",
    "    }\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    int array[5] = {1, 2, 3, 4, 5};\n",
    "    int size = 5;\n",
    "\n",
    "    printf(\"Array antes de la modificación: \");\n",
    "    for (int i = 0; i < size; i++) {\n",
    "        printf(\"%d \", array[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    incrementarArray(array, size);  // Pasamos el array a la función\n",
    "\n",
    "    printf(\"Array después de la modificación: \");\n",
    "    for (int i = 0; i < size; i++) {\n",
    "        printf(\"%d \", array[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explicación del código:**\n",
    "- La función `incrementarArray` recibe un puntero al array y su tamaño.\n",
    "- Utilizamos aritmética de punteros (`*(arr + i)`) para acceder y modificar los elementos del array.\n",
    "- En el `main`, imprimimos el array antes y después de la modificación para visualizar los cambios.\n",
    "\n",
    "Este enfoque permite manipular arrays y otras estructuras complejas de manera eficiente usando punteros.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio:**\n",
    "\n",
    "Escribir una función que ordene un array de enteros usando punteros en lugar de índices.\n",
    "\n",
    "**Instrucciones:**\n",
    "1. Implementar una función que reciba un puntero a un array y su tamaño.\n",
    "2. Utilizar aritmética de punteros para comparar e intercambiar los elementos del array.\n",
    "3. Probar el programa con diferentes valores de arrays.\n",
    "\n",
    "#### **Ejemplo de salida esperada:**\n",
    "```\n",
    "Array original: 5 3 8 4 1\n",
    "Array ordenado: 1 3 4 5 8\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Punteros y Memoria Dinámica en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Objetivo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introducir el uso de memoria dinámica en C y cómo los punteros permiten la manipulación eficiente de grandes estructuras de datos. Este módulo ayudará a comprender cómo reservar, reutilizar y liberar memoria de manera eficiente, algo esencial para aplicaciones que requieren grandes cantidades de datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Memoria estática vs dinámica en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Memoria estática:** Es asignada en tiempo de compilación y tiene un tamaño fijo durante toda la ejecución del programa. Las variables globales y locales declaradas de manera normal (como `int a[10];`) usan memoria estática.\n",
    "  \n",
    "- **Memoria dinámica:** Se asigna en tiempo de ejecución según las necesidades del programa. Esto permite reservar más o menos memoria durante la ejecución del programa, lo cual es crucial cuando no se conoce el tamaño de los datos con anticipación.\n",
    "\n",
    "La memoria dinámica en C se gestiona mediante punteros y las funciones de la biblioteca estándar que permiten reservar y liberar memoria."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Funciones para gestionar memoria dinámica:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **`malloc` (memory allocation):**\n",
    "   - Asigna un bloque de memoria de tamaño dado (en bytes) y devuelve un puntero al comienzo del bloque. La memoria asignada no está inicializada, es decir, puede contener basura.\n",
    "   ```c\n",
    "   int *ptr = (int *) malloc(10 * sizeof(int));  // Asigna memoria para 10 enteros\n",
    "   ```\n",
    "   Si `malloc` falla (por ejemplo, si no hay suficiente memoria), devuelve `NULL`.\n",
    "\n",
    "2. **`calloc` (contiguous allocation):**\n",
    "   - Similar a `malloc`, pero además inicializa la memoria asignada a cero. Se usa para asignar múltiples bloques de memoria de un tamaño específico.\n",
    "   ```c\n",
    "   int *ptr = (int *) calloc(10, sizeof(int));  // Asigna e inicializa memoria para 10 enteros\n",
    "   ```\n",
    "\n",
    "3. **`realloc` (reallocate memory):**\n",
    "   - Se usa para cambiar el tamaño de un bloque de memoria previamente asignado por `malloc` o `calloc`.\n",
    "   ```c\n",
    "   ptr = (int *) realloc(ptr, 20 * sizeof(int));  // Redimensiona el bloque a 20 enteros\n",
    "   ```\n",
    "   Si el nuevo tamaño es mayor, los nuevos bytes añadidos no están inicializados.\n",
    "\n",
    "4. **`free`:**\n",
    "   - Libera la memoria asignada previamente por `malloc`, `calloc` o `realloc`. Es fundamental liberar la memoria para evitar fugas de memoria.\n",
    "   ```c\n",
    "   free(ptr);  // Libera la memoria\n",
    "   ```\n",
    "\n",
    "**Ejemplo de uso de `malloc`, `calloc`, `realloc` y `free`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "\n",
    "int main() {\n",
    "    // Uso de malloc para asignar memoria para 5 enteros\n",
    "    int *ptr = (int *) malloc(5 * sizeof(int));\n",
    "    \n",
    "    // Verificamos si la memoria fue asignada\n",
    "    if (ptr == NULL) {\n",
    "        printf(\"Error: No se pudo asignar memoria.\\n\");\n",
    "        return 1;\n",
    "    }\n",
    "\n",
    "    // Inicializamos los valores\n",
    "    for (int i = 0; i < 5; i++) {\n",
    "        ptr[i] = i + 1;\n",
    "    }\n",
    "\n",
    "    // Imprimimos los valores\n",
    "    printf(\"Valores iniciales: \");\n",
    "    for (int i = 0; i < 5; i++) {\n",
    "        printf(\"%d \", ptr[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    // Redimensionamos el bloque de memoria con realloc\n",
    "    ptr = (int *) realloc(ptr, 10 * sizeof(int));\n",
    "\n",
    "    // Inicializamos los nuevos valores\n",
    "    for (int i = 5; i < 10; i++) {\n",
    "        ptr[i] = i + 1;\n",
    "    }\n",
    "\n",
    "    // Imprimimos los nuevos valores\n",
    "    printf(\"Valores después de realloc: \");\n",
    "    for (int i = 0; i < 10; i++) {\n",
    "        printf(\"%d \", ptr[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    // Liberamos la memoria asignada\n",
    "    free(ptr);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este código:\n",
    "- Se asigna memoria para 5 enteros con `malloc`.\n",
    "- Se redimensiona la memoria para 10 enteros con `realloc`.\n",
    "- Se liberan los recursos con `free`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Importancia de liberar memoria:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es crucial usar `free` para liberar cualquier memoria asignada dinámicamente. No hacerlo puede llevar a fugas de memoria, donde el programa sigue consumiendo memoria sin reutilizarla ni devolverla al sistema, lo que degrada el rendimiento del sistema y puede provocar que el programa se quede sin memoria disponible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Punteros a Punteros (Arrays Multidimensionales)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los punteros a punteros son útiles para manejar **matrices dinámicas** en C. Una matriz bidimensional (o superior) se puede implementar con punteros a punteros. Esto permite asignar memoria dinámica para cada fila y sus columnas, lo que es útil cuando el tamaño de la matriz no es fijo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Implementación de matrices dinámicas con punteros:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Creación de una matriz dinámica (por ejemplo, de 3x3):**\n",
    "   Para una matriz de `n` filas y `m` columnas, se puede crear un array de punteros, donde cada puntero apunta a una fila.\n",
    "   ```c\n",
    "   int **matriz = (int **) malloc(n * sizeof(int *));  // Asignar memoria para las filas\n",
    "   for (int i = 0; i < n; i++) {\n",
    "       matriz[i] = (int *) malloc(m * sizeof(int));  // Asignar memoria para cada columna\n",
    "   }\n",
    "   ```\n",
    "\n",
    "2. **Liberación de memoria de una matriz:**\n",
    "   Es importante liberar cada fila individualmente y luego el array de punteros:\n",
    "   ```c\n",
    "   for (int i = 0; i < n; i++) {\n",
    "       free(matriz[i]);  // Liberar cada fila\n",
    "   }\n",
    "   free(matriz);  // Liberar el array de punteros\n",
    "   ```\n",
    "\n",
    "**Ejemplo de creación y liberación de una matriz en memoria dinámica:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "\n",
    "int main() {\n",
    "    int n = 3, m = 3;\n",
    "    \n",
    "    // Crear la matriz dinámica\n",
    "    int **matriz = (int **) malloc(n * sizeof(int *));\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        matriz[i] = (int *) malloc(m * sizeof(int));\n",
    "    }\n",
    "\n",
    "    // Inicializar la matriz con valores\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        for (int j = 0; j < m; j++) {\n",
    "            matriz[i][j] = i * m + j + 1;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    // Imprimir la matriz\n",
    "    printf(\"Matriz 3x3:\\n\");\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        for (int j = 0; j < m; j++) {\n",
    "            printf(\"%d \", matriz[i][j]);\n",
    "        }\n",
    "        printf(\"\\n\");\n",
    "    }\n",
    "\n",
    "    // Liberar la memoria\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        free(matriz[i]);\n",
    "    }\n",
    "    free(matriz);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo:\n",
    "- Se crea una matriz dinámica de 3x3.\n",
    "- Los valores se asignan a cada posición.\n",
    "- La memoria se libera correctamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejemplo práctico**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enunciado:** Implementar una matriz dinámica de enteros utilizando `malloc` y `free`, e imprimir sus valores mediante punteros.\n",
    "\n",
    "**Código de ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "\n",
    "int main() {\n",
    "    int filas = 4, columnas = 4;\n",
    "    \n",
    "    // Asignar memoria para la matriz dinámica\n",
    "    int **matriz = (int **) malloc(filas * sizeof(int *));\n",
    "    for (int i = 0; i < filas; i++) {\n",
    "        matriz[i] = (int *) malloc(columnas * sizeof(int));\n",
    "    }\n",
    "\n",
    "    // Inicializar los valores de la matriz\n",
    "    for (int i = 0; i < filas; i++) {\n",
    "        for (int j = 0; j < columnas; j++) {\n",
    "            matriz[i][j] = i + j;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    // Imprimir los valores de la matriz\n",
    "    printf(\"Matriz de 4x4:\\n\");\n",
    "    for (int i = 0; i < filas; i++) {\n",
    "        for (int j = 0; j < columnas; j++) {\n",
    "            printf(\"%d \", matriz[i][j]);\n",
    "        }\n",
    "        printf(\"\\n\");\n",
    "    }\n",
    "\n",
    "    // Liberar la memoria de la matriz\n",
    "    for (int i = 0; i < filas; i++) {\n",
    "        free(matriz[i]);\n",
    "    }\n",
    "    free(matriz);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Explicación del código:**\n",
    "- Se asigna memoria dinámica para una matriz de 4x4 usando `malloc`.\n",
    "- Los valores de la matriz se inicializan sumando los índices de las filas y las columnas.\n",
    "- Finalmente, se libera la memoria con `free` para cada fila y el array de punteros."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enunciado:** Crear una estructura dinámica para almacenar una lista de cadenas de texto.\n",
    "\n",
    "**Descripción:**\n",
    "El objetivo de esta tarea es implementar una estructura dinámica que pueda almacenar varias cadenas de texto. Para lograr esto, utilizaremos memoria dinámica con `malloc` y `free`, y punteros para manipular las cadenas de texto.\n",
    "\n",
    "**Instrucciones:**\n",
    "1. Crear una estructura para almacenar múltiples cadenas de texto.\n",
    "2. Implementar un programa que permita al usuario ingresar varias cadenas.\n",
    "3. Almacenar las cadenas de manera dinámica.\n",
    "4. Imprimir las cadenas ingresadas.\n",
    "5. Liberar la memoria asignada dinámicamente.\n",
    "\n",
    "**Conceptos clave:**\n",
    "- **Cadenas de texto en C:** Las cadenas de texto en C son arrays de caracteres terminados en `'\\0'`.\n",
    "- **Asignación dinámica para cadenas:** Se puede usar `malloc` para reservar espacio suficiente para almacenar cada cadena.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Uso de Punteros en Programas Paralelos**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se trabaja en un entorno de **memoria compartida**, como el que ofrece OpenMP, el uso de **punteros** es crucial para optimizar el acceso a los datos. En lugar de copiar grandes estructuras de datos entre los hilos, se puede utilizar un único bloque de memoria compartida al que acceden varios hilos simultáneamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Compartición de datos entre hilos mediante punteros:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- En un entorno de memoria compartida, todos los hilos pueden acceder a las mismas variables globales o cualquier dato al que se apunte mediante punteros.\n",
    "- Esto permite que los hilos trabajen sobre una estructura de datos compartida, como un array o una matriz, sin la necesidad de replicar la estructura en cada hilo, lo que ahorra memoria y mejora la eficiencia.\n",
    "\n",
    "**Ejemplo:** Si se tiene un array y se desea que varios hilos lo llenen con valores, los punteros se utilizan para que cada hilo acceda a la posición de memoria correspondiente sin crear copias adicionales.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Beneficios del uso de punteros en ambientes de memoria compartida:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Eficiencia de memoria:** Los punteros permiten que los hilos compartan la misma memoria en lugar de copiar grandes cantidades de datos para cada hilo.\n",
    "- **Optimización del rendimiento:** Evitar la duplicación de datos minimiza el tiempo de inicialización y el uso de memoria.\n",
    "- **Flexibilidad en la manipulación de datos:** Los punteros permiten modificar directamente grandes estructuras de datos (como matrices) en paralelo sin tener que pasar copias entre hilos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejemplo práctico: Paralelización de un Ciclo `for` con OpenMP y Punteros**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enunciado:** Paralelizar un ciclo `for` utilizando OpenMP para llenar un array con punteros. Cada hilo se encargará de llenar una parte del array, y al final se mostrará el array completo.\n",
    "\n",
    "**Solución con OpenMP y punteros:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <omp.h>\n",
    "#include <stdlib.h>\n",
    "\n",
    "int main() {\n",
    "    int n = 1000;\n",
    "    int *array;\n",
    "\n",
    "    // Asignar memoria dinámica para el array\n",
    "    array = (int *) malloc(n * sizeof(int));\n",
    "\n",
    "    // Paralelización con OpenMP\n",
    "    #pragma omp parallel for\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array[i] = i * 2;  // Cada hilo llena parte del array\n",
    "    }\n",
    "\n",
    "    // Imprimir los primeros 10 elementos para verificar\n",
    "    printf(\"Primeros 10 elementos del array:\\n\");\n",
    "    for (int i = 0; i < 10; i++) {\n",
    "        printf(\"%d \", array[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    // Liberar la memoria dinámica\n",
    "    free(array);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explicación del código:**\n",
    "1. **Asignación de memoria dinámica para el array:** Usamos `malloc` para asignar un array de 1000 enteros.\n",
    "   ```c\n",
    "   array = (int *) malloc(n * sizeof(int));\n",
    "   ```\n",
    "2. **Paralelización del ciclo `for` con OpenMP:** Usamos `#pragma omp parallel for` para dividir el ciclo entre varios hilos. Cada hilo llena una parte del array.\n",
    "   ```c\n",
    "   #pragma omp parallel for\n",
    "   for (int i = 0; i < n; i++) {\n",
    "       array[i] = i * 2;\n",
    "   }\n",
    "   ```\n",
    "3. **Acceso a memoria compartida mediante punteros:** Todos los hilos trabajan sobre el mismo array, modificando los valores en paralelo.\n",
    "4. **Liberación de la memoria:** Al finalizar, liberamos la memoria asignada dinámicamente para evitar fugas de memoria."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Optimización del Acceso a Memoria Compartida Utilizando Punteros**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se trabaja con punteros y memoria compartida, se debe tener en cuenta lo siguiente para optimizar el rendimiento:\n",
    "- **Evitar condiciones de carrera:** Si varios hilos intentan modificar la misma posición de memoria al mismo tiempo, se produce una condición de carrera. Es importante asegurarse de que cada hilo acceda a distintas ubicaciones de memoria, o usar mecanismos de sincronización como las directivas `critical` o `atomic` en OpenMP.\n",
    "  \n",
    "- **Minimizar el acceso a memoria compartida:** Aunque la memoria compartida es útil, el acceso simultáneo de múltiples hilos a la misma región de memoria puede generar cuellos de botella. Usar punteros para dividir el trabajo y minimizar conflictos puede mejorar el rendimiento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Ejemplo de optimización utilizando punteros y OpenMP:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <omp.h>\n",
    "#include <stdlib.h>\n",
    "\n",
    "int main() {\n",
    "    int n = 1000;\n",
    "    int *array;\n",
    "\n",
    "    // Asignar memoria dinámica para el array\n",
    "    array = (int *) malloc(n * sizeof(int));\n",
    "\n",
    "    // Paralelización con OpenMP, sin conflictos de acceso a memoria\n",
    "    #pragma omp parallel for\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array[i] = i * 2;  // Cada hilo trabaja en una región independiente del array\n",
    "    }\n",
    "\n",
    "    // Imprimir los últimos 10 elementos para verificar\n",
    "    printf(\"Últimos 10 elementos del array:\\n\");\n",
    "    for (int i = n - 10; i < n; i++) {\n",
    "        printf(\"%d \", array[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    // Liberar la memoria dinámica\n",
    "    free(array);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explicación de la optimización:**\n",
    "- **División de trabajo entre hilos:** Cada hilo trabaja en una región diferente del array, evitando conflictos de acceso a la memoria.\n",
    "- **Acceso eficiente mediante punteros:** Los punteros permiten un acceso directo a las posiciones de memoria, lo que reduce la sobrecarga en la gestión de memoria."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Enunciado:** Paralelizar una función que realiza operaciones matemáticas sobre matrices dinámicas utilizando OpenMP y punteros. Cada hilo debe trabajar en una parte de la matriz para realizar la operación más eficientemente.\n",
    "\n",
    "#### **Instrucciones:**\n",
    "1. Implementar una función que reciba una matriz dinámica y realice una operación matemática (por ejemplo, multiplicar cada elemento por un valor constante).\n",
    "2. Utilizar OpenMP para paralelizar el proceso.\n",
    "3. Usar punteros para acceder y modificar los elementos de la matriz.\n",
    "4. Liberar la memoria al finalizar.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Ventajas del Uso de Punteros en Computación Paralela**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Objetivo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprender las ventajas del uso de punteros en ambientes de computación paralela, comparando con soluciones que no los utilizan, y cómo afectan la eficiencia y el rendimiento. Se discutirá cómo los punteros permiten la manipulación eficiente de grandes estructuras de datos y cómo evitar duplicaciones innecesarias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Comparación: Uso de Punteros vs. No Punteros**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **¿Qué sería equivalente a no usar punteros?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando no se utilizan punteros en C, normalmente se trabaja con **paso por valor**. En el contexto de computación paralela, esto significa que se crea una **copia** de las variables o estructuras de datos que se desean procesar en cada hilo.\n",
    "\n",
    "**Paso por valor:**\n",
    "- **Definición:** Cuando una variable se pasa a una función o a un hilo por valor, se crea una copia de esa variable.\n",
    "- **Limitaciones:** Las modificaciones que se hacen dentro de la función o el hilo no afectan a la variable original. Además, este enfoque consume más memoria y tiempo, ya que se deben crear copias adicionales para cada hilo.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Costos de copia de datos en computación paralela:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se pasa un gran bloque de datos (como un array o una estructura) por valor, se crea una copia en cada hilo o función que necesita procesar esos datos. Esto tiene varias implicaciones:\n",
    "- **Mayor uso de memoria:** Cada copia consume espacio de memoria adicional.\n",
    "- **Costos de tiempo:** Copiar grandes bloques de datos puede ser costoso en términos de tiempo, especialmente cuando se manipulan grandes estructuras.\n",
    "- **Redundancia:** Los hilos o las funciones trabajan sobre sus propias copias, lo que puede causar inconsistencias si las modificaciones no se sincronizan."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Eficiencia en la gestión de memoria con punteros:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El uso de punteros permite que las funciones o hilos trabajen directamente sobre los datos originales, en lugar de crear copias. Esto tiene varias ventajas:\n",
    "- **Menor uso de memoria:** Se pasa la **dirección de la memoria** donde están almacenados los datos, lo que significa que no se crean copias adicionales.\n",
    "- **Mayor eficiencia en el tiempo:** Evita los tiempos de copia, ya que se trabaja directamente con la memoria original.\n",
    "- **Consistencia:** Todos los hilos o funciones pueden trabajar sobre los mismos datos compartidos, lo que facilita la sincronización de resultados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Ejemplo de paso por valor vs. paso por referencia (con punteros):**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Paso por valor:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "void incrementarValor(int x) {\n",
    "    x += 10;  // Solo se modifica la copia de 'x'\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    int a = 5;\n",
    "    incrementarValor(a);\n",
    "    printf(\"Valor de 'a' después de incrementar por valor: %d\\n\", a);  // 'a' sigue siendo 5\n",
    "    return 0;\n",
    "}\n",
    "```\n",
    "\n",
    "**Paso por referencia (con punteros):**\n",
    "```c\n",
    "#include <stdio.h>\n",
    "\n",
    "void incrementarReferencia(int *x) {\n",
    "    *x += 10;  // Modifica el valor original al que apunta el puntero\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    int a = 5;\n",
    "    incrementarReferencia(&a);\n",
    "    printf(\"Valor de 'a' después de incrementar por referencia: %d\\n\", a);  // 'a' es 15\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Mejora del Rendimiento con Punteros en OpenMP**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Uso de punteros para evitar la duplicación innecesaria de datos:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En computación paralela, uno de los principales beneficios del uso de punteros es evitar la duplicación innecesaria de datos. Al utilizar punteros, todos los hilos pueden acceder a los mismos bloques de memoria, lo que reduce la sobrecarga de la creación de copias y permite una sincronización más eficiente entre los hilos.\n",
    "\n",
    "**Ejemplo:**\n",
    "En un programa paralelo que utiliza matrices grandes, en lugar de pasar la matriz por valor a cada hilo, se puede pasar un puntero a la matriz. De esta manera, todos los hilos trabajan directamente sobre los mismos datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Ejemplo de mejora del rendimiento:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <omp.h>\n",
    "#include <stdlib.h>\n",
    "\n",
    "int main() {\n",
    "    int n = 1000000;\n",
    "    int *array = (int *) malloc(n * sizeof(int));\n",
    "    \n",
    "    // Inicializar el array con 0\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array[i] = 0;\n",
    "    }\n",
    "\n",
    "    // Paralelizar el cálculo utilizando punteros\n",
    "    #pragma omp parallel for\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array[i] += i * 2;  // Cada hilo accede directamente a la memoria compartida\n",
    "    }\n",
    "\n",
    "    // Imprimir los primeros 10 elementos\n",
    "    printf(\"Primeros 10 elementos:\\n\");\n",
    "    for (int i = 0; i < 10; i++) {\n",
    "        printf(\"%d \", array[i]);\n",
    "    }\n",
    "    printf(\"\\n\");\n",
    "\n",
    "    // Liberar memoria\n",
    "    free(array);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Sin duplicación de datos:** Todos los hilos acceden al mismo bloque de memoria utilizando punteros, lo que reduce la sobrecarga de copiar datos.\n",
    "- **Mejora del rendimiento:** Al evitar la duplicación de datos y trabajar directamente con la memoria compartida, el tiempo de ejecución es más rápido y eficiente.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejemplo Práctico: Comparación del Rendimiento entre Paso por Valor y Paso por Referencia (con Punteros)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Enunciado:** Escribir un programa que compare el rendimiento de una operación matemática sobre un array grande utilizando dos enfoques:\n",
    "1. **Paso por valor:** Se pasa una copia del array a cada hilo.\n",
    "2. **Paso por referencia (con punteros):** Se pasa un puntero al array, permitiendo que los hilos trabajen directamente sobre los datos originales.\n",
    "\n",
    "#### **Solución:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "#include <omp.h>\n",
    "#include <time.h>\n",
    "\n",
    "// Función con paso por valor (crea una copia)\n",
    "void procesoPorValor(int array[], int n) {\n",
    "    #pragma omp parallel for\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array[i] += i;\n",
    "    }\n",
    "}\n",
    "\n",
    "// Función con paso por referencia (usa punteros)\n",
    "void procesoPorReferencia(int *array, int n) {\n",
    "    #pragma omp parallel for\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array[i] += i;\n",
    "    }\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    int n = 10000000;\n",
    "    int *array1 = (int *) malloc(n * sizeof(int));\n",
    "    int *array2 = (int *) malloc(n * sizeof(int));\n",
    "\n",
    "    // Inicializar los arrays\n",
    "    for (int i = 0; i < n; i++) {\n",
    "        array1[i] = array2[i] = 0;\n",
    "    }\n",
    "\n",
    "    // Medir el tiempo del proceso por valor\n",
    "    clock_t start = clock();\n",
    "    procesoPorValor(array1, n);\n",
    "    clock_t end = clock();\n",
    "    double tiempoValor = (double)(end - start) / CLOCKS_PER_SEC;\n",
    "\n",
    "    // Medir el tiempo del proceso por referencia\n",
    "    start = clock();\n",
    "    procesoPorReferencia(array2, n);\n",
    "    end = clock();\n",
    "    double tiempoReferencia = (double)(end - start) / CLOCKS_PER_SEC;\n",
    "\n",
    "    // Mostrar resultados\n",
    "    printf(\"Tiempo con paso por valor: %.6f segundos\\n\", tiempoValor);\n",
    "    printf(\"Tiempo con paso por referencia: %.6f segundos\\n\", tiempoReferencia);\n",
    "\n",
    "    // Liberar memoria\n",
    "    free(array1);\n",
    "    free(array2);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Paso por valor:** La función `procesoPorValor` trabaja sobre una copia del array.\n",
    "- **Paso por referencia:** La función `procesoPorReferencia` utiliza un puntero, trabajando directamente sobre la memoria original del array.\n",
    "- **Medición del tiempo:** Se usa `clock()` para medir el tiempo de ejecución de cada enfoque.\n",
    "- **Resultado:** El tiempo de ejecución con punteros será considerablemente menor, ya que no se crean copias adicionales del array.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optimizar un programa paralelo que realiza operaciones sobre grandes arreglos utilizando punteros y comparar el tiempo de ejecución con una implementación sin punteros.\n",
    "\n",
    "**Instrucciones:**\n",
    "1. Implementar dos versiones de un programa que manipule un array grande: una versión usando paso por valor y otra usando punteros.\n",
    "2. Medir y comparar los tiempos de ejecución en ambos enfoques.\n",
    "3. Analizar los resultados y explicar cómo el uso de punteros mejora el rendimiento."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}