diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
index 2f689c3b72..2369749346 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
@@ -1,6 +1,6 @@
---
id: 587d7da9367417b2b2512b67
-title: Add Elements to the End of an Array Using concat Instead of push
+title: Agrega elementos al final de un arreglo utilizando concat en lugar de push
challengeType: 1
forumTopicId: 301226
dashedName: add-elements-to-the-end-of-an-array-using-concat-instead-of-push
@@ -8,50 +8,50 @@ dashedName: add-elements-to-the-end-of-an-array-using-concat-instead-of-push
# --description--
-Functional programming is all about creating and using non-mutating functions.
+La programación funcional consiste en crear y utilizar funciones no mutantes.
-The last challenge introduced the `concat` method as a way to combine arrays into a new one without mutating the original arrays. Compare `concat` to the `push` method. `Push` adds an item to the end of the same array it is called on, which mutates that array. Here's an example:
+El último desafío introdujo el método `concat` como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Compara `concat` con el método `push`. `push` añade un elemento al final del arreglo desde el que se llama, lo cual muta ese arreglo. Aquí hay un ejemplo:
```js
var arr = [1, 2, 3];
arr.push([4, 5, 6]);
-// arr is changed to [1, 2, 3, [4, 5, 6]]
-// Not the functional programming way
```
-`Concat` offers a way to add new items to the end of an array without any mutating side effects.
+`arr` tendría un valor modificado de `[1, 2, 3, [4, 5, 6]]`, que no encaja con el paradigma de la programación funcional.
+
+`concat` ofrece una forma de añadir nuevos elementos al final de un arreglo, sin provocar ningún efecto de mutación.
# --instructions--
-Change the `nonMutatingPush` function so it uses `concat` to add `newItem` to the end of `original` instead of `push`. The function should return an array.
+Cambia la función `nonMutatingPush` para que use `concat` para añadir `newItem` al final de `original` en lugar de `push`. La función debe devolver un arreglo.
# --hints--
-Your code should use the `concat` method.
+El código debe utilizar el método `concat`.
```js
assert(code.match(/\.concat/g));
```
-Your code should not use the `push` method.
+El código no debe utilizar el método `push`.
```js
assert(!code.match(/\.?[\s\S]*?push/g));
```
-The `first` array should not change.
+El arreglo `first` no debe modificarse.
```js
assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]));
```
-The `second` array should not change.
+El arreglo `second` no debe modificarse.
```js
assert(JSON.stringify(second) === JSON.stringify([4, 5]));
```
-`nonMutatingPush([1, 2, 3], [4, 5])` should return `[1, 2, 3, 4, 5]`.
+`nonMutatingPush([1, 2, 3], [4, 5])` debe devolver `[1, 2, 3, 4, 5]`.
```js
assert(
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
index 4bfd0ef5c3..5e37c124d5 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
@@ -1,6 +1,6 @@
---
id: 587d7da9367417b2b2512b66
-title: Combine Two Arrays Using the concat Method
+title: Combina dos arreglos utilizando el método "concat"
challengeType: 1
forumTopicId: 301229
dashedName: combine-two-arrays-using-the-concat-method
@@ -8,38 +8,39 @@ dashedName: combine-two-arrays-using-the-concat-method
# --description--
-Concatenation means to join items end to end. JavaScript offers the `concat` method for both strings and arrays that work in the same way. For arrays, the method is called on one, then another array is provided as the argument to `concat`, which is added to the end of the first array. It returns a new array and does not mutate either of the original arrays. Here's an example:
+Concatenation significa unir elementos de extremo a extremo. JavaScript ofrece el método `concat` para cadenas y arreglos, que funciona de la misma manera. Para arreglos, el método es llamado desde un arreglo, un segundo arrelgo es proporcionado como argumento de `concat`, este se añadirá al final del primer arreglo. Devuelve un nuevo arreglo, sin mutar ninguno de los arreglos originales. Aquí hay un ejemplo:
```js
[1, 2, 3].concat([4, 5, 6]);
-// Returns a new array [1, 2, 3, 4, 5, 6]
```
+El arreglo devuelto sería `[1, 2, 3, 4, 5, 6]`.
+
# --instructions--
-Use the `concat` method in the `nonMutatingConcat` function to concatenate `attach` to the end of `original`. The function should return the concatenated array.
+Usa el método `concat` en la función `nonMutatingConcat` para concatenar `attach` al final de `original`. La función deber devolver el arreglo concatenado.
# --hints--
-Your code should use the `concat` method.
+Tu código debe usar el método `concat`.
```js
assert(code.match(/\.concat/g));
```
-The `first` array should not change.
+El arreglo `first` no debe cambiar.
```js
assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]));
```
-The `second` array should not change.
+El arreglo `second` no debe cambiar.
```js
assert(JSON.stringify(second) === JSON.stringify([4, 5]));
```
-`nonMutatingConcat([1, 2, 3], [4, 5])` should return `[1, 2, 3, 4, 5]`.
+`nonMutatingConcat([1, 2, 3], [4, 5])` debe devolver `[1, 2, 3, 4, 5]`.
```js
assert(
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
index a0cc4d99a3..440a9d4bab 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
@@ -1,6 +1,6 @@
---
id: 587d7b8d367417b2b2512b5b
-title: Learn About Functional Programming
+title: Aprende sobre programación funcional
challengeType: 1
forumTopicId: 301233
dashedName: learn-about-functional-programming
@@ -8,33 +8,33 @@ dashedName: learn-about-functional-programming
# --description--
-Functional programming is a style of programming where solutions are simple, isolated functions, without any side effects outside of the function scope.
+La programación funcional es un estilo de programación donde las soluciones son simples, funciones aisladas, sin ningún efecto secundario fuera del ámbito de la función.
`INPUT -> PROCESS -> OUTPUT`
-Functional programming is about:
+La programación funcional se refiere a:
-1) Isolated functions - there is no dependence on the state of the program, which includes global variables that are subject to change
+1) Funciones aisladas: sin dependencia alguna del estado del programa, que incluye variables globales sujetas a cambios
-2) Pure functions - the same input always gives the same output
+2) Funciones puras: una misma entrada siempre da la misma salida
-3) Functions with limited side effects - any changes, or mutations, to the state of the program outside the function are carefully controlled
+3) Funciones con efectos secundarios limitados: cualquier cambio o mutación en el estado del programa fuera de la función son cuidadosamente controlados
# --instructions--
-The members of freeCodeCamp happen to love tea.
+A los miembros de freeCodeCamp les encanta el té.
-In the code editor, the `prepareTea` and `getTea` functions are already defined for you. Call the `getTea` function to get 40 cups of tea for the team, and store them in the `tea4TeamFCC` variable.
+En el editor de código, las funciones `prepareTea` y `getTea` ya están definidas. Llama a la función `getTea` para obtener 40 tazas de té para el equipo y guárdalas en la variable `tea4TeamFCC`.
# --hints--
-The `tea4TeamFCC` variable should hold 40 cups of tea for the team.
+La variable `tea4TeamFCC` debe contener 40 tazas de té para el equipo.
```js
assert(tea4TeamFCC.length === 40);
```
-The `tea4TeamFCC` variable should hold cups of green tea.
+La variable `tea4TeamFCC` debe contener tazas de té verde.
```js
assert(tea4TeamFCC[0] === 'greenTea');
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
index 19d7d355e9..e0a87646aa 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
@@ -1,6 +1,6 @@
---
id: 587d7b8e367417b2b2512b5f
-title: Pass Arguments to Avoid External Dependence in a Function
+title: Pasa argumentos para evitar la dependencia externa en una función
challengeType: 1
forumTopicId: 301234
dashedName: pass-arguments-to-avoid-external-dependence-in-a-function
@@ -8,39 +8,39 @@ dashedName: pass-arguments-to-avoid-external-dependence-in-a-function
# --description--
-The last challenge was a step closer to functional programming principles, but there is still something missing.
+El último reto fue un paso más cerca de los principios de la programación funcional, pero todavía falta algo.
-We didn't alter the global variable value, but the function `incrementer` would not work without the global variable `fixedValue` being there.
+No alteramos el valor global de la variable, pero la función `incrementer` no funcionaría sin que la variable global `fixedValue` estuviera allí.
-Another principle of functional programming is to always declare your dependencies explicitly. This means if a function depends on a variable or object being present, then pass that variable or object directly into the function as an argument.
+Otro principio de programación funcional es declarar siempre sus dependencias de forma explícita. Esto significa si una función depende de que una variable u objeto esté presente, después pasa esa variable u objeto directamente a la función como argumento.
-There are several good consequences from this principle. The function is easier to test, you know exactly what input it takes, and it won't depend on anything else in your program.
+Este principio tiene varias consecuencias positivas. La función es más fácil de probar, se sabe exactamente lo que necesita, y no dependerá de nada más en tu programa.
-This can give you more confidence when you alter, remove, or add new code. You would know what you can or cannot change and you can see where the potential traps are.
+Esto puede darte más confianza cuando cambias, eliminas o agregas código nuevo. Sabrás lo que se puede o no se puede cambiar y, puedes ver dónde están los posibles trampas.
-Finally, the function would always produce the same output for the same set of inputs, no matter what part of the code executes it.
+Finalmente, la función siempre produciría el mismo resultado para el mismo conjunto de entradas, sin importar qué parte del código la ejecute.
# --instructions--
-Let's update the `incrementer` function to clearly declare its dependencies.
+Actualicemos la función `incrementer` para declarar claramente sus dependencias.
-Write the `incrementer` function so it takes an argument, and then returns a result after increasing the value by one.
+Escribe la función `incrementer` para que reciba un argumento, y luego devuelva un resultado después de aumentar el valor en uno.
# --hints--
-Your function `incrementer` should not change the value of `fixedValue` (which is `4`).
+Tu función `incrementer` no debe cambiar el valor de `fixedValue` (que es `4`).
```js
assert(fixedValue === 4);
```
-Your `incrementer` function should take an argument.
+Tu función `incrementer` debe recibir un argumento.
```js
assert(incrementer.length === 1);
```
-Your `incrementer` function should return a value that is one larger than the `fixedValue` value.
+La función `incrementer` debe devolver el valor de `fixedValue` más uno.
```js
const __newValue = incrementer(fixedValue);
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
index 082deb8650..fe201c8f62 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
@@ -1,6 +1,6 @@
---
id: 9d7123c8c441eeafaeb5bdef
-title: Remove Elements from an Array Using slice Instead of splice
+title: Remueve elementos de un arreglo usando slice en lugar de splice
challengeType: 1
forumTopicId: 301236
dashedName: remove-elements-from-an-array-using-slice-instead-of-splice
@@ -8,37 +8,38 @@ dashedName: remove-elements-from-an-array-using-slice-instead-of-splice
# --description--
-A common pattern while working with arrays is when you want to remove items and keep the rest of the array. JavaScript offers the `splice` method for this, which takes arguments for the index of where to start removing items, then the number of items to remove. If the second argument is not provided, the default is to remove items through the end. However, the `splice` method mutates the original array it is called on. Here's an example:
+Un patrón común al trabajar con arreglos es cuando deseas eliminar elementos y conservar el resto del arreglo. JavaScript ofrece el método `splice` para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos para eliminar. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método `splice` muta el arreglo original en el que se llama. Por ejemplo:
```js
var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
-cities.splice(3, 1); // Returns "London" and deletes it from the cities array
-// cities is now ["Chicago", "Delhi", "Islamabad", "Berlin"]
+cities.splice(3, 1);
```
-As we saw in the last challenge, the `slice` method does not mutate the original array, but returns a new one which can be saved into a variable. Recall that the `slice` method takes two arguments for the indices to begin and end the slice (the end is non-inclusive), and returns those items in a new array. Using the `slice` method instead of `splice` helps to avoid any array-mutating side effects.
+Aquí `splice` devluelve la "string" `London` y la elimina del arreglo `cities`. `cities` tendrá el valor de `["Chicago", "Delhi", "Islamabad", "Berlin"]`.
+
+Como vimos en el último desafío, el método `slice` no muta el arreglo original, pero devuelve uno nuevo que puede ser guardado en una variable. Recuerda que el método `slice` recibe dos argumentos para indicar el comienzo y el final del segmento (el final es no inclusivo) y retorna estos elementos en un nuevo arreglo. Usar el método `slice` en lugar de `splice` ayuda a prevenir cualquier efecto colateral de mutar un arreglo.
# --instructions--
-Rewrite the function `nonMutatingSplice` by using `slice` instead of `splice`. It should limit the provided `cities` array to a length of 3, and return a new array with only the first three items.
+Reescribe la función `nonMutatingSplice` usando `slice` en lugar de `splice`. Debe limitar el arreglo proporcionado `cities` a una longitud de 3 y devolver un nuevo arreglo con solo los primeros tres elementos.
-Do not mutate the original array provided to the function.
+No modifiques el arreglo original proporcionado en la función.
# --hints--
-Your code should use the `slice` method.
+Tu código debe usar el método `slice`.
```js
assert(code.match(/\.slice/g));
```
-Your code should not use the `splice` method.
+Tu código no debe usar el método `splice`.
```js
assert(!code.match(/\.?[\s\S]*?splice/g));
```
-The `inputCities` array should not change.
+El arreglo `inputCities` no debe ser cambiado.
```js
assert(
@@ -47,7 +48,7 @@ assert(
);
```
-`nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])` should return `["Chicago", "Delhi", "Islamabad"]`.
+`nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])` debe devolver `["Chicago", "Delhi", "Islamabad"]`.
```js
assert(
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
index bc3fb9f25e..f69462da13 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
@@ -1,6 +1,6 @@
---
id: 587d7b88367417b2b2512b45
-title: 'Use Higher-Order Functions map, filter, or reduce to Solve a Complex Problem'
+title: 'Utiliza las funciones de orden superior "map", "filter" o "reduce" para resolver un problema complejo'
challengeType: 1
forumTopicId: 301311
dashedName: use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem
@@ -8,30 +8,30 @@ dashedName: use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-p
# --description--
-Now that you have worked through a few challenges using higher-order functions like `map()`, `filter()`, and `reduce()`, you now get to apply them to solve a more complex challenge.
+Ahora que has superado algunos desafíos usando funciones de orden superior como `map()`, `filter()`, y `reduce()`, ahora puedes aplicarlos para resolver un desafío más complejo.
# --instructions--
-We have defined a function named `squareList`. You need to complete the code for the `squareList` function using any combination of `map()`, `filter()`, and `reduce()` so that it returns a new array containing only the square of *only* the positive integers (decimal numbers are not integers) when an array of real numbers is passed to it. An example of an array containing only real numbers is `[-3, 4.8, 5, 3, -3.2]`.
+Hemos definido una función llamada `squareList`. Necesitas completar el código para la función `squareList` usando cualquier combinación de `map()`, `filter()`, y `reduce()` para que devuelva un nuevo arreglo que contenga *sólo* el cuadrado de los enteros positivos (los números decimales no son enteros) cuando se le pase un arreglo de números reales. Un ejemplo de un arreglo que contiene sólo números reales es `[-3, 4.8, 5, 3, -3.2]`.
-**Note:** Your function should not use any kind of `for` or `while` loops or the `forEach()` function.
+**Nota:** Tu función no debe usar ningún tipo de bucle `for` o `while` o la función `forEach()`.
# --hints--
-`squareList` should be a `function`.
+`squareList` debe ser una función (`function`).
```js
assert.typeOf(squareList, 'function'),
'squareList should be a function';
```
-`for`, `while`, and `forEach` should not be used.
+`for`, `while`, y `forEach` no deben ser usados.
```js
assert(!__helpers.removeJSComments(code).match(/for|while|forEach/g));
```
-`map`, `filter`, or `reduce` should be used.
+`map`, `filter`, o `reduce` deben ser usados.
```js
assert(
@@ -41,13 +41,13 @@ assert(
);
```
-The function should return an `array`.
+La función debe devolver un arreglo (`array`).
```js
assert(Array.isArray(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])));
```
-`squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])` should return `[16, 1764, 36]`.
+`squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])` debe devolver `[16, 1764, 36]`.
```js
assert.deepStrictEqual(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2]), [
@@ -57,7 +57,7 @@ assert.deepStrictEqual(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2]), [
]);
```
-`squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3])` should return `[9, 100, 49]`.
+`squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3])` debe devolver `[9, 100, 49]`.
```js
assert.deepStrictEqual(squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3]), [
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
index c3c51c294d..4c2a35e370 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
@@ -1,6 +1,6 @@
---
id: a97fd23d9b809dac9921074f
-title: Arguments Optional
+title: Argumentos opcionales
challengeType: 5
forumTopicId: 14271
dashedName: arguments-optional
@@ -8,51 +8,51 @@ dashedName: arguments-optional
# --description--
-Create a function that sums two arguments together. If only one argument is provided, then return a function that expects one argument and returns the sum.
+Crea una función que sume dos argumentos. Si sólo se proporciona un argumento, entonces devuelve una función que espera un argumento y devuelve la suma.
-For example, `addTogether(2, 3)` should return `5`, and `addTogether(2)` should return a function.
+Por ejemplo, `addTogether(2, 3)` debe devolver `5` y `addTogether(2)` debe devolver una función.
-Calling this returned function with a single argument will then return the sum:
+Si se llama a esta función devuelta con un solo argumento, se obtendrá la suma:
`var sumTwoAnd = addTogether(2);`
-`sumTwoAnd(3)` returns `5`.
+`sumTwoAnd(3)` devuelve `5`.
-If either argument isn't a valid number, return undefined.
+Si cualquiera de los dos argumentos no es un número válido, devuelve undefined.
# --hints--
-`addTogether(2, 3)` should return 5.
+`addTogether(2, 3)` debe devolver 5.
```js
assert.deepEqual(addTogether(2, 3), 5);
```
-`addTogether(23, 30)` should return 53.
+`addTogether(23, 30)` debe devolver 53.
```js
assert.deepEqual(addTogether(23, 30), 53);
```
-`addTogether(5)(7)` should return 12.
+`addTogether(5)(7)` debe devolver 12.
```js
assert.deepEqual(addTogether(5)(7), 12);
```
-`addTogether("http://bit.ly/IqT6zt")` should return undefined.
+`addTogether("http://bit.ly/IqT6zt")` debe devolver `undefined`.
```js
assert.isUndefined(addTogether('http://bit.ly/IqT6zt'));
```
-`addTogether(2, "3")` should return undefined.
+`addTogether(2, "3")` debe devolver `undefined`.
```js
assert.isUndefined(addTogether(2, '3'));
```
-`addTogether(2)([3])` should return undefined.
+`addTogether(2)([3])` debe devolver `undefined`.
```js
assert.isUndefined(addTogether(2)([3]));
diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
index 954865c428..579a819439 100644
--- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
+++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
@@ -1,6 +1,6 @@
---
id: a8d97bd4c764e91f9d2bda01
-title: Binary Agents
+title: Agentes binarios
challengeType: 5
forumTopicId: 14273
dashedName: binary-agents
@@ -8,13 +8,13 @@ dashedName: binary-agents
# --description--
-Return an English translated sentence of the passed binary string.
+Devuelve una frase traducida al inglés de una cadena binaria pasada.
-The binary string will be space separated.
+La cadena binaria estará separada por espacios.
# --hints--
-`binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")` should return "Aren't bonfires fun!?"
+`binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")` debe devolver la cadena `Aren't bonfires fun!?`
```js
assert.deepEqual(
@@ -25,7 +25,7 @@ assert.deepEqual(
);
```
-`binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")` should return "I love FreeCodeCamp!"
+`binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")` debe devolver la cadena `I love FreeCodeCamp!`
```js
assert.deepEqual(