### Install and Load R Packages

Source: https://aprendiendo-r-intro.netlify.app/que-es-r

Demonstrates how to install and load R packages. `install.packages()` downloads packages from CRAN, and `library()` loads them into the current R session for use.

```R
install.packages("nombre_paquete")
```

```R
library(ggplot2)
```

--------------------------------

### R Output Example: Seconds Calculation

Source: https://aprendiendo-r-intro.netlify.app/fechas

This snippet shows an example output from an R calculation, likely the result of the previous code. It displays the calculated number of seconds as a string prefixed with '[1] "'.

```R
[1] "12058S"
```

--------------------------------

### R: While Loop Example

Source: https://aprendiendo-r-intro.netlify.app/bucles

Illustrates the usage of a 'while' loop in R. The loop continues to execute as long as a specified condition is true. This example increments a counter and prints a message until the counter exceeds 5.

```r
ciclos <- 1
# Mientras el número de ciclos sea inferior 5, imprime
while(ciclos <= 5) {
  
  print(paste("Todavía no, vamos por el ciclo ", ciclos)) # Pegamos la frase al número de ciclo por el que vayamos con paste
  ciclos <- ciclos + 1
  
}
```

--------------------------------

### R: Infinite While Loop (Caution)

Source: https://aprendiendo-r-intro.netlify.app/bucles

Shows an example of a 'while' loop that creates an infinite loop because its condition (1 > 0) will always be true. It includes a warning about the potential for infinite loops and how to exit them using ESC.

```r
while (1 > 0) { # Nunca va a dejar de ser cierto
  
  print("Presiona ESC para salir del bucle")
  
}
```

--------------------------------

### Instalar el paquete bookdown en R

Source: https://aprendiendo-r-intro.netlify.app/index

Instala el paquete bookdown desde CRAN o desde su versión de desarrollo en GitHub. Bookdown se utiliza para elaborar informes y libros con una estructura similar de forma nativa en R.

```r
install.packages("bookdown")
# o desde su versión en desarrollo actualizada
# devtools::install_github("rstudio/bookdown")
```

--------------------------------

### Ejecución de código básico en R

Source: https://aprendiendo-r-intro.netlify.app/instalacionr

Este snippet muestra cómo realizar operaciones aritméticas simples en R, asignando valores a variables e imprimiendo el resultado. Es fundamental para iniciarse en la consola de R.

```R
a <- 1
b <- 2
a + b
```

--------------------------------

### Asignación de variables y suma en R

Source: https://aprendiendo-r-intro.netlify.app/instalacionr

Demuestra la asignación de valores a variables y la posterior suma de estas variables en la consola de R. Explica el uso del operador de asignación '<-' y cómo R muestra los resultados.

```R
a <- 1
b <- 2
a + b
```

```R
## [1] 3
```

--------------------------------

### Get Number of Rows and Columns in R

Source: https://aprendiendo-r-intro.netlify.app/datos

Shows how to directly obtain the number of rows and columns of a matrix in R using the nrow() and ncol() functions, respectively. These functions provide a more direct way to get individual dimensions compared to dim().

```R
nrow(datos_matriz)

```

```R
ncol(datos_matriz)

```

--------------------------------

### Transpose a Matrix in R

Source: https://aprendiendo-r-intro.netlify.app/datos

Explains and demonstrates how to get the transpose of a matrix in R using the t() function. Transposing swaps rows and columns.

```R
t(datos_matriz) # Matriz transpuesta

```

--------------------------------

### Instalar y cargar el paquete purrr

Source: https://aprendiendo-r-intro.netlify.app/listas

Instrucciones para instalar el paquete `purrr` desde CRAN y cargarlo en la sesión de R para su uso.

```R
# install.packages("purrr")
library(purrr)
```

--------------------------------

### R: While loop with a condition that is never met

Source: https://aprendiendo-r-intro.netlify.app/bucles

An example of a `while` loop in R where the condition (`conteo == 2`) is initially false and never becomes true. This demonstrates a loop that will not execute its body.

```R
conteo <- 1
while (conteo == 2) {
  
  print(conteo)
}
```

--------------------------------

### Iterar sobre filas de 'airquality' e imprimir temperatura usando un bucle for en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Este código utiliza un bucle `for` en R para iterar sobre las primeras 8 filas del conjunto de datos `airquality`. En cada iteración, imprime un mensaje formateado que incluye la temperatura de la fila actual, utilizando la función `glue` para la interpolación de cadenas.

```r
for (i in 1:8) {
  
  print(glue("La temperatura es de {airquality$Temp[i]}ºF"))
}
```

--------------------------------

### R: Asignar variables y multiplicar

Source: https://aprendiendo-r-intro.netlify.app/instalacionr

Asigna valores a dos variables 'a' y 'b' en R y luego realiza la multiplicación de estas variables en la consola.

```R
# Para poner comentarios en el código se usa #

# Definición de variables
a <- 2
b <- 5

# Multiplicación
a * b
```

```R
## [1] 10
```

--------------------------------

### R: Repeat Loop with break

Source: https://aprendiendo-r-intro.netlify.app/bucles

Shows the 'repeat' loop structure in R, which executes indefinitely until a 'break' condition is met. This example increments a counter and breaks the loop when the counter reaches 100.

```r
conteo <- 0
repeat { 
  
  conteo <- conteo + 1
  if (conteo >= 100) { break }
  
}
conteo
```

--------------------------------

### R: Check for even or odd numbers using modulo operator

Source: https://aprendiendo-r-intro.netlify.app/bucles

Demonstrates how to determine if a number is even or odd in R using the modulo operator (`%%`). It shows examples of calculating the remainder when dividing by 2.

```R
5 %% 2
```

```R
12 %% 2
```

```R
23 %% 2
```

```R
46 %% 2
```

--------------------------------

### Instalar y Cargar Paquete 'datasets' en R

Source: https://aprendiendo-r-intro.netlify.app/datos

Instala el paquete 'datasets' si no está presente y lo carga en la sesión de R para su uso. Este paquete proporciona conjuntos de datos de ejemplo.

```R
install.packages("datasets") # Descomentar si nunca se ha instalado
library(datasets)
```

--------------------------------

### R: Simple for loop iterating from 1 to 5

Source: https://aprendiendo-r-intro.netlify.app/bucles

A basic `for` loop in R that iterates from 1 to 5 and prints the current iteration number. This serves as a fundamental example of loop syntax and control flow.

```R
for (i in 1:5) {
  
  print(i)
}
```

--------------------------------

### Instalar un paquete en R

Source: https://aprendiendo-r-intro.netlify.app/que-es-r

Este código instala el paquete 'ggplot2' desde los repositorios de R. La instalación solo es necesaria la primera vez que se utiliza un paquete en un sistema. El proceso descarga el código del paquete y lo guarda localmente.

```r
install.packages("ggplot2")
```

--------------------------------

### R: Asignar variables y dividir

Source: https://aprendiendo-r-intro.netlify.app/instalacionr

Modifica el código para definir dos variables 'c' y 'd' con valores específicos y calcula su división en R.

```R
# Definición de variables
c <- 3
d <- -1

# División
c / d
```

```R
## [1] -3
```

--------------------------------

### R Function to Convert Fahrenheit to Celsius

Source: https://aprendiendo-r-intro.netlify.app/funs

Defines a function 'pasar_a_celsius' that converts a temperature from Fahrenheit to Celsius using the formula (ºF−32)∗59. The example also shows how to apply this function to a column in the 'airquality' dataset to create a new 'Temp_Celsius' column.

```r
# Definimos función
pasar_a_celsius <- function(x) {
  
  # Temperatura en Celsius
  x_celsius <- (x - 32) * (5 / 9)
  
  # Devolvemos la salida
  return(x_celsius)
}

# Aplicamos la función
pasar_a_celsius(0)

pasar_a_celsius(80)

# Aplicamos
data.frame(airquality,
           "Temp_Celsius" = pasar_a_celsius(airquality$Temp))
```

--------------------------------

### Suma y Operaciones Básicas con Vectores en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Instrucciones para definir vectores numéricos y realizar operaciones básicas como la suma de vectores y el conteo de elementos que cumplen una condición.

```r
# Vector de números
x <- c(1, 10, -1, 2)

# Suma
sum(x)
```

```r
# Vector de números
y <- c(5, -7, 8, -3)

# Suma
x + y
```

```r
sum((x + y) > 0)
```

```r
# Otra forma
suma <- x + y
sum(suma > 0)
```

--------------------------------

### Get Matrix Dimensions in R

Source: https://aprendiendo-r-intro.netlify.app/datos

Demonstrates how to retrieve the dimensions (rows and columns) of a matrix in R using the dim() function. It also shows how to access the number of rows and columns individually using indexing on the result of dim().

```R
dim(datos_matriz)

```

```R
dim(datos_matriz)[1]

```

```R
dim(datos_matriz)[2]

```

--------------------------------

### Instalar y cargar paquete owidR para datos de Our World in Data

Source: https://aprendiendo-r-intro.netlify.app/importar-exportar

Instala el paquete 'owidR' y lo carga en la sesión de R para acceder a datasets de Our World in Data. Requiere la instalación del paquete si no está presente.

```r
# install.packages("owidR")
library(owidR)
```

--------------------------------

### Acceder al Segundo Elemento de una Lista en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Accede al segundo elemento de una lista predefinida en R utilizando la indexación de corchetes dobles.

```R
# Accedemos al elemento dos
lista_ejemplo[[2]]
```

--------------------------------

### R: For loop with conditional addition/subtraction

Source: https://aprendiendo-r-intro.netlify.app/bucles

A `for` loop in R that runs 200 iterations, starting with 100 euros. In each iteration, it adds 3 euros if the current amount is even or subtracts 5 euros if it's odd, based on the remainder when divided by 2.

```R
dinero <- 100

# Bucle for
for (i in 1:200) {
  
  dinero <- ifelse(dinero %% 2 == 0, dinero + 3, dinero  - 5)
  
}
dinero
```

--------------------------------

### Sort Titanic Age Column Descending in R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

This R code snippet sorts the 'Age' column of the 'titanic' dataset in descending order. It utilizes the base R `sort` function with the `decreasing = TRUE` argument. The output shows the sorted ages, starting from the highest.

```R
sort(titanic$Age, decreasing = TRUE) # mayor a menor
```

--------------------------------

### R: Accediendo a la documentación de una función

Source: https://aprendiendo-r-intro.netlify.app/primeros-pasos

Muestra cómo utilizar el operador '?' en R para acceder a la documentación de ayuda de una función específica, como 'sqrt'. La ayuda se muestra en un panel dedicado, detallando su uso y argumentos.

```r
? sqrt
```

--------------------------------

### Consultar y listar archivos del directorio de trabajo en R

Source: https://aprendiendo-r-intro.netlify.app/proyecto

Permite consultar la ruta del directorio de trabajo actual con `getwd()` y listar los archivos y carpetas dentro de ese directorio con `dir()`.

```r
getwd()
dir()
```

--------------------------------

### Calculate Days Since Birth Date in R

Source: https://aprendiendo-r-intro.netlify.app/fechas

This R code snippet calculates the number of seconds that have passed since a specified birth date. It utilizes the `today()` function to get the current date and assumes a variable `cumple` holds the birth date. The result is the difference in seconds.

```R
seconds(today() - cumple)
```

--------------------------------

### R: Multiplicar y guardar resultado en variable

Source: https://aprendiendo-r-intro.netlify.app/instalacionr

Realiza la multiplicación de dos variables en R y guarda el resultado en una nueva variable 'c', mostrando luego el contenido de 'c'.

```R
# Variables
a <- 2
b <- 5

# Resultado
c <- a * b

# Muestro en consola
c
```

```R
## [1] 10
```

--------------------------------

### Instalar y cargar el paquete glue en R

Source: https://aprendiendo-r-intro.netlify.app/var-num

Instrucciones para instalar el paquete 'glue' por primera vez y para cargarlo en la sesión de R. Este paquete facilita la interpolación de variables en cadenas de texto.

```R
install.packages("glue") # solo la primera vez
```

```R
library(glue)
```

--------------------------------

### Acceder al primer elemento de una lista compleja en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Demuestra cómo acceder al primer elemento (fecha de nacimiento) de la lista `datos` utilizando el operador `[[1]]`.

```r
datos[[1]]
```

--------------------------------

### Instalar y usar el paquete microbenchmark en R

Source: https://aprendiendo-r-intro.netlify.app/operacionesvectores

Instala el paquete microbenchmark para comparar el rendimiento de diferentes fragmentos de código R. Luego, usa la función microbenchmark() para ejecutar y medir el tiempo de múltiples expresiones.

```r
install.packages("microbenchmark")
library(microbenchmark)
```

```r
x <- rnorm(1e3) # 1000 elementos aleatorias de una normal N(0, 1)
microbenchmark(sort(x), # primera forma
               x[order(x)], # segunda forma
               times = 1e3) # se repetirá 1000 veces
```

--------------------------------

### Función R de producto con argumento por defecto para cuadrado

Source: https://aprendiendo-r-intro.netlify.app/funs

Crea una función en R `funcion_producto` que calcula el producto de dos números. Por defecto, si solo se proporciona un argumento, calcula el cuadrado del número.

```R
# Definimos función
funcion_producto <- function(x, y = x) {
  
  # Multiplicamos
  producto <- x * y
  
  # Devolvemos la salida
  return(producto)
}

# Aplicamos la función
funcion_producto(3) # por defecto x = 3, y = 3
funcion_producto(3, -7)
```

--------------------------------

### Simular ganancia/pérdida de dinero con bucle for en R basado en paridad

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Este ejercicio en R implementa un bucle `for` de 200 iteraciones para simular un saldo de dinero. Comienza con 100 euros. Si el saldo actual es par, se suman 3 euros; si es impar, se restan 5 euros. Utiliza el operador `%%` para determinar la paridad.

```r
# dinero inicial
dinero <- 100

# Bucle for
for (i in 1:200) {
  
  dinero <- ifelse(dinero %% 2 == 0, dinero + 3, dinero  - 5)
  
}
dinero
```

--------------------------------

### Crear función de producto en R

Source: https://aprendiendo-r-intro.netlify.app/funs

Define una función en R llamada `funcion_producto` que toma dos argumentos y devuelve su producto. Se muestra cómo aplicar la función con valores de ejemplo.

```R
# Definimos función
funcion_producto <- function(x, y) {
  
  # Multiplicamos
  producto <- x * y
  
  # Devolvemos la salida
  return(producto)
}

# Aplicamos la función
funcion_producto(3, -7)
```

--------------------------------

### Operaciones binarias con map2 en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Realiza operaciones elemento a elemento entre dos listas usando la función map2 del paquete purrr, permitiendo la aplicación de funciones con múltiples argumentos. Requiere el paquete purrr.

```r
x <- list("a" = 1:3, "b" = 4:7)
y <- list("c" = c(-1, 4, 0), "b" = c(5, -4, -1, 2))

# dos listas como argumentos
map2(x, y, .f = function(x, y) { x^2 + y^2})
```

--------------------------------

### Aplicación de Funciones a Matrices en R (Suma y Media)

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Demuestra cómo aplicar funciones como 'sum' y 'mean' a matrices, tanto a nivel general como por filas o columnas, utilizando la función 'apply'.

```r
# Matriz
matriz <- matrix(1:12, nrow = 4)

# Suma por columnas
apply(matriz, MARGIN = 2, FUN = "sum")
```

```r
# Matriz
matriz <- matrix(1:12, nrow = 4)

# Suma por filas
apply(matriz, MARGIN = 1, FUN = "sum")
```

```r
# Matriz
matriz <- matrix(1:12, nrow = 4)

#  media de todos
mean(matriz)
```

```r
# Media por filas (MARGIN = 1 ya que es una operación por filas)
apply(matriz, MARGIN = 1, FUN = "mean")
```

```r
# Media por filas (MARGIN = 2 ya que es una operación por filas)
apply(matriz, MARGIN = 2, FUN = "mean")
```

--------------------------------

### Imprimir mensaje si alguna temperatura supera 100 (R)

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Verifica si alguna temperatura en el conjunto 'airquality' excede los 100 grados Fahrenheit. Si se cumple la condición, imprime un mensaje. Utiliza la función any().

```r
temperatura <- airquality$Temp

if (any(temperatura > 100)) { 
  print("Alguno de los registros tiene temperatura superior a 100 Farenheit")
}
```

--------------------------------

### Filtrar filas de airquality por mes 7 (Julio)

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Selecciona y muestra las filas del conjunto de datos 'airquality' donde el mes es igual a 7 (Julio). Utiliza la función subset() de R.

```r
filtro_fila <- subset(airquality, subset = Month == 7)
filtro_fila
```

--------------------------------

### Acceder a Múltiples Elementos de una Lista por Índice en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Extrae los elementos en las posiciones 1 y 4 de una lista R usando un vector de índices numéricos.

```R
# Accedemos al 1 y al 4
lista_ejemplo[c(1, 4)]
```

--------------------------------

### Instalar y cargar el paquete stringr en R

Source: https://aprendiendo-r-intro.netlify.app/var-num

Proporciona los comandos para instalar el paquete 'stringr' y cargarlo en R. Este paquete ofrece una amplia gama de funciones para la manipulación de cadenas de texto.

```R
# install.packages("stringr") # solo la primera vez
library(stringr)
```

--------------------------------

### Limpiar y desactivar warnings en R

Source: https://aprendiendo-r-intro.netlify.app/index

Limpia los warnings antiguos estableciendo 'last.warning' a NULL y desactiva las advertencias futuras para evitar que ensucien la ejecución en la consola. Útil para mantener la salida limpia durante la ejecución del código.

```r
assign("last.warning", NULL, envir = baseenv())
options(warn = -1)
```

--------------------------------

### Crear una lista básica en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Demuestra cómo crear una lista en R con diferentes tipos de datos y longitudes. Las listas son colecciones heterogéneas que pueden contener vectores, caracteres, números, u otras listas.

```r
variable_1 <- c("Paloma", "Gregorio")
variable_2 <- "Madrid"
variable_3 <- c(25, 30, 26)

lista <- list("progenitores" = variable_1,
              "lugar_nacimiento" = variable_2,
              "edades_hermanos" = variable_3)
lista
```

--------------------------------

### Acceder a múltiples elementos de una lista en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Muestra cómo usar el corchete simple `[i:j]` para seleccionar y extraer múltiples elementos de una lista, a diferencia del doble corchete que accede a un solo elemento.

```r
# Varios elementos
lista[1:2]
```

--------------------------------

### Crear y ejecutar un script simple en R

Source: https://aprendiendo-r-intro.netlify.app/primeros-pasos

Explica cómo crear un script de R (.R) para escribir y guardar código, evitando la pérdida de trabajo al cerrar RStudio. Se muestra un ejemplo de asignación de variables y una suma simple dentro de un script.

```R
a <- 1
b <-2
a + b
```

--------------------------------

### Verificar temperatura alta con if (R)

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Comprueba si alguna temperatura en el conjunto 'airquality' es superior a 90 grados Fahrenheit. Si es así, establece la variable 'temperatura_alta' a TRUE. Utiliza la función any().

```r
temperatura <- airquality$Temp
temperatura_alta <- FALSE
if (any(temperatura > 90)) {
  temperatura_alta <- TRUE
}
```

--------------------------------

### Verificar el tipo de dato de variables en R

Source: https://aprendiendo-r-intro.netlify.app/practica-final

Comprueba el tipo de dato de variables específicas dentro de un dataset R. Utiliza la función class() con el operador de acceso por nombre (\$).

```r
class(titanic$Name)
```

```r
class(titanic$Pclass)
```

```r
class(titanic$Age)
```

```r
class(titanic$Survived)
```

--------------------------------

### Instalar y Cargar Paquetes en R

Source: https://aprendiendo-r-intro.netlify.app/if-else

Demuestra cómo instalar un paquete (solo la primera vez) y luego cargarlo en la sesión actual de R usando library(). Se utiliza el paquete 'datasets' para acceder a datos como 'airquality'.

```R
install.packages("dataset") # solo la primera vez
library(datasets) # paquete con los datos
mes <- airquality$Month

if (mes == 2) {
  
  print("Ningún dato es del mes de enero")
  
}
```

--------------------------------

### Obtener la fecha actual en R con lubridate

Source: https://aprendiendo-r-intro.netlify.app/fechas

Muestra cómo obtener la fecha actual utilizando la función `today()` del paquete `lubridate`. Se demuestra la clase del objeto resultante y cómo realizar operaciones básicas como sumar días para obtener una fecha futura.

```R
# Obtener la fecha de hoy
hoy <- today()
class(hoy) # de clase fecha
```

```R
# Calcular la fecha dentro de una semana
hoy + 7
```

--------------------------------

### Visualizar una matriz en R

Source: https://aprendiendo-r-intro.netlify.app/datos

Muestra cómo utilizar la función `View()` en R para visualizar una matriz de datos en un formato similar a una hoja de cálculo, facilitando su inspección.

```R
View(datos_matriz)
```

--------------------------------

### Definir función de producto con argumento por defecto en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Define una función en R que calcula el producto de dos números. Si solo se proporciona un argumento, calcula el cuadrado del número. Utiliza un argumento con valor por defecto para lograr esta funcionalidad.

```r
# Definimos función
funcion_producto <- function(x, y = x) {
  
  # Multiplicamos
  producto <- x * y
  
  # Devolvemos la salida
  return(producto)
}

# Aplicamos la función
funcion_producto(3) # por defecto x = 3, y = 3

funcion_producto(3, -7)
```

--------------------------------

### Operaciones aritméticas básicas en R

Source: https://aprendiendo-r-intro.netlify.app/primeros-pasos

Demuestra cómo R puede ser utilizado como una calculadora para realizar operaciones aritméticas simples como la suma. El resultado se muestra directamente en la consola.

```R
1 + 2
```

--------------------------------

### Llamada a función con argumentos nombrados en R

Source: https://aprendiendo-r-intro.netlify.app/funs

Demuestra cómo llamar a una función en R especificando explícitamente los nombres de los argumentos para mejorar la legibilidad. Se utiliza la función `calcular_area` como ejemplo.

```R
calcular_area <- function(lado_1, lado_2) {
  return(lado_1 * lado_2)
}

# Equivalente a calcular_area(5, 3)
calcular_area(lado_1 = 5, lado_2 = 3)
```

--------------------------------

### Obtener fecha y hora actual en R

Source: https://aprendiendo-r-intro.netlify.app/fechas

Utiliza la función `now()` para obtener la fecha y hora actuales. Esta función proporciona información precisa del momento de ejecución.

```R
now()
```

--------------------------------

### R: Accessing Elements from a Returned List

Source: https://aprendiendo-r-intro.netlify.app/funs

Demonstrates how to call the R function that returns a list and how to access individual elements of the returned list, such as 'area', 'lado_1', and 'lado_2'.

```R
salida <- calcular_area(5, 3)
salida

salida["area"]

salida["lado_1"]
```

--------------------------------

### Crear una lista compleja con datos de estudiante en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Ejemplo práctico de cómo crear una lista más compleja para almacenar datos de un estudiante, incluyendo fecha de nacimiento, notas (como un data.frame), números de teléfono y nombres de padres.

```r
# Fecha de nacimiento
fecha_nacimiento <- as_date("1989-09-10")

# Notas de asignaturas en primer y segundo parcial
notas <- data.frame("biología" = c(5, 7), "física" = c(4, 5),
                    "matemáticas" = c(8, 9.5))
row.names(notas) <- # Nombre a las filas
  c("primer_parcial", "segundo_parcial")

# Números de teléfono
tlf <- c("914719567", "617920765", "716505013")

# Nombres
padres <- c("Juan", "Julia")

# Guardamos TODO en una lista (con nombres de cada elemento)
datos <- list("nacimiento" = fecha_nacimiento,
              "notas_insti" = notas, "teléfonos" = tlf,
              "nombre_padres" = padres)
datos
```

--------------------------------

### Crear y mostrar una lista en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Demuestra cómo crear una lista en R con diferentes tipos de datos (nombre, apellidos, edad, estado civil) y cómo mostrar su contenido.

```r
lista_personal <- list("nombre" = "Javier",
                       "apellidos" = "Álvarez Liébana",
                       "edad" = 32,
                       "soltero" = TRUE)
lista_personal
```

--------------------------------

### Comparar map vs lapply con microbenchmark en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Compara el tiempo de ejecución entre la función map del paquete purrr y la función lapply nativa de R para aplicar una función a cada elemento de una lista. Requiere el paquete purrr y la función microbenchmark.

```r
microbenchmark(map(x, .f = function(x) { mean(x^2) }),
               lapply(x, FUN = function(x) { mean(x^2) }),
               times = 1e3)
```

--------------------------------

### Definir y acceder a una lista compleja en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Crea una lista en R que contiene diferentes tipos de datos, incluyendo un data frame, y demuestra cómo acceder a sus elementos por índice numérico y por nombre. No requiere paquetes adicionales.

```r
# Ejemplo: lista con texto, numérico, lógico y un data.frame
lista_ejemplo <- list("nombre" = "Javier", "cp" = 28019,
                      "soltero" = TRUE,
                      "notas" = data.frame("mates" = c(7.5, 8, 9),
                                           "lengua" = c(10, 5, 6)))
lista_ejemplo
```

```r
# Longitud
length(lista_ejemplo)
```

```r
# Accedemos al elemento dos
lista_ejemplo[[2]]
```

```r
# Accedemos al 1 y al 4
lista_ejemplo[c(1, 4)]
```

```r
# Accedemos al 1 y al 4
lista_ejemplo$nombre
```

```r
lista_ejemplo$notas
```

```r
lista_ejemplo[c("nombre", "notas")]
```

--------------------------------

### Acceder a elementos de una lista en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Demuestra cómo acceder a elementos específicos dentro de una lista R, utilizando tanto la notación de dólar '$' para nombres de elementos como la doble corchete '[[]]' para índices numéricos.

```R
datos$nacimiento
```

```R
datos[[2]]
```

--------------------------------

### Crear función de suma en R

Source: https://aprendiendo-r-intro.netlify.app/funs

Define una función en R llamada `funcion_suma` que toma dos argumentos y devuelve su suma. Se muestra cómo aplicar la función con valores de ejemplo.

```R
# Definimos función
funcion_suma <- function(x, y) {
  
  # Sumamos
  suma <- x + y
  
  # Devolvemos la salida
  return(suma)
}

# Aplicamos la función
funcion_suma(3, 7)
```

--------------------------------

### Manipulación de Matrices en R: Creación, Operaciones y Transposición

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Crea matrices de ceros, realiza operaciones aritméticas (suma y división) sobre ellas, y calcula su transpuesta, obteniendo también sus dimensiones.

```r
# Matriz
x <- matrix(0, nrow = 3, ncol = 7)
x
```

```r
# Matriz
x <- matrix(0, nrow = 3, ncol = 7)
x
```

```r
(x + 1) / 5
```

```r
# Transpuesta
t(x)
```

```r
# Dimensiones transpuesta: pasa de ser 3x7 a 7x3
dim(t(x))
```

```r
ncol(t(x)) # número de columnas de la transpuesta
```

```r
nrow(t(x)) # número de filas de la transpuesta
```

--------------------------------

### Crear y acceder a listas anidadas en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Explica cómo crear listas que contienen otras listas y cómo navegar a través de estos niveles anidados utilizando la notación de doble corchete '[[]]'.

```R
lista_de_listas <- list("lista_1" = datos[3:4], "lista_2" = datos[1:2])
names(lista_de_listas) # Nombres de los elementos del primer nivel
```

```R
names(lista_de_listas[[1]]) # Nombres de los elementos guardados en el primer elemento, que es a su vez una lista
```

```R
lista_de_listas[[1]][[1]] # Elemento 1 de la lista guardada como elemento 1 de la lista superior
```

--------------------------------

### Función R que modifica variable globalmente con doble asignación

Source: https://aprendiendo-r-intro.netlify.app/funs

Muestra cómo usar la doble asignación (`<<-`) en R dentro de una función para modificar una variable en el entorno global. Se ejemplifica con dos variables, `x` y `y`.

```R
x <- 1
y <- 2
funcion_ejemplo <- function() {
  
  x <- 3 # no cambia globalmente, solo localmente
  y <<- 0 # cambia globalmente
  print(x)
  print(y)
}

funcion_ejemplo() # lo que vale dentro

x # lo que vale fuera

y # lo que vale fuera
```

--------------------------------

### R: 'for' loop with 'glue' for formatted output

Source: https://aprendiendo-r-intro.netlify.app/bucles

Shows how to use a 'for' loop in R along with the 'glue' package to create and print formatted strings, combining names and ages.

```R
library(glue)

nombres <- c("Javi", "Laura", "Carlos", "Lucía", "Mar")
edades <- c(32, 51, 18, 43, 29)

# Recorremos cada uno de los 5 elementos e imprimimos un
# mensaje que depende de ese índice i
for (i in 1:5) { 
  
  print(glue("{nombres[i]} tiene {edades[i]} años")) 
  
}
```

--------------------------------

### Visualizar las primeras filas de un data.frame en R

Source: https://aprendiendo-r-intro.netlify.app/importar-exportar

La función head() se utiliza para mostrar las primeras filas de un data.frame, lo cual es útil para una inspección rápida de los datos cargados.

```R
head(titanic)
```

--------------------------------

### Fijar directorio de trabajo automáticamente en R

Source: https://aprendiendo-r-intro.netlify.app/proyecto

Establece el directorio de trabajo automáticamente a la ruta del script actual utilizando `rstudioapi::getSourceEditorContext()$path` y `dirname()`. Esto asegura que el código funcione independientemente de la ubicación de la carpeta.

```r
# Fijamos directorio de trabajo automáticamente
setwd(dirname(rstudioapi::getSourceEditorContext()$path))
```

--------------------------------

### Verificar si la suma de dos números es par en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Desarrolla una función en R que reciba dos números, `x` e `y`. La función suma ambos números y devuelve `TRUE` si la suma es par (el resto de la división entre 2 es 0), y `FALSE` en caso contrario. Utiliza el operador `%%` para obtener el resto.

```r
# Definimos función pares <- function(x, y) {
  
  # Sumamos
  suma <- x + y
  
  # Comprobamos si es par
  par <- suma %% 2 == 0
  
  # Devolvemos la salida
  return(par)
}

# Aplicamos la función
pares(1, 3) # suma 4 (par)

pares(2, 7) # suma 9 (impar)
```

--------------------------------

### Crear una lista personal con información básica en R

Source: https://aprendiendo-r-intro.netlify.app/listas

Define una lista en R que almacena información personal como nombre, apellidos, edad y estado civil. No requiere paquetes adicionales.

```r
# Creamos lista: con lubridate calculamos la diferencia de años desde la fecha de nuestro nacimiento hasta hoy (sea cuando sea hoy)
lista_personal <- list("nombre" = "Javier",
                       "apellidos" = "Álvarez Liébana",
                       "edad" = 32,
                       "soltero" = TRUE)
lista_personal
```

--------------------------------

### Especificar formato de fecha en R con as_date

Source: https://aprendiendo-r-intro.netlify.app/fechas

Explica cómo usar el argumento `format` en la función `as_date` para manejar diferentes formatos de entrada de fechas. Se proporcionan ejemplos de formatos comunes como día-mes-año y mes-día-año, incluyendo formatos con años de dos y cuatro dígitos.

```R
# Convertir fecha con formato día-mes-año (4 cifras)
as_date("10-03-2020", format = "%d-%m-%Y")
```

```R
# Convertir fecha con formato día-mes-año (2 cifras)
as_date("10-03-20", format = "%d-%m-%y")
```

```R
# Convertir fecha con formato mes-día-año (4 cifras)
as_date("03-10-2020", format = "%m-%d-%Y")
```

```R
# Convertir fecha escrita con formato específico
as_date("Octubre 21, 1995 21:24", format = "%B %d, %Y %H:%M")
```

--------------------------------

### Imprimir mensaje si ningún dato es de enero (R)

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Utiliza una estructura if con la función all() para verificar si todos los datos en el conjunto 'airquality' no pertenecen a enero. Si la condición se cumple, imprime un mensaje específico. Requiere el paquete 'datasets'.

```r
library(datasets)
mes <- airquality$Month

if (all(mes != 1)) { 
  print("Ningún dato es del mes de enero")
}
```

--------------------------------

### Aplicar funciones a filas y columnas de una matriz en R

Source: https://aprendiendo-r-intro.netlify.app/datos

Muestra el uso de la función `apply()` en R para ejecutar una función especificada (como `mean`) sobre cada fila (`MARGIN = 1`) o columna (`MARGIN = 2`) de una matriz. Se incluye el manejo de valores ausentes (`NA`) con `na.rm = TRUE`.

```R
# Media (mean) por columnas (MARGIN = 2)
apply(datos_matriz, MARGIN = 2, FUN = "mean")

```

```R
# Media por filas (MARGIN = 1)
apply(datos_matriz, MARGIN = 1, FUN = "mean")

```

```R
# Nos devolverá ausente porque en ambas columnas tenemos
apply(datos_matriz_bis, MARGIN = 2, FUN = "mean")

```

```R
# Media por columnas (MARGIN = 2) ignorando los ausentes
apply(datos_matriz_bis, MARGIN = 2, FUN = "mean", na.rm = TRUE)

```

--------------------------------

### Ordenación y Búsqueda en Vectores R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Cómo ordenar un vector numérico en R utilizando `sort()` y `order()`, y cómo encontrar los índices del valor mínimo y máximo en un vector.

```r
# Ordenamos el vector (con sort)
sort(x)
```

```r
# Ordenamos el vector  (con order)
x[order(x)]
```

```r
x<- c(1, 10, -1, 2)

# Encontrando el lugar que ocupa el máximo y mínimo
which.max(x)
```

```r
which.min(x)
```

--------------------------------

### Acceder a Elementos de una Lista por Nombre en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Demuestra cómo acceder a elementos específicos de una lista R utilizando sus nombres (ej. $nombre, $notas) y también seleccionando por nombre usando corchetes.

```R
# Accedemos al 1 y al 4
lista_ejemplo$nombre
```

```R
lista_ejemplo$notas
```

```R
lista_ejemplo[c("nombre", "notas")]
```

--------------------------------

### Análisis del Dataframe 'airquality' en R

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Muestra cómo cargar el paquete 'datasets', obtener los nombres de las variables de un dataframe y determinar sus dimensiones (filas y columnas).

```r
library(datasets)
names(airquality)
```

```r
# Dimensiones
dim(airquality)
```

```r
nrow(airquality)
```

```r
ncol(airquality)
```

--------------------------------

### R: Apply Function with Default Argument

Source: https://aprendiendo-r-intro.netlify.app/funs

Shows how to use the 'calcular_area' function in R, demonstrating both calculating the area of a square (using the default second argument) and a rectangle (by providing both arguments).

```R
calcular_area(lado_1 = 5) # cuadrado: si no indicamos nada, lado_2 = lado_1

calcular_area(lado_1 = 5, lado_2 = 7) # rectángulo

```

--------------------------------

### Comparar rendimiento: Vectorización vs. Bucle vs. sqrt

Source: https://aprendiendo-r-intro.netlify.app/listas

Utiliza `microbenchmark` para comparar la velocidad de la función `sqrt()` vectorizada, un bucle `for` y la aplicación de `sqrt` elemento por elemento.

```R
library(microbenchmark)
x <- 1:1000
y <- sqrt(x) # vectorizado

# bucle
for (i in 1:1000) { y[i] <- sqrt(x[i]) }

microbenchmark(sqrt(x), for (i in 1:1000) { y[i] <- sqrt(x[i]) }, times = 1e3)
```

--------------------------------

### Calcular la media de elementos de lista con purrr::map

Source: https://aprendiendo-r-intro.netlify.app/listas

Demuestra el uso de `purrr::map()` para calcular la media de cada vector dentro de una lista de vectores generados aleatoriamente.

```R
library(purrr)
x <- list(rnorm(n = 1e3, mean = 0, sd = 1),
          rnorm(n = 1e3, mean = 2, sd = 1))
map(x, mean)
```

--------------------------------

### R: Asignar y multiplicar variables

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Asigna valores numéricos a variables 'a' y 'b' y luego multiplica estas variables en la consola de R.

```R
# Definición de variables
a <- 2
b <- 5

# Multiplicación
a * b
```

--------------------------------

### R: Raíz cuadrada de variables

Source: https://aprendiendo-r-intro.netlify.app/ejercicios-recopilados

Calcula la raíz cuadrada de tres variables 'a', 'b', y 'c' en R, demostrando el manejo de números positivos y negativos.

```R
# Variables
a <- 1
b <- -2
c <- 3

# Resultado
sqrt(a)
sqrt(b)
sqrt(c)
```

--------------------------------

### Cargar un paquete en R

Source: https://aprendiendo-r-intro.netlify.app/que-es-r

Este comando carga un paquete previamente instalado (en este caso, 'ggplot2') en la sesión actual de R. Esto permite acceder a las funciones y datos contenidos en el paquete para su uso. Debe ejecutarse cada vez que se inicia una nueva sesión de R y se desea utilizar un paquete específico.

```r
library(ggplot2)
```

--------------------------------

### Suma por filas y columnas de una matriz en R

Source: https://aprendiendo-r-intro.netlify.app/datos

Muestra cómo utilizar la función `apply` para calcular la suma de los elementos por filas (MARGIN = 1) y por columnas (MARGIN = 2) de una matriz. Permite realizar operaciones de agregación eficientes.

```R
# Matriz
matriz <- matrix(1:12, nrow = 4)

# Suma por filas
apply(matriz, MARGIN = 1, FUN = "sum")

# Suma por columnas
apply(matriz, MARGIN = 2, FUN = "sum")
```