Está es una pequeña guía desde cómo inicializar un proyecto de **Git**, hasta cómo subirlo a un repositorio de **GitHub**. Para lograrlo, sigue los siguientes pasos.
# Git
Primero, debes asegurarte de tener **[Git instalado](https://git-scm.com/)** y **añadirlo al path**. Además de tener todas las configuraciones de usuario hechas.
Te recomiendo habilitar la opción de usar a git como bash, esto se habilita al momento de instalarlo.

![Instalación de git](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711333474/blog/articles/xr0estp8gkvbytrqre0l.webp)

Para abrir la consola, tienes que ir a la dirección de tu proyecto, dar clic derecho y elegir la opción __Git bash here__.
Y ahora sí, puedes comenzar con los siguientes comandos.

~~~bash
git init
~~~

Este primer comando inicializa el repositorio del proyecto en local.

~~~bash
git status
~~~

En caso de tener modificaciones, este comando te mostrará cuáles archivos han tenido esas modificaciones.

~~~bash
git add nombreArchivo.tipoArchivo
# ó
git add . 
~~~

Para agregar los cambios, se hace `git add` acompañado del archivo ó "." en caso de querer añadir todos los cambios.

~~~bash
git commit -m "Nombre del commit"
~~~

Guarda los cambios hechos en un commit, esto se asegura de crear un "commit", el cual será como un punto de retorno en caso de querer regresar a ese momento del proyecto.

~~~bash
git config --global user.name "Nombre(s) y Apellido(s)"

git config --global user.email "ejemplo@mail.com"
~~~

En caso de ser tu primer commit, antes de ello te pedirá configurar tu usuario y tu email.

# GitHub
Considerando que ya se tiene una cuenta de GitHub, lo primero que se hace es **[crear un nuevo repositorio](https://github.com/new)**.
Da el nombre, descripción y las configuraciones necesarias a tu repositorio y créalo.
Una vez creado, copia el URL de tu repositorio que se encuentra en las instrucciones de comandos y ve nuevamente al bash de tu proyecto y pega la URL en la línea de comandos.

~~~bash
git remote add origin https://github.com/nombre-del-repositorio.git"
~~~
Finalmente, para subir tu proyecto a tu repositorio ejecuta el comando con el nombre del branch que tiene tu proyecto, generalmente es "master" o "main".

~~~bash
git push -u origin master
# ó
git push
~~~
En caso de hacer otras modificaciones, vuelve a hacer los pasos de `git status`, `git add` y `git commit`, al finalizar, en lugar de hacer el último comando sólo haz `git push`.
Si tienes más dudas, puedes encontrar estos comandos, además de otras explicaciones en este vídeo de **[Fazt](https://www.youtube.com/watch?v=HiXLkL42tMU)** o en la **[Git Cheat Sheet oficial de GitHub Education](https://education.github.com/git-cheat-sheet-education.pdf)**.

Aprende desde cómo inicializar un repositorio local en Git, hasta subir un proyecto en un repositorio de GitHub.

Comandos básicos de Git

## ¿Qué son las variables de CSS?
**Custom Properties**, también conocidas como **variables de CSS** o **variables en cascada** son entidades definidas por los autores de CSS que representan valores específicos que se reutilizarán en todo un documento. Literalmente son *variables* que se pueden reutilizar en un mismo archivo.

Como ejemplos de algunas variables que se peuden reutilizar son colores, bordes, tamaños u otros estilos que serán usados más de una vez en una aplicación.

### Estructura de variables de CSS
![Estructura de variables CSS](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711333472/blog/articles/mqyfjankacivmg7tmvrl.webp)
Los nombres pueden ser escritos de cualquier forma, siempre y cuando no contenga espacios.
Para declarar las variables de CSS se tienen que hacer dentro de la pseudo-clase `root`.

~~~css
:root{
  --primary-color: blue; 
}
~~~

### Uso

Para usar las variables de CSS, se tiene que usar la función `var()`.
Normalmente para asignar un valor, se asigna la propiedad acompañada del valor, pero, en lugar de el valor, se escribirá la función `var()` que contendrá el nombre de la variable que queremos usar.

~~~css
:root{
  --primary-color: blue; 
}

p{
  color: var(--primary-color);
}
~~~

Otro casos donde se pueden utilizar las variables de CSS son para declarar clases que se utilizarán más de una vez a lo largo de la aplicación. Esto para acceder fácilmente a aquellos valores que podrían modificarse en un futuro.

~~~css
:root{
  --caja: flex;
  --alineacion--vertical: center;
  --alineacion-horizontal: center;
}

.centrar-div{
  display: var(--caja);
  align-items: var(--alineacion--vertical);
  justify-content: var(--alineacion-horizontal);
}
~~~

En CSS, las variables son contenedores para almacenar valores que se pueden reutilizar en todo el documento. Se definen con el prefijo `--` y se accede a ellas utilizando la función `var()`. Las variables facilitan la gestión y la consistencia de estilos en una aplicación web al permitir cambios globales con una sola modificación.

Las Custom Properties de CSS, o mejor conocidas como Variables de CSS, son una forma de mejorar la legibilidad y adaptabilidad del código de un proyecto.

Variables en CSS

## ¿Por qué un objeto?
Si vienes de otro lenguaje de programación como **C** o **C++** seguro conoces los `unordered_map` (HashMap), o lenguajes como **Python** con los **diccionarios**, es un concepto parecido llamado *Tabla de búsqueda* o *Mapeo de valores* donde se usa una estructura de `Key-Value`.

En algunos lenguajes de programación se puede poner el tipo de variable tanto para el `key` como para el `value`.
![Key-Value Table](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711333472/blog/articles/jxkylahbwrxsb9sectjq.webp)

En *JavaScript*, estás *Tablas de búsqueda* o *Mapeo de valores* son simplemente un *Objeto* de *JavaScript*. La estructura se verá más adelante en este artículo.

### Error con Switch
En ocaciones, el `switch` se utiliza para ciertos usos, pero esto trae un código muy grande y/o desordenado.
Por ejemplo, dado el caso de crear una función donde reciba ciertos valores, y regresar otros dependiendo de ese valor.

```js
function quePais(pais) {
  switch(pais){
    case "México":
      return "América"
    case "España":
      return "Europa"
    case "Japón":
      return "Asia"
    case "Egipto":
      return "África"
    case "Australia":
      return "Oceanía"
    default:
      return "No se encuentra ese país"
  }
}
```

A pesar de que el código es correcto, puede verse un poco desordenado, y tedioso de leer.
Para solucionar esto, se usaría la estructura de un *Objeto*, de la manera en la que se había planteado.

Para dar un ejemplo más práctico y visualmente entendible, vamos a imaginar el caso de una función donde dado el nombre de de un país, regresa el continente al que pertenece.

```js
function queContinente(pais) {
  const map = {
    "México": "América",
    "España": "Europa",
    "Japón": "Asia",
    "Egipto": "África",
    "Australia": "Oceanía"
  }
  // Regresa el continente de acuerdo al país, si no se encuentra, devuelve un valor default
  return map[pais] ?? "No se encuentra ese país"
}
```

Como se puede ver, el código es más corto, fácil de entender e incluso más fácil de modificar.

Aunque esto parece no tener muchos casos prácticos de uso, puede ser muy útil, ya que para casos más complejos, se podría recibir o devolver cualquier tipo de dato, incluyendo otros Objetos o estructuras más complejas.



Mejora la flexibilidad, legibilidad y escalabilidad de tu código utilizando un Objeto en lugar de Switch.

Evita el código repetitivo

El proceso de **Debugging** o **Depuración**, sirve principalmente para identificar y corregir errores, además es una forma de darte una idea de cómo funciona un programa paso a paso.

Muchos IDE's o editores de código incluyen un Debugger para algún lenguaje de programación, y se identifica con el icono de un insecto.
![Debugger icon](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711333474/blog/articles/bnpguegu80xfz8gc9gnm.webp)
Incluso puedes especificar la línea del código la cual quieres observar su funcionamiento.
Estos debuggers te muestran cómo funciona un código señalando la creación de variables, los cambios en ellas, las iteraciones en ciclos, etc.
Pero el problema con estos debuggers es que muchas veces no se puede llegar a entender completamente lo que el usuario quiere ver, por lo que en podrías preferir algo más visual.
Para ello, encontré una herramienta online que podría ayudar: **[Pythontutor](https://pythontutor.com/)**, el cual es un debugger visual para lenguajes como **JavaScript, Python, C++, C y Java**.

Para usarlo, entras al sitio, das clic en el lenguaje a utilizar, y debajo del ejemplo que dá, hay una parte para escribir tu propio código, lo pegas y das clic en `Visualize Execution`.
![Code](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711333473/blog/articles/kc4xtqg8cgfdef0cjbpl.webp)
Una vez dentro, puedes interactuar con los botones de `First`, `Prev`, `Next` y `Last`, para ver una parte específica, o también puedes señalar la línea de código que quieres visualizar cada que se ejecute esa parte.
![Visualize Execution](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711333473/blog/articles/m1erd6zdjfsnqhbxitao.webp)

Observa cómo funciona tu programa con un debugger visual que muestra el paso a paso de cada parte de tu código.

Visual Debugger para JavaScript, Python, C++, C y Java

# ¿Qué es SQL?
SQL (Structured Query Language) es un lenguaje de programación con el objetivo de administrar y manipular bases de datos **relacionales**. Con SQL, los usuarios pueden crear, modificar y eliminar bases de datos, así como también insertar, actualizar y recuperar datos almacenados en esas bases de datos.

Además de su aplicación en Bases de Datos, SQL se utiliza bastante en el enfoque de **Análisis y Ciencia de Datos**, esto debido a que al ser relacional, permite ejecutar consultas que nos permiten obtener información con un formato perfecto para estas áreas.

En SQL existen varios tipos de comandos como los siguientes:

- DDL (Data Definition Language)
- DML (Data Manipulation Language)
- DCL (Data Control Language)
- TCL (Transactional Control Language)

Cada uno de estos tienen enfoques distintos en una base de datos SQL.

Si deseas obtener más información sobre qué sentencias utiliza cada uno de estos enfoques, puedes revisar el siguiente artículo en **[platzi.com](https://platzi.com/tutoriales/50-sql-mysql-2016/1564-que-es-ddl-dml-dcl-y-tcl-integridad-referencial/)**.

## SQL Bolt

El primer recurso que te comparto es **[SQLBolt](https://sqlbolt.com/)** el cual te enseña desde cero los conceptos básicos de SQL, desde una pequeña introducción sobre qué es SQL, todo lo que necesitas saber sobre consultas, subconsultas, JOIN's, u otras operaciones del DDL o DML.

Esta herramienta sirve mucho para personas principiantes en SQL o incluso como repaso de algunas operaciones del DDL y DML.
Personalmente esto me ayudó bastante a entender la manera en cómo funcionan las subconsultas y JOIN's, ya que estos son muy usados para filtrar información específica.

![SQLBolt](https://res.cloudinary.com/dovf1hs5j/image/upload/v1711744506/blog/articles/dfozsltkccxj0c7lflgq.png)

## The SQL Murder Mystery

Una vez ya hayas aprendido las operaciones básicas de SQL, puedes usar el siguiente recurso **[The SQL Murder Mystery](https://mystery.knightlab.com/)**, en este sitio, con los conocimientos previos que ya tienes de SQL, tratarás de resolver un misterio ejecutando consultas SQL hasta encontrar al culpable de ese misterio.

![The SQL Murder Mystery](https://mystery.knightlab.com/174092-clue-illustration.png)

Por último, te comparto una imagen que me ha ayudado mucho para comprender y recordar cómo funcionan y cuál es la sintaxis de los JOIN más comunes.

![SQL JOINS](https://substackcdn.com/image/fetch/w_1456,c_limit,f_webp,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0e377725-1e0a-400c-bab7-0099dbf1efb8_1280x1664.png)

Esta imagen proviene del sitio **[ByteByteGo](https://blog.bytebytego.com/p/ep90-how-do-sql-joins-work)** donde en el mismo artículo puedes encontrar más información sobre otros conceptos de SQL.

Recursos para aprender y entender sobre el funcionamiento de SQL.

Herramientas para aprender SQL

Muchas veces, a la hora de querer aprender sobre un área nueva de tecnología o programación, tenemos la duda de por donde o cómo comenzar, incluso, después de haber aprendido una tecnología o un lenguaje de programación nos preguntamos *"¿Qué es lo que sigue?"*. A lo que muchas veces los **Roadmaps** pueden ser de gran utilidad.

Un Roadmap es una guía sobre qué aprender y en qué orden hacerlo para llegar a una meta, la cual es poder aprender una nueva área de la tecnología, desde el frontend, backend, fullstack, diseño, algún lenguaje de programación, o incluso temas de inteligencia artificial.

**[Roadmap.sh](https://roadmap.sh/)**  es una de los sitios web más conocidos para encontrar muy buenos roadmapas para cualquier área de tecnología.

![Roadmap.sh website](https://res.cloudinary.com/dovf1hs5j/image/upload/v1712296082/blog/articles/mb3rt2gfitshbccm1qbk.png)

Cada roadmap en el sitio ofrece una visión general de los conceptos fundamentales, las herramientas, los lenguajes de programación y las habilidades necesarias para progresar en el campo elegido.
Además, incluye enlaces a recursos como cursos, tutoriales, libros, etc.

![Roadmap AI and Data Science](https://res.cloudinary.com/dovf1hs5j/image/upload/v1712296341/blog/articles/upwffzx6mvhuxnosfsq0.png)

Los roadmaps son una herramienta útil para aprender un nuevo tema o para darte una guía sobre cuál es el orden para alcanzar a aprender un nuevo campo de la tecnología.

Roadmaps para aprender a programar en cualquier área y/o lenguaje de programación.

Cómo aprender a programar

La Inteligencia Artificial ha dado mucho de qué hablar en los últimos años, lo que ha hecho que mucha gente no solo en el área de la tecnología, sino en otras áreas de trabajo, tenga un gran interés por aprender cómo usar estas tecnologías o incluso crearlas.

Siendo estudiante, no puedo dar como un hecho que tengo los mejores recursos para aprender sobre estos temas, pero quiero compartir algunas guías y recursos que he encontrado para estudiar y aprender sobre ello.
Te daré las herramientas y algunos puntos de vista de cómo los he usado yo.

**[AI and Data Scientist Roadmap](https://roadmap.sh/ai-data-scientist)** te da una guía sobre qué temas debes aprender y en qué orden, además de que incluye enlaces a recursos para aprender sobre cada tema por separado. Un resumen sobre el *Roadmap* es el siguiente:
### 1. Matemáticas:
- Álgebra lineal
- Probabilidad
- Estadística
### 2. Código
- Programación con Python
- Kaggle
- Estructuras de Datos
- SQL
### 3. Análisis Exploratorio de Datos (EDA)
- Análisis de Datos con Pandas
- Análisis Exploratorio de Datos con Seaborn
### 4. Machine Learing
- Cursos de Machine Learning
- Reconocimiento de Patrones y Machine Learning
### 5. Deep Learning
- Especialización en Deep Learning

Comparto también otro Roadmap del YouTuber *Rafa Gonzalez Gouveia* que lo divide en 4 bloques principales.

![Roadmap Rafa Gonzales Gouveia](https://user-images.githubusercontent.com/20340577/212917908-70660d2d-7d56-4f69-8fef-10589a03c3cb.png)

Puedes encontrar su Roadmap en su **[repositorio de GitHub](https://github.com/gonzalezgouveia/clases-youtube/blob/main/recursos/data_science_roadmap_2023.md)** o ver su **[vídeo de YouTube](https://youtu.be/x9PlR2CLxwY?si=0Inccy-4HnaDlbgi)** para tener una mejor explicación de él mismo.

Igualmente te doy un resumen de los temas por ver para este Roadmap.

### Bloque 0
- Conceptos sobre Data Science
### Bloque 1 Fundamentals
- Programación en Python
- Data Wrangling (organización / limpieza de datos)
- Matemáticas y Estadística
### Bloque 2 Análisis de Datos
- EDA
- Bases de Datos
### Bloque 3 MLOps
- Machine Learning
- Python y Programación Avanzada

De este mismo youtuber tiene un vídeo sobre **[libros para aprender sobre Data Science](https://youtu.be/xU9Usa7jS1U?si=PsvxwU6VKCg2w_2p)**.
Personalmente te recomiendo 2, los cuales son:

- **Python Data Science Handbook**

![Python Data Science Handbook](https://m.media-amazon.com/images/I/51SW8EM7PuL.jpg)
- **Practical Statistics for Data Scientists**

![Practical Statistics for Data Scientists](https://m.media-amazon.com/images/I/81Sdk02bg+L._AC_UF1000,1000_QL80_.jpg)

El siguiente **[Roadmap de Moataz Elmesmary](https://github.com/Moataz-Elmesmary/Data-Science-Roadmap)** donde habla sobre las diferencias entre Data Science, Data Analytics y Data Engineering. Además de las **herramientas específicas** que se ocupan para diferentes áreas y temas.

Te recomiendo también visitar el canal de **[Codificando Bits](https://www.youtube.com/@codificandobits)**, **[Pyninja](https://www.youtube.com/@pyninja)** y **[Santiago Fiorino](https://www.youtube.com/@santifiorino)** los cuales hablan sobre temas de Inteligencia Artificial y Machine Learning, tienen contenido muy visual haciendo el aprendizaje más dinámico para el espectador.
![Codificando Bits](https://res.cloudinary.com/dovf1hs5j/image/upload/v1714419879/blog/articles/utl4weakwxtbzgdpfh5p.png) ![Pyninja](https://res.cloudinary.com/dovf1hs5j/image/upload/v1714240442/blog/articles/k9tmegyobyykqxlomlk4.png)
![Santiago Fiorino](https://res.cloudinary.com/dovf1hs5j/image/upload/v1714240405/blog/articles/rwrsl0iwyajdthsaugnv.png)
Como último vídeo te comparto este titulado **[How I'd Learn AI (If I Had to Start Over)](https://youtu.be/TR7AGmey1C8?si=4_mwGwfjlqOsf5os)**, donde da consejos en base a experiencia personal de cómo y qué aprender.

Y, Finalmente, te comparto un recurso para prepararse con **[Trabajos en Data](https://ironhack.notion.site/Data-Job-Preparation-3b4da46b431e42efaa18700605c39da5)**.

## Consejos personales


Como consejos personales te recomiendo lo siguiente:
> Aprender lo necesario en matemáticas: **Álgebra lineal, Probabilidad y Estadística**

Estos temas se ven demasiado para temas de análisis de datos y comprender como se comportan los datos ante ciertas circunstancias.

> Programación en **Python**

Python es el lenguaje más usado para Inteligencia Artificial y Datos. También existe la alternativa con R, pero muchas veces este se usa en situaciones más específicas de investigación u otras cosas.
Python tiene muchas librerías bastante buenas como los son **NumPy, Pandas, SciPy, Matplotlib, Scikit Learn, entre otros**.

> Aprender **Inglés**

El inglés se usa bastante en cualquier área de la tecnología, por lo que es muy importante dominarlo tanto para comunicarse, como para tener la mejor información y recursos para aprender.

> **Proyectos en [Kaggle](https://www.kaggle.com/) y proyectos propios**

Puedes comenzar buscando proyectos y datasets en plataformas como *Kaggle* para poder practicar las habilidades conseguidas. Un consejo que he escuchado constantemente es crear un portafolio con proyectos propios y de preferencias con datos reales. 
>   Consultas en **SQL** 

Las consultas en SQL ayudan a comprender un mejor manejo de datos, esto también se puede hacer con librerías de Python como Pandas.

> Control de versiones con **Git**

Aprender control de versiones para el manejo del flujo de trabajo o para la seguridad y mantenimiento del trabajo que se haga. De la mano de esto, lo cual se hace en su mayoría con *Git* y de igual forma *GitHub* y/o *GitLab* para subir los proyectos en repositorios.

Roadmaps, guías y recursos para aprender sobre Inteligencia Artificial, Ciencia de Datos y Análisis de Datos.

Roadmap para Inteligencia Artificial y Data

En el mundo de la programación y de la tecnología como tal, siempre se busca una alta eficiencia en la realización de determinadas tareas. Muchas de estas tareas se relacionan indirectamente o directamente con el escribir en el teclado, para lo cual, entre más rápido y con menos errores será mucho más efectivo.

Aprender mecanografía no solo implica aumentar la velocidad de escritura, sino también desarrollar una técnica ergonómica que prevenga lesiones relacionadas con el trabajo repetitivo, como el síndrome del túnel carpiano. Los profesionales de la tecnología pasan largas horas frente a un teclado, por lo que es crucial aprender técnicas de mecanografía adecuadas para mantener la salud a largo plazo.

Por todas estas razones, **[Typing Club](https://www.typingclub.com/)** puede ser una gran herramienta para aprender sobre mecanografía.

![Typing Club Logo](https://res.cloudinary.com/dovf1hs5j/image/upload/v1715565373/blog/articles/gz0kuxrcy79iobtnsdpb.png)

En *Typing Club* puedes encontrar una guía de forma gratuita con más de 500 lecciones para aprender y practicar mecanografía, además de muchos otros juegos interactivos para practicar.

![Typing Club GIF](https://res.cloudinary.com/dovf1hs5j/image/upload/v1715565620/blog/articles/nxvso26ho67ueig2nh6a.gif)

Además de la mecanografía, otra manera de ser eficiente en cuanto al mundo de la programación es aprender atajos de teclado, ya sea de tu sistema operativo, el navegador o tus aplicaciones favoritas, como editores de código, entre otros.
En otro artículo te compartiré los atajos de teclado que más uso en el contexto de la programación. 🤓

La mecanografía es algo esencial en el mundo de la programación y la tecnología para tener mayor eficiencia en el tiempo de trabajo. En este artículo te presento una herramienta para mejorar tus habilidades de mecanografía.

Domina la escritura con ambas manos

Cuando comenzamos en el mundo de la programación, nos empiezan a decir términos que a veces no terminamos de comprender.
En Estructura de Datos podrías haber escuchado del término de *"Big-O"*. Este es un concepto dentro de la complejidad de los algoritmos, los cuales pueden dividirse en dos:
- Complejidad de tiempo
- Complejidad de memoria

Seguramente has visto la siguiente gráfica:
![Big-O Complexity](https://res.cloudinary.com/dovf1hs5j/image/upload/v1718922251/blog/articles/ankfptq6afnrs2bsoxrg.png)

Esta gráfica muestra cómo se comportan las operaciones en cuanto a la complejidad que tienen.

### ¿Para qué se necesita saber la complejidad?

Cuando creamos un algoritmo, muchas veces puede ser una respuesta correcta a un problema determinado, pero muchas veces existen *casos específicos* donde estos algoritmos no son eficientes o pueden fallar, o incluso nos limitamos a ciertas cosas que no dependen del programador, como los son el **tiempo y memoria** que pueden ocupar, por lo que se tiene que pensar en cómo mejorar los algoritmos incluso antes de escribir el código.
Es por eso que se busca una complejidad "baja" para estos casos.

La complejidad $$O(1)$$ es una complejidad constante, la cual es la complejidad más eficiente.
Entre más crezca la complejidad, más tiempo tardará en ejecutarse el código.

Tanto la complejidad del tiempo como la de memoria se pueden calcular a grandes razgos. En seguida te doy ejemplos de cómo tener una noción de cómo se calcula.

## Complejidad de tiempo
La complejidad de tiempo mide la cantidad de tiempo que un algoritmo tarda en ejecutarse en función del tamaño de la entrada. Describe el comportamiento asintótico del algoritmo a medida que el tamaño de la entrada crece.

1. **Identifica las operaciones básicas**: Encuentra las operaciones que consumen tiempo de manera significativa (comparaciones, asignaciones).
2. **Cuenta el número de operaciones básicas**: Estima el número de veces que se ejecutan estas operaciones en términos de $$n$$ (el tamaño de la entrada).
3. **Determina el término dominante**: En la expresión resultante, identifica el término que más crece a medida que $$n$$ aumenta.
4. **Expresa en notación Big-O**: Elimina constantes y coeficientes no dominantes y expresa el término dominante en notación Big-O.

~~~ cpp
for (int i = 0; i < n; i++) {
    // Operación básica
}
~~~
Aquí, la operación básica se ejecuta $$n$$ veces, por lo que la complejidad de tiempo es $$O(n)$$.

## Complejidad de memoria
La complejidad de memoria mide la cantidad de espacio de memoria que un algoritmo necesita en función del tamaño de la entrada.

1. **Identifica las variables y estructuras de datos**: Encuentra las variables y estructuras que el algoritmo utiliza.
2. **Cuenta la memoria utilizada**: Estima la cantidad de memoria utilizada por estas variables y estructuras en términos de $$n$$.
3. **Determina el término dominante**: Identifica el término que más crece a medida que nn aumenta.
4. **Expresa en notación Big-O**: Elimina constantes y coeficientes no dominantes y expresa el término dominante en notación Big-O.

~~~ cpp
int arr[n];
for (int i = 0; i < n; i++) {
    arr[i] = i;
}
~~~

Aquí, el arreglo `arr` ocupa $$n$$ espacios de memoria, por lo que la complejidad de memoria es $$O(n)$$.

La diferencia entre estas dos mediciones es que la complejidad de tiempo evalúa cuánto tiempo tarda un algoritmo en ejecutarse, mientras que la complejidad de memoria evalúa cuánta memoria necesita un algoritmo para ejecutarse.

La complejidad de tiempo y memoria son esenciales para evaluar la eficiencia de un algoritmo. Comprender cómo calcularlas te permitirá diseñar algoritmos más eficientes y seleccionar los más apropiados para tus necesidades.

Para finalizar, te dejo este recurso el cual es una página donde encuentras el gráfico mostrado de las complejidades de Big-O, la complejidad de algunas estructuras de datos y la complejidad de algunos algoritmos de ordenamiento.

➡️ **[Big-O Cheat Sheet](https://www.bigocheatsheet.com/)** ⬅️

Comprende las bases de la complejidad de tiempo y memoria de los algoritmos.

Encuentra lo que necesitas para convertirte en un experto en código

Herramientas, recursos y consejos para mejorar tus habilidades en programación y tecnología.

Artículos

Big-O ¿Qué es?