chapter2.Rmd

--- 
title_meta  : Capítulo 2
title       : Vectores
description : Vamos a ir a Las Vegas! donde aprenderemos como analizar los resultados de los juegos usando vectores en R! Después de completar este capítulo serás capaz de crear vectores en R, nombrarlos, seleccionar elementos de ellos y comparar diferentes vectores.

--- type:NormalExercise xp:100 key:9674d73d9c
## Creando vectores

Te sientes de suerte? 

Eso espero, porque en este capítulo vamos de viaje a la Ciudad del Pecado, también conocida como el *"Paraíso del estadístico"* ;-).

Gracias a R y a tus nuevas habilidades analíticas, vas a aprender cómo mejorar tus ganancias en el casino y empezar una lucrativa carrera como jugador profesional. En este capítulo veremos cómo puedes fácilmente llevar la cuenta de tus apuestas y como hacer análisis simples de tus jugadas. Próxima parada... Viva las Vegas!!!

*** =instructions
- Esperamos que recuerdes lo que aprendiste en el capítulo anterior. Asigna el valor `"Alla vamos!"` a la variable `Vegas`

*** =hint
Solo escribe lo siguiente en el editor:
```
Vegas <- "Alla vamos!"
```
Ten en cuenta que R distingue las mayúsculas de las minúsculas.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Define la variable Vegas
```

*** =solution
```{r eval=FALSE}
# Define the variable Vegas
Vegas <- "Alla vamos!"
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_object("Vegas", 
            undefined_msg = "Asegúrate de haber definido la variable <code>Vegas</code>.",
            incorrect_msg = "Asegúrate de haber asignado el valor correcto a la variable<code>Vegas</code>. Ten cuidado con las mayúsculas y minúsculas")
success_msg("Muy bien! Sigamos.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:70876ac6d8
## Creando vectores (2)

Primero concentrémonos.

En nuestro camino a para quebrar al casino, haremos uso extensivo de los vectores. Un vector es un arreglo unidimensional que puede contener datos numéricos, caracteres, o valores lógicos. En otras palabras un vector es una herramienta simple para guardar un conjunto de datos del mismo tipo. Por ejemplo podemos llevar la cuenta de las ganancias y pérdidas en los juegos de casino.

En R, se crea un vector con la función [`c()`](http://www.rdocumentation.org/packages/base/functions/c). La función se llama c por "combinar". Se ponen los valores o elementos del vector dentro de paréntesis, separados por coma. Por ejemplo:

```
vector_numerico <- c(1, 2, 3)
vector_caracter <- c("a", "b", "c")
vector_logico <- c(TRUE, FALSE)
```
Una vez has creado estos vectores en R puedes usarlos para hacer cálculos.

*** =instructions 
Completa el código de tal manera que el `vector_logico` contenga tres elementos: `TRUE`, `FALSE` y `TRUE` (en ese orden). 

*** =hint 
Asigna `c(TRUE,FALSE,TRUE)` a la variable `vector_logico` con el operador `<-`. Puedes utilizar las notaciones cortas `T` y `F` para `TRUE` y `FALSE` pero no es recomendable.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
vector_numerico <- c(1, 10, 49)
vector_caracter <- c("a", "b", "c")
# Completa el código para vector_logico
vector_logico <-
```

*** =solution
```{r eval=FALSE}
vector_numerico <- c(1, 10, 49)
vector_caracter <- c("a", "b", "c")
# Completa el código para vector_logico
vector_logico <- c(TRUE, FALSE, TRUE)
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_object("vector_numerico")
test_object("vector_caracter")
test_object("vector_logico",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_logico</code>.",
            incorrect_msg = "Aseg&#250;rate de haber asignado los valores correctos a <code>vector_logico</code>. El orden es importante!")
success_msg("Perfecto! notemos que agregar espacios despu&#233;s de las comas ayuda a que el c&#243;digo sea mas legible. Practiquemos un poco más con los vectores.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:74e329e45e
## Creando vectores (3)

Después de una semana en Las Vegas y cero Ferraris en tu garage, decides que es hora de empezar a utilizar tus super-poderes analíticos.

Antes de hacer un primer análisis, decides llevar un registro de todas tus ganancias y pérdidas de la semana pasada:

En el poker:
- Lunes: ganaste 140
- Martes: perdiste 50
- Miercoles: ganaste 20
- Jueves: perdiste 120
- Viernes: ganaste 240

En la ruleta: 
- Lunes: perdiste 24
- Martes: perdiste 50
- Miercoles: ganaste 100
- Jueves: perdiste 350
- Viernes: ganaste 10

Solamente has jugado poker y ruleta, porque un grupo de adivinos se ha apoderado de la mesa de dados. Para poder utilizar esos datos en R, decides crear las variables `vector_poker` y `vector_ruleta`.

*** =instructions
Asigna las pérdidas/ganancias en la ruleta a `vector_ruleta`.

*** =hint
El editor contiene el código para crear el `vector_poker`. Asigna los valores correctos al `vector_ruleta` usando los números presentados. No olvides que usamos números negativos para las pérdidas.

*** =sample_code

```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <-  
```

*** =solution

```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_object("vector_poker",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_poker</code>.",
            incorrect_msg = "Aseg&#250;rate de haber asignado los valores correctos a <code>vector_poker</code>.")
test_object("vector_ruleta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_ruleta</code>.",
            incorrect_msg = "Aseg&#250;rate de haber asignado los valores correctos a <code>vector_ruleta</code>.")
success_msg("Muy bien! revisa los contenidos en tus vectores, puedes hacerlo simplemente escribiendo el nombre de la variable en la consola y presionando enter. Sigamos, esto se pone interesante!")
```

*** =skills
1

---  type:NormalExercise xp:100 key:81e15ff44f
## Nombrando elementos

Como analista de datos, es importante tener una clara visión de que datos estas usando. Entender a qué se refiere cada elemento es por lo tanto esencial.

En el ejercicio anterior, creamos un vector con tus ganancias de la semana. Cada elemento del vector se refiere a cada día de la semana, pero es difícil decir que elemento corresponde a que día. Sería muy conveniente si pudiéramos mostrar esa información en el vector mismo.

Puedes dar nombres a los elementos de un vector con la función `names()` Mira este ejemplo:

```{r}
vector <- c("Perez", "Jugador de Poker")
names(vector) <- c("Apellido", "Profesion")
```

Este código primero crea el vector `vector` y luego le da nombres a los dos elementos. Al primer elemento `Perez` se le asigna el nombre `Apellido`, al segundo elemento le da el nombre `Profesion`. Nota que estamos asignando a `names(vector)` otro vector que contiene los nombres que deseamos dar a los elementos de `vector`. Al imprimir los contenidos del vector en la consola obtenemos:

```{r, echo = FALSE}
vector
```

*** =instructions
- Ahora asigna los días de la semana como nombres a los vectores `vector_poker` y `vector_ruleta`. Usa los nombres con mayúscula inicial y sin acentos (esto no es clase de ortografía...): Lunes, Martes, Miercoles, Jueves y Viernes.

- Imprime los vectores en la consola

*** =hint
Puedes usar `names(vector_poker)` para asignar nombres a los elementos de `vector_poker`. No olvides ni las mayúsculas ni las comillas al crear el vector de nombres:
```
c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
```

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}

# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Asigna los nombres a los vectores


# Imprime los vectores en la consola

```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Asigna los nombres a los vectores
names(vector_poker) <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_ruleta) <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")

# Imprime los vectores en la consola
vector_poker
vector_ruleta
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_object("vector_poker",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_poker</code>.",
            incorrect_msg = "No cambies los valores dentro de <code>vector_poker</code>; ya estaban escritos para ti.")
test_object("vector_ruleta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_ruleta</code>.",
            incorrect_msg = "No cambies los valores dentro de <code>vector_ruleta</code>; ya estaban escritos para ti")
test_object("vector_poker",
            eq_condition = "equal",
            incorrect_msg = "Aseg&#250;rate de haber asignado los nombres correctos a<code>vector_poker</code>.")
test_object("vector_ruleta",
            eq_condition = "equal",
            incorrect_msg = "Aseg&#250;rate de haber asignado los nombres correctos a <code>vector_ruleta</code>.")
test_output_contains("vector_poker", incorrect_msg = "Imprime vector_poker para que puedas ver sus contenidos, solo escribe vector_poker en el editor.")
test_output_contains("vector_ruleta", incorrect_msg = "Imprime vector_ruleta para que puedas ver sus contenidos, solo escribe vector_ruleta en el editor.")
success_msg("Bien hecho! Continuemos al siguiente ejercicio.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:edfb334946
## Nombrando elementos (2)

Si quieres ser un buen estadístico, tienes que ser un poco perezoso. (Si ya eres perezoso, quizás hayas nacido con esos excepcionales talentos estadísticos.)

En los ejercicios anteriores probablemente sentiste que es aburrido escribir una y otra vez información como los días de la semana. Sin embargo, existe una manera mas eficiente de lograr esto, que tal si asignamos el vector que contiene los días de la semana a una **variable**.

Así como lo hiciste con las ganancias/pérdidas de la ruleta y el poker, puedes también crear un vector que contenga los días de la semana. Al asignarlo a una variable, éste puede ser reusado.

*** =instructions
- Crea la variable `vector_dias` que contenga un vector con los días de la semana, de Lunes a Viernes.
- Usa la variable `vector_dias` para asignar nombres a los elementos de `vector_poker` y `vector_ruleta`.

*** =hint
Puedes usar `names(vector_poker)` para asignar nombres a los elementos de `vector_poker`. No olvides los parentesis al crear el vector `vector_dias`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Crea la variable vector_dias
vector_dias <- 
 
# Asigna los nombres a los elementos de vector_poker y vector_ruleta
names(vector_poker) <-   
names(vector_ruleta) <- 
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Crea la variable vector_dias
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
 
# Asigna los nombres a los elementos de vector_poker y vector_ruleta
names(vector_poker) <- vector_dias   
names(vector_ruleta) <- vector_dias
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_object("vector_poker",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_poker</code>.",
            incorrect_msg = "No cambies los valores de <code>vector_poker</code>; ya fueron escritos para ti")
test_object("vector_ruleta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_ruleta</code>.",
            incorrect_msg = "No cambies los valores de <code>vector_ruleta</code>; ya fueron escritos para ti")
test_object("vector_dias",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_dias</code>.",
            incorrect_msg = "Aseg&#250;rate de asignar los valores correctos a <code>vector_dias</code>.")
test_object("vector_poker",
            eq_condition = "equal",
            incorrect_msg = "Aseg&#250;rate de asignar los valores de  <code>vector_dias</code> como nombres de <code>vector_poker</code>.")
test_object("vector_ruleta",
            eq_condition = "equal",
            incorrect_msg = "Aseg&#250;rate de asignar los valores de <code>vector_dias</code> como nombres de <code>vector_ruleta</code>.")
success_msg("Bien hecho! Un consejo de programaci&#243;n: trata de evitar duplicar el c&#243;digo que ya has escrito, eso te har&#224; mucho m&#224;s productivo. Continuemos para ver c&#243;mo hacer aritm&#233;tica con vectores!")
```

*** =skills
1

--- type:NormalExercise xp:100 key:121375f169
## Calculando las ganancias totales

Ahora que tienes los resultados del poker y la ruleta en un vector con elementos apropiadamente nombrados, puedes empezar a hacer análisis.

Veremos como encontrar la siguiente información:
- La ganancia/pérdida total por cada día de la semana.
- La ganancia/pérdida total en la semana.
- Sabremos si estas ganando o perdiendo dinero en el poker y en la ruleta.

Para saber lo que nos proponemos tenemos que hacer cálculos aritméticos con los vectores. Cuando sumamos dos vectores en R, éste hace la suma elemento por elemento, por ejemplo las siguientes líneas de código son completamente equivalentes:

```
c(1, 2, 3) + c(4, 5, 6)
c(1 + 4, 2 + 5, 3 + 6)
c(5, 7, 9)
```

Primero experimentemos sumando!

*** =instructions
- Toma la suma de las variables `vector_A` y `vector_B` y asígnala a `vector_total`.
- Mira el resultado imprimiendo el valor de `vector_total` en la consola.

*** =hint
Usa el operador `+` para sumar `vector_A` y `vector_B`. Usa `<-` para asignar el resultado a `vector_total`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
vector_A <- c(1, 2, 3)
vector_B <- c(4, 5, 6)

# Asigna la suma de vector_A y vector_B
vector_total <- 
  
# Imprime el vector_total a la consola
vector_total
```

*** =solution
```{r eval=FALSE}
vector_A <- c(1, 2, 3)
vector_B <- c(4, 5, 6)

# Asigna la suma de vector_A y vector_B
vector_total <- vector_A + vector_B

# Imprime el vector_total a la consola
vector_total
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_object("vector_A")
test_object("vector_B")
test_object("vector_total",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_total</code>.",
            incorrect_msg = "Aseg&#250;rate de que <code>vector_total</code> contiene la suma de  <code>vector_A</code> y <code>vector_B</code>.")


success_msg("Buen trabajo! Continuemos.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:2b468bdaa1
## Calculando las ganancias totales (2)

¿Entendiste como R realiza aritmética con los vectores?

Ya es hora de tener uno de esos Ferraris en el garage! Primero, hay que saber cuál fue la ganancia/pérdida por cada día. La ganancia neta de cada día es la suma de las ganancias/pérdidas que hiciste en el poker y en la ruleta. 

En R, este cálculo es simplemente la suma de `vector_ruleta` y `vector_poker`.

*** =instructions
- Asigna a la variable `total_diario` lo que ganaste/perdiste cada día en total (poker y ruleta combinado).

- Nombra los elementos de `total_diario` utilizando `vector_dias`. 

- Imprime `total_diario` en la consola para que puedas ver tus resultados totales en cada día de la semana. Cuáles fueron los días buenos y los días malos?

*** =hint
Justo como en el ejercicio anterior, asigna la suma de los vectores a `total_diario`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Calculando las ganancias/pérdidas diarias:
total_diario <- 
  
# Dando nombres a total_diario
names(total_diario) <- 
  
# Imprime total_diario a la consola para ver tus resultados por día
  
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Calculando las ganancias/pérdidas diarias:
total_diario <- vector_poker + vector_ruleta

# Dando nombres a total_diario
names(total_diario) <- vector_dias
  
# Imprime total_diario a la consolo para ver tus resultados por día
total_diario

```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("total_diario", eq_condition = "equal",
            incorrect_msg = "Aseg&#250;rate de asignar la suma de <code>vector_poker</code> y <code>vector_ruleta</code> a <code>total_diario</code>. Tambi&#233;n tienes que nombrar los elementos de <code>total_diario</code> usando <code>vector_dias</code>.")
test_output_contains("total_diario", incorrect_msg = "Imprime <code>total_diario</code> para que puedas ver sus contenidos, solo escribe <code>total_diario</code> en el editor.")
success_msg("Bien! Vamos al siguiente ejercicio.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:9ab41c0ec1
## Calculando ganancias totales (3)

Basado en los análisis previos, parece que tuviste una mezcla de días buenos y malos. Esto no era lo que tu ego esperaba, y te preguntas si quizás hay una (muy pequeña) posibilidad de que hayas perdido dinero en la semana.

La función que nos ayudará a contestar esta pregunta es [`sum()`](http://www.rdocumentation.org/packages/base/functions/sum). Ésta función calcula la suma de todos los elementos de un vector. Por ejemplo para calcular (y asignar a una variable) el monto total de dinero que has ganado/perdido en el poker en la semana, escribe: 

```
total_poker <- sum(vector_poker)
```

*** =instructions
- Calcula el monto total de dinero que has ganado/perdido en la ruleta, asígnalo a la variable `total_ruleta`.
- Ahora que tienes los totales para la ruleta y el poker, puedes fácilmente calcular el valor de `total_semana`, que es la suma de todas las ganancias y pérdidas en la semana.
- Imprime el valor de `total_semana` a la consola. ¿En total ganaste o perdiste en la semana?

*** =hint
Usa la función `sum` para obtener el total de `vector_ruleta`. `total_semana` debe de ser la suma de `vector_ruleta` y `vector_poker`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de Poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Ganancias totales en el poker
total_poker <- sum(vector_poker)

# Ahora completa el código:
total_ruleta <-
total_semana <-
  
#Imprime el total que ganaste/perdiste en la semana
  
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Ganancias totales en el poker
total_poker <- sum(vector_poker)

# Ahora completa el código:
total_ruleta <-  sum(vector_ruleta)
total_semana <- total_ruleta + total_poker

#Imprime el total que ganaste/perdiste en la semana
total_semana
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("total_poker", 
            undefined_msg = "Aseg&#250;rate de definir la variable <code>total_poker</code>.",
            incorrect_msg = "Aseg&#250;rate de asignar a <code>total_poker</code> la suma de <code>vector_poker</code>.")
test_object("total_ruleta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>total_ruleta</code>.",
            incorrect_msg = "Aseg&#250;rate de asignar a <code>total_ruleta</code> la suma de  <code>vector_ruleta</code>.")
test_object("total_semana",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>total_semana</code>.",
            incorrect_msg = "Aseg&#250;rate de asignar a <code>total_semana</code> la suma de totales de los vectores.")

test_output_contains("total_semana", incorrect_msg = "Imprime <code>total_semana</code> para que puedas ver sus contenidos, solo escribe <code>total_semana</code> en el editor.")
success_msg("Bien! Eres muy bueno en R! aunque como vemos no te fue tan bien en el casino... no importa, vamos al siguiente ejercicio.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:c1329e546f
## Comparando ganancias totales

Mmmmm.... parece que estás perdiendo dinero. Que sorpresa! Hora de repensar tu estrategia! Esto va a requerir un análisis más profundo.

Después de una breve lluvia de ideas en el jacuzzi del hotel, piensas que una posible explicación puede ser que tus habilidades en la ruleta no están tan bien desarrolladas como las de poker. Así que talvez tus ganancias totales en el poker son más grandes (`>`) que en la ruleta.

*** =instructions
- Calcula `total_poker` y `total_ruleta` como en el ejercicio anterior.
- Fíjate si tus ganancias totales en el poker son más altas que en la ruleta haciendo una comparación. Asigna el resultado de esta comparación a la variable `respuesta`.
¿Cuál es tu conclusión? ¿Deberías dedicarte a la ruleta o al poker?
- Imprime `respuesta` a la consola.

*** =hint
Prácticamente ya calculaste la respuesta en el ejercicio anterior. Para saber si 6 es más grande que 5, escribe `6 > 5`. Esto devuelve un valor lógico (`TRUE`)  o bien `FALSE` para `6 < 5 `. 

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Ganancias totales en el poker y en la ruleta
total_poker <-
total_ruleta <-

# Probando si las ganancias en el poker son más altas que en la ruleta:
respuesta <-

# Imprime respuesta a la consola  
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Ganancias totales en el poker y en la ruleta
total_poker <- sum(vector_poker)
total_ruleta <- sum(vector_ruleta)

# Probando si las ganancias en el poker son más altas que en la ruleta:
respuesta <- total_poker > total_ruleta

# Imprime respuesta a la consola  
respuesta
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("total_poker", 
            undefined_msg = "Aseg&#250;rate de definir la variable <code>total_poker</code>.",
            incorrect_msg = "Aseg&#250;rate de asignar a <code>total_poker</code> la suma de <code>vector_poker</code>.")
test_object("total_ruleta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>total_ruleta</code>.",
            incorrect_msg = "Aseg&#250;rate de asignar a <code>total_ruleta</code> la suma de <code>vector_ruleta</code>.")
test_object("respuesta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>respuesta</code>.",
            incorrect_msg = "Parece que la variable respuesta no contiene el valor correcto. Lee las instrucciones cuidadosamente")
test_output_contains("respuesta", incorrect_msg = "Imprime <code>respuesta</code> para que puedas ver sus contenidos, solo escribe <code>respuesta</code> en el editor.")
success_msg("Buen trabajo! Continúa al siguiente ejercicio.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:6375c00c0d
## Seleccionando elementos: los buenos tiempos

La corazonada parece que fue cierta. Parece que te va mejor en el poker que en la ruleta.

Otro posible aspecto a investigar son tus resultados al comienzo de la semana comparados con los últimos días. Talvez te excediste en los tequilas al final de la semana...

Para responder esta pregunta, concentrémonos en solo unos elementos del `vector_total`. En otras palabras, nuestro objetivo es seleccionar elementos específicos de los vectores. Para seleccionar elementos de un vector (y luego matrices, data frames, etc.), puedes utilizar los corchetes. Entre corchetes indicamos los elementos que queremos seleccionar. Por ejemplo, para seleccionar el primer elemento de un vector, escribes `vector_poker[1]`. Para seleccionar el segundo elemento escribimos `vector_poker[2]`, etc.

*** =instructions
Asigna tu ganancia del Miércoles a la variable `poker_miercoles`

*** =hint
Miercoles es el tercer elemento del `vector_poker`, por lo tanto puede ser seleccionado así: `vector_poker[3]`.
Nota que el primer elemento tiene índice 1 no 0 como en muchos otros lenguajes de programación.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Asigna el valor de lo ganado el Miercoles en el poker
poker_miercoles <- 
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Asigna el valor de lo ganado el Miercoles en el poker
poker_miercoles <- vector_poker[3]
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("poker_miercoles", 
            undefined_msg = "Aseg&#250;rate de haber definido la variable <code>poker_miercoles</code>.",
            incorrect_msg = "Parece que <code>poker_miercoles</code> no contiene el valor correcto de <code>vector_poker</code>.")
success_msg("Vamos muy bien! Tambi&#233;n es posible seleccionar múltiples elementos de un vector, veamos como en el siguiente ejercicio!")
```

*** =skills
1

--- type:NormalExercise xp:100 key:05c342af5b
## Seleccionando elementos: los buenos tiempos (2)


¿Qué tal si analizamos los resultados en los días medios de la semana? 

Para seleccionar múltiples elementos de un vector, puedes hacerlo usando corchetes. En el ejercicio anterior pusimos un número, llamado **índice**, entre los corchetes y obtuvimos el elemento del vector correspondiente a ese índice. Para seleccionar varios elementos podemos utilizar otro vector cuyos elementos son los índices que deseamos seleccionar. Por ejemplo, para seleccionar el primero y el quinto elemento usamos el vector `c(1,5)` dentro de los corchetes. El siguiente código selecciona el primero y quinto elementos de `vector_poker`:

```
vector_poker[c(1,5)]
```

*** =instructions
- Asigna los resultados de obtenidos del poker de los días Martes, Miercoles y Jueves a la variable `dias_medios_poker`.
- Imprime el vector `dias_medios_poker` a la consola para ver sus elementos.

*** =hint
Usa el vector `c(2,3,4)` entre corchetes para seleccionar los elementos deseados `vector_poker`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
``` 

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Define la nueva variable:
dias_medios_poker <- 
  
# Imprime dias_medios_poker

```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Define la nueva variable:
dias_medios_poker <- vector_poker[c(2, 3, 4)]

# Imprime dias_medios_poker
dias_medios_poker
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("dias_medios_poker", 
            undefined_msg = "Aseg&#250;rate de definir la variable <code>dias_medios_poker</code>.",
            incorrect_msg = "Parece que <code>dias_medios_poker</code> no contiene los valores correctos de <code>vector_poker</code>.")
test_output_contains("dias_medios_poker", incorrect_msg = "Imprime <code>dias_medios_poker</code> para que puedas ver sus contenidos, solo escribe <code>dias_medios_poker</code> en el editor.")
success_msg("Bien hecho! Seleccionar elementos es de las operaciones m&#224;s importantes en R, y hemos aprendiendo mucho, pero falta m&#224;s aun");
```

*** =skills
1

--- type:NormalExercise xp:100 key:073de542e2
## Seleccionando elementos: los buenos tiempos (3)

Seleccionar varios elementos del `vector_poker` con `c(2,3,4)` quizás no sea muy conveniente.  Recordemos como estadísticos nuestras raíces perezosas, así que usemos una notación que R utiliza para crear vectores de números consecutivos `c(2,3,4)` se puede crear con el código `2:4`, que genera el vector que contiene los números naturales del 2 al 4 (incluyendo ambos extremos).

Así que ahora tenemos otra manera de seleccionar los elementos que corresponden a los días medios de la semana: `vector_poker[2:4]`.

Quizás en este ejemplo no haya mucha diferencia entre `c(2,3,4)` y `2:4` pero imagina que tuviéramos que extraer los primeros 80 elementos consecutivos de un vector, con la primera notación tendríamos que escribir todos los números del 1 al 80, sin embargo ahora sabemos que podemos hacerlo así de simple: `1:80`.

*** =instructions
- Asigna los resultados del Martes al Viernes del `vector_ruleta` a la variable `martes_a_viernes_ruleta`. Utiliza la notación de dos puntos`:`.
- Imprime `martes_a_viernes_ruleta` en la consola.

*** =hint
Asigna los elementos de `vector_ruleta` solicitados a `vector_ruleta` usando `2:5` entre corchetes.

*** =sample_code

```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Define la nueva variable siguiendo las instrucciones
martes_a_viernes_ruleta <- 

#Imprime martes_a_viernes_ruleta en la consola
```

*** =solution

```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Define la nueva variable siguiendo las instrucciones
martes_a_viernes_ruleta <- vector_ruleta[2:5]

#Imprime martes_a_viernes_ruleta en la consola
martes_a_viernes_ruleta
```

*** =sct

```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("martes_a_viernes_ruleta", 
            undefined_msg = "Aseg&#250;rate de haber definido <code>martes_a_viernes_ruleta</code>.",
            incorrect_msg = "Parece que <code>martes_a_viernes_ruleta</code> no contiene los valores correctos de <code>vector_ruleta</code>. Verifica que utilizaste los &#237;ndices correctos.")
test_output_contains("martes_a_viernes_ruleta", incorrect_msg = "Imprime <code>martes_a_viernes_ruleta</code> para que puedas ver sus contenidos, solo escribe <code>martes_a_viernes_ruleta</code> en el editor.")
success_msg("Fant&#224;stico! El operados dos puntos es muy &#250;til y se usa mucho en R. As&#237; que recu&#233;rdalo bien. Vamos al siguiente ejercicio")
```

*** =skills
1

--- type:NormalExercise xp:100 key:7da15e2b32
## Seleccionando elementos: los buenos tiempos (4)

Otra forma de abordar este problema es usar los nombres de los elementos (Lunes, Martes, etc.) en lugar de sus índices. Por ejemplo:

```
vector_poker["Lunes"]
```

Seleccionará el primer elemento de `vector_poker` porque el primer elemento es el que tiene el nombre "Lunes". De la misma manera en que lo hicimos en el ejercicio anterior, puedes utilizar un vector que tenga los nombres de los elementos que deseas extraer: 

```
vector_poker[c("Lunes","Martes")]
```

*** =instructions
Calcula tus ganancias promedio durante los primeros tres días de la semana seleccionando los elementos por nombre. Asigna este valor a `promedio_primeros3_dias`. Puedes usar la función [`mean()`](http://www.rdocumentation.org/packages/base/functions/mean) para obtener el promedio de los elementos de un vector.

*** =hint
Si usas `mean(vector_poker)` vas a obtener el promedio de todos los días. Pero recuerda que solo nos interesa el promedio de los primeros tres días.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

promedio_primeros3_dias <- 
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

promedio_primeros3_dias <- mean(vector_poker[c("Lunes", "Martes", "Miercoles")])
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("promedio_primeros3_dias", 
            undefined_msg = "Aseg&#250;rate de definir la variable <code>promedio_primeros3_dias</code>.",
            incorrect_msg = "Parece que <code>promedio_primeros3_dias</code> no tiene el valor correcto, intenta de nuevo.")
success_msg("Buen trabajo! Aparte de seleccionar elementos por índice y por nombre tambi&#233;n lo puedes hacer por comparación. En los siguientes ejercicios veremos como.");
```

*** =skills
1

--- type:NormalExercise xp:100 key:07424a76c0
## Selección por comparación - Paso 1

Al utilizar los operadores de comparación, podemos abordar las preguntas anteriores de una manera más interesante.

Los operadores de comparación en R son los siguientes:

- `<` menor que
- `>` mayor que
- `>=` mayor o igual que
- `==` igualdad
- `!=` no igual

Como ya hemos visto, `6 > 5` da un valor verdadero: `TRUE`. Una característica muy buena de R es que puedes utilizar operaciones de comparación también en vectores. por ejemplo `c(4,5,6) > 5` resulta en: `FALSE, FALSE, TRUE`. En otras palabras R hace la comparación por cada elemento y responde `TRUE` o `FALSE` dependiendo del resultado de la comparación. Esto es muy interesante y puede ser difícil de entender, practícalo en la consola!

Internamente, R *recicla* el valor `5` cuando ejecuta `c(4,5,6) > 5`. R quiere hacer una comparación elemento por elemento de `c(4,5,6)` con `5`, pero  `5` no es un vector de tamaño 3. Para resolver esto R crea el vector `c(5,5,5)` y luego hace la comparación elemento por elemento.

*** =instructions
Obtengamos los días en que obtuvimos valores positivos (> 0) en el poker (`vector_poker`) y asignémoslo a la variable `positivos_poker`.

*** =hint
Para obtener los días en que tuviste ganancias, R debe chequear cada elemento y decidir si es mayor que cero. El código `vector > 0` es la manera de conseguir esto.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Que días obtiviste ganancias en el poker?
positivos_poker <- 
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Que días obtuviste ganancias en el poker?
positivos_poker <- vector_poker > 0
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("positivos_poker", 
            undefined_msg = "Aseg&#250;rate de haber definido la variable <code>positivos_poker</code>.",
            incorrect_msg = "Parece que <code>positivos_poker</code> no tiene el resultado correcto. Recuerda que R usa operaciones elemento por elemento.")
success_msg("Bien! Algo equivalente a reciclar el valor <code>0</code> cinco veces y luego hacer la comparación es hacer la comparación con el vector `c(0,0,0,0,0)`, en ambos casos el resultado es el mismo.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:4db760f93d
## Selección por comparación - Paso 2

Trabajar con comparaciones hará tu vida analítica más fácil. En lugar de seleccionar "a mano" un conjunto de días para analizar (como en los primeros ejercicios), puedes decirle a R que te seleccione solo aquellos días en los que tuviste ganancias en el poker.

En el ejercicio anterior usaste `positivos_poker <- vector_poker >0` para encontrar aquellos días en los cuales tuviste ganancias. Ahora, nos gustaría saber no solo los días, sino las cantidades que ganaste en esos días.

Puedes seleccionar los elementos deseados usando `positivos_poker` entre corchetes para seleccionar los elementos de `vector_poker`. Esto funciona, porque R seleccionará solo aquellos elementos en los cuales el vector `positivos_poker` tiene un valor verdadero (`TRUE`).

*** =instructions
Asigna las ganancias en el poker a la variable `ganancias_poker`.

*** =hint
Usa el vector `positivos_poker` para elegir los elementos positivos del `vector_poker`, luego asigna el resultado a `ganancias_poker`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Que días obtuviste ganancias en el poker?
selection_vector <- vector_poker > 0

# Selecciona de vector_poker los días con ganancias
ganancias_poker <- 
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Que días obtiviste ganancias en el poker?
selection_vector <- vector_poker > 0

# Selecciona de vector_poker los días con ganancias
ganancias_poker <- vector_poker[selection_vector]
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("ganancias_poker",
            undefined_msg =  "Aseg&#250;rate de definir la variable <code>ganancias_poker</code>.",
            incorrect_msg =  "Parece que <code>ganancias_poker</code> No contiene el resultado adecuado, por favor intenta de nuevo.")
success_msg("Muy bien! Haz aprendido algo muy importante en R, seleccionar utilizando comparaciones y valores l&#243;gicos. Vamos al &#250;ltimo ejercicio!")
```

*** =skills
1

--- type:NormalExercise xp:100 key:72ff62da0f
## Selección Avanzada

Así como lo hiciste con el poker, también quisieras saber aquellos días en los que tuviste ganancia en la ruleta.

*** =instructions
- Asigna los valores de las ganancias que tuviste en la ruleta a la variable `ganancias_ruleta`. Es decir selecciona solo aquellos valores de `vector_ruleta` que son positivos y asignalos a la variable `ganancias_ruleta`.

*** =hint
Puedes consultar los dos ejercicios previos y hacer lo mismo, esta vez con `vector_ruleta`.


*** =pre_exercise_ocde
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Resultados en la mesa de poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Que días obtiviste ganancias en la ruleta?
positivos_ruleta <- 
  
# Selecciona los valores de vector_ruleta que fueron ganancias
```

*** =solution
```{r eval=FALSE}
# Resultados en la mesa de Poker en la semana
vector_poker <- c(140, -50, 20, -120, 240)

# Resultados en la ruleta en la semana
vector_ruleta <- c(-24, -50, 100, -350, 10)

# Dando nombres a vector_poker y vector_ruleta
vector_dias <- c("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")
names(vector_poker) <- vector_dias
names(vector_ruleta) <- vector_dias

# Que días obtuviste ganancias en la ruleta?
positivos_ruleta <- vector_ruleta > 0
  
# Selecciona los valores de vector_ruleta que fueron ganancias
ganancias_ruleta <- vector_ruleta[positivos_ruleta]
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies los valores o nombres de <code>vector_poker</code> y <code>vector_ruleta</code>."
test_object("vector_dias", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_poker", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_ruleta", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("positivos_ruleta", 
            undefined_msg = "Aseg&#250;rate de definir la variable <code>positivos_ruleta</code>.",
            incorrect_msg = "Parece que <code>positivos_ruleta</code> No contiene el resultado esperado. Por favor, intenta de nuevo.")
test_object("ganancias_ruleta",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>ganancias_ruleta</code>.",
            incorrect_msg = "Parece que <code>positivos_ruleta</code> no contiene el resultado esperado. Por favor, intenta de nuevo.")
success_msg("Excelente! Ahora sabemos lo b&#224;sico de los vectores, los cuales son estructuras de datos sumamente importantes en R. En el siguiente cap&#237;tulo introduciremos la versi&#243;n de dos dimensiones de los vectores: las matrices.")
```

*** =skills
1