fix(guide): simplify directory structure

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who/index.md

@@ -0,0 +1,70 @@
+---
+title: Boo Who
+localeTitle: Boo quien
+---
+![](//discourse-user-assets.s3.amazonaws.com/original/2X/3/3c8584a085a0deaea66b3400e6321eeadab552a2.jpg)
+
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### Explicación del problema:
+
+Este programa es muy simple, el truco es entender qué es un primitivo booleano. Los programas requieren una respuesta verdadera o falsa.
+
+#### Enlaces relevantes
+
+*   [Booleano](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+*   Deberá verificar el tipo de parámetro para ver si es un valor booleano.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+*   Para verificar el tipo de parámetro, puede usar `typeof` .
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+*   Como debe devolver verdadero o falso, puede usar declaraciones if o simplemente hacer que devuelva el valor booleano utilizado para la instrucción if.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+    function booWho(bool) { 
+      return typeof bool === 'boolean'; 
+    } 
+ 
+    // test here 
+    booWho(null); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLnK/0)
+
+# Explicación del código:
+
+Utiliza el operador `typeof` para comprobar si la variable es un valor lógico. Si lo es, volverá `true` . De lo contrario, si es de otro tipo devolverá `false` .
+
+#### Enlaces relevantes
+
+*   Utilizando typeof
+*   [tipo de](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey/index.md

@@ -0,0 +1,220 @@
+---
+title: Chunky Monkey
+localeTitle: Mono grueso
+---
+![](//discourse-user-assets.s3.amazonaws.com/original/2X/a/aadd6bead83ab7d79a795c326f005a89e6ad81f5.png)
+
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Nuestro objetivo para este algoritmo es dividir `arr` (primer argumento) en trozos más pequeños de matrices con la longitud proporcionada por `size` (segundo argumento). Hay 4 controles verdes (objetivos) que nuestro código debe aprobar para completar este algoritmo:
+
+1.  `(['a', 'b', 'c', 'd'], 2)` se espera que sea `[['a', 'b'], ['c', 'd']]`
+2.  `([0, 1, 2, 3, 4, 5], 3)` se espera que sea `[[0, 1, 2], [3, 4, 5]]`
+3.  `([0, 1, 2, 3, 4, 5], 2)` se espera que sea `[[0, 1], [2, 3], [4, 5]]`
+4.  `([0, 1, 2, 3, 4, 5], 4)` se espera que sea `[[0, 1, 2, 3], [4, 5]]`
+
+#### Enlaces relevantes
+
+*   [Array.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   [Array.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Los enlaces anteriores sugieren usar `Array.push()` , así que comencemos por crear primero una nueva matriz para almacenar las matrices más pequeñas que pronto tendremos como esto:
+
+```javascript
+    var newArray = []; 
+```
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+A continuación necesitaremos un `for loop` para pasar por `arr` .
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Finalmente, necesitamos un método para hacer la división real y podemos usar `Array.slice()` para hacerlo. La clave de este algoritmo es entender cómo un `for loop` , `size` , `Array.slice()` y `Array.push()` funcionan juntos.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+    function chunkArrayInGroups(arr, size) { 
+ 
+      var temp = []; 
+      var result = []; 
+ 
+      for (var a = 0; a < arr.length; a++) { 
+        if (a % size !== size - 1) 
+          temp.push(arr[a]); 
+        else { 
+          temp.push(arr[a]); 
+          result.push(temp); 
+          temp = []; 
+        } 
+      } 
+ 
+      if (temp.length !== 0) 
+        result.push(temp); 
+      return result; 
+    } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/24)
+
+### Explicación del código:
+
+*   En primer lugar, creamos dos matrices vacías llamadas `temp` y `result` , que eventualmente devolveremos.
+*   Our **for loop** loops hasta que `a` es igual o mayor que la longitud de la matriz en nuestra prueba.
+*   Dentro de nuestro bucle, presionamos a `temp` usando `temp.push(arr[a]);` si el resto de `a / size` no es igual al `size - 1` .
+*   De lo contrario, presionamos a `temp` , presionamos `temp` a la variable de `result` y reiniciamos `temp` a una matriz vacía.
+*   A continuación, si `temp` no es una matriz vacía, la presionamos para obtener el `result` .
+*   Finalmente, devolvemos el valor del `result` .
+
+#### Enlaces relevantes
+
+*   [Array.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   [Para loops](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+```javascript
+    function chunkArrayInGroups(arr, size) { 
+      // Break it up. 
+      var arr2 = []; 
+      for (var i = 0; i < arr.length; i+=size) { 
+        arr2.push(arr.slice(i , i+size)); 
+      } 
+      return arr2; 
+    } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/Cj9x/3)
+
+### Explicación del código:
+
+*   Primero, creamos una matriz vacía `arr2` donde almacenaremos nuestros 'trozos'.
+*   El bucle for comienza en cero, aumenta de `size` cada vez que pasa por el bucle y se detiene cuando alcanza `arr.length` .
+*   Tenga en cuenta que este bucle for no pasa por `arr` . En su lugar, estamos utilizando el bucle para generar números que podemos usar como índices para dividir la matriz en las ubicaciones correctas.
+*   Dentro de nuestro bucle, creamos cada fragmento utilizando `arr.slice(i, i+size)` , y agregamos este valor a `arr2` con `arr2.push()` .
+*   Finalmente, devolvemos el valor de `arr2` .
+
+#### Enlaces relevantes
+
+*   [Array.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   [Array.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+*   [Para loops](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+
+```javascript
+    function chunkArrayInGroups(arr, size) { 
+      // Break it up. 
+      var newArr = []; 
+      var i = 0; 
+ 
+      while (i < arr.length) { 
+        newArr.push(arr.slice(i, i+size)); 
+        i += size; 
+      } 
+      return newArr; 
+    } 
+    chunkArrayInGroups(["a", "b", "c", "d"], 2); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/26)
+
+### Explicación del código:
+
+*   En primer lugar, creamos dos variables. `newArr` es una matriz vacía a la que enviaremos. También tenemos la variable `i` configurada en cero, para usar en nuestro bucle while.
+    
+*   Nuestro bucle while realiza un bucle hasta que `i` es igual o mayor que la longitud de la matriz en nuestra prueba.
+    
+*   Dentro de nuestro bucle, empujamos a la `newArr` matriz mediante `arr.slice(i, i+size)` . Por primera vez los bucles se verán como:
+    
+    newArr.push (arr.slice (1, 1 + 2))
+    
+*   Después de que presionamos a `newArr` , agregamos la variable de `size` a `i` .
+    
+*   Finalmente, devolvemos el valor de `newArr` .
+    
+
+#### Enlaces relevantes
+
+*   [Array.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   [Array.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+*   [Mientras bucles](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/while)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Código avanzado de solución 2:
+
+```javascript
+    function chunkArrayInGroups(arr, size) { 
+      var newArr = []; 
+      while (arr.length) { 
+        newArr.push(arr.splice(0,size)); 
+      } 
+      return newArr; 
+    } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/579)
+
+### Explicación del código:
+
+*   En primer lugar, creamos una variable. `newArr` es una matriz vacía a la que enviaremos.
+*   Nuestra `while` bucle de un bucle hasta que la longitud de la matriz en nuestra prueba no es 0.
+*   Dentro de nuestro bucle, empujamos a la `newArr` matriz mediante `arr.splice(0, size)` .
+*   Para cada iteración de `while` de bucle, se elimina `size` número de elementos de la parte frontal de `arr` y empuje como una matriz para `newArr` .
+*   Finalmente, devolvemos el valor de `newArr` .
+
+#### Enlaces relevantes
+
+*   [Array.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   [Array.splice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+*   [Mientras bucles](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/while)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Código avanzado de solución 3:
+
+```javascript
+    function chunkArrayInGroups(arr, size) { 
+      if (arr.length <= size){ 
+        return [arr]; 
+      } 
+      else { 
+        return [arr.slice(0,size)].concat(chunkArrayInGroups(arr.slice(size),size)); 
+      } 
+    } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/579)
+
+### Explicación del código:
+
+*   La matriz más pequeña que el tamaño se devuelve anidada.
+*   Para cualquier matriz más grande que el tamaño, se divide en dos. El primer segmento está anidado y concatnado con el segundo segundo segmento que hace una llamada recursiva.
+
+#### Enlaces relevantes
+
+*   [Recursion](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions#Recursion)
+*   [Array.splice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending/index.md

@@ -0,0 +1,36 @@
+---
+title: Confirm the Ending
+localeTitle: Confirmar el final
+---
+## Confirmar el final
+
+# Solution Solución de código intermedio:
+
+(Enfoque declarativo)
+
+```javascript
+function confirmEnding(str, target) { 
+  // "Never give up and good luck will find you." 
+  // -- Falcor 
+ 
+  return str.slice(str.length - target.length) === target; 
+ } 
+ 
+ confirmEnding("He has to give me a new name", "name"); 
+```
+
+#### 🚀 [Ejecutar Código](https://repl.it/repls/SardonicRoundAfkgaming)
+
+# Explicación del código:
+
+*   Primero usamos el método de `slice` , copiamos la cadena.
+*   Para obtener los últimos caracteres en `str` equivalentes a la longitud del `target` , usamos el método de `slice` .
+*   El primer parámetro dentro del método de `slice` es el índice inicial y el segundo parámetro sería el índice final.
+*   Por ejemplo `str.slice(10, 17)` devolvería `give me` .
+*   En este caso, solo incluimos un parámetro que copiará todo del índice de inicio.
+*   Restamos la longitud de `str` y la longitud del `target` , de esa forma, obtendremos los últimos caracteres restantes equivalentes a la longitud del `target` .
+*   Finalmente, comparamos el resultado devuelto de slice a `target` y verificamos si tienen los mismos caracteres.
+
+### Enlaces relevantes
+
+*   [String.prototype.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit/index.md

@@ -0,0 +1,67 @@
+---
+title: Convert Celsius to Fahrenheit
+localeTitle: Convertir Celsius a Fahrenheit
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+El algoritmo para convertir de Celsius a Fahrenheit es la temperatura en grados Celsius `9/5` , más `32` .
+
+Te dan una variable **celsius que** representa una temperatura en grados celsius. Utilice la variable **fahrenheit** ya definida y aplique el algoritmo para asignarle la temperatura correspondiente en Fahrenheit.
+
+#### Enlaces relevantes
+
+*   [La Orden de Operaciones: PEMDAS](http://www.purplemath.com/modules/orderops.htm)
+*   [Orden de Operación: Video](https://www.khanacademy.org/math/pre-algebra/order-of-operations/order_of_operations/v/order-of-operations)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Echa un vistazo al código. Hay un área que no debes editar. A partir de ahí, pregúntate: ¿qué se usa allí que no haya visto antes?
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Tenga en cuenta el **orden de operación;** consulte el enlace en la sección de _enlaces_ para obtener más información.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+    function convertToF(celsius) { 
+      // Only change code below this line 
+      var fahrenheit = (celsius * (9/5)) + 32; 
+ 
+      // Only change code above this line 
+      if ( typeof fahrenheit !== 'undefined' ) { 
+      return fahrenheit; 
+      } else { 
+        return 'fahrenheit not defined'; 
+      } 
+    } 
+ 
+    // Change the inputs below to test your code 
+    convertToF(30); 
+```
+
+### Explicación del código:
+
+*   Declara la variable **fahrenheit** .
+*   Asegúrese de seguir el orden correcto de las operaciones aritméticas usando paréntesis ( `()` ) cuando sea necesario.
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number/index.md

@@ -0,0 +1,115 @@
+---
+title: Factorialize a Number
+localeTitle: Factorializar un número
+---
+![Recursion](//discourse-user-assets.s3.amazonaws.com/original/2X/d/dcf927a2e8c3beb7a9c28770153821982398bd99.jpg)
+
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+## ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Devuelve el factorial del entero proporcionado. Si el número entero se representa con la letra n, un factorial es el producto de todos los números enteros positivos menores o iguales a n.
+
+Los factoriales a menudo se representan con la notación abreviada n!
+
+Por ejemplo: `5! = 1 * 2 * 3 * 4 * 5 = 120`
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+¡Este empieza fácilmente desde `0! = 1` , por lo que puede seguir adelante y simplemente `return 1` allí.
+
+Podemos usar eso como un `if` con el fin de romper el bucle que vamos a crear usando una **función recursiva.** Verificará si el número que le dio a la función es 0 (que sería el final de su cadena factorial). Las funciones "terminan" cuando devuelven algo. De hecho, **todas las** funciones sin una declaración de `return` explícita se devolverán `undefined` .
+
+Esta es también la razón por la que, en **lugar** de haber _"terminado"_ , siempre se dice que una función _"ha regresado"_ . Y ahora esto ...
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+**Entendiendo recursion**
+
+Recursión se refiere a una función que se repite (llama) a sí misma. En este caso estamos básicamente devolver el número dado (es decir, 5), multiplicado por la función en sí, pero esta vez el valor pasado al parámetro _num_ es `num-1` (que se traduce inicialmente a 4). La misma función se va a **ejecutar dentro de sí** interesante, ¿eh?
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+**Entendiendo el flujo**
+
+El primer valor **devuelto** se puede visualizar mejor si piensa en las operaciones de paréntesis que realizó en la escuela secundaria, donde realiza los cálculos matemáticos dentro de cada paréntesis desde adentro hacia afuera, corchete y corchete hasta obtener un resultado final (un total). Esta vez es lo mismo, mira el flujo del programa:
+
+### Durante la primera ejecución de la función:
+
+\[ **num** = 5\]
+
+¿Es 5 _igual_ a 1 o 0? **No** ---> Oki doki, continuemos ...
+
+**Devoluciones:**
+
+( **5** _(_ segunda ejecución\_: **4** \_ ( _tercera ejecución_ : **3** _(_ cuarta ejecución\_: **2** \_ _quinta ejecución_ : **1** ))))
+
+Lo que devuelve puede verse como `(5*(4*(3*(2*1))))` o solo `5 * 4 * 3 * 2 * 1` , y la función devolverá el resultado de esa operación: `120` . Ahora, vamos a ver qué hacen las demás ejecuciones:
+
+### Durante el resto de las ejecuciones:
+
+**Segunda ejecución** : _num_ = 5-1 = **4** -> es _num_ 0 o 1? No
+
+\-> devuelve la multiplicación entre 4 y el siguiente resultado cuando _num_ es ahora 4-1.
+
+**Tercera ejecución** : _num_ = 4 - 1 = **3** -> es _num_ 0 o 1? No
+
+\-> devuelve la multiplicación entre 3 y el siguiente resultado cuando _num_ ahora es 3-1.
+
+**Cuarta ejecución** : _num_ = 3-1 = **2** -> es _num_ 0 o 1? No
+
+\-> devuelve la multiplicación entre 2 y el siguiente resultado cuando _num_ ahora es 2-1.
+
+**Quinta ejecución** : _num_ = 2-1 = **1** -> es _num_ 0 o 1? Sí
+
+\-> volver **1** . Y aquí es donde la recursión se detiene porque no hay más ejecuciones.
+
+¿Lo tengo? ![:wink:](https://forum.freecodecamp.com/images/emoji/emoji_one/wink.png?v=3 ":guiño:")
+
+> _intenta resolver el problema ahora_
+
+#### Enlaces relevantes
+
+*   [Funciones js](https://www.youtube.com/watch?v=R8SjM4DKK80)
+*   [Recursion en JS](https://www.youtube.com/watch?v=k7-N8R0-KY4)
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código:
+```
+function factorialize(num) { 
+  if (num === 0) { return 1; } 
+  return num * factorialize(num-1); 
+ } 
+ 
+ factorialize(5); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/1)
+
+## Explicación del código:
+
+Observe en la primera línea que tenemos la condición terminal, es decir, una condición para verificar el final de la recursión. Si `num == 0` , devolvemos 1, es decir, finalizamos la recursión e informamos a la pila para que propague este valor a los niveles superiores. Si no tenemos esta condición, la recursión continuaría hasta que el espacio de pila se consuma, lo que resultaría en un [desbordamiento de pila](https://en.wikipedia.org/wiki/Stack_overflow) .
+
+### Enlaces relevantes
+
+*   [Recursion](https://www.codecademy.com/en/courses/javascript-lesson-205/0/1)
+*   [Factorialización](https://en.wikipedia.org/wiki/Factorial)
+*   [Operadores aritméticos](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer/index.md

@@ -0,0 +1,73 @@
+---
+title: Falsy Bouncer
+localeTitle: Falsy Bouncer
+---
+![](//discourse-user-assets.s3.amazonaws.com/original/2X/5/55dedad40d9f3f662c70d1eac4effc00c7d26bd9.jpg)
+
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Eliminar todos los valores [falsos](https://guide.freecodecamp.org/javascript/falsy-values/) de una matriz.
+
+#### Enlaces relevantes
+
+*   [Valores de Falsía](https://guide.freecodecamp.org/javascript/falsy-values/)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+La falsedad es algo que se evalúa como FALSO. Solo hay seis valores falsos en JavaScript: indefinido, nulo, NaN, 0, "" (cadena vacía), y falso, por supuesto.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Necesitamos asegurarnos de tener todos los valores falsos para comparar, podemos saberlo, tal vez con una función con todos los valores falsos ...
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Entonces necesitamos agregar un `filter()` con la función de valores falsos ...
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+```
+function bouncer(arr) { 
+  return arr.filter(Boolean); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/32)
+
+### Explicación del código:
+
+El `Array.prototype.filter` método espera una función que devuelve un `Boolean` valor que toma un único argumento y devuelve `true` para [Truthy](http://forum.freecodecamp.com/t/javascript-truthy-value/15975) valor o `false` para [Falsy](https://guide.freecodecamp.org/javascript/falsy-values/) valor. De ahí pasamos la función `Boolean` incorporada.
+
+#### Enlaces relevantes
+
+*   [Booleano](http://forum.freecodecamp.com/t/javascript-boolean/14311)
+*   [Verdad](http://forum.freecodecamp.com/t/javascript-truthy-value/15975)
+*   [Array.prototype.filter ()](http://forum.freecodecamp.com/t/javascript-array-prototype-filter/14289)
+
+## ![:trophy:](https://forum.freecodecamp.com/images/emoji/emoji_one/trophy.png?v=3 ":trofeo:") Créditos:
+
+Si encontró útil esta página, puede agradecer copiando y pegando esto en el chat principal:
+
+**`Thanks @renelis @abhisekp @Rafase282 for your help with Algorithm: Falsy Bouncer`**
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string/index.md

@@ -0,0 +1,143 @@
+---
+title: Find the Longest Word in a String
+localeTitle: Encuentra la palabra más larga en una cadena
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Tienes que repasar cada palabra y descubrir cuál es la más larga y no devolver la palabra, sino cuántos caracteres tiene.
+
+#### Enlaces relevantes
+
+*   [Longitud de la cuerda de JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Debe dividir la cadena en una matriz de palabras.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Tendrá que encontrar una manera de realizar un seguimiento global de la mayor longitud actual.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+¿Recuerda cómo obtener la longitud de los elementos en la matriz? `Array[index].length` .
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function findLongestWordLength(str) { 
+  var words = str.split(' '); 
+  var maxLength = 0; 
+ 
+  for (var i = 0; i < words.length; i++) { 
+    if (words[i].length > maxLength) { 
+      maxLength = words[i].length; 
+    } 
+  } 
+ 
+  return maxLength; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/5)
+
+### Explicación del código:
+
+Toma la cadena y conviértela en una matriz de palabras. Declare una variable para realizar un seguimiento de la longitud máxima y el bucle de 0 a la longitud de la matriz de palabras.
+
+Luego busque la palabra más larga comparando la palabra actual con la anterior y almacenando la nueva palabra más larga. Al final del ciclo, simplemente devuelva el valor numérico de la variable maxLength.
+
+#### Enlaces relevantes
+
+*   [JS Array.length](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+**Utilizando `.reduce()`**
+```
+function findLongestWordLength(s) { 
+  return s.split(' ') 
+    .reduce(function(x, y) { 
+      return Math.max(x, y.length) 
+    }, 0); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/6)
+
+### Explicación del código:
+
+Para más información sobre `reduce` [haga clic aquí.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)
+
+En caso de que se esté preguntando sobre ese `0` después de la función de devolución de llamada, se usa para dar un valor inicial a la `x` , de modo que `Math.max` sabrá dónde comenzar.
+
+#### Enlaces relevantes
+
+*   [JS Reducir](http://forum.freecodecamp.com/t/javascript-array-prototype-reduce/14299)
+*   [JS Reduce Made Easy](http://forum.freecodecamp.com/t/using-array-prototype-reduce-to-reduce-conceptual-boilerplate-for-problems-on-arrays/14687)
+*   [JS Math Max](http://forum.freecodecamp.com/t/javascript-math-max/14682.md)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+
+**Usando la recursividad**
+```
+function findLongestWordLength(str) { 
+ 
+  //split the string into individual words 
+  //(important!!, you'll see why later) 
+  str = str.split(" "); 
+ 
+  //str only has 1 element left that is the longest element, 
+  //return the length of that element 
+  if(str.length == 1){ 
+    return str[0].length; 
+  } 
+ 
+  //if the first element's length is greater than the second element's (or equal) 
+  //remove the second element and recursively call the function) 
+  if(str[0].length >= str[1].length){ 
+    str.splice(1,1); 
+    return findLongestWordLength(str.join(" ")); 
+  } 
+ 
+  //if the second element's length is greater thant the first element's start 
+  //call the function past the first element 
+  if(str[0].length <= str[1].length){ 
+    // from the first element to the last element inclusive. 
+    return findLongestWordLength(str.slice(1,str.length).join(" ")); 
+  } 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/7)
+
+### Explicación del código:
+
+La primera línea divide la cadena en palabras individuales. Luego verificamos si a `str` solo le queda 1 elemento, entonces ese es el elemento más largo y lo devolvemos. Si la longitud del primer elemento es mayor que la del segundo elemento (o igual), eliminamos el segundo elemento y llamamos recursivamente a la función `findLongestWord` . Sin embargo, si la longitud del segundo elemento es mayor que el comienzo del primer elemento, entonces llamamos a la función más allá del primer elemento.
+
+#### Enlaces relevantes
+
+*   [Funciones js](https://www.youtube.com/watch?v=R8SjM4DKK80)
+*   [Conceptos básicos de recursión](https://www.youtube.com/watch?v=k7-N8R0-KY4)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers/index.md

@@ -0,0 +1,49 @@
+---
+title: Finders Keepers
+localeTitle: Buscadores guardianes
+---
+## Explicación del problema
+
+Necesitamos devolver el elemento desde una matriz que pasa una función. Tanto la `function` como la `array` se pasan a nuestra función `findElement(arr, func)` .
+
+## Sugerencia: 1
+
+Mirando a través de la matriz se puede hacer con un bucle `for` .
+
+> _intenta resolver el problema ahora_
+
+## Sugerencia: 2
+
+`num` se pasa a la función. Tendremos que establecerlo en los elementos que queremos verificar con la función.
+
+> _intenta resolver el problema ahora_
+
+## Sugerencia: 3
+
+No se olvide, si ninguno de los números en la matriz pasa la prueba, debe regresar `undefined` .
+
+> _intenta resolver el problema ahora_
+
+## Solucion basica
+
+```javascript
+function findElement(arr, func) { 
+  let num = 0; 
+ 
+  for(var i = 0; i < arr.length; i++) { 
+    num = arr[i]; 
+    if (func(num)) { 
+      return num; 
+    } 
+  } 
+ 
+  return undefined; 
+ } 
+```
+
+## Explicación del Código
+
+*   El desafío nos pide que miremos a través de la matriz. Esto se hace usando un bucle `for` .
+*   La variable `num` se está pasando a la función, por lo que la establecemos en cada índice de nuestra matriz.
+*   La función predefinida ya verifica cada número por nosotros, por lo que si es "verdadero", devolvemos ese número.
+*   Si ninguno de los números en la matriz pasa la prueba de la función, devolvemos undefined.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/index.md

@@ -0,0 +1,11 @@
+---
+title: Basic Algorithm Scripting
+localeTitle: Algoritmo básico de secuencias de comandos
+---
+## Algoritmo básico de secuencias de comandos
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations/index.md

@@ -0,0 +1,102 @@
+---
+title: Mutations
+localeTitle: Mutaciones
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+*   Devuelva verdadero si la cadena en el primer elemento de la matriz contiene todas las letras de la cadena en el segundo elemento de la matriz.
+
+#### Enlaces relevantes
+
+*   [String.indexOf ()](http://forum.freecodecamp.com/t/javascript-string-prototype-indexof/15936)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+*   Si todo está en minúsculas, será más fácil de comparar.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+*   Puede ser más fácil trabajar con nuestras cadenas si fueran matrices de caracteres.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+*   Un bucle podría ayudar. Use `indexOf()` para verificar si la letra de la segunda palabra está en la primera.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+**Procesal**
+```
+function mutation(arr) { 
+  var test = arr[1].toLowerCase(); 
+  var target = arr[0].toLowerCase(); 
+  for (var i=0;i<test.length;i++) { 
+    if (target.indexOf(test[i]) < 0) 
+      return false; 
+  } 
+  return true; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/30)
+
+### Explicación del código:
+
+Primero hacemos las dos cadenas en la matriz en minúsculas. `test` mantendrá lo que estamos buscando en el `target` .  
+Luego hacemos un bucle a través de nuestros personajes de prueba y si no se encuentra alguno de ellos, `return false` .
+
+Si se encuentran _todos_ , el bucle terminará sin devolver nada y podemos `return true` .
+
+#### Enlaces relevantes
+
+*   [String.toLowerCase ()](http://forum.freecodecamp.com/t/javascript-string-prototype-tolowercase/15948)
+*   [Para bucles](http://forum.freecodecamp.com/t/javascript-for-loop/14666s-Explained)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+**Declarativo**
+```
+function mutation(arr) { 
+  return arr[1].toLowerCase() 
+    .split('') 
+    .every(function(letter) { 
+      return arr[0].toLowerCase() 
+        .indexOf(letter) != -1; 
+    }); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/31)
+
+### Explicación del código:
+
+Toma la segunda cadena, en minúscula y conviértela en una matriz; luego asegúrese de que _cada_ una de sus _letras_ sea ​​parte de la primera cadena en minúsculas.
+
+Básicamente, `Every` le daremos letra por letra para comparar, lo que hacemos al usar `indexOf` en la primera cadena. `indexOf` le dará -1 si falta la `letter` actual. Verificamos que no sea así, ya que si esto sucede incluso una vez, `every` será falso.
+
+#### Enlaces relevantes
+
+*   [Array.split ()](http://forum.freecodecamp.com/t/javascript-string-prototype-split/15944)
+*   [Array.every ()](http://forum.freecodecamp.com/t/javascript-array-prototype-every/14287)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string/index.md

@@ -0,0 +1,119 @@
+---
+title: Repeat a String Repeat a String
+localeTitle: Repetir una cadena Repetir una cadena
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+El programa es muy simple, tenemos que tomar una variable y devolver esa variable repetida cierta cantidad de veces. No es necesario agregar espacio ni nada, simplemente repítalo en una sola cadena.
+
+#### Enlaces relevantes
+
+*   [Objeto de cadena global](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+No puede editar cadenas, tendrá que crear una variable para almacenar la nueva cadena.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Cree un bucle para repetir el código tantas veces como sea necesario.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Haga que la variable creada almacene el valor actual y agregue la palabra a la misma.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function repeatStringNumTimes(str, num) { 
+  var accumulatedStr = ''; 
+ 
+  while (num > 0) { 
+    accumulatedStr += str; 
+    num--; 
+  } 
+ 
+  return accumulatedStr; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/19)
+
+### Explicación del código:
+
+*   Cree una variable de cadena vacía para almacenar la palabra repetida.
+*   Use un bucle while o para repetir el código tantas veces como sea necesario de acuerdo con `num`
+*   Luego, solo tenemos que agregar la cadena a la variable creada en el paso uno, y aumentar o disminuir el `num` dependiendo de cómo establezca el bucle.
+*   Al final del bucle, devuelva la variable para la palabra repetida.
+
+#### Enlaces relevantes
+
+*   JS mientras bucle
+*   [JS For Loops Explicado](https://forum.freecodecamp.com/t/javascript-for-loop/14666s-Explained)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+```
+function repeatStringNumTimes(str, num) { 
+  if(num < 0) 
+    return ""; 
+  if(num === 1) 
+    return str; 
+  else 
+    return str + repeatStringNumTimes(str, num - 1); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/21)
+
+### Explicación del código:
+
+*   Esta solución utiliza la recursión.
+*   Verificamos si `num` es negativo y devolvemos una cadena vacía si es verdadero.
+*   Luego verificamos si es igual a 1 y, en ese caso, devolvemos la cadena.
+*   Si no, agregamos la cadena a una llamada de nuestra función con `num` disminuyendo en 1, lo que agregará otra `str` y otra ... hasta que finalmente `num` sea ​​1. Y devolvemos todo el proceso.
+
+#### Enlaces relevantes
+
+*   [Funciones - Recursion](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions#Recursion)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+```
+function repeatStringNumTimes(str, num) { 
+  return num > 0 ? str.repeat(num) : ''; 
+ } 
+ 
+ repeatStringNumTimes("abc", 3); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/85)
+
+### Explicación del código:
+
+*   Esta solución tiene un enfoque declarativo.
+*   Es similar a la tercera solución, excepto que utiliza la forma de operador ternario de la sentencia `if` .
+
+#### Enlaces relevantes
+
+*   [Js ternario](https://forum.freecodecamp.com/t/javascript-ternary-operator/15973)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](https://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays/index.md

@@ -0,0 +1,160 @@
+---
+title: Return Largest Numbers in Arrays
+localeTitle: Devolver los números más grandes en matrices
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Obtendrá una matriz que contiene matrices secundarias de números y debe devolver una matriz con el número más alto de cada una de las matrices secundarias.
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Deberá realizar un seguimiento de la matriz con la respuesta y el mayor número de cada sub-matriz.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Puede trabajar con matrices multidimensionales por `Array[Index][SubIndex]`
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Preste mucha atención a la sincronización del almacenamiento de variables cuando trabaje con bucles
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Soluciones por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+**(Enfoque procesal)**
+```
+function largestOfFour(arr) { 
+  var results = []; 
+  for (var n = 0; n < arr.length; n++) { 
+    var largestNumber = arr[n][0]; 
+    for (var sb = 1; sb < arr[n].length; sb++) { 
+      if (arr[n][sb] > largestNumber) { 
+        largestNumber = arr[n][sb]; 
+      } 
+    } 
+ 
+    results[n] = largestNumber; 
+  } 
+ 
+  return results; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/734)
+
+### Explicación del código:
+
+*   Crea una variable para almacenar los _resultados_ como una matriz.
+*   Cree un bucle externo para iterar a través de la matriz externa.
+*   Cree una segunda variable para mantener el número más grande e inicialícelo con el primer número. Esto debe estar fuera de un bucle interno para que no se reasigne hasta que encontremos un número mayor.
+*   Cree dicho bucle interno para trabajar con los subarreglos.
+*   Compruebe si el elemento de la matriz secundaria es más grande que el número más grande almacenado actualmente. Si es así, entonces actualice el número en la variable.
+*   Después del ciclo interno, guarde el número más grande en la posición correspondiente dentro de la matriz de `results` .
+*   Y, finalmente, devolver dicho conjunto.
+
+#### Enlaces relevantes
+
+*   [Para bucles](http://forum.freecodecamp.com/t/javascript-for-loop/14666s-Explained)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+**(Enfoque declarativo)**
+```
+function largestOfFour(arr) { 
+  return arr.map(function(group){ 
+    return group.reduce(function(prev, current) { 
+      return (current > prev) ? current : prev; 
+    }); 
+  }); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/733)
+
+### Explicación del código:
+
+*   asignamos todos los elementos dentro de la matriz principal a una nueva matriz utilizando `Array.prototype.map()` y devolvemos esta matriz como el resultado final
+*   dentro de cada matriz interna, reducimos su contenido a un solo valor utilizando `Array.prototype.reduce()`
+*   La función de devolución de llamada pasada al método de reducción toma el valor anterior y el valor actual y compara los dos valores.
+*   si el valor actual es mayor que el valor anterior, lo establecemos como el nuevo valor anterior para comparar con el siguiente elemento dentro de la matriz o lo devuelve al método de devolución de llamada si es el último elemento
+
+#### Enlaces relevantes
+
+*   [Array.prototype.map ()](http://forum.freecodecamp.com/t/javascript-array-prototype-map/14294)
+*   [Array.prototype.reduce ()](http://forum.freecodecamp.com/t/javascript-array-prototype-reduce/14299)
+*   [Operadores Ternarios](http://forum.freecodecamp.com/t/javascript-ternary-operator/15973)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+
+**(Enfoque declarativo)**
+```
+function largestOfFour(arr) { 
+  return arr.map(Function.apply.bind(Math.max, null)); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/17)
+
+### Explicación del código:
+
+TL; DR: Construimos una función de devolución de llamada especial (usando el método `Function.bind` ), que funciona como `Math.max` pero también tiene la capacidad de `Function.prototype.apply` de tomar arreglos como sus argumentos ![:smiley:](https://forum.freecodecamp.com/images/emoji/emoji_one/smiley.png?v=3 ": smiley:")
+
+*   Comenzamos por mapear a través de los elementos dentro de la matriz principal. Significando cada una de las matrices internas.
+*   Ahora se necesita una función de devolución de llamada para encontrar el máximo de cada matriz interna proporcionada por el mapa.
+
+Así que queremos crear una función que haga el trabajo de `Math.max` y acepte la entrada como una matriz (que no lo hace por defecto).
+
+En otras palabras, sería realmente agradable y simple si esto funcionara solo:
+
+`Math.max([9, 43, 20, 6]); // Resulting in 43`
+
+Ay, no lo hace.
+
+*   Para hacer el trabajo de aceptar argumentos en forma de una matriz, existe este método `Function.prototype.apply` , pero complica un poco las cosas _invocando_ la función de _contexto_ .
+
+es decir, `Math.max.apply(null, [9, 43, 20, 6]);` `Max.max` algo como un método `Max.max` . Lo que estamos buscando ... casi.
+
+Aquí estamos pasando `null` como el _contexto_ del método `Function.prototype.apply` ya que `Math.max` no necesita ningún contexto.
+
+*   Como `arr.map` espera una función de devolución de llamada, no solo una expresión, creamos una función a partir de la expresión anterior mediante el método `Function.bind` .
+    
+*   Dado que `Function.prototype.apply` es un _método_ estático del mismo _objeto_ `Function` , podemos llamar a `Function.prototype.bind` en `Function.prototype.apply` es decir, `Function.prototype.apply.bind` .
+    
+*   Ahora pasamos el _contexto_ para la llamada `Function.prototype.apply.bind` (en este caso queremos `Math.max` para que podamos obtener su funcionalidad).
+    
+*   Dado que el método incorporado `Function.prototype.apply` también requerirá un contexto como primer argumento, debemos pasarle un _contexto_ falso.
+    
+    *   Por lo tanto, pasamos `null` como el segundo parámetro a `Function.prototype.apply.bind` que da un _contexto_ al método `Math.max` .
+        
+    *   Dado que `Math.max` es independiente de cualquier _contexto_ , por lo tanto, ignora el _contexto_ falso dado por la llamada al método `Function.prototype.apply` .
+        
+    *   Por lo tanto, nuestro `Function.prototype.apply.bind(Math.max, null)` una nueva función que acepta los valores `arr.map` , es decir, las matrices internas.
+        
+
+#### Enlaces relevantes
+
+*   [Matemáticas.max](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max)
+*   [Function.prototype.apply en DevDocs](http://devdocs.io/#q=js+Function+apply)
+*   [Function.bind en DevDocs](http://devdocs.io/#q=js+Function+bind)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string/index.md

@@ -0,0 +1,68 @@
+---
+title: Reverse a String
+localeTitle: Revertir una cadena
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Necesitamos tomar la cadena y revertirla, así que si originalmente lee 'hola', ahora leerá 'olleh'. Necesitaremos dividir la cadena y, por lo tanto, también trabajaremos con Arrays.
+
+#### Enlaces relevantes
+
+*   [str.split ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+*   [arr.reverse ()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)
+*   [arr.join ()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/join)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Comience por dividir la cadena por caracteres.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Busque la función incorporada para revertir una cadena.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+No olvides volver a unir a los personajes después de revertirlos.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function reverseString(str) { 
+  return str.split('').reverse().join(''); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU)
+
+### Explicación del código:
+
+*   Nuestro objetivo es tomar la entrada, `str` y devolverla en reversa. Nuestro primer paso es dividir la cadena por caracteres usando `split('')` . Tenga en cuenta que no dejamos nada entre las comillas simples, esto le dice a la función que separe la cadena por cada carácter.
+    
+*   El uso de la función `split()` convertirá nuestra cadena en una matriz de caracteres, tenlo en cuenta a medida que avanzamos.
+    
+*   A continuación, _encadenamos_ la función `reverse()` , que toma nuestra matriz de caracteres y los invierte.
+    
+*   Finalmente, _encadenamos_ `join('')` para volver a juntar a nuestros personajes en una cadena. Tenga en cuenta una vez más que no dejamos espacios en el argumento para unirse, esto se asegura de que la matriz de caracteres esté unida de nuevo por cada carácter.
+    
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice/index.md

@@ -0,0 +1,77 @@
+---
+title: Slice and Splice
+localeTitle: Rebanada y empalme
+---
+## Rebanada y empalme
+
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Necesitamos copiar cada elemento de la primera matriz en la segunda matriz comenzando en el índice n. También tenemos que asegurarnos de que las matrices originales no estén mutadas. Es decir, no podemos realizar ningún cambio en las matrices originales.
+
+#### Enlaces relevantes
+
+*   [str.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)
+*   [str.splice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Crea una copia de la segunda matriz dentro de la función. Esto asegurará que la matriz original no esté mutada. Esto se puede hacer usando la operación de división en la segunda matriz y asignándola a una variable.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Recorre todos los elementos de la primera matriz. Para cada elemento de la primera matriz, empalme en la matriz copiada en el índice dado como argumento.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Incrementa el índice después de realizar el empalme.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](https://discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function frankenSplice(arr1, arr2, n) { 
+  // It's alive. It's alive! 
+  let localArray = arr2.slice(); 
+  for (let i = 0; i < arr1.length; i++) { 
+    localArray.splice(n, 0, arr1[i]); 
+    n++; 
+  } 
+  return localArray; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU)
+
+### Explicación del código:
+
+*   Nuestro objetivo es tomar todos los elementos de `arr1` e insertarlos en `arr2` comenzando con la posición de índice `n` . Al mismo tiempo, debemos asegurarnos de que ni `arr` ni `arr2` hayan sido mutados.
+    
+*   Usando la función `slice()` podemos crear una réplica exacta de `arr2` y asignar el resultado de la operación a una variable, `localArray` .
+    
+*   Ahora que tenemos una matriz en la que podemos mutar, podemos iterar a través de cada elemento en la primera matriz. Para cada elemento de la primera matriz, podemos usar la función `splice()` para insertar el elemento en el índice `n` de `localArray` .
+    
+*   Incrementamos el índice `n` en uno. Esto asegurará que cada elemento del `arr1` se inserte en `localArray` en la posición de índice adecuada.
+    
+*   Finalmente, devolvemos el `localArray` y `localArray` la función.
+    
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence/index.md

@@ -0,0 +1,144 @@
+---
+title: Title Case a Sentence
+localeTitle: Título Caso una oración
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Tenemos que devolver una frase con el título del caso. Esto significa que la primera letra siempre estará en mayúsculas y el resto en minúsculas.
+
+#### Enlaces relevantes
+
+*   [Objeto de cadena global](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)
+*   [JS String Prototype ToLowerCase](http://forum.freecodecamp.com/t/javascript-string-prototype-tolowercase/15948)
+*   [JS String Prototype ToUpperCase](http://forum.freecodecamp.com/t/javascript-string-prototype-touppercase/15950)
+*   [JS String Prototype Replace](http://forum.freecodecamp.com/t/javascript-string-prototype-replace/15942)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+*   Debes comenzar dividiendo la cadena en una matriz de palabras.
+*   Dividir la frase.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+*   Debe hacer que la palabra sea minúscula antes de hacer la primera letra en mayúscula.
+*   Use el método de reemplazo en cada palabra para poner en mayúscula la primera letra de cada palabra.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+*   Necesitará crear una nueva cadena con partes de la anterior y al final fusionar todo en una sola cadena de nuevo.
+*   En el método de reemplazo, indique el primer argumento como la posición de la primera letra utilizando charAt. Para el segundo argumento, escriba una función para devolver la letra mayúscula como reemplazo.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+String.prototype.replaceAt = function(index, character) { 
+    return this.substr(0, index) + character + this.substr(index+character.length); 
+ }; 
+ 
+ function titleCase(str) { 
+    var newTitle = str.split(' '); 
+    var updatedTitle = []; 
+    for (var st in newTitle) { 
+        updatedTitle[st] = newTitle[st].toLowerCase().replaceAt(0, newTitle[st].charAt(0).toUpperCase()); 
+    } 
+    return updatedTitle.join(' '); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/8)
+
+### Explicación del código:
+
+Estamos modificando la función `replaceAt` utilizando un prototipo para facilitar el uso del programa.
+
+Divida la cadena por espacios en blanco y cree una variable para rastrear el título actualizado. Luego usamos un bucle para convertir el primer carácter de la palabra en mayúsculas y el resto en minúsculas. al crear una cadena concatenada compuesta de la palabra completa en minúsculas con el primer carácter reemplazado por su mayúscula.
+
+#### Enlaces relevantes
+
+*   [JS For Loops Explicado](http://forum.freecodecamp.com/t/javascript-for-loop/14666s-Explained)
+*   [JS String Prototype Split](http://forum.freecodecamp.com/t/javascript-string-prototype-split/15944)
+*   [JS String Prototype Substr](http://forum.freecodecamp.com/t/javascript-string-prototype-substr/15945)
+*   [JS Array Prototype Join](http://forum.freecodecamp.com/t/javascript-array-prototype-join/14292)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+```
+function titleCase(str) { 
+  var convertToArray = str.toLowerCase().split(" "); 
+  var result = convertToArray.map(function(val){ 
+      return val.replace(val.charAt(0), val.charAt(0).toUpperCase()); 
+  }); 
+  return result.join(" "); 
+ } 
+ 
+ titleCase("I'm a little tea pot"); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/9)
+
+### Explicación del código:
+
+Estamos haciendo una cadena entera en minúsculas y luego la convertimos en una matriz. Luego estamos usando la función de mapa para reemplazar el carácter en minúscula con mayúscula. Finalmente, estamos devolviendo la cadena usando el método de `join` .
+
+#### Enlaces relevantes
+
+*   [Mapa de prototipos JS Array](http://forum.freecodecamp.com/t/javascript-array-prototype-map/14294)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+```
+function titleCase(str) { 
+  return str.toLowerCase().replace(/(^|\s)\S/g, (L) => L.toUpperCase()); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/14)
+
+### Explicación del código:
+
+La solución funciona primero escribiendo en minúsculas todos los caracteres de la cadena y, a continuación, solo subiendo en mayúsculas el primer carácter de cada palabra.
+
+*   Minúsculas en toda la cadena usando `str.toLowerCase()` .
+    
+*   Reemplace el primer carácter de cada palabra en mayúsculas usando `.replace` .
+    
+*   Busque el carácter al principio de cada palabra, es decir, que coincida con cualquier carácter que siga un `space` o que coincida con el primer carácter de toda la cadena, utilizando el siguiente patrón.
+    
+*   Explicación de Regex:
+    
+*   Buscar todos los caracteres que no sean espacios en blanco `(\S` )
+    
+*   Al comienzo de la cuerda `(^)`
+    
+*   O después de cualquier carácter de espacio en blanco `(\s)`
+    
+    *   El modificador `g` busca otro patrón de palabra similar en toda la cadena y los reemplaza.
+        
+    *   Esta solución funciona con símbolos nacionales y letras acentuadas, como se ilustra en los siguientes ejemplos.  
+        `international characters:` 'бабушка курит трубку' // -> 'Бабушка Курит Трубку'  
+        `accented characters:` 'località àtilacol' // -> 'Località Àtilacol'
+        
+
+#### Enlaces relevantes
+
+*   [Recursos JS Regex](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string/index.md

@@ -0,0 +1,101 @@
+---
+title: Truncate a String
+localeTitle: Truncar una cadena
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Necesitamos reducir la longitud de la cadena o **truncarla** si es más larga que las longitudes máximas especificadas y agregar `...` al final. Si no es tan largo entonces lo mantenemos como está.
+
+#### Enlaces relevantes
+
+*   [String.prototype.slice ()](https://github.com/FreeCodeCamp/FreeCodeCamp/wiki/JS-String-Prototype-Slice)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Las cadenas son inmutables en JavaScript, por lo que necesitaremos una nueva variable para almacenar la cadena truncada.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Deberá usar el método slice () y especificar dónde comenzar y dónde parar.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+No olvide que cuando truncamos la palabra, también debemos contar la longitud agregada por `...`
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function truncateString(str, num) { 
+  // Clear out that junk in your trunk 
+  if (str.length > num && num > 3) { 
+    return str.slice(0, (num - 3)) + '...'; 
+  } else if (str.length > num && num <= 3) { 
+    return str.slice(0, num) + '...'; 
+  } else { 
+    return str; 
+  } 
+ 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/55)
+
+### Explicación del código:
+
+*   Primero, comenzamos con una simple declaración `if` para determinar uno de los tres resultados ...
+*   Si la longitud de nuestra cadena es mayor que el `num` que queremos truncar, y nuestro punto de truncado tiene al menos tres caracteres o más en la cadena, devolvemos un segmento de nuestra cadena que comienza en el carácter 0 y termina en el `num - 3` . Luego agregamos nuestro `'...'` al final de la cadena.
+*   Sin embargo, si la longitud de nuestra cadena es mayor que el `num` pero el `num` está dentro de los primeros tres caracteres, no tenemos que contar nuestros puntos como caracteres. Por lo tanto, devolvemos la misma cadena que la anterior, con una diferencia: el punto final de nuestro sector ahora es solo `num` .
+*   Por último, si ninguna de las situaciones anteriores son ciertos, significa nuestra longitud de la cadena es menor que nuestra truncamiento `num` . Por lo tanto, podemos devolver la cadena.
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+```
+function truncateString(str, num) { 
+  if (str.length <= num) { 
+    return str; 
+  } else { 
+    return str.slice(0, num > 3 ? num - 3 : num) + '...'; 
+  } 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/54)
+
+### Explicación del código:
+
+*   Primero necesitamos una instrucción if para probar si la longitud de la cadena completa que se pasa como primer argumento ya se encuentra dentro del límite de tamaño pasado como segundo argumento. Si es así, podemos devolver la cadena que se pasó.
+    
+    if (str.length <= num) volver str
+    
+*   Si nuestra instrucción `if` falla, nos movemos a `else` , donde devolveremos un "segmento" de la cadena. El método slice extrae una sección de una cadena y devuelve una nueva cadena. Aquí pasamos 0 como punto de partida para nuestra rebanada. Para determinar el punto final, utilizamos un operador ternario: `num > 3 ? num - 3 : num` . En nuestro ternario, si `num` es mayor que 3, debemos tener en cuenta los tres puntos a nuestra longitud total, y así terminamos nuestra división en `num-3` . Si num es menor o igual a 3, nuestra división obtiene una variable final de solo `num` . Finalmente, el `'...'` se agrega al final de nuestra nueva cadena y se devuelve.
+    
+    } else { devuelve str.slice (0, num> 3? num - 3: num) + '…'; }
+    
+*   **NOTA** Para comprender el código anterior, debe comprender cómo funciona un operador ternario. El operador ternario se usa frecuentemente como acceso directo para la sentencia `if` y sigue este formato: `condition ? expr1 : expr2` . Si la `condition` evalúa como verdadera, el operador devuelve el valor de `expr1` . De lo contrario, devuelve el valor de `expr2` .
+    
+
+#### Enlaces relevantes
+
+*   [Operador condicional (ternario)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator)
+*   [String.prototype.slice ()](https://github.com/FreeCodeCamp/FreeCodeCamp/wiki/JS-String-Prototype-Slice)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong/index.md

@@ -0,0 +1,205 @@
+---
+title: Where Do I Belong
+localeTitle: Dónde pertenezco
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Esto puede ser un problema difícil de entender. Debe encontrar en qué lugar de la matriz se debe insertar un número por orden y devolver el índice a donde debe ir.
+
+#### Enlaces relevantes
+
+*   [JS Array Sort](http://forum.freecodecamp.com/t/javascript-array-prototype-sort/14306)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Lo primero que debe hacer es ordenar la matriz de menor a mayor, solo para facilitar el código. Aquí es donde entra la ordenación, necesita una función de devolución de llamada, por lo que debe crearla.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Una vez que la matriz esté ordenada, solo busque el primer número que sea más grande y devuelva el índice.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Si no hay un índice para ese número, también tendrá que lidiar con ese caso.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function getIndexToIns(arr, num) { 
+  arr.sort(function(a, b) { 
+    return a - b; 
+  }); 
+ 
+  for (var a = 0; a < arr.length; a++) { 
+    if (arr[a] >= num) 
+      return a; 
+  } 
+ 
+  return arr.length; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/36)
+
+## Explicación del código:
+
+*   Primero, `.sort(callbackFuntion)` la matriz utilizando `.sort(callbackFuntion)` para clasificarla de menor a mayor, de izquierda a derecha.
+*   Luego uso un bucle for para comparar los elementos de la matriz a partir del más pequeño. Cuando un elemento de la matriz es mayor que el número con el que comparamos, devolvemos el índice como un entero.
+
+#### Enlaces relevantes
+
+*   [parseInt ()](http://forum.freecodecamp.com/t/javascript-parseint/14686)
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function getIndexToIns(arr, num) { 
+  // Find my place in this sorted array. 
+  var times = arr.length; // runs the for loop once for each thing in the array 
+  var count = 0; 
+  for (var i=0;i<times;i++){ 
+    if(num>arr[i]){count++;} } // counts how many array numbers are smaller than num 
+    return count; // the above equals num's position in a sorted array 
+ } 
+ 
+ getIndexToIns([40, 60], 50); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/2547)
+
+## Explicación del código:
+
+*   No ordeno la matriz de entrada arr
+*   Ejecuto un recuento de bucles for cuando la entrada num es más grande que un número de entrada arr.
+*   Este número es equivalente a la posición de num que estaría en una matriz ordenada.
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+por [@HarinaPana](/u/harinapana)
+```
+function getIndexToIns(arr, num) { 
+ 
+  arr.sort(function(a, b) { 
+  return a - b; 
+  }); 
+ 
+  var i = 0; 
+  while (num > arr[i]) { 
+  i++; 
+  } 
+ 
+  return i; 
+ } 
+ 
+ getIndexToIns([40, 60], 50); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/4135)
+
+## Explicación del código:
+
+*   Ordenar la matriz existente.
+*   Iterar a través de la matriz mientras se comprueba si _num_ es más grande.
+*   El bucle se detendrá cuando _num_ no sea mayor que _i_ y devolverá el último elemento marcado.
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+por [@faustodc](/u/faustodc)
+```
+function getIndexToIns(arr, num) { 
+  arr.push(num); 
+  arr.sort(function(a, b){return ab}); 
+  return arr.indexOf(num); 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/EB10/1)
+
+## Explicación del código:
+
+*   Primero agregamos el número `num` a la matriz usando `push()` que lo agrega como el último elemento de la matriz.
+*   Luego usamos `sort()` con la función de `function(a, b){return ab}` devolución de llamada `function(a, b){return ab}` para ordenar los números en orden ascendente.
+*   Finalmente, devolvemos la posición o el índice de `num` en la matriz con la función `indexOf()` .
+
+#### Enlaces relevantes
+
+*   [empujar()](http://forum.freecodecamp.com/t/javascript-array-prototype-push/14298)
+*   [ordenar()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+*   [índice de()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+**Utilizando `.findIndex()`**
+```
+function getIndexToIns(arr, num) { 
+  // sort and find right index 
+  var index = arr.sort((curr, next) => curr > next) 
+    .findIndex((currNum)=> num <= currNum); 
+  // Returns proper answer 
+  return index === -1 ? arr.length : index; 
+ } 
+ 
+ getIndexToIns([40, 60], 500); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLjU/63)
+
+## Explicación del código:
+
+*   Primero ordene la matriz en orden ascendente, esto se hace actualmente usando funciones de matriz para una huella mínima.
+*   Una vez que la matriz está ordenada, aplicamos directamente el `.findIndex()` donde vamos a comparar cada elemento de la matriz hasta que encontremos donde `num <= currNum` significa que el número que queremos insertar es menor o igual al número actual Número en la iteración.
+*   Luego usamos operaciones ternarias para verificar si obtuvimos un índice devuelto o `-1` . Sólo tenemos `-1` cuando no se encontró el índice es decir, cuando tenemos una falsa para todos los elementos que int matriz, y para tal caso, eso significaría que `num` debe insertarse al final de la lista, por tanto, por qué usamos `arr.length` .
+
+#### Enlaces relevantes
+
+*   [Array.findIndex ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
+*   [Funciones de flecha](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions)
+*   [Operador ternario](http://forum.freecodecamp.com/t/javascript-ternary-operator/15973)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+
+por [@nivrith](/u/nivrith)
+```
+function getIndexToIns(arr, num) { 
+ 
+ return arr.concat(num).sort((a,b) => ab).indexOf(num); 
+ 
+ } 
+ 
+ getIndexToIns([1,3,4],2); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/IUJE/0)
+
+## Explicación del código:
+
+*   Utilizamos el encadenamiento de métodos para invocar un método tras otro para resolver el problema en una sola línea. Primero fusionamos `arr` y `num` invocando el método arr.concat (num)
+*   Luego usamos `sort()` con la **función de flecha de** devolución de llamada `(a, b) => return ab` para ordenar los números en orden ascendente
+*   Por último, devolvemos la posición o el índice de `num` en la matriz con el método `indexOf()`
+
+#### Enlaces relevantes
+
+*   [Método de encadenamiento en JavaScript](https://schier.co/blog/2013/11/14/method-chaining-in-javascript.html)
+*   [concat ()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/concat?v=example)
+*   [Funciones de flecha](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/-iterate-through-the-keys-of-an-object-with-a-for...in-statement/index.md

@@ -0,0 +1,69 @@
+---
+title:  Iterate Through the Keys of an Object with a for...in Statement
+localeTitle:  Iterar a través de las claves de un objeto con una for ... in Statement
+---
+## Iterar a través de las claves de un objeto con una for ... in Statement
+
+Método:
+
+*   Nota: `dot-notation` causará errores en este desafío.
+*   `[square-bracket]` debe usar la notación `[square-bracket]` para llamar a un nombre de propiedad variable.
+*   El siguiente código no funcionará.
+
+### Ejemplo 1:
+
+```javascript
+for (let user in obj) { 
+    if(obj.user.online === true) { 
+      //code 
+    } 
+  } 
+```
+
+*   El ejemplo 2 demuestra cómo usar la notación `[square-bracket]` se ejecutará el código.
+
+### Ejemplo 2:
+
+```javascript
+for (let user in obj) { 
+    if(obj[user]online === true) { 
+      //code 
+    } 
+  } 
+```
+
+### Solución:
+
+```javascript
+let users = { 
+  Alan: { 
+    age: 27, 
+    online: false 
+  }, 
+  Jeff: { 
+    age: 32, 
+    online: true 
+  }, 
+  Sarah: { 
+    age: 48, 
+    online: false 
+  }, 
+  Ryan: { 
+    age: 19, 
+    online: true 
+  } 
+ }; 
+ function countOnline(obj) { 
+  // change code below this line 
+  let result = 0; 
+  for (let user in obj) { 
+    if(obj[user].online === true) { 
+      result++; 
+    } 
+  } 
+  return result; 
+  // change code above this line 
+ } 
+ console.log(countOnline(users)); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation/index.md

@@ -0,0 +1,14 @@
+---
+title: Access an Array's Contents Using Bracket Notation
+localeTitle: Acceder a los contenidos de una matriz usando notación de corchete
+---
+## Acceder a los contenidos de una matriz usando notación de corchete
+
+*   Recuerde que el índice de matrices comienza en 0, por lo que la posición de b se ubicará en `myArray[1]` .
+
+## Solución
+
+```javascript
+myArray[1] = "anything we want"; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation/index.md

@@ -0,0 +1,45 @@
+---
+title: Access Property Names with Bracket Notation
+localeTitle: Acceso a nombres de propiedades con notación de corchete
+---
+## Acceso a nombres de propiedades con notación de corchete
+
+Método:
+
+*   Usando la notación de corchetes, simplemente escriba la declaración de retorno en la función `checkInventory()` .
+*   El siguiente bloque de código muestra la sintaxis requerida.
+
+## Ejemplo:
+
+```javascript
+let juice = { 
+  apple: 1.15, 
+  orange: 1.45 
+ }; 
+ function checkInventory(scannedItem) { 
+  return juice[scannedItem]; 
+ } 
+```
+
+## Solución:
+
+```javascript
+let foods = { 
+  apples: 25, 
+  oranges: 32, 
+  plums: 28, 
+  bananas: 13, 
+  grapes: 35, 
+  strawberries: 27 
+ }; 
+ // do not change code above this line 
+ 
+ function checkInventory(scannedItem) { 
+  // change code below this line 
+  return foods[scannedItem]; 
+ } 
+ 
+ // change code below this line to test different cases: 
+ console.log(checkInventory("apples")); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift/index.md

@@ -0,0 +1,23 @@
+---
+title: Add Items to an Array with push() and unshift()
+localeTitle: Agregar elementos a una matriz con push () y unshift ()
+---
+## Agregar elementos a una matriz con push () y unshift ()
+
+*   Al igual que en el ejemplo dado, use el método `.unshift()` en la matriz para agregar elementos al inicio de la matriz y use el método `.push()` para agregar elementos al final de la matriz.
+
+## Solución:
+
+```javascript
+function mixedNumbers(arr) { 
+  // change code below this line 
+ arr.unshift('I',2,'three'); 
+ arr.push(7,'VIII', 9); 
+  // change code above this line 
+  return arr; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(mixedNumbers(['IV', 5, 'six'])); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice/index.md

@@ -0,0 +1,35 @@
+---
+title: Add Items Using splice()
+localeTitle: Agregar artículos usando splice ()
+---
+## Agregar artículos usando splice ()
+
+*   Uso de la función de empalme (), debe quitar los 2 primeros elementos de matriz `arr` y reemplazarlos con `DarkSalmon` y `BlanchedAlmond` .
+*   Recuerde que la función de empalme puede tomar hasta tres parámetros.
+
+## Ejemplo:
+
+```javascript
+arr.splice(0, 1, "Two"); 
+ /*  The first two paramemters are the same as they were in the previous challenge. 
+    `0` will start the `splice()` function off at index 0. 
+    The second parameter `1` will remove only 1 variable from the array. 
+    The final variable "Two" will replace the variable in arr[0]. 
+    Note: The final parameter can take more than 1 arguement. 
+ */ 
+```
+
+## Solución:
+
+```javascript
+function htmlColorNames(arr) { 
+  // change code below this line 
+  arr.splice(0, 2, "DarkSalmon", "BlanchedAlmond"); 
+  // change code above this line 
+  return arr; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurqoise', 'FireBrick'])); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects/index.md

@@ -0,0 +1,30 @@
+---
+title: Add Key-Value Pairs to JavaScript Objects
+localeTitle: Agregue pares de valor-clave a los objetos de JavaScript
+---
+## Agregue pares de valor-clave a los objetos de JavaScript
+
+*   El objeto alimentos ya ha sido declarado. Todo lo que queda por hacer es agregar tres nuevos `key-values` .
+
+```javascript
+OBJECT[{KEY}] = {VALUE} 
+```
+
+*   El código anterior creará un nuevo `key-value` dentro del objeto.
+
+## Solución
+
+```javascript
+let foods = { 
+  apples: 25, 
+  oranges: 32, 
+  plums: 28 
+ }; 
+ // change code below this line 
+ foods['bananas'] = 13; 
+ foods['grapes'] = 35; 
+ foods['strawberries'] = 27; 
+ // change code above this line 
+ console.log(foods); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof/index.md

@@ -0,0 +1,33 @@
+---
+title: Check For The Presence of an Element With indexOf()
+localeTitle: Comprobar la presencia de un elemento con indexOf ()
+---
+## Comprobar la presencia de un elemento con indexOf ()
+
+*   Se puede usar una `if-statement` simple para verificar si el valor devuelto por la función `indexOf()` es menor que 0.
+*   Una vez que se descubre el valor, puede devolver `true` o `false` .
+*   `Solution-1` demuestra cómo una simple `if-statement` puede devolver el resultado correcto.
+
+## Solución-1:
+
+```javascript
+function quickCheck(arr, elem) { 
+  if(arr.indexOf(elem)>=0) { 
+    return true; 
+  } 
+  return false; 
+ } 
+ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); 
+```
+
+*   `Solution-2` demuestra cómo se puede resolver el problema usando `? : (conditional)` operador `? : (conditional)` .
+
+## Solución-2:
+
+```javascript
+function quickCheck(arr, elem) { 
+ return arr.indexOf(elem) >= 0 ? true : false; 
+ } 
+ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property/index.md

@@ -0,0 +1,55 @@
+---
+title: Check if an Object has a Property
+localeTitle: Compruebe si un objeto tiene una propiedad
+---
+## Compruebe si un objeto tiene una propiedad
+
+Método:
+
+*   La forma más sencilla de completar este desafío es crear una `ìf-statement` para verificar si el objeto contiene todos los usuarios, y luego devolver una declaración verdadera o falsa. La primera solución hace justamente esto.
+*   La segunda solución funciona exactamente de la misma manera, solo que utiliza 1 línea de código - `Conditional(ternary)-Operator` - dentro de la función.
+
+[developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) proporciona un análisis más profundo del operador ternario.
+
+### Solución-1:
+
+```javascript
+let users = { 
+  Alan: { 
+    age: 27, 
+    online: true 
+  }, 
+  Jeff: { 
+    age: 32, 
+    online: true 
+  }, 
+  Sarah: { 
+    age: 48, 
+    online: true 
+  }, 
+  Ryan: { 
+    age: 19, 
+    online: true 
+  } 
+ }; 
+ 
+ function isEveryoneHere(obj) { 
+  // change code below this line 
+  if(users.hasOwnProperty('Alan','Jeff','Sarah','Ryan')) { 
+    return true; 
+  } 
+  return false; 
+  // change code above this line 
+ } 
+ 
+ console.log(isEveryoneHere(users)); 
+```
+
+### Solución-2:
+
+```javascript
+function isEveryoneHere(obj) { 
+  return (users.hasOwnProperty('Alan','Jeff','Sarah','Ryan')) ? true : false; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator/index.md

@@ -0,0 +1,21 @@
+---
+title: Combine Arrays with the Spread Operator
+localeTitle: Combina matrices con el operador de propagación
+---
+## Combina matrices con el operador de propagación
+
+*   La solución es exactamente igual al ejemplo dado. Simplemente inserte la matriz del `fragment[]` en la matriz de la `sentence[]` en el índice deseado.
+
+## Solución:
+
+```javascript
+function spreadOut() { 
+  let fragment = ['to', 'code']; 
+  let sentence = ["learning", ...fragment, "is", "fun"]; // change this line 
+  return sentence; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(spreadOut()); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator/index.md

@@ -0,0 +1,20 @@
+---
+title: Copy an Array with the Spread Operator
+localeTitle: Copiar una matriz con el operador de propagación
+---
+## Copiar una matriz con el operador de propagación
+
+*   La sugerencia final del ejemplo le indica que use un método aprendido recientemente.
+*   El operador de propagación copia todos los elementos en un nuevo objeto vacío.
+
+\`\` \`javascript while (num> = 1) { newArr = \[… arr\] num--; }
+```
+- The code above will copy all of the elements into `newArr` but will also reinitialise `newArr` with every new iteration of the while loop. 
+ - A new variable should first be initialised using the spread operator - `let obj = [...arr];` - then this variable should be added to the `newArr` for every iteration of the while loop. 
+ 
+ ## Solution: 
+```
+
+javascript función copyMachine (arr, num) { deja newArr = \[\]; while (num> = 1) { // cambiar código debajo de esta línea newArr.push (\[… arr\]); // cambiar código por encima de esta línea num--; } devuelve newArr; }
+
+// cambia el código aquí para probar diferentes casos: console.log (copyMachine (\[true, false, true\], 2)); \`\` \`

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice/index.md

@@ -0,0 +1,30 @@
+---
+title: Copy Array Items Using slice()
+localeTitle: Copiar elementos de matriz utilizando slice ()
+---
+## Copiar elementos de matriz utilizando slice ()
+
+*   la función `slice()` debe usar para devolver una matriz que consiste solo en `warm` y `sunny` .
+*   Por lo tanto, se deben pasar dos parámetros a la función `slice()` . El primer parámetro debe ser el índice en el que desea que comience la subcadena. El segundo parámetro debe ser el índice en el que finaliza la subcadena.
+*   Nota: el segundo parámetro finalizará la subcadena en ese índice exacto.
+
+## Ejemplo:
+
+```javascript
+ return arr.slice(1,4); 
+ /* This will return a substring consisting of indexs [1,2,3] 
+    Note: arr[4] is NOT included. 
+```
+
+## Solución:
+
+```javascript
+function forecast(arr) { 
+  // change code below this line 
+  return arr.slice(2,4); 
+ } 
+ 
+ // do not change code below this line 
+ console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms'])); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays/index.md

@@ -0,0 +1,28 @@
+---
+title: Create complex multi-dimensional arrays
+localeTitle: Crear complejos arreglos multidimensionales.
+---
+## Crear complejos arreglos multidimensionales.
+
+*   La primera cuerda - `deep` - debe insertarse a tres niveles de profundidad. Esto significa dentro de exactamente tres conjuntos de `[square-brackets]` .
+
+```javascript
+let threeLevelArray = ["first level", ["Two levels deep", ["Three levels deep"]]]; 
+```
+
+*   Usando esta lógica, inserte cadenas más `deep` , `deeper` y `deepest` en la matriz tres niveles de profundidad, cuatro niveles de profundidad y cinco niveles de profundidad respectivamente.
+
+## Solución:
+
+```javascript
+let myNestedArray = [ 
+  // change code below this line 
+  ['unshift', false, 1, 2, 3, 'complex', 'nested'], 
+  ['loop', 'shift', 6, 7, 1000, 'method'], 
+  ['concat', false, true, 'spread', 'array',["deep"]], 
+  ['mutate', 1327.98, 'splice', 'slice', 'push', [["deeper"]]], 
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth', [[["deepest"]]] ] 
+  // change code above this line 
+ ]; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys/index.md

@@ -0,0 +1,42 @@
+---
+title: Generate an Array of All Object Keys with Object.keys()
+localeTitle: Generar una matriz de todas las claves de objeto con Object.keys ()
+---
+## Generar una matriz de todas las claves de objeto con Object.keys ()
+
+### Método:
+
+*   Para devolver la matriz de usuarios, el método `Object.keys()` debe tomar un argumento.
+*   Este desafío se puede resolver utilizando una sola línea de declaración de retorno.
+
+### Solución:
+
+```javascript
+let users = { 
+  Alan: { 
+    age: 27, 
+    online: false 
+  }, 
+  Jeff: { 
+    age: 32, 
+    online: true 
+  }, 
+  Sarah: { 
+    age: 48, 
+    online: false 
+  }, 
+  Ryan: { 
+    age: 19, 
+    online: true 
+  } 
+ }; 
+ 
+ function getArrayOfUsers(obj) { 
+  // change code below this line 
+  return Object.keys(obj); 
+  // change code above this line 
+ } 
+ 
+ console.log(getArrayOfUsers(users)); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/index.md

@@ -0,0 +1,11 @@
+---
+title: Basic Data Structures
+localeTitle: Estructuras de datos básicos
+---
+## Estructuras de datos básicos
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops/index.md

@@ -0,0 +1,54 @@
+---
+title: Iterate Through All an Array's Items Using For Loops
+localeTitle: Iterar a través de todos los elementos de una matriz utilizando bucles for
+---
+## Iterar a través de todos los elementos de una matriz utilizando bucles for
+
+## Sugerencia 1
+
+*   Se debe utilizar un bucle anidado `for` buscar a través de cada elemento de la matriz.
+
+```javascript
+ for (let i = 0; i < arr.length; i++) { 
+```
+
+\`
+
+## Sugerencia 2
+
+*   Cada elemento de la matriz debe compararse con el parámetro `elem` pasado a través de la función `filteredArray()` .
+
+```javascript
+if (arr[i].indexOf(elem)==-1){ 
+```
+
+## Sugerencia 3
+
+*   Si NO se encuentra una coincidencia, a `newArr` se le `newArr` todo el subarreglo. La función `push()` es muy útil aquí.
+
+```javascript
+newArr.push(arr[i]); 
+```
+
+*   Una vez que toda la subarray se agrega a `newArr` el bucle continúa con el siguiente elemento.
+
+## Solución:
+
+```javascript
+function filteredArray(arr, elem) { 
+  let newArr = []; 
+  // change code below this line 
+ 
+ for (let i = 0; i < arr.length; i++) { 
+    if (arr[i].indexOf(elem)==-1){ //Checks every parameter for the element and if is NOT there continues the code 
+          newArr.push(arr[i]); //Inserts the element of the array in the new filtered array 
+            }; 
+          }; 
+ 
+  // change code above this line 
+  return newArr; 
+ }; 
+ // change code here to test different cases: 
+ console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object/index.md

@@ -0,0 +1,45 @@
+---
+title: Modify an Array Stored in an Object
+localeTitle: Modificar una matriz almacenada en un objeto
+---
+## Modificar una matriz almacenada en un objeto
+
+### Método:
+
+*   La función se puede escribir en sólo dos líneas de código.
+*   La primera línea debería usar la función `push()` para agregar el parámetro `friend` a la matriz que se encuentra en `user.data.friend` . La segunda línea devolverá la matriz modificada.
+*   Recuerde que se debe hacer referencia al `user` con el primer parámetro dado a la función `addFriend()` .
+
+### Solución:
+
+```javascript
+let user = { 
+  name: 'Kenneth', 
+  age: 28, 
+  data: { 
+    username: 'kennethCodesAllDay', 
+    joinDate: 'March 26, 2016', 
+    organization: 'freeCodeCamp', 
+    friends: [ 
+      'Sam', 
+      'Kira', 
+      'Tomo' 
+    ], 
+    location: { 
+      city: 'San Francisco', 
+      state: 'CA', 
+      country: 'USA' 
+    } 
+  } 
+ }; 
+ 
+ function addFriend(userObj, friend) { 
+  // change code below this line 
+  userObj.data.friends.push(friend); 
+  return userObj.data.friends; 
+  // change code above this line 
+ } 
+ 
+ console.log(addFriend(user, 'Pete')); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object/index.md

@@ -0,0 +1,46 @@
+---
+title: Modify an Object Nested Within an Object
+localeTitle: Modificar un objeto anidado dentro de un objeto
+---
+## Modificar un objeto anidado dentro de un objeto
+
+Método:
+
+*   Recuerde que el objeto que desea cambiar tiene dos niveles de profundidad, `dot-notation` es más fácil de usar en esta instancia.
+*   Simplemente defina el objeto y luego use `dot-notation` para acceder al segundo objeto y finalmente el elemento final que desea modificar.
+
+## Ejemplo:
+
+```javascript
+let myObject = { 
+  level_1: 'outside', 
+  first_level_object: { 
+    level_2: '2 levels deep', 
+    second_level_object: { 
+      level_3: '3 levels deep' 
+      } 
+   } 
+ }; 
+ //The following line of code will modify the data found in level_2. 
+ myObject.first_level_object.level_2 = 'level-2 has been reached'; 
+```
+
+## Solución:
+
+```javascript
+let userActivity = { 
+  id: 23894201352, 
+  date: 'January 1, 2017', 
+  data: { 
+    totalUsers: 51, 
+    online: 42 
+  } 
+ }; 
+ 
+ // change code below this line 
+ userActivity.data.online = 45; 
+ // change code above this line 
+ 
+ console.log(userActivity); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift/index.md

@@ -0,0 +1,21 @@
+---
+title: Remove Items from an Array with pop() and shift()
+localeTitle: Eliminar elementos de una matriz con pop () y shift ()
+---
+## Eliminar elementos de una matriz con pop () y shift ()
+
+*   El `.pop()` método y `.shift()` método debe ser llamado y inicializado usando los `popped` y `shifted` variables para devolver la respuesta correcta de la función.
+
+## Solución:
+
+```javascript
+function popShift(arr) { 
+  let popped = arr.pop(); 
+  let shifted = arr.shift(); 
+  return [shifted, popped]; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(popShift(['challenge', 'is', 'not', 'complete'])); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice/index.md

@@ -0,0 +1,23 @@
+---
+title: Remove Items Using splice()
+localeTitle: Quitar elementos utilizando empalme ()
+---
+## Quitar elementos utilizando empalme ()
+
+*   Se debe llamar a la función `splice()` en la matriz `arr` para eliminar 1 o más elementos del centro de la matriz.
+*   La matriz `arr` actualmente suma el valor de 16. Simplemente elimine todas las variables necesarias para obtener 10.
+
+## Solución:
+
+```javascript
+function sumOfTen(arr) { 
+  // change code below this line 
+  arr.splice(1,2); 
+  // change code above this line 
+  return arr.reduce((a, b) => a + b); 
+ } 
+ 
+ // do not change code below this line 
+ console.log(sumOfTen([2, 5, 1, 5, 2, 1])); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data/index.md

@@ -0,0 +1,28 @@
+---
+title: Use an Array to Store a Collection of Data
+localeTitle: Utilice una matriz para almacenar una colección de datos
+---
+## Utilice una matriz para almacenar una colección de datos
+
+### Método:
+
+*   En JS, las matrices son una de las estructuras de datos más utilizadas. A diferencia de otros idiomas, las matrices en JS pueden almacenar diferentes tipos de datos y también pueden cambiar su tamaño en tiempo de ejecución y, por lo tanto, también se denominan "matrices dinámicas". También están 0 indexados.
+*   Las matrices se pueden inicializar de diferentes maneras:
+
+1.  Literales array
+2.  Constructores de matrices
+
+*   En este desafío nos centraremos en los literales de Array. Para inicializar una matriz simplemente `let arr = [];`
+*   Podemos agregar valores a esta matriz accediendo a su índice, ejemplo: `javascript let arr = []; arr[0] = "hello"; console.log(arr); // ["hello"]`
+*   También podemos inicializar los valores en el arreglo cuando lo declaremos, ejemplo: `javascript let arr = [1, 2, 3, "John"];`
+*   En este desafío, debe crear una matriz con al menos 5 elementos y al menos una cadena, un número y un booleano.
+
+### Solución:
+
+```js
+ let yourArray = ["a", 2, true, "c", null, {name: "john"}]; 
+```
+
+### Recursos
+
+Más información sobre matrices en [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties/index.md

@@ -0,0 +1,27 @@
+---
+title: Use the delete Keyword to Remove Object Properties
+localeTitle: Utilice la palabra clave delete para eliminar las propiedades del objeto
+---
+## Utilice la palabra clave delete para eliminar las propiedades del objeto
+
+[Developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete) proporciona un tutorial completo sobre el operador de eliminación.
+
+### Solución:
+
+```javascript
+let foods = { 
+  apples: 25, 
+  oranges: 32, 
+  plums: 28, 
+  bananas: 13, 
+  grapes: 35, 
+  strawberries: 27 
+ }; 
+ // change code below this line 
+ delete foods.oranges; 
+ delete foods.plums; 
+ delete foods.strawberries; 
+ // change code above this line 
+ console.log(foods); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes/index.md

@@ -0,0 +1,17 @@
+---
+title: Access Array Data with Indexes
+localeTitle: Acceso a datos de matriz con índices
+---
+## Acceso a datos de matriz con índices
+
+El primer elemento de una matriz está en la posición cero. Entonces, si desea acceder al primer elemento de una matriz, puede hacerlo así:
+
+```javascript
+var arr = ["Programming", 123, "Coding", 789]; 
+ 
+ var firstElem = arr[0] // This is "Programming" 
+ var thirdElem = arr[2] // This is "Coding" 
+ var fourthElem = arr[3] // This is 789 
+```
+
+Observe que la longitud de la matriz es 4, y la posición del último elemento de la matriz es 3.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes/index.md

@@ -0,0 +1,29 @@
+---
+title: Access Multi-Dimensional Arrays With Indexes
+localeTitle: Acceder a matrices multidimensionales con índices
+---
+## Acceder a matrices multidimensionales con índices
+
+Considere la siguiente matriz multidimensional:
+
+```javascript
+var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]; 
+```
+
+Esto es lo que parece en forma tabular.
+
+| Posición | 0 | 1 | 2 | 3 | | --- | --- | --- | --- | --- | | **0** | 1 | 4 | 7 | 10 | | **1** | 2 | 5 | 8 | 11 | | **2** | 3 | 6 | 9 | 12 |
+
+¡Ahora todo lo que tiene que hacer es elegir las coordenadas de los datos que desea! Por ejemplo, si queremos que `myNum` igual a 8, entonces ...
+
+```javascript
+var myNum = arr[2][1]; // Equal to 8 
+```
+
+O, si quieres que sea igual a 1. Lo haces ...
+
+```javascript
+var myNum = arr[0][0]; // Equal to 1 
+```
+
+Primero comienza seleccionando en qué columna está el número, luego eliges la fila. Es algo así como el plano de coordenadas xy!

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays/index.md

@@ -0,0 +1,69 @@
+---
+title: Accessing Nested Arrays
+localeTitle: Acceso a matrices anidadas
+---
+## Acceso a matrices anidadas
+
+### Accediendo a elementos dentro de una matriz usando notación de corchete `[]`
+
+```js
+var fruitBasket = ['apple', 'banana' 'orange', 'melon']; 
+ var favoriteFruit = fruitBasket[2]; 
+ 
+ console.log(favoriteFruit) // 'orange' 
+```
+
+En este ejemplo, nuestra fruta favorita es 'naranja', que está en el índice `2` en la matriz `fruitBasket` . Usando la notación de braket, asignamos el índice `2` de la matriz `fruitBasket` a `favoriteFruit` . Esto hace que `favoriteFruit` sea ​​igual a 'naranja'.
+
+### Accediendo a objetos dentro de arreglos usando braket `[]` y dot `.` notación
+
+```js
+var garage = [ 
+  { 
+    type: 'car', 
+    color: 'red', 
+    make: 'Ford' 
+  }, 
+  { 
+    type: 'motorbike', 
+    color: 'black', 
+    make: 'Yamaha' 
+  }, 
+  { 
+    type: 'bus', 
+    color: 'yellow', 
+    make: 'Blue Bird' 
+  } 
+ ]; 
+ 
+ var busColor = garage[2].color; // 'yellow' 
+```
+
+## Solución:
+
+```js
+// Setup 
+ var myPlants = [ 
+  { 
+    type: "flowers", 
+    list: [ 
+      "rose", 
+      "tulip", 
+      "dandelion" 
+    ] 
+  }, 
+  { 
+    type: "trees", 
+    list: [ 
+      "fir", 
+      "pine", 
+      "birch" 
+    ] 
+  } 
+ ]; 
+ 
+ // Only change code below this line 
+ 
+ var secondTree = myPlants[1].list[1]; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects/index.md

@@ -0,0 +1,50 @@
+---
+title: Accessing Nested Objects
+localeTitle: Accediendo a objetos anidados
+---
+## Accediendo a objetos anidados
+
+Pista: **_"Use la notación de corchete para las propiedades con un espacio en su nombre"._**
+
+Si miramos nuestro objeto:
+
+```javascript
+var myStorage = { 
+  "car": { 
+    "inside": { 
+      "glove box": "maps", 
+      "passenger seat": "crumbs" 
+     }, 
+    "outside": { 
+      "trunk": "jack" 
+    } 
+  } 
+ }; 
+```
+
+Nuestro nombre de objeto es `myStorage` .
+
+| - Dentro de eso tenemos un objeto anidado llamado `car` .
+
+| --- Dentro de eso tenemos dos más llamados `inside` y `outside` cada uno con su propiedades propias
+
+Puedes visualizar la estructura del objeto de esta manera, si te ayuda:
+```
+myStorage 
+ |-- car 
+ |--- inside 
+ |----- glove box: maps 
+ |----- passenger seat: crumbs 
+ |--- outside 
+ |----- trunk: jack 
+```
+
+Se nos pide que asignemos los contenidos de la `glove box` , Lo que podemos ver está anidado en el objeto `inside` , que a su vez, está anidado en el objeto del `car` .
+
+Podemos usar la notación de puntos para acceder a la `glove box` siguiente manera:
+
+```javascript
+var gloveBoxContents = myStorage.car.inside'complete here' 
+```
+
+Debe reemplazar `complete here` con la forma correcta de acceder a la propiedad. Ver la pista de arriba si te quedas atascado.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation/index.md

@@ -0,0 +1,21 @@
+---
+title: Accessing Object Properties with Bracket Notation
+localeTitle: Acceso a las propiedades del objeto con notación de corchete
+---
+## Acceso a las propiedades del objeto con notación de corchete
+
+Aquí hay una posible solución:
+
+```js
+var testObj = { 
+  "an entree": "hamburger", 
+  "my side": "veggies", 
+  "the drink": "water" 
+ }; 
+ 
+ // Only change code below this line 
+ 
+ var entreeValue = testObj["an entree"];   // Change this line 
+ var drinkValue = testObj["the drink"];    // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation/index.md

@@ -0,0 +1,21 @@
+---
+title: Accessing Object Properties with Dot Notation
+localeTitle: Acceso a las propiedades del objeto con notación de puntos
+---
+## Acceso a las propiedades del objeto con notación de puntos
+
+Aquí hay una posible solución:
+
+```js
+var testObj = { 
+  "hat": "ballcap", 
+  "shirt": "jersey", 
+  "shoes": "cleats" 
+ }; 
+ 
+ // Only change code below this line 
+ 
+ var hatValue = testObj.hat;      // Change this line 
+ var shirtValue = testObj.shirt;    // Change this line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables/index.md

@@ -0,0 +1,22 @@
+---
+title: Accessing Object Properties with Variables
+localeTitle: Accediendo a las propiedades del objeto con variables
+---
+## Accediendo a las propiedades del objeto con variables
+
+Aquí hay una solución de trabajo en caso de que esté atascado:
+
+```js
+// Setup 
+ var testObj = { 
+  12: "Namath", 
+  16: "Montana", 
+  19: "Unitas" 
+ }; 
+ 
+ // Only change code below this line; 
+ 
+ var playerNumber = 16;       // Change this Line 
+ var player = testObj[playerNumber];   // Change this Line 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object/index.md

@@ -0,0 +1,33 @@
+---
+title: Add New Properties to a JavaScript Object
+localeTitle: Agregar nuevas propiedades a un objeto de JavaScript
+---
+## Agregar nuevas propiedades a un objeto de JavaScript
+
+Aquí está el ejemplo:
+
+```js
+var ourDog = { 
+  "name": "Camper", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["everything!"] 
+ }; 
+ 
+ ourDog.bark = "bow-wow"; 
+```
+
+Aquí hay una solución:
+
+```js
+var myDog = { 
+  "name": "Happy Coder", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["freeCodeCamp Campers"] 
+ }; 
+ 
+ // Only change code below this line. 
+ myDog.bark = "woof"; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Add Two Numbers with JavaScript
+localeTitle: Añadir dos números con JavaScript
+---
+# Añadir dos números con JavaScript
+
+JavaScript usa el símbolo `+` para la suma.
+```
+var sum = 10 + 10; //sum gets the value 20 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements/index.md

@@ -0,0 +1,28 @@
+---
+title: Adding a Default Option in Switch Statements
+localeTitle: Adición de una opción predeterminada en los estados de cambio
+---
+# Adición de una opción predeterminada en los estados de cambio
+
+*   Al agregar una opción predeterminada, se asegura de que, en caso de que su variable no coincida con ninguna de las opciones, se use el valor predeterminado.
+
+## Solución:
+
+```javascript
+function switchOfStuff(val) { 
+  var answer = ""; 
+ 
+  switch(val){ 
+    case 'a': answer = 'apple'; 
+    break; 
+    case 'b': answer = 'bird'; 
+    break; 
+    case 'c': answer = 'cat'; 
+    break; 
+    default: answer = 'stuff'; 
+  } 
+ 
+  return answer; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings/index.md

@@ -0,0 +1,13 @@
+---
+title: Appending Variables to Strings
+localeTitle: Anexando Variables a las Cadenas
+---
+## Anexando Variables a las Cadenas
+
+Asegúrese de que su ortografía y el espaciado son correctos. Anexar cadenas (almacenadas dentro de variables) se puede hacer así:
+```
+var adj = "happy!"; 
+ var sent = "Today, I woke up being "; 
+ sent += adj; // The result is "Today, I woke up being happy!" 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value/index.md

@@ -0,0 +1,14 @@
+---
+title: Assignment with a Returned Value
+localeTitle: Asignación con un valor devuelto
+---
+## Asignación con un valor devuelto
+
+Las funciones actúan como marcadores de posición para los datos que generan. Básicamente, puede asignar la salida de una función a una variable, al igual que cualquier dato normal.
+
+Aquí está la solución de código básico:
+
+```javascript
+processed = processArg(7); // Equal to 2 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects/index.md

@@ -0,0 +1,19 @@
+---
+title: Build JavaScript Objects
+localeTitle: Construir objetos de JavaScript
+---
+# Construir objetos de JavaScript
+
+Los objetos son similares a las matrices, excepto que, en lugar de utilizar índices para acceder y modificar sus datos, puede acceder a los datos de los objetos a través de lo que se denomina propiedades.
+
+Aquí hay un objeto de muestra:
+```
+var cat = { 
+    "name": "Whiskers", 
+    "legs": 4, 
+    "tails": 1, 
+    "enemies": ["Water", "Dogs"] 
+ }; 
+```
+
+Los objetos son útiles para almacenar datos de forma estructurada y pueden representar objetos del mundo real, como los gatos.

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements/index.md

@@ -0,0 +1,63 @@
+---
+title: Chaining If Else Statements
+localeTitle: Encadenamiento en caso contrario
+---
+## Encadenamiento en caso contrario
+
+*   `If` : el primer condicional en cada sentencia if / else, en caso de que el condicional sea _verdadero_ , ejecute el código e ignore el resto.
+*   `Else if` : nunca se puede utilizar como el primer condicional. Siempre es un condicional después de un `if` , en caso de que el condicional sea verdadero, ejecute el código. De lo contrario salta al siguiente condicional.
+*   `Else` : en caso de que todos los condicionales anteriores sean _falsos_ , de lo **contrario** se ejecuta.
+
+### Explicación del problema:
+
+_Escriba las instrucciones `if` / `else if` encadenadas para cumplir las siguientes condiciones_ :
+
+_`num < 5` - devuelve "Tiny" `num < 10` - devuelve "Small" `num < 15` - devuelve "Medio" `num < 20` - devuelve "Large" `num >= 20` - devuelve "Enorme"_
+
+#### Sugerencia 1
+
+Recuerde que puede combinar (encadenar) varias declaraciones `if...else` , una después de la otra, hasta que la última use `else if (condition) {do this}` .
+
+> _intenta resolver el problema ahora_
+> 
+> #### Sugerencia 2
+> 
+> A veces, cuando escribes más código del que estás acostumbrado y no funciona, las pequeñas cosas son las que nos traicionan. La comprobación de puntos y comas que faltan, corchetes, etc. puede resultar muy útil. _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución:
+
+```javascript
+function testSize(num) { 
+  // Only change code below this line 
+  if (num < 5){ 
+    return "Tiny"; 
+  } 
+  else if (num < 10) { 
+    return "Small"; 
+  } 
+  else if (num < 15){ 
+    return "Medium"; 
+  } 
+  else if (num < 20){ 
+    return "Large"; 
+  } 
+  else { 
+    return "Huge"; 
+  } 
+  // Only change code above this line 
+ } 
+```
+
+· Ejecutar código en [repl.it](https://repl.it/@AdrianSkar/Basic-JS-Chaining-ifelse-statements)
+
+### Explicación del código
+
+La función primero verifica la condición `if` `(num < 5)` . Si se evalúa como `true` , devuelve la instrucción entre las llaves ("Diminuto"). Si no lo hace, verifica la siguiente condición hasta la última declaración de lo `else` .
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code/index.md

@@ -0,0 +1,22 @@
+---
+title: Comment Your JavaScript Code
+localeTitle: Comenta tu código JavaScript
+---
+## Comenta tu código JavaScript
+
+El comentar le permite escribir cosas que no desea que la computadora ejecute como código. Por ejemplo, notas a otros programadores, direcciones y más. Aquí es cómo crear un comentario de una sola línea.
+```
+// Hey, I'm a comment! 
+```
+
+Ahora, si quieres comentar un párrafo completo, eso se puede lograr fácilmente con ...
+```
+/* 
+  Hey, I'm a paragraph comment. 
+  This allows for programmers to 
+  write tons and tons of random 
+  words, without the fear of me 
+  being compiled! 
+ */ 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator/index.md

@@ -0,0 +1,46 @@
+---
+title: Comparison with the Equality Operator
+localeTitle: Comparación con el operador de igualdad
+---
+## Comparación con el operador de igualdad
+
+### Explicación del problema:
+
+_Agregue el operador de igualdad a la línea indicada para que la función devuelva "Igual" cuando `val` sea ​​equivalente a 12._
+
+#### Sugerencia 1
+
+Recuerde que la _igualdad es diferente de la asignación ( `=` ), que asigna el valor a la derecha del operador a una variable en la izquierda._ [1](#cite1)
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+function testEqual(val) { 
+  if (val == 12) { // Change this line 
+    return "Equal"; 
+  } 
+  return "Not equal"; 
+ } 
+ // Change this value to test 
+ testEqual(10); 
+```
+
+· [Ejecutar código en repl.it](https://repl.it/@AdrianSkar/Basic-JS-Equality-operator)
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(val == 12)` evalúa como `true` . Si lo hace, devuelve la instrucción entre las llaves ("Igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("No es igual").
+
+### Fuentes
+
+1 . ["JavaScript básico: comparación con el operador de igualdad", lección de la FCC en la _certificación de algoritmos y estructuras de datos de Javascript_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)
+
+### Recursos
+
+*   ["Operador de igualdad" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality_())

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Greater Than Operator
+localeTitle: Comparación con el operador mayor que
+---
+## Comparación con el operador mayor que
+
+`>` (Greater Than) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es más alto que el de la derecha.
+
+## Solucion basica
+
+```javascript
+function testGreaterThan(val) { 
+  if (val > 100) 
+    return "Over 100"; 
+ 
+  if (val > 10) 
+    return "Over 10"; 
+ 
+  return "10 or Under"; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Greater Than Or Equal To Operator
+localeTitle: Comparación con el operador mayor o igual que el operador
+---
+## Comparación con el operador mayor o igual que el operador
+
+*   `>=` (Mayor que o Igual a) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es el **mismo o superior** al de la derecha.
+
+## Solucion basica
+
+```javascript
+function testGreaterOrEqual(val) { 
+  if (val >= 20) 
+    return "20 or Over"; 
+ 
+  if (val >= 10) 
+    return "10 or Over"; 
+ 
+  return "Less than 10"; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator/index.md

@@ -0,0 +1,20 @@
+---
+title: Comparison with the Inequality Operator
+localeTitle: Comparación con el operador de desigualdad
+---
+## Comparación con el operador de desigualdad
+
+*   `!=` (Desigualdad) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es diferente del de la derecha.
+*   El operador de desigualdad considera que `7` y `"7"` son iguales porque no compara el tipo de variable.
+
+## Solucion basica
+
+```javascript
+function testNotEqual(val) { 
+  if (val != 99) 
+    return "Not Equal"; 
+ 
+  return "Equal"; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Less Than Operator
+localeTitle: Comparación con el operador menor que
+---
+## Comparación con el operador menor que
+
+**`<`** (Menos que) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es más bajo que el de la derecha.
+
+## Solucion basica
+
+```javascript
+function testLessThan(val) { 
+  if (val < 25) 
+    return "Under 25"; 
+ 
+  if (val < 55) 
+    return "Under 55"; 
+ 
+  return "55 or Over"; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Less Than Or Equal To Operator
+localeTitle: Comparación con el operador menor o igual que
+---
+## Comparación con el operador menor o igual que
+
+**`<=`** (Menos que o igual a) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es el **mismo o inferior** al de la derecha.
+
+## Solucion basica
+
+```javascript
+function testLessOrEqual(val) { 
+  if (val <= 12) 
+    return "Smaller Than or Equal to 12"; 
+ 
+  if (val <= 24) 
+    return "Smaller Than or Equal to 24"; 
+ 
+  return "More Than 24"; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator/index.md

@@ -0,0 +1,56 @@
+---
+title: Comparison with the strict equality operator
+localeTitle: Comparación con el operador de igualdad estricta.
+---
+## Comparación con el operador de igualdad estricta.
+
+### Explicación del problema:
+
+· _Use el operador de igualdad estricta en la instrucción `if` para que la función devuelva "Igual" cuando `val` sea ​​estrictamente igual a `7` ._
+
+#### Sugerencia 1
+
+Recuerde, desde el último ejercicio, que la _igualdad es diferente de la asignación ( `=` ), que asigna el valor a la derecha del operador a una variable en la izquierda._ [1](#cite1)
+
+> _intenta resolver el problema ahora_
+> 
+> #### Sugerencia 2
+> 
+> _A diferencia del operador de igualdad, que intenta convertir ambos valores en comparación con un tipo común, el operador de igualdad estricta no realiza una conversión de tipo._ [2](#cite2) _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+// Setup 
+ function testStrict(val) { 
+  if (val === 7) { // Change this line 
+    return "Equal"; 
+  } 
+  return "Not equal"; 
+ } 
+ 
+ // Change this value to test 
+ testStrict(10); 
+```
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(val === 7)` evalúa como `true` . Si lo hace, devuelve la instrucción entre las llaves ("Igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("No es igual").
+
+### Fuentes
+
+1 . ["JavaScript básico: comparación con el operador de igualdad", lección de la FCC en la _certificación de algoritmos y estructuras de datos de Javascript_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)
+
+2 . ["JavaScript Básico: Comparación con el Operador de Igualdad Estricta", lección de la FCC en _Algoritmos de Javascript y Certificación de Estructuras de Datos_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator)
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)
+    
+*   [Kondov, Alexander. "Entendiendo JS: Coerción". _Hackernoon_](https://hackernoon.com/understanding-js-coercion-ff5684475bfc) , consultado el 15 de septiembre de 2018
+    
+*   ["Operadores de comparación" - _Referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator/index.md

@@ -0,0 +1,41 @@
+---
+title: Comparison with the Strict Inequality Operator
+localeTitle: Comparación con el operador de desigualdad estricta
+---
+## Comparación con el operador de desigualdad estricta
+
+### Explicación del problema:
+
+· _Agregue el `strict inequality operator` a la instrucción `if` para que la función devuelva "No igual" cuando `val` no sea estrictamente igual a `17` ._
+
+#### Sugerencia 1
+
+El operador de desigualdad estricta ( `!==` ) devolverá `true` si el primer valor no es igual al segundo teniendo en cuenta el tipo de valor.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+function testStrictNotEqual(val) { 
+  if (val !== 17) { 
+    return "Not equal"; 
+  } 
+  return "Equal"; 
+ } 
+ 
+ // Change this value to test 
+ testStrictNotEqual(10); 
+```
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(val !== 17)` evalúa como `true` considerando tanto el valor como el tipo de valor. Si lo hace, devuelve la instrucción entre las llaves ("No es igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("Igual").
+
+### Recursos
+
+*   ["No identidad / desigualdad estricta (! ==)" - _Referencia de JavaScript de MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Non-identity_strict_inequality_(!))

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator/index.md

@@ -0,0 +1,53 @@
+---
+title: Comparisons with the && (logical AND) operator
+localeTitle: Comparaciones con el operador && (AND lógico)
+---
+## Comparaciones con el operador && (AND lógico)
+
+### Explicación del problema:
+
+· _Combine las dos declaraciones if en una declaración que devolverá `"Yes"` si `val` es menor o igual a `50` y mayor o igual a `25` . De lo contrario, devolverá `"No"` ._
+
+#### Sugerencia 1
+
+El operador lógico AND ( `&&` ) compara ambas afirmaciones y devuelve `true` solo si ambos son verdaderos o se pueden convertir en verdaderos (truey).
+
+> _intenta resolver el problema ahora_
+
+#### Sugerencia 2
+
+Recuerde que este efecto puede también lograrse mediante la anidación `if` las declaraciones.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+function testLogicalAnd(val) { 
+  // Only change code below this line 
+ 
+  if (val <= 50 && val >= 25) { 
+      return "Yes"; 
+  } 
+ 
+  // Only change code above this line 
+  return "No"; 
+ } 
+ 
+ // Change this value to test 
+ testLogicalAnd(10); 
+```
+
+· [Ejecutar código en repl.it](https://repl.it/@AdrianSkar/Basic-JS-Comparison-with-the-and-operator)
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `val <= 50` evalúa como `true` conversión de `val` en un número si es necesario, luego hace lo mismo con `val >=25` debido al operador lógico AND ( `&&` ); Si ambos devuelven verdadero, se ejecuta la instrucción de `return "Yes"` .
+
+### Recursos
+
+*   ["Operadores lógicos" - _Referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator/index.md

@@ -0,0 +1,19 @@
+---
+title: Comparisons with the Logical Or Operator
+localeTitle: Comparaciones con el operador lógico o
+---
+## Comparaciones con el operador lógico o
+
+### Guía: Sigue el código dado en el ejemplo.
+
+**Alerta de spoiler**
+
+A continuación se muestra el código de ejemplo (la forma más sencilla).
+
+```javascript
+if ( val < 10 || val > 20 ) { 
+    return "Outside"; 
+ } 
+```
+
+El código anterior devolverá "Fuera" solo si `val` está entre 10 y 20 (inclusive).

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Addition
+localeTitle: Asignación compuesta con adición aumentada
+---
+## Asignación compuesta con adición aumentada
+
+Las computadoras leen de izquierda a derecha. Entonces, usar el operador '+ =' significa que la variable se agrega con el número correcto, luego la variable se asigna a la suma. Al igual que:
+```
+var a = 9; 
+ a += 10; // Now, 'a' is equal to 19 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Division
+localeTitle: Asignación compuesta con división aumentada
+---
+## Asignación compuesta con división aumentada
+
+Las computadoras leen de izquierda a derecha. Entonces, usar el operador '/ =' significa que la variable se divide con el número a la derecha, luego la variable se asigna al cociente. Al igual que:
+```
+var d = 10; 
+ d /= 5; // Now, 'd' is equal to 2 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Multiplication
+localeTitle: Asignación compuesta con multiplicación aumentada
+---
+## Asignación compuesta con multiplicación aumentada
+
+Las computadoras leen de izquierda a derecha. Por lo tanto, usar el operador de asignación de multiplicación significa que la variable se multiplica por el número a la derecha, luego la variable se asigna al producto. Al igual que:
+```
+var c = 2; 
+ c *= 3; // Now, 'c' is equal to 6 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Subtraction
+localeTitle: Asignación compuesta con resta aumentada
+---
+## Asignación compuesta con resta aumentada
+
+Las computadoras leen de izquierda a derecha. Entonces, usar el operador '- =' significa que la variable se resta por el número a la derecha, luego la variable se asigna a la diferencia. Al igual que:
+```
+var b = 10; 
+ b -= 4; // Now, 'b' is 6 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator/index.md

@@ -0,0 +1,12 @@
+---
+title: Concatenating Strings with Plus Operator
+localeTitle: Concatenando cuerdas con el operador Plus
+---
+## Concatenando cuerdas con el operador Plus
+
+Concatenar significa enlazar juntos. Piense en el operador '+' como una cadena que une cadenas; agrega las cuerdas al igual que agregas números. ¡Asegúrate que tu ortografía esté correcta! Toma nota de los espacios entre las palabras.
+```
+var str = "Good " + "job!" // It says "Good job!" 
+ var abc = "Good" + "job!" // It says "Goodjob!" 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator/index.md

@@ -0,0 +1,13 @@
+---
+title: Concatenating Strings with the Plus Equals Operator
+localeTitle: Concatenando cadenas con el operador Plus Equals
+---
+## Concatenando cadenas con el operador Plus Equals
+
+El operador '+ =' puede concatenar (enlazar) cadenas fácilmente. Asegúrese de que su ortografía sea correcta y que haya dejado los espacios apropiados.
+```
+var str = "Hello "; 
+ str += "coding"; // Now the string reads "Hello coding" 
+ str += "camper!"; // And now the string reads "Hello codingcamper!" 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables/index.md

@@ -0,0 +1,14 @@
+---
+title: Constructing Strings with Variables
+localeTitle: Construyendo cuerdas con variables
+---
+## Construyendo cuerdas con variables
+
+Agregue variables que almacenen cadenas, para crear cadenas más largas. Asegúrese de que su ortografía y el espacio sea correcto.
+```
+var myName = "Bobby"; 
+ var myFavLetter = "B"; 
+ var sentence = "Hello, I'm " + myName + ". My favorite letter is " + myFavLetter + "."; 
+  //The result is "Hello, I'm Bobby. My favorite letter is B. 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop/index.md

@@ -0,0 +1,48 @@
+---
+title: Count Backwards With a For Loop
+localeTitle: Contar hacia atrás con un bucle for
+---
+## Contar hacia atrás con un bucle for
+
+Aquí está el ejemplo:
+
+```javascript
+// Example 
+ var ourArray = []; 
+ 
+ for (var i = 10; i > 0; i -= 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+```
+
+#### SUGERENCIA: 1
+
+*   crear un nuevo for for loop para myArray
+
+#### SUGERENCIA: 2
+
+*   comienza desde el primer número impar justo antes del 9
+
+# ADVERTENCIA DE SPOILER: SOLUCIÓN A CONTINUACIÓN
+
+```javascript
+var ourArray = []; 
+ 
+ for (var i = 10; i > 0; i -= 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+ for (var i = 9; i > 0; i-=2){ 
+  myArray.push(i) 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/counting-cards/index.md

@@ -0,0 +1,134 @@
+---
+title: Counting Cards
+localeTitle: Tarjetas de conteo
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+En el juego de casino **Blackjack** , un jugador puede obtener una ventaja sobre la casa al hacer un seguimiento del número relativo de cartas altas y bajas que quedan en el mazo. Esto se llama conteo de cartas.
+
+Tener más cartas altas en el mazo favorece al jugador. A cada tarjeta se le asigna un valor de acuerdo con la siguiente tabla. Cuando el conteo es positivo, el jugador debe apostar alto. Cuando el conteo es cero o negativo, el jugador debe apostar bajo.
+
+Valor | Tarjetas  
+\----- | : -------------------:  
++1 | 2, 3, 4, 5, 6  
+0 | 7, 8, 9  
+\-1 | 10, 'J', 'Q', 'K', 'A'
+
+Escribirás una función de conteo de cartas. Recibirá un parámetro de **tarjeta** e incrementará o disminuirá la variable de **conteo** global de acuerdo con el valor de la tarjeta (consulte la tabla). La función devolverá una cadena con el recuento actual y la cadena `Bet` si el recuento es positivo, o `Hold` si el recuento es cero o negativo. El conteo actual y la decisión del jugador ( `Bet` o `Hold` ) deben estar separados por un solo espacio.
+
+*   Cambie el código a continuación `// Only change code below this line` y hasta `// Only change code above this line`
+*   Asegúrese de que está editando el interior de la función `cc` .
+*   Use lo que ha aprendido para verificar el valor de cada parámetro de **tarjeta** que se pasó a la función.
+*   Mantenga una cuenta corriente de ese número.
+*   Si el conteo final es 1 o mayor, devuelve **\# Mantener** .
+*   Si el conteo final es 0 o menos, devuelve **\# Bet** .
+
+**Ejemplo de salida:**
+
+*   \-3 espera
+*   5 Apuesta
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Use una instrucción de `switch` (o `else if` ) para contar el valor de cada tarjeta.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Suma / resta el valor de cada carta a la **cuenta** variable. Si la tarjeta vale 0, no hagas nada.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Una vez que haya contado las tarjetas, use una instrucción `if` para verificar el valor del **conteo** . Además, asegúrese de que su `return` tenga un espacio entre el número y la cadena.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+    function cc(card) { 
+      // Only change code below this line 
+      switch(card){ 
+        case 2: 
+        case 3: 
+        case 4: 
+        case 5: 
+        case 6: 
+          count++; 
+          break; 
+        case 10: 
+        case "J": 
+        case "Q": 
+        case "K": 
+        case "A": 
+          count--; 
+          break; 
+      } 
+      if (count > 0){ 
+        return count + " Bet"; 
+      } else { 
+        return count + " Hold"; 
+      } 
+      // Only change code above this line 
+    } 
+```
+
+### Explicación del código:
+
+*   Compruebe el valor de cada tarjeta a través de una declaración de `switch` .
+*   La **cuenta** variable:
+    *   Aumenta en 1 si la tarjeta es un 2, 3, 4, 5 o 6.
+    *   Como 7, 8 y 9 no valen nada, ignoramos esas tarjetas en nuestra declaración de `switch` .
+    *   Disminuye en 1 si la tarjeta es un 10, 'J', 'Q', 'K' o 'A'.
+*   Verifique el valor de **contar** y devuelva la respuesta apropiada.
+
+**Ejecución de ejemplo**
+
+*   `cc(2);` carreras.
+*   La instrucción de `switch` golpea el `case 2` , salta hacia abajo y agrega 1 a la `count` variable.
+*   La instrucción `switch` `break` y `cc(3);` carreras.
+*   Este ciclo continúa hasta que se realiza la llamada final, `cc('A');` .
+*   Después de la instrucción `switch` , la instrucción `if` cuenta `count` , que ahora es 0.
+*   Esto luego cae a la instrucción `else` , que devolverá **0 Hold** .
+
+**_Nota_** : Como se mencionó anteriormente, la instrucción `switch` también podría haber sido una instrucción `else if` .
+
+## Solución de código adicional:
+
+```javascript
+function cc(card) { 
+  // Only change code below this line 
+  var regex = /[JQKA]/; 
+  if (card > 1 && card < 7){count++;} 
+  else if (card === 10 || String(card).match(regex)){count--;} 
+ 
+  if (count > 0) return count + " Bet"; 
+  return count + " Hold"; 
+ 
+  // Only change code above this line 
+ } 
+```
+
+· Ejecutar código en [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Counting-cards)
+
+### Explicación del código
+
+· La función primero evalúa `if` la `card` condición es un valor mayor que `1` y menor que `7` , en cuyo caso la `count` se incrementa en uno. · Luego, si la tarjeta es `10` o más, se reduce la `count` en uno. · La variable `regex` es una [expresión regular que](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) representa valores (letras) para las tarjetas más altas. · La sentencia `else` comprueba esos valores con el `|| (logical OR)` operador `|| (logical OR)` ; primero para `10` y luego para cualquier cadena que coincida con la expresión regular usando [String.match ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) .
+
+#### Recursos
+
+*   [Recuento de cartas en Wikipedia](https://en.wikipedia.org/wiki/Card_counting)
+*   [Desafío: seleccionar entre muchas opciones con instrucciones de cambio](http://www.freecodecamp.com/challenges/selecting-from-many-options-with-switch-statements)
+*   [Desafío: Encadenar Si En Else Declaraciones](http://www.freecodecamp.com/challenges/chaining-if-else-statements)
+*   [Desafío: Incrementar un número con Javascript](http://www.freecodecamp.com/challenges/increment-a-number-with-javascript)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Create Decimal Numbers with JavaScript
+localeTitle: Crea números decimales con JavaScript
+---
+# Crea números decimales con JavaScript
+
+Las variables de número de JavaScript pueden tener decimales.
+```
+var myDecimal = 2.8; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables/index.md

@@ -0,0 +1,28 @@
+---
+title: Declare JavaScript Variables
+localeTitle: Declarar las variables de JavaScript
+---
+# Declarar las variables de JavaScript
+
+Cuando almacenamos datos en una estructura de datos, lo llamamos una variable. Las variables de JavaScript están escritas en camel case. Un ejemplo de camel case es: `camelCase` .
+
+Puedes declarar una variable de esta manera
+
+```js
+    var myName = "Rafael"; 
+```
+
+ES6 introdujo otras dos formas de declarar variables. **let** y **const** . _Let_ es bastante similar a var y en su mayor parte es intercambiable:
+
+```js
+    let myAge = 36; 
+```
+
+Donde _dejar que_ se diferencia, es en su alcance. Cuando declaramos que utilizamos _var_ , su alcance es global. Cuando declaramos usando _let_ , el alcance está limitado a esa función. Si desea utilizar una variable _Let_ fuera de una función, hay que hacerlo de alcance mundial o redeclare en la siguiente función.
+
+**Const** , por otro lado, solo puede ser declarado una vez. Su valor nunca puede cambiar.
+
+```js
+    const myName = "Christina"; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables/index.md

@@ -0,0 +1,16 @@
+---
+title: Declare String Variables
+localeTitle: Declarar variables de cadena
+---
+## Declarar variables de cadena
+
+En JavaScript, las variables son **dinámicas** . Eso significa que pueden contener números, cadenas o cualquier otro tipo de datos en un momento dado. Para declarar una cadena, simplemente **inicialice** (cree) una variable:
+```
+var a; 
+```
+
+Luego, utilizando comillas simples o dobles, declare la cadena:
+```
+a = "Hello Camper!"; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript/index.md

@@ -0,0 +1,13 @@
+---
+title: Decrement a Number with JavaScript
+localeTitle: Disminuir un número con JavaScript
+---
+## Disminuir un número con JavaScript
+
+Disminuye un número usando el operador '-':
+```
+var a = 5; 
+ a--; // Now, 'a' is 4 
+ --a; // Now, 'a' is 3 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object/index.md

@@ -0,0 +1,36 @@
+---
+title: Delete Properties from a JavaScript Object
+localeTitle: Eliminar propiedades de un objeto de JavaScript
+---
+## Eliminar propiedades de un objeto de JavaScript
+
+### SUGERENCIA: 1
+
+*   cambia las propiedades de myDog usando notación de puntos
+
+# ADVERTENCIA DE SPOILER: SOLUCIÓN A CONTINUACIÓN
+
+```javascript
+var ourDog = { 
+  "name": "Camper", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["everything!"], 
+  "bark": "bow-wow" 
+ }; 
+ 
+ delete ourDog.bark; 
+ 
+ // Setup 
+ var myDog = { 
+  "name": "Happy Coder", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["freeCodeCamp Campers"], 
+  "bark": "woof" 
+ }; 
+ 
+ // Only change code below this line. 
+ delete myDog.tails; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Divide One Decimal by Another with JavaScript
+localeTitle: Divide un decimal por otro con JavaScript
+---
+# Divide un decimal por otro con JavaScript
+
+Javascript usa el símbolo `/` para la división.
+```
+var quotient = 0.6 / 0.3; //quotient gets the value 2 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Divide One Number by Another with JavaScript
+localeTitle: Divide un número por otro con JavaScript
+---
+# Divide un número por otro con JavaScript
+
+Javascript usa el símbolo `/` para la división.
+```
+var quotient = 6 / 3; //quotient will get value 2 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings/index.md

@@ -0,0 +1,9 @@
+---
+title: Escape Sequences in Strings
+localeTitle: Secuencias de escape en cuerdas
+---
+## Secuencias de escape en cuerdas
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings/index.md

@@ -0,0 +1,19 @@
+---
+title: Escaping Literal Quotes in Strings
+localeTitle: Escapar de citas literales en cuerdas
+---
+## Escapar de citas literales en cuerdas
+
+*   Cuando necesite usar un carácter especial como `"` dentro de una cadena, debe escapar de ella usando `\` .
+*   Si usa comillas dobles `"` para la cadena, las comillas simples `'` en la cadena no necesitan escaparse.
+*   Si usa comillas simples `'` para la cadena, las comillas dobles `"` en la cadena no necesitan escaparse.
+
+## Solución
+
+```javascript
+var myStr = "I am a \"double quoted\" string inside \"double quotes\"."; 
+ var otherStr = 'I am a \'single quoted\' string inside \'single quotes\'.'; 
+ var noEscapeSingle = "There is no need to 'escape' the single quotes."; 
+ var noEscapeDouble = 'There is no need to "escape" the double quotes.'; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string/index.md

@@ -0,0 +1,14 @@
+---
+title: Find the Length of a String
+localeTitle: Encuentra la longitud de una cuerda
+---
+## Encuentra la longitud de una cuerda
+
+Las cadenas tienen un **atributo** (característica) llamado 'longitud'. Todo lo que tienes que hacer es etiquetarlo después de la cadena / variable.
+```
+var str1 = "Hello"; 
+ var length1 = str1.length; // This returns 5 
+ 
+ var length2 = " Camper".length; // This returns 7 because the space is counted as one character. 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Finding a Remainder in JavaScript
+localeTitle: Encontrar un resto en JavaScript
+---
+# Encontrar un resto en JavaScript
+
+El operador restante `%` da el resto de la división de dos números.
+```
+var remainder = 11 % 3; //remainder gets the value 2 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript/index.md

@@ -0,0 +1,38 @@
+---
+title: Generate Random Fractions with JavaScript
+localeTitle: Generar fracciones aleatorias con JavaScript
+---
+# Generar fracciones aleatorias con JavaScript
+
+Los números aleatorios son útiles para crear un comportamiento aleatorio.
+
+JavaScript tiene una función `Math.random()` que genera un número decimal aleatorio entre 0 (incluido) y no hasta 1 (exclusivo). Por `Math.random()` tanto, `Math.random()` puede devolver un 0 pero nunca devolver un 1.
+
+## Nota
+
+Al igual que el almacenamiento de valores con el operador igual, todas las llamadas de función se resolverán antes de que se ejecute la devolución, por lo que podemos devolver el valor de la función `Math.random()` .
+
+## Instrucciones
+
+Cambie randomFraction para devolver un número aleatorio en lugar de devolver 0.
+
+## **Advertencia !!!**
+
+### **Alerta de spoiler !!**
+
+Una solución a seguir:
+```
+function randomFraction() { 
+  // Only change code below this line. 
+  var result = 0; 
+  // Math.random() can generate 0. We don't want to     return a 0, 
+  // so keep generating random numbers until we get one     that isn't 0 
+  while (result === 0) { 
+    result = Math.random(); 
+  } 
+ 
+  return result; 
+  // Only change code above this line. 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md

@@ -0,0 +1,9 @@
+---
+title: Generate Random Whole Numbers with JavaScript
+localeTitle: Generar números enteros al azar con JavaScript
+---
+## Generar números enteros al azar con JavaScript
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range/index.md

@@ -0,0 +1,9 @@
+---
+title: Generate Random Whole Numbers within a Range
+localeTitle: Generar números enteros al azar dentro de un rango
+---
+## Generar números enteros al azar dentro de un rango
+
+**Ayuda para pasar la prueba final:** _`randomRange` debe usar `myMax` y `myMin` , y devolver un número aleatorio en su rango._
+
+No puede pasar la prueba final si solo está reutilizando la función `ourRandomRange` dentro de su fórmula `randomRange` . Necesita escribir su propia fórmula que use las variables `myMax` y `myMin` . Hará el mismo trabajo que con `ourRandomRange` , pero garantiza que haya comprendido los principios de las `Math.floor()` y `Math.random()` .

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions/index.md

@@ -0,0 +1,62 @@
+---
+title: Global Scope and Functions
+localeTitle: Ámbito global y funciones
+---
+## Ámbito global y funciones
+
+El alcance de una variable es su visibilidad; ¿En qué parte del código está disponible la función? Aquí hay una lista de los diferentes ámbitos que puede tener una variable.
+
+*   **Ámbito global** : la variable está disponible en todo el código.
+*   **Alcance local** : Disponible solo en un área determinada (como solo dentro de la función)
+*   **Ámbito de bloque** : disponible dentro de un área _aún más_ cierta (como una sentencia if)
+
+Su tarea es entender cómo agregar `var` (y no agregar) antes del nombre de una variable, puede cambiar el alcance de la variable.
+
+Cuando agrega `var` antes del nombre de la variable, su alcance está determinado por el lugar donde se coloca. Al igual que:
+
+```javascript
+var num1 = 18; // Global scope 
+ function fun() { 
+  var num2 = 20; // Local (Function) Scope 
+  if (true) { 
+    var num3 = 22; // Block Scope (within an if-statement) 
+  } 
+ } 
+```
+
+Cuando no lo haces, este es el resultado:
+
+```javascript
+num1 = 18; // Global scope 
+ function fun() { 
+  num2 = 20; // Global Scope 
+  if (true) { 
+    num3 = 22; // Global Scope 
+  } 
+ } 
+```
+
+Muy bien, aquí está la solución de código básico.
+
+```javascript
+// Declare your variable here 
+ var myGlobal = 10; 
+ 
+ function fun1() { 
+  oopsGlobal = 5; 
+ 
+ } 
+ 
+ // Only change code above this line 
+ function fun2() { 
+  var output = ""; 
+  if (typeof myGlobal != "undefined") { 
+    output += "myGlobal: " + myGlobal; 
+  } 
+  if (typeof oopsGlobal != "undefined") { 
+    output += " oopsGlobal: " + oopsGlobal; 
+  } 
+  console.log(output); 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions/index.md

@@ -0,0 +1,22 @@
+---
+title: Global vs. Local Scope in Functions
+localeTitle: Ámbito global vs. local en funciones
+---
+## Ámbito global vs. local en funciones
+
+Recuerde que el alcance global significa que la variable está disponible en todo el código. Ámbito local, significa que la variable está disponible dentro de un cierto rango.
+
+En este ejercicio, tiene una variable `outerWear` en el alcance global con "T-shirt" como valor. Ahora debe crear otra variable llamada `outerWear` , pero esta vez dentro de la función `myOutfit()` . La solución de código básico de la siguiente manera:
+
+```javascript
+var outerWear = "T-shirt"; 
+ 
+ function myOutfit() { 
+  var outerWear = "sweater"; 
+  return outerWear; 
+ } 
+ 
+ myOutfit(); 
+```
+
+La función devolverá el `outerWear` más `outerWear` que pueda encontrar. Ya que creamos un `outerWear` dentro de la función, es el 'más cercano', por lo que la función devolverá "sweater".

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/golf-code/index.md

@@ -0,0 +1,125 @@
+---
+title: Golf Code
+localeTitle: Codigo de golf
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+En el juego de golf, cada hoyo tiene un **par, lo que** significa el número promedio de **golpes** que se espera que un golfista realice para hundir la bola en un hoyo para completar el juego. Dependiendo de qué tan por encima o **por** debajo de tus **golpes** , hay un apodo diferente.
+
+Su función se pasará **par** y **trazos** argumentos. Debe devolver la cadena correcta de acuerdo con esta tabla que enumera los trazos en orden de prioridad; arriba (más alto) a abajo (más bajo):
+
+Trazos | Regreso  
+: --------- | : -------------  
+1 | "¡Hoyo en uno!"  
+<= par - 2 | "Águila"  
+par - 1 | "Pajarito"  
+par | "Par"  
+par + 1 | "Espectro"  
+par + 2 | "Doble Bogey" > = par + 3 | "¡Vete a casa!"
+
+**Par** y **trazos** siempre serán numéricos y positivos.
+
+*   Cambie el código a continuación `// Only change code below this line` y arriba `// Only change code above this line` .
+*   Asegúrese de que está editando el interior de la función `golfScore` .
+*   Tendrá que hacer que la función devuelva exactamente la misma cadena que se muestra en la tabla, dependiendo del valor de los parámetros **par** y los **trazos** que se pasan a su función.
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+`+number -number` puede utilizarse para aumentar o disminuir un parámetro en su condición.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Usas `if / else if` cadenas para devolver diferentes valores en diferentes escenarios.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Controle el flujo de su función según el orden de prioridad de las tablas: de arriba (más alto) a más bajo (más bajo) para devolver valores de cadena coincidentes.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function golfScore(par, strokes) { 
+  // Only change code below this line 
+  if (strokes == 1){ 
+    return "Hole-in-one!"; 
+  } else if (strokes <= par -2){ 
+    return "Eagle"; 
+  } else if (strokes == par -1) { 
+    return "Birdie"; 
+  } else if (strokes == par) { 
+    return "Par"; 
+  } else if (strokes == par +1) { 
+    return "Bogey"; 
+  } else if (strokes == par +2) { 
+    return "Double Bogey"; 
+  } else { 
+    return "Go Home!"; 
+  } 
+  // Only change code above this line 
+ } 
+ // Change these values to test 
+ golfScore(5, 4); 
+```
+
+### Explicación del código:
+
+*   Compare los parámetros **par** y **trazos** para devolver valores de cadena apropiados.
+*   `if / else if` cadena se utiliza para el control de flujo.
+*   Cuerda "ir a casa!" se devuelve para cada condición donde los **trazos** son mayores o iguales al **par + 3** .
+
+## Solución de código alternativo:
+
+```javascript
+var names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"]; 
+ function golfScore(par, strokes) { 
+  // Only change code below this line 
+  if (strokes == 1){ 
+    return names[0]; 
+  } 
+  else if (strokes <= par-2){ 
+    return names[1]; 
+  } 
+  else if (strokes == par -1){ 
+    return names[2]; 
+  } 
+  else if (strokes == par){ 
+    return names[3]; 
+  } 
+  else if (strokes == par +1){ 
+    return names[4]; 
+  } 
+  else if (strokes == par +2){ 
+    return names[5]; 
+  } 
+  else {return names[6];} 
+  // Only change code above this line 
+ } 
+ 
+ // Change these values to test 
+ golfScore(5, 4); 
+```
+
+· Ejecutar en [repl.it](https://repl.it/@AdrianSkar/Basic-JS-Golf-code)
+
+\## explicación del código Como ya tenemos una matriz definida en los `names` las variables, podemos aprovecharla y utilizarla para nuestras declaraciones de devolución usando índices (por ejemplo: `names[0] is the first one` ). De esa manera, si alguna vez necesita cambiar un resultado específico, no tendría que buscarlo dentro de la función, estaría al principio, en su matriz.
+
+### Recursos
+
+*   [Golf](https://en.wikipedia.org/wiki/Golf)
+*   [Desafío: Encadenar Si En Else Declaraciones](http://www.freecodecamp.com/challenges/chaining-if-else-statements)
+*   [Desafío: Comparación con el operador mayor que igual](http://www.freecodecamp.com/challenges/comparison-with-the-greater-than-equal-to-operator)
+*   [Desafío: Comparación con el operador menos que igual](http://www.freecodecamp.com/challenges/comparison-with-the-less-than-equal-to-operator)
+*   ["Array" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript/index.md

@@ -0,0 +1,13 @@
+---
+title: Increment a Number with JavaScript
+localeTitle: Incrementar un número con JavaScript
+---
+## Incrementar un número con JavaScript
+
+Puede incrementar (agregar uno) fácilmente a una variable numérica usando el operador de incremento '++'. Por ejemplo:
+```
+var a = 6; 
+ a++; // Now, 'a' is equal to 7 -- post-fixing 
+ ++a; // Now, 'a' is equal to 8 -- pre-fixing 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Basic Javascript
+localeTitle: Javascript básico
+---
+## Javascript básico
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator/index.md

@@ -0,0 +1,11 @@
+---
+title: Initializing Variables with the Assignment Operator
+localeTitle: Inicializando variables con el operador de asignación
+---
+## Inicializando variables con el operador de asignación
+
+**Inicializar** una variable es darle un valor inicial. Puedes declarar e inicializar una variable así:
+```
+var num = 5; // This is equal to 5 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements/index.md

@@ -0,0 +1,63 @@
+---
+title: Introducing Else If statements
+localeTitle: Introduciendo las instrucciones Else If
+---
+## Introduciendo las instrucciones Else If
+
+Recuerda usar Read-Search-Ask si te atascas. Intenta emparejar el programa y escribe tu propio código.
+
+\### Explicación del problema:
+
+```javascript
+function testElseIf(val) { 
+  if (val > 10) { 
+    return "Greater than 10"; 
+  } 
+ 
+  if (val < 5) { 
+    return "Smaller than 5"; 
+  } 
+ 
+  return "Between 5 and 10"; 
+ } 
+ 
+ // Change this value to test 
+ testElseIf(7); 
+```
+
+Estaremos modificando el código existente arriba para que siga el flujo de lógica que tiene una sentencia **else-if** .
+
+\### Sugerencia: 1 `javascript if (val > 10) { return "Greater than 10"; }` Todas las declaraciones `if` y sus variantes comienzan con una declaración `if` .
+
+> _intenta resolver el problema ahora_
+
+\### Sugerencia: 2 `javascript else if (val < 5) { return "Smaller than 5"; }` Las declaraciones entre la instrucción `if` y la instrucción `else` en un flujo **else-if** están en el formato else-if
+
+> _intenta resolver el problema ahora_
+
+\### Sugerencia: 3 `javascript else { return "Between 5 and 10"; }` La última declaración en un flujo **else-if** está en el formato `else` ### ¡Alerta de spoiler! ![alerón](http://discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif) ¡Solución por delante! ## Solución de código básico:
+
+```javascript
+function testElseIf(val) { 
+  if (val > 10) { 
+    return "Greater than 10"; 
+  } 
+ 
+  else if (val < 5) { 
+    return "Smaller than 5"; 
+  } 
+ 
+  else { 
+  return "Between 5 and 10"; 
+  } 
+ } 
+ 
+ // Change this value to test 
+ testElseIf(7); 
+```
+
+: cohete: [Ejecutar código](https://repl.it/@RyanPisuena/GoldenWorriedRuntime) ## explicación del código La estructura de un **flujo lógico else-if** es una declaración inicial `if` , una instrucción `if-else` y una instrucción `else` final.
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements/index.md

@@ -0,0 +1,58 @@
+---
+title: Introducing Else statements
+localeTitle: Introduciendo declaraciones Else
+---
+## Introduciendo declaraciones Else
+
+### Explicación del problema:
+
+· _Combina las sentencias `if` en una sola sentencia `if/else` ._
+
+#### Sugerencia 1
+
+Cuando la primera instrucción `if` devuelve `false` el siguiente fragmento de código se ejecuta / evalúa (como `return` , `if` o `else` ).
+
+> _intenta resolver el problema ahora_
+
+#### Sugerencia 2
+
+A veces `if` ( `condition` ) declaraciones pueden ser reemplazados por `else {code to execute instead}` declaraciones (en esencia está diciendo a su función para hacer _"y"_ si no se puede hacer _"x"_ en lugar de especificar _"x"_ varias veces).
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+function testElse(val) { 
+  var result = ""; 
+  // Only change code below this line 
+ 
+  if (val > 5) { 
+    result = "Bigger than 5"; 
+  } 
+ 
+  else { 
+    result = "5 or smaller"; 
+  } 
+ 
+  // Only change code above this line 
+  return result; 
+ } 
+ 
+ // Change this value to test 
+ testElse(4); 
+```
+
+· [Ejecutar código en repl.it](https://repl.it/@AdrianSkar/Introducing-else-statements)
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `val > 5` evalúa como `true` . Si no lo hace, ejecuta la siguiente instrucción ( `else { return "5 or smaller";})` .
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop/index.md

@@ -0,0 +1,38 @@
+---
+title: Iterate Odd Numbers With a For Loop
+localeTitle: Iterar números impares con un bucle for
+---
+## Iterar números impares con un bucle for
+
+Aquí está el ejemplo:
+
+```javascript
+var ourArray = []; 
+ 
+ for (var i = 0; i < 10; i += 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+```
+
+Aquí hay una solución: Después de la cadena `// Only change code below this line.` Añadimos `for` bucle. Necesitas copiar loop desde la parte superior:
+
+`javascript for (var i = 0; i < 10; i += 2) { ourArray.push(i); }` Y cambie la `initialization` `var i = 0` a `var i = 1` , también necesita cambiar el nombre de la matriz `ourArray` a `myArray` :
+
+`javascript for (var i = 1; i < 10; i += 2) { myArray.push(i); }`
+
+Aquí hay una solución completa:
+
+\`\` \`javascript var ourArray = \[\];
+
+para (var i = 0; i <10; i + = 2) { nuestroArray.push (i); }
+
+// Preparar var myArray = \[\];
+
+// Solo cambia el código debajo de esta línea.
+
+para (var i = 1; i <10; i + = 2) { myArray.push (i); } \`\` \`

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md

@@ -0,0 +1,9 @@
+---
+title: Iterate Through an Array with a For Loop
+localeTitle: Iterar a través de una matriz con un bucle For
+---
+## Iterar a través de una matriz con un bucle For
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops/index.md

@@ -0,0 +1,20 @@
+---
+title: Iterate with JavaScript Do...While Loops
+localeTitle: Iterar con JavaScript Do ... While Loops
+---
+## Iterar con JavaScript Do ... While Loops
+
+*   `Do...While` Loops se asegura de que el código se ejecute al menos una vez, y después de la ejecución, si la condición dentro de `while()` es **verdadera** , continúa con el bucle, de lo contrario, se detiene.
+
+## Solución
+
+```javascript
+var myArray = []; 
+ var i = 10; 
+ 
+ do { 
+  myArray.push(i); 
+  i++; 
+ } while(i <= 10); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops/index.md

@@ -0,0 +1,9 @@
+---
+title: Iterate with JavaScript For Loops
+localeTitle: Iterar con JavaScript para bucles
+---
+## Iterar con JavaScript para bucles
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops/index.md

@@ -0,0 +1,40 @@
+---
+title: Iterate with JavaScript While Loops
+localeTitle: Iterar con JavaScript mientras bucles
+---
+## Iterar con JavaScript mientras bucles
+
+Mientras que los bucles se ejecutarán mientras la condición dentro de () sea verdadera. Ejemplo:
+
+```javascript
+while(condition){ 
+ code... 
+ } 
+```
+
+## Sugerencia 1:
+
+Use una variable de iterador como i en su condición
+
+```javascript
+var i = 0; 
+ while(i <= 4){ 
+ } 
+```
+
+## Spoiler Alert Solution por delante!
+
+## Solución:
+
+```javascript
+// Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+ var i = 0; 
+ while (i <= 4){ 
+    myArray.push(i); 
+    i++; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions/index.md

@@ -0,0 +1,19 @@
+---
+title: Local Scope and Functions
+localeTitle: Ámbito local y funciones
+---
+## Ámbito local y funciones
+
+El alcance local significa que la variable está disponible dentro de un área determinada. En el caso de este ejercicio, `myVar` solo está disponible dentro de la función, y no en ningún lugar fuera.
+
+Aquí está la solución de código básica para crear una variable `myVar` local.
+
+```javascript
+function myLocalScope() { 
+  var myVar; 
+  console.log(myVar); 
+ } 
+ myLocalScope(); 
+```
+
+La variable solo existe en la función. Fuera de la función, no existe.