feat: add content for slices and integers, update navigation paths

Author: Phosphorus-M

content/10.bool-and-float.md

@@ -16,6 +16,7 @@ initialCode: |
 tests:
     - should be contain `.`
     - should be contain `true` `false`
+    - code should be contain `true` `false`
 order: 10
 ---
 # Tipos de datos

content/11.characters.md

@@ -1,5 +1,5 @@
 ---
-nextPath: ""
+nextPath: "slice-string"
 previousPath: "bool-and-float"
 initialCode: |
     fn main() {

content/12.slice-string.md

@@ -0,0 +1,93 @@
+---
+nextPath: ""
+previousPath: "characters"
+initialCode: |
+    fn main() {
+        let texto = "Ejercitando en Rustlings Web";
+
+        let slice1 = 
+        let slice2 =
+
+        println!("{slice1}");
+        println!("{slice2}");
+    }
+expectedResponse: "Ejercitando\nRust\n"
+order: 12
+---
+
+# Tipos de datos: Slices de cadena (`&str`)
+
+En Rust, además de los caracteres (`char`), existe una forma muy común de representar texto: el **slice de cadena** o `&str`.
+
+---
+
+## 🔹 ¿Qué es un `&str`?
+
+Un `&str` es una **vista inmutable sobre una cadena de texto**.
+
+* Se suele usar para literales de cadena (`"hola"`).
+* No lo podemos modificar.
+* Se guarda como una **referencia** a una secuencia de bytes UTF-8.
+
+👉 Piensa en `&str` como un "texto prestado": está ahí, puedes leerlo, pero no puedes cambiarlo.
+
+---
+
+## Ejemplo básico
+
+```rust
+fn main() {
+    let saludo: &str = "Hola mundo";
+
+    println!("Saludo: {saludo}");
+}
+```
+
+Salida:
+
+```sh [salida]
+Saludo: Hola mundo
+```
+
+También podemos crear slices a partir de otros `&str`:
+
+```rust
+fn main() {
+    let texto: &str = "Aprendiendo Rust";
+    let slice1: &str = &texto[0..11]; // "Aprendiendo"
+    let slice2: &str = &texto[12..16]; // "Rust"
+
+    println!("Slice 1: {slice1}");
+    println!("Slice 2: {slice2}");
+}
+```
+
+Salida:
+
+```sh [salida]
+Slice 1: Aprendiendo
+Slice 2: Rust
+```
+
+---
+
+## 🔹 Recapitulemos
+
+* `&str` representa una **cadena inmutable**, comúnmente usada para literales (`"hola"`).
+* Es el tipo más **ligero y eficiente** para representar cadenas de texto, ya que no necesita asignar memoria dinámica.
+* Podemos obtener `&str` a partir de:
+
+  * Un literal (`"texto"`).
+  * Un slice de otro `&str` (`texto[0..4]`).
+
+👉 En capítulos posteriores veremos cómo combinar `&str` y `String` para trabajar con texto mutable y prestado al mismo tiempo.
+
+---
+
+## ✍️ Ejercicio
+
+1. Declara un `&str` con el valor `"Ejercitando en Rustlings Web"`.
+2. Crea un slice con la palabra `"Ejercitando"`.
+3. Crea otro slice con la palabra `"Rust"`.
+4. Imprime ambos slices con `println!`.
+5. 👉 No modifiques los `println!` que ya están en el código base.

content/13.integers.md

@@ -0,0 +1,145 @@
+---
+nextPath: ""
+previousPath: "slice-string"
+initialCode: |
+    fn main() {
+        let entero_negativo
+        let entero_positivo
+        let entero_mil 
+
+        let suma = entero_negativo + entero_positivo + entero_mil;
+        let multiplicacion = entero_negativo * entero_positivo * entero_mil;
+
+        // No modificar esto 👀
+        println!("Suma: {suma}");
+        println!("Multiplicación: {multiplicacion}");
+    }
+tests:
+    - code should be contain `i8`
+    - code should be contain `u16`
+    - code should be contain `i32`
+    - code should be contain `Suma: `
+    - code should be contain `Multiplicación: `
+order: 13
+---
+
+# Tipos de datos: Enteros
+
+En Rust, además de los booleanos, flotantes, caracteres (`char`) y los slices (`&str`), tenemos otros tipos **escalares**.
+Los escalares representan un único valor simple, no una colección.
+Los más comunes son: **enteros, flotantes, booleanos y caracteres**.
+
+## 🔹 Enteros
+
+Los enteros son números sin parte decimal.
+En Rust existen varios tamaños, tanto **con signo** (`i`) como **sin signo** (`u`):
+
+* `i8`, `i16`, `i32`, `i64`, `i128`, `isize` → con signo (pueden ser negativos).
+* `u8`, `u16`, `u32`, `u64`, `u128`, `usize` → sin signo (solo positivos).
+
+👉 El número indica la **cantidad de bits** que ocupa en memoria.
+Por ejemplo:
+
+* `i8` → son numeros en el rango de -128 a 127.
+* `u8` → son numeros en el rango de 0 a 255.
+* `i32` → son numeros en el rango de -2,147,483,648 a 2,147,483,647.
+
+---
+
+## Ejemplo básico
+
+```rust
+fn main() {
+    let positivo: u32 = 42;
+    let negativo: i32 = -42;
+
+    println!("Número positivo: {positivo}");
+    println!("Número negativo: {negativo}");
+}
+```
+
+Salida:
+
+```sh [salida]
+Número positivo: 42
+Número negativo: -42
+```
+
+---
+
+## 🔹 Operaciones con enteros
+
+Podemos realizar operaciones aritméticas básicas:
+
+```rust
+fn main() {
+    let a: i32 = 10;
+    let b: i32 = 3;
+
+    println!("Suma: {}", a + b);
+    println!("Resta: {}", a - b);
+    println!("Multiplicación: {}", a * b);
+    println!("División: {}", a / b);
+    println!("Módulo: {}", a % b);
+}
+```
+
+---
+
+## 🔹 Literales de enteros
+
+Rust permite escribir enteros en distintos formatos:
+
+```rust
+fn main() {
+    let decimal = 98_222;     // decimal (los _ son separadores)
+    let hexadecimal = 0xff;   // hexadecimal
+    let octal = 0o77;         // octal
+    let binario = 0b1111_0000; // binario
+    let byte = b'A';          // byte (u8 con valor ASCII)
+
+    println!("{decimal}, {hexadecimal}, {octal}, {binario}, {byte}");
+}
+```
+
+Los cuales no suelen ser formatos tipicos pero estan disponibles.
+
+La manera más sencilla de declarar un entero es sin especificar el tipo, en cuyo caso Rust asume que es `i32`:
+
+```rust
+fn main() {
+    let numero = 42; // Asumido como i32 por defecto
+    println!("Número: {numero}");
+}
+```
+
+Salida:
+
+```sh [salida]
+Número: 42
+```
+
+Es la forma más típica.
+
+---
+
+## 🔹 Recapitulemos
+
+* Los **enteros** son valores escalares que representan números sin decimales.
+* Existen tipos con signo (`iXX`) y sin signo (`uXX`).
+* Podemos hacer operaciones aritméticas básicas (`+`, `-`, `*`, `/`, `%`).
+* También existen literales en distintas bases: decimal, hex, octal, binario y byte.
+
+---
+
+## ✍️ Ejercicio
+
+1. Declara tres variables de tipo entero:
+
+   * Una de tipo `i8` con un número negativo.
+   * Una de tipo `u16` con un número positivo.
+   * Una de tipo `i32` con el valor `1000`.
+2. Realiza una suma y una multiplicación usando esas variables.
+3. 👉 No cambies los `println!` ya escritos.
+4. ¡Ejecuta el código y revisa el resultado!
+