gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(i8n,learn): processed translations (#41141)

Browse Source 
Co-authored-by: Crowdin Bot <support+bot@crowdin.com>
This commit is contained in:
Randell Dawson
2021-02-16 15:21:30 -07:00
committed by GitHub
parent 785405fdfd
commit 4696b47c01
13 changed files with 73 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
View File

@ -1,6 +1,6 @@
---
id: a302f7aae1aa3152a5b413bc
title: Factorialize a Number
title: Factorializar un número
challengeType: 5
forumTopicId: 16013
dashedName: factorialize-a-number
@ -8,43 +8,43 @@ dashedName: factorialize-a-number
# --description--
Return the factorial of the provided integer.
Devuelve el factorial del entero proporcionado.
If the integer is represented with the letter n, a factorial is the product of all positive integers less than or equal to n.
Si el entero está representado con la letra n, un factorial es el producto de todos los enteros positivos menores o iguales a n.
Factorials are often represented with the shorthand notation `n!`
¡Los factoriales suelen representarse con la abreviatura `n!`
For example: `5! = 1 * 2 * 3 * 4 * 5 = 120`
Por ejemplo: `5! = 1 * 2 * 3 * 4 * 5 = 120`
Only integers greater than or equal to zero will be supplied to the function.
Sólo se proporcionara a la función enteros mayores o igual a cero.
# --hints--
`factorialize(5)` should return a number.
`factorialize(5)` debe devolver un número.
```js
assert(typeof factorialize(5) === 'number');
```
`factorialize(5)` should return 120.
`factorialize(5)` debe devolver 120.
```js
assert(factorialize(5) === 120);
```
`factorialize(10)` should return 3628800.
`factorialize(10)` debe devolver 3628800.
```js
assert(factorialize(10) === 3628800);
```
`factorialize(20)` should return 2432902008176640000.
`factorialize(20)` debe devolver 2432902008176640000.
```js
assert(factorialize(20) === 2432902008176640000);
```
`factorialize(0)` should return 1.
`factorialize(0)` debe devolver 1.
```js
assert(factorialize(0) === 1);

18
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
View File

@ -1,6 +1,6 @@
---
id: a26cbbe9ad8655a977e1ceb5
title: Find the Longest Word in a String
title: Encuentra la palabra más larga en una cadena
challengeType: 5
forumTopicId: 16015
dashedName: find-the-longest-word-in-a-string
@ -8,13 +8,13 @@ dashedName: find-the-longest-word-in-a-string
# --description--
Return the length of the longest word in the provided sentence.
Devuelve la longitud de la palabra más larga en la oración proporcionada.
Your response should be a number.
Tu respuesta debe ser un número.
# --hints--
`findLongestWordLength("The quick brown fox jumped over the lazy dog")` should return a number.
`findLongestWordLength("The quick brown fox jumped over the lazy dog")` debe devolver un número.
```js
assert(
@ -24,7 +24,7 @@ assert(
);
```
`findLongestWordLength("The quick brown fox jumped over the lazy dog")` should return 6.
`findLongestWordLength("The quick brown fox jumped over the lazy dog")` debe devolver 6.
```js
assert(
@ -32,19 +32,19 @@ assert(
);
```
`findLongestWordLength("May the force be with you")` should return 5.
`findLongestWordLength("May the force be with you")` debe devolver 5.
```js
assert(findLongestWordLength('May the force be with you') === 5);
```
`findLongestWordLength("Google do a barrel roll")` should return 6.
`findLongestWordLength("Google do a barrel roll")` debe devolver 6.
```js
assert(findLongestWordLength('Google do a barrel roll') === 6);
```
`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` should return 8.
`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` debe devolver 8.
```js
assert(
@ -54,7 +54,7 @@ assert(
);
```
`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` should return 19.
`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` debe devolver 19.
```js
assert(

8
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
View File

@ -1,6 +1,6 @@
---
id: a6e40f1041b06c996f7b2406
title: Finders Keepers
title: Buscadores guardianes
challengeType: 5
forumTopicId: 16016
dashedName: finders-keepers
@ -8,11 +8,11 @@ dashedName: finders-keepers
# --description--
Create a function that looks through an array `arr` and returns the first element in it that passes a 'truth test'. This means that given an element `x`, the 'truth test' is passed if `func(x)` is `true`. If no element passes the test, return `undefined`.
Crea una función que recorra un arreglo `arr` y devuelva el primer elemento que pase un "detector de verdad". Esto significa que dado un elemento `x`, el "detector de verdad" es pasado si `func(x)` es `true`. Si ningún elemento pasa la prueba. la función debería devolver `undefined`.
# --hints--
`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` should return 8.
`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` debería devolver 8.
```js
assert.strictEqual(
@ -23,7 +23,7 @@ assert.strictEqual(
);
```
`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` should return undefined.
`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` debería devolver undefined.
```js
assert.strictEqual(

20
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
View File

@ -1,6 +1,6 @@
---
id: afcc8d540bea9ea2669306b6
title: Repeat a String Repeat a String
title: Repetir una cadena repetir una cadena
challengeType: 5
forumTopicId: 16041
dashedName: repeat-a-string-repeat-a-string
@ -8,53 +8,53 @@ dashedName: repeat-a-string-repeat-a-string
# --description--
Repeat a given string `str` (first argument) for `num` times (second argument). Return an empty string if `num` is not a positive number. For the purpose of this challenge, do *not* use the built-in `.repeat()` method.
Repita una cadena dada `str` (primer argumento) por `num` veces (segundo argumento). Retorne una cadena vacía si `num` no es un número positivo. Para este desafío, utiliza *not* el método `.repeat()` incorporado.
# --hints--
`repeatStringNumTimes("*", 3)` should return `"***"`.
`repeatStringNumTimes("*", 3)` debe devolver `"***"`.
```js
assert(repeatStringNumTimes('*', 3) === '***');
```
`repeatStringNumTimes("abc", 3)` should return `"abcabcabc"`.
`repeatStringNumTimes("abc", 3)` debe devolver `"abcabcabc"`.
```js
assert(repeatStringNumTimes('abc', 3) === 'abcabcabc');
```
`repeatStringNumTimes("abc", 4)` should return `"abcabcabcabc"`.
`repeatStringNumTimes("abc", 4)` debe devolver `"abcabcabcabc"`.
```js
assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc');
```
`repeatStringNumTimes("abc", 1)` should return `"abc"`.
`repeatStringNumTimes("abc", 1)` debe devolver `"abc"`.
```js
assert(repeatStringNumTimes('abc', 1) === 'abc');
```
`repeatStringNumTimes("*", 8)` should return `"********"`.
`repeatStringNumTimes("*", 8)` debe devolver `"********"`.
```js
assert(repeatStringNumTimes('*', 8) === '********');
```
`repeatStringNumTimes("abc", -2)` should return `""`.
`repeatStringNumTimes("abc", -2)` debe devolver `""`.
```js
assert(repeatStringNumTimes('abc', -2) === '');
```
The built-in `repeat()` method should not be used.
El método integrado `repeat()` no debe ser utilizado.
```js
assert(!/\.repeat/g.test(code));
```
`repeatStringNumTimes("abc", 0)` should return `""`.
`repeatStringNumTimes("abc", 0)` debe devolver `""`.
```js
assert(repeatStringNumTimes('abc', 0) === '');

14
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
View File

@ -1,6 +1,6 @@
---
id: a789b3483989747d63b0e427
title: Return Largest Numbers in Arrays
title: Devolver los números mayores del arreglo
challengeType: 5
forumTopicId: 16042
dashedName: return-largest-numbers-in-arrays
@ -8,13 +8,13 @@ dashedName: return-largest-numbers-in-arrays
# --description--
Return an array consisting of the largest number from each provided sub-array. For simplicity, the provided array will contain exactly 4 sub-arrays.
Devuelve un arreglo que consista en el mayor número de cada sub-arreglo dada. Por simplicidad, el arreglo dado contendrá exactamente 4 sub-arreglos.
Remember, you can iterate through an array with a simple for loop, and access each member with array syntax `arr[i]`.
Recuerde, usted puede iterar con cada arreglo con un simple bucle for, y acceder a cada miembro del arreglo con la sintaxis `arr[i]`.
# --hints--
`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` should return an array.
`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` debe devolver un arreglo.
```js
assert(
@ -27,7 +27,7 @@ assert(
);
```
`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` should return `[27, 5, 39, 1001]`.
`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` debe devolver `[27, 5, 39, 1001]`.
```js
assert.deepEqual(
@ -41,7 +41,7 @@ assert.deepEqual(
);
```
`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` should return `[9, 35, 97, 1000000]`.
`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` debe devolver`[9, 35, 97, 1000000]`.
```js
assert.deepEqual(
@ -55,7 +55,7 @@ assert.deepEqual(
);
```
`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` should return `[25, 48, 21, -3]`.
`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` debe devolver `[25, 48, 21, -3]`.
```js
assert.deepEqual(

16
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
View File

@ -1,6 +1,6 @@
---
id: a202eed8fc186c8434cb6d61
title: Reverse a String
title: Invertir una Cadena
challengeType: 5
forumTopicId: 16043
dashedName: reverse-a-string
@ -8,33 +8,33 @@ dashedName: reverse-a-string
# --description--
Reverse the provided string.
Invertir la cadena provista.
You may need to turn the string into an array before you can reverse it.
Es posible que necesites convertir la cadena en una matriz antes de poder invertirla.
Your result must be a string.
Tu resultado deber ser una cadena.
# --hints--
`reverseString("hello")` should return a string.
`reverseString("hello")` debería devolver una cadena.
```js
assert(typeof reverseString('hello') === 'string');
```
`reverseString("hello")` should become `"olleh"`.
`reverseString("hello")` debería convertirse en `"olleh"`.
```js
assert(reverseString('hello') === 'olleh');
```
`reverseString("Howdy")` should become `"ydwoH"`.
`reverseString("Howdy")` debería convertirse en `"ydwoH"`.
```js
assert(reverseString('Howdy') === 'ydwoH');
```
`reverseString("Greetings from Earth")` should return `"htraE morf sgniteerG"`.
`reverseString("Greetings from Earth")` debería devolver `"htraE morf sgniteerG"`.
```js
assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG');

22
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
View File

@ -1,6 +1,6 @@
---
id: 579e2a2c335b9d72dd32e05c
title: Slice and Splice
title: Cortar y rebanar
challengeType: 5
forumTopicId: 301148
dashedName: slice-and-splice
@ -8,29 +8,29 @@ dashedName: slice-and-splice
# --description--
You are given two arrays and an index.
Tienes dos arreglos y un índice.
Copy each element of the first array into the second array, in order.
Copia cada elemento del primer arreglo en el segundo arreglo, en orden.
Begin inserting elements at index `n` of the second array.
Comienza insertando elementos en el índice `n` del segundo arreglo.
Return the resulting array. The input arrays should remain the same after the function runs.
Devuelve el arreglo resultante. Los arreglos de entrada deben permanecer iguales luego de que se ejecute la función.
# --hints--
`frankenSplice([1, 2, 3], [4, 5], 1)` should return `[4, 1, 2, 3, 5]`.
`frankenSplice([1, 2, 3], [4, 5], 1)` debe devolver`[4, 1, 2, 3, 5]`.
```js
assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]);
```
`frankenSplice([1, 2], ["a", "b"], 1)` should return `["a", 1, 2, "b"]`.
`frankenSplice([1, 2], ["a", "b"], 1)` debe devolver `["a", 1, 2, "b"]`.
```js
assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']);
```
`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` should return `["head", "shoulders", "claw", "tentacle", "knees", "toes"]`.
`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` debe devolver `["head", "shoulders", "claw", "tentacle", "knees", "toes"]`.
```js
assert.deepEqual(
@ -43,20 +43,20 @@ assert.deepEqual(
);
```
All elements from the first array should be added to the second array in their original order.
Todos los elementos del primer arreglo deben ser añadidos al segundo arreglo en su orden original.
```js
assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4]);
```
The first array should remain the same after the function runs.
El primer arreglo debe permanecer igual después de ejecutar la función.
```js
frankenSplice(testArr1, testArr2, 1);
assert.deepEqual(testArr1, [1, 2]);
```
The second array should remain the same after the function runs.
El segundo arreglo debe permanecer igual después de ejecutar la función.
```js
frankenSplice(testArr1, testArr2, 1);

14
curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
View File

@ -1,6 +1,6 @@
---
id: ab6137d4e35944e21037b769
title: Title Case a Sentence
title: Haz que la primera letra de una palabra este en mayúscula
challengeType: 5
forumTopicId: 16088
dashedName: title-case-a-sentence
@ -8,31 +8,31 @@ dashedName: title-case-a-sentence
# --description--
Return the provided string with the first letter of each word capitalized. Make sure the rest of the word is in lower case.
Devuelve la cadena proporcionada con la primera letra de cada palabra en mayúsculas. Asegúrese de que el resto de la palabra esté en minúsculas.
For the purpose of this exercise, you should also capitalize connecting words like "the" and "of".
Para este ejercicio, también debes usar mayúsculas en los conectores como "the" y "of".
# --hints--
`titleCase("I'm a little tea pot")` should return a string.
`titleCase("I'm a little tea pot")` debe devolver una cadena.
```js
assert(typeof titleCase("I'm a little tea pot") === 'string');
```
`titleCase("I'm a little tea pot")` should return `I'm A Little Tea Pot`.
`titleCase("I'm a little tea pot")` debe devolver `I'm A Little Tea Pot`.
```js
assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot");
```
`titleCase("sHoRt AnD sToUt")` should return `Short And Stout`.
`titleCase("sHoRt AnD sToUt")` debe devolver `Short And Stout`.
```js
assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout');
```
`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` should return `Here Is My Handle Here Is My Spout`.
`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` debe devolver `Here Is My Handle Here Is My Spout`.
```js
assert(