diff --git a/curriculum/challenges/chinese/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md b/curriculum/challenges/chinese/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md index 48a28e55b6..9cf5d06c63 100644 --- a/curriculum/challenges/chinese/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md +++ b/curriculum/challenges/chinese/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md @@ -17,8 +17,8 @@ HTML5 的 `audio` 标签用于呈现音频内容或音频流，它也具有语 ```html ``` diff --git a/curriculum/challenges/espanol/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md b/curriculum/challenges/espanol/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md index 5c12070ce2..074aa1d9ec 100644 --- a/curriculum/challenges/espanol/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md +++ b/curriculum/challenges/espanol/01-responsive-web-design/applied-accessibility/improve-accessibility-of-audio-content-with-the-audio-element.md @@ -17,8 +17,8 @@ Acá tenemos un ejemplo: ```html ``` diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md index 3be6335b3a..f60f85b616 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md @@ -26,7 +26,7 @@ En orden, estas expresiones se evaluarían como `true`, `true`, `false` y `false # --instructions-- -Agrega el operador "mayor que" a las líneas indicadas para que las declaraciones de devolución tengan sentido. +Agrega el operador mayor que a las líneas indicadas para que las declaraciones de devolución tengan sentido. # --hints-- diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md index 5fd6bc8d55..fd4b6f3a71 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244d6 -title: Comparison with the Less Than Operator +title: Comparación con el operador "menor que" challengeType: 1 videoUrl: 'https://scrimba.com/c/cNVRWtB' forumTopicId: 16789 @@ -9,61 +9,63 @@ dashedName: comparison-with-the-less-than-operator # --description-- -The less than operator (`<`) compares the values of two numbers. If the number to the left is less than the number to the right, it returns `true`. Otherwise, it returns `false`. Like the equality operator, less than operator converts data types while comparing. +El operador menor que (`<`) compara los valores de dos números. Si el número a la izquierda es menor que el número a la derecha, devuelve `true`. De lo contrario, devuelve `false`. Al igual que el operador de igualdad, el operador menor que convertirá los tipos de datos mientras los compara. -**Examples** +**Ejemplos** ```js -2 < 5 // true -'3' < 7 // true -5 < 5 // false -3 < 2 // false -'8' < 4 // false +2 < 5 +'3' < 7 +5 < 5 +3 < 2 +'8' < 4 ``` +En orden, estas expresiones se evaluarían como `true`, `true`, `false`, `false` y `false`. + # --instructions-- -Add the less than operator to the indicated lines so that the return statements make sense. +Agrega el operador menor que a las líneas indicadas para que las declaraciones de devolución tengan sentido. # --hints-- -`testLessThan(0)` should return "Under 25" +`testLessThan(0)` debe devolver la cadena `Under 25` ```js assert(testLessThan(0) === 'Under 25'); ``` -`testLessThan(24)` should return "Under 25" +`testLessThan(24)` debe devolver la cadena `Under 25` ```js assert(testLessThan(24) === 'Under 25'); ``` -`testLessThan(25)` should return "Under 55" +`testLessThan(25)` debe devolver la cadena `Under 55` ```js assert(testLessThan(25) === 'Under 55'); ``` -`testLessThan(54)` should return "Under 55" +`testLessThan(54)` debe devolver la cadena `Under 55` ```js assert(testLessThan(54) === 'Under 55'); ``` -`testLessThan(55)` should return "55 or Over" +`testLessThan(55)` debe devolver la cadena `55 or Over` ```js assert(testLessThan(55) === '55 or Over'); ``` -`testLessThan(99)` should return "55 or Over" +`testLessThan(99)` debe devolver la cadena `55 or Over` ```js assert(testLessThan(99) === '55 or Over'); ``` -You should use the `<` operator at least twice +Debes usar el operador `<` por lo menos dos veces ```js assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md index 5174b635b4..6fbb8e42e1 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244d7 -title: Comparison with the Less Than Or Equal To Operator +title: Comparación con el operador "menor o igual que" challengeType: 1 videoUrl: 'https://scrimba.com/c/cNVR7Am' forumTopicId: 16788 @@ -9,67 +9,69 @@ dashedName: comparison-with-the-less-than-or-equal-to-operator # --description-- -The less than or equal to operator (`<=`) compares the values of two numbers. If the number to the left is less than or equal to the number to the right, it returns `true`. If the number on the left is greater than the number on the right, it returns `false`. Like the equality operator, `less than or equal to` converts data types. +El operador menor o igual que (`<=`) compara el valor de dos números. Si el número de la izquierda es menor o igual que el número de la derecha, devuelve `true`. Si el número a la izquierda es mayor que el número a la derecha, devuelve `false`. Al igual que el operador de igualdad, el operador menor o igual que convierte los tipos de datos. -**Examples** +**Ejemplos** ```js -4 <= 5 // true -'7' <= 7 // true -5 <= 5 // true -3 <= 2 // false -'8' <= 4 // false +4 <= 5 +'7' <= 7 +5 <= 5 +3 <= 2 +'8' <= 4 ``` +En orden, estas expresiones se evaluarían como `true`, `true`, `true`, `false` y `false`. + # --instructions-- -Add the less than or equal to operator to the indicated lines so that the return statements make sense. +Agrega el operador menor o igual que a las líneas indicadas para que el valor devuelto tenga sentido. # --hints-- -`testLessOrEqual(0)` should return "Smaller Than or Equal to 12" +`testLessOrEqual(0)` debe devolver la cadena `Smaller Than or Equal to 12` ```js assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12'); ``` -`testLessOrEqual(11)` should return "Smaller Than or Equal to 12" +`testLessOrEqual(11)` debe devolver la cadena `Smaller Than or Equal to 12` ```js assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12'); ``` -`testLessOrEqual(12)` should return "Smaller Than or Equal to 12" +`testLessOrEqual(12)` debe devolver la cadena `Smaller Than or Equal to 12` ```js assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12'); ``` -`testLessOrEqual(23)` should return "Smaller Than or Equal to 24" +`testLessOrEqual(23)` debe devolver la cadena `Smaller Than or Equal to 24` ```js assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24'); ``` -`testLessOrEqual(24)` should return "Smaller Than or Equal to 24" +`testLessOrEqual(24)` debe devolver la cadena `Smaller Than or Equal to 24` ```js assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24'); ``` -`testLessOrEqual(25)` should return "More Than 24" +`testLessOrEqual(25)` debe devolver la cadena `More Than 24` ```js assert(testLessOrEqual(25) === 'More Than 24'); ``` -`testLessOrEqual(55)` should return "More Than 24" +`testLessOrEqual(55)` debe devolver la cadena `More Than 24` ```js assert(testLessOrEqual(55) === 'More Than 24'); ``` -You should use the `<=` operator at least twice +Debes utilizar el operador `<=` al menos dos veces ```js assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md index b8d73b9aa4..f9b89bed2e 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244d1 -title: Comparison with the Strict Equality Operator +title: Comparación con el operador de estricta igualdad challengeType: 1 videoUrl: 'https://scrimba.com/c/cy87atr' forumTopicId: 16790 @@ -9,44 +9,46 @@ dashedName: comparison-with-the-strict-equality-operator # --description-- -Strict equality (`===`) is the counterpart to the equality operator (`==`). However, unlike the equality operator, which attempts to convert both values being compared to a common type, the strict equality operator does not perform a type conversion. +La estricta igualdad (`===`) es la contraparte del operador de igualdad (`==`). Sin embargo, a diferencia del operador de igualdad, el cual intenta convertir ambos valores comparados a un tipo común, el operador de estricta igualdad no realiza una conversión de tipo. -If the values being compared have different types, they are considered unequal, and the strict equality operator will return false. +Si los valores que se comparan tienen diferentes tipos, se consideran desiguales, y el operador de estricta igualdad devolverá falso. -**Examples** +**Ejemplos** ```js -3 === 3 // true -3 === '3' // false +3 === 3 +3 === '3' ``` -In the second example, `3` is a `Number` type and `'3'` is a `String` type. +Estas condiciones devuelven `true` y `false` respectivamente. + +En el segundo ejemplo, `3` es de tipo `Number` (número) y `'3'` es de tipo `String` (cadena). # --instructions-- -Use the strict equality operator in the `if` statement so the function will return "Equal" when `val` is strictly equal to `7` +Usa el operador de estricta igualdad en la sentencia `if` para que la función devuelva la cadena `Equal` cuando `val` sea estrictamente igual a `7` # --hints-- -`testStrict(10)` should return "Not Equal" +`testStrict(10)` debe devolver la cadena `Not Equal` ```js assert(testStrict(10) === 'Not Equal'); ``` -`testStrict(7)` should return "Equal" +`testStrict(7)` debe devolver la cadena `Equal` ```js assert(testStrict(7) === 'Equal'); ``` -`testStrict("7")` should return "Not Equal" +`testStrict("7")` debe devolver la cadena `Not Equal` ```js assert(testStrict('7') === 'Not Equal'); ``` -You should use the `===` operator +Debes usar el operador `===` ```js assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md index b24b31da75..a61b2aba5d 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md @@ -9,7 +9,7 @@ dashedName: comparison-with-the-strict-inequality-operator # --description-- -El operador de estricta desigualdad `!==` es el opuesto lógico del operador de estricta igualdad. Esto significa "Estrictamente No Igual", y devuelve `false` cuando la comparación de estricta igualdad devolvería `true` y *vice versa*. Una estricta desigualdad no convertirá los tipos de datos. +El operador de estricta desigualdad `!==` es el opuesto lógico del operador de estricta igualdad. Esto significa "Estrictamente Desigual", y devuelve `false` cuando la comparación de estricta igualdad devolvería `true` y *vice versa*. Una estricta desigualdad no convertirá los tipos de datos. **Ejemplos** diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md index bf9c2a6c1a..c53cfc790b 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244d8 -title: Comparisons with the Logical And Operator +title: Comparaciones con el operador lógico "and" challengeType: 1 videoUrl: 'https://scrimba.com/c/cvbRVtr' forumTopicId: 16799 @@ -9,9 +9,9 @@ dashedName: comparisons-with-the-logical-and-operator # --description-- -Sometimes you will need to test more than one thing at a time. The logical and operator (`&&`) returns `true` if and only if the operands to the left and right of it are true. +A veces tendrás que probar más de una cosa a la vez. El operador lógico and (`&&`) devuelve `true` si y solo si los operandos a la izquierda y a la derecha son verdaderos. -The same effect could be achieved by nesting an if statement inside another if: +El mismo efecto se podría lograr anidando una sentencia if dentro de otra sentencia if: ```js if (num > 5) { @@ -22,7 +22,7 @@ if (num > 5) { return "No"; ``` -will only return "Yes" if `num` is greater than `5` and less than `10`. The same logic can be written as: +solo devolverá `Yes` si `num` es mayor que `5` y menor que `10`. La misma lógica se puede escribir como: ```js if (num > 5 && num < 10) { @@ -33,65 +33,65 @@ return "No"; # --instructions-- -Replace the two if statements with one statement, using the && operator, which will return `"Yes"` if `val` is less than or equal to `50` and greater than or equal to `25`. Otherwise, will return `"No"`. +Reemplaza las dos sentencias if por una sola, usando el operador `&&`, el cual devolverá la cadena `Yes` si `val` es menor o igual a `50` y mayor o igual a `25`. De lo contrario, devolverá la cadena `No`. # --hints-- -You should use the `&&` operator once +Debes usar el operador `&&` una vez ```js assert(code.match(/&&/g).length === 1); ``` -You should only have one `if` statement +Debes tener una sola sentencia `if` ```js assert(code.match(/if/g).length === 1); ``` -`testLogicalAnd(0)` should return "No" +`testLogicalAnd(0)` debe devolver la cadena `No` ```js assert(testLogicalAnd(0) === 'No'); ``` -`testLogicalAnd(24)` should return "No" +`testLogicalAnd(24)` debe devolver la cadena `No` ```js assert(testLogicalAnd(24) === 'No'); ``` -`testLogicalAnd(25)` should return "Yes" +`testLogicalAnd(25)` debe devolver la cadena `Yes` ```js assert(testLogicalAnd(25) === 'Yes'); ``` -`testLogicalAnd(30)` should return "Yes" +`testLogicalAnd(30)` debe devolver la cadena `Yes` ```js assert(testLogicalAnd(30) === 'Yes'); ``` -`testLogicalAnd(50)` should return "Yes" +`testLogicalAnd(50)` debe devolver la cadena `Yes` ```js assert(testLogicalAnd(50) === 'Yes'); ``` -`testLogicalAnd(51)` should return "No" +`testLogicalAnd(51)` debe devolver la cadena `No` ```js assert(testLogicalAnd(51) === 'No'); ``` -`testLogicalAnd(75)` should return "No" +`testLogicalAnd(75)` debe devolver la cadena `No` ```js assert(testLogicalAnd(75) === 'No'); ``` -`testLogicalAnd(80)` should return "No" +`testLogicalAnd(80)` debe devolver la cadena `No` ```js assert(testLogicalAnd(80) === 'No'); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md index cd5d09d36f..0abcb29e40 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244d9 -title: Comparisons with the Logical Or Operator +title: Comparaciones con el operador lógico "or" challengeType: 1 videoUrl: 'https://scrimba.com/c/cEPrGTN' forumTopicId: 16800 @@ -9,11 +9,11 @@ dashedName: comparisons-with-the-logical-or-operator # --description-- -The logical or operator (`||`) returns `true` if either of the operands is `true`. Otherwise, it returns `false`. +El operador lógico or (`||`) devuelve `true` si cualquiera de los operandos es `true`. De lo contrario, devuelve `false`. -The logical or operator is composed of two pipe symbols: (`||`). This can typically be found between your Backspace and Enter keys. +El operador lógico or se compone de dos símbolos de barra vertical: (`||`). Este se puede encontrar normalmente entre las teclas de tabulación y escape. -The pattern below should look familiar from prior waypoints: +El patrón de abajo debería parecer familiar desde los puntos de referencia anteriores: ```js if (num > 10) { @@ -25,7 +25,7 @@ if (num < 5) { return "Yes"; ``` -will return "Yes" only if `num` is between `5` and `10` (5 and 10 included). The same logic can be written as: +devolverá `Yes` sólo si `num` está entre `5` y `10` (5 y 10 incluidos). La misma lógica se puede escribir como: ```js if (num > 10 || num < 5) { @@ -36,65 +36,65 @@ return "Yes"; # --instructions-- -Combine the two `if` statements into one statement which returns `"Outside"` if `val` is not between `10` and `20`, inclusive. Otherwise, return `"Inside"`. +Combina las dos sentencias `if` en una sola sentencia que devuelva la cadena `Outside` si `val` no está entre `10` y `20`, inclusivo. De lo contrario, devuelve la cadena `Inside`. # --hints-- -You should use the `||` operator once +Debes usar el operador `||` una vez ```js assert(code.match(/\|\|/g).length === 1); ``` -You should only have one `if` statement +Debes tener una sola sentencia `if` ```js assert(code.match(/if/g).length === 1); ``` -`testLogicalOr(0)` should return "Outside" +`testLogicalOr(0)` debe devolver la cadena `Outside` ```js assert(testLogicalOr(0) === 'Outside'); ``` -`testLogicalOr(9)` should return "Outside" +`testLogicalOr(9)` debe devolver la cadena `Outside` ```js assert(testLogicalOr(9) === 'Outside'); ``` -`testLogicalOr(10)` should return "Inside" +`testLogicalOr(10)` debe devolver la cadena `Inside` ```js assert(testLogicalOr(10) === 'Inside'); ``` -`testLogicalOr(15)` should return "Inside" +`testLogicalOr(15)` debe devolver la cadena `Inside` ```js assert(testLogicalOr(15) === 'Inside'); ``` -`testLogicalOr(19)` should return "Inside" +`testLogicalOr(19)` debe devolver la cadena `Inside` ```js assert(testLogicalOr(19) === 'Inside'); ``` -`testLogicalOr(20)` should return "Inside" +`testLogicalOr(20)` debe devolver la cadena `Inside` ```js assert(testLogicalOr(20) === 'Inside'); ``` -`testLogicalOr(21)` should return "Outside" +`testLogicalOr(21)` debe devolver la cadena `Outside` ```js assert(testLogicalOr(21) === 'Outside'); ``` -`testLogicalOr(25)` should return "Outside" +`testLogicalOr(25)` debe devolver la cadena `Outside` ```js assert(testLogicalOr(25) === 'Outside'); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md index b8c2d7716a..0836929d23 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md @@ -20,9 +20,11 @@ Uno de estos operadores es el operador `+=`. ```js var myVar = 1; myVar += 5; -console.log(myVar); // Returns 6 +console.log(myVar); ``` +Se mostrará un `6` en la consola. + # --instructions-- Convierte las asignaciones de `a`, `b` y `c` para que utilicen el operador `+=`. diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md index 92b7d49cb4..c43d2601dc 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244b2 -title: Compound Assignment With Augmented Division +title: Asignación compuesta con división aumentada challengeType: 1 videoUrl: 'https://scrimba.com/c/c2QvKT2' forumTopicId: 16659 @@ -9,45 +9,45 @@ dashedName: compound-assignment-with-augmented-division # --description-- -The `/=` operator divides a variable by another number. +El operador `/=` divide una variable entre otro número. `myVar = myVar / 5;` -Will divide `myVar` by `5`. This can be rewritten as: +Dividirá `myVar` entre `5`. Esto se puede reescribir como: `myVar /= 5;` # --instructions-- -Convert the assignments for `a`, `b`, and `c` to use the `/=` operator. +Convierte las asignaciones de `a`, `b` y `c` para que utilicen el operador `/=`. # --hints-- -`a` should equal `4`. +`a` debe ser igual a `4`. ```js assert(a === 4); ``` -`b` should equal `27`. +`b` debe ser igual a `27`. ```js assert(b === 27); ``` -`c` should equal `3`. +`c` debe ser igual a `3`. ```js assert(c === 3); ``` -You should use the `/=` operator for each variable. +Debes usar el operador `/=` para cada variable. ```js assert(code.match(/\/=/g).length === 3); ``` -You should not modify the code above the specified comment. +No debes modificar el código por encima del comentario especificado. ```js assert( diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md index ec94ec73ed..61c5fdf36d 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244b7 -title: Concatenating Strings with Plus Operator +title: Concatena cadenas con el operador "más" challengeType: 1 videoUrl: 'https://scrimba.com/c/cNpM8AN' forumTopicId: 16802 @@ -9,49 +9,48 @@ dashedName: concatenating-strings-with-plus-operator # --description-- -In JavaScript, when the `+` operator is used with a `String` value, it is called the concatenation operator. You can build a new string out of other strings by concatenating them together. +En JavaScript, cuando el operador `+` se utiliza con un valor de cadena (`String`), se le llama operador de concatenación. Puedes construir una nueva cadena a partir de otras cadenas concatenándolas juntas. -**Example** +**Ejemplo** ```js 'My name is Alan,' + ' I concatenate.' ``` -**Note** -Watch out for spaces. Concatenation does not add spaces between concatenated strings, so you'll need to add them yourself. +**Nota:** Ten cuidado con los espacios. La concatenación no añade espacios entre las cadenas concatenadas, así que tendrás que añadirlos por tu cuenta. -Example: +Ejemplo: ```js var ourStr = "I come first. " + "I come second."; -// ourStr is "I come first. I come second." ``` +La cadena `I come first. I come second.` se mostrará en la consola. # --instructions-- -Build `myStr` from the strings `"This is the start. "` and `"This is the end."` using the `+` operator. +Construye `myStr` a partir de las cadenas `This is the start.` y `This is the end.` utilizando el operador `+`. # --hints-- -`myStr` should have a value of `This is the start. This is the end.` +`myStr` debe tener una cadena con valor `This is the start. This is the end.` ```js assert(myStr === 'This is the start. This is the end.'); ``` -You should use the `+` operator to build `myStr`. +Debes usar el operador `+` para construir `myStr`. ```js assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g)); ``` -`myStr` should be created using the `var` keyword. +`myStr` debe ser creada usando la palabra clave `var`. ```js assert(/var\s+myStr/.test(code)); ``` -You should assign the result to the `myStr` variable. +Debes asignar el resultado a la variable `myStr`. ```js assert(/myStr\s*=/.test(code)); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md index 183aa48865..f99326a40c 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244b9 -title: Constructing Strings with Variables +title: Construye cadenas con variables challengeType: 1 videoUrl: 'https://scrimba.com/c/cqk8rf4' forumTopicId: 16805 @@ -9,29 +9,30 @@ dashedName: constructing-strings-with-variables # --description-- -Sometimes you will need to build a string, [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs) style. By using the concatenation operator (`+`), you can insert one or more variables into a string you're building. +A veces necesitarás construir una cadena, al estilo [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs). Al usar el operador de concatenación (`+`), puedes insertar una o más variables en una cadena que estés construyendo. -Example: +Ejemplo: ```js var ourName = "freeCodeCamp"; var ourStr = "Hello, our name is " + ourName + ", how are you?"; -// ourStr is now "Hello, our name is freeCodeCamp, how are you?" ``` +`ourStr` tendrá como valor la cadena `Hello, our name is freeCodeCamp, how are you?`. + # --instructions-- -Set `myName` to a string equal to your name and build `myStr` with `myName` between the strings `"My name is "` and `" and I am well!"` +Establece `myName` en una cadena igual a tu nombre y construye `myStr` con `myName` entre las cadenas `My name is` y `and I am well!` # --hints-- -`myName` should be set to a string at least 3 characters long. +`myName` debe establecerse en una cadena de al menos 3 caracteres de largo. ```js assert(typeof myName !== 'undefined' && myName.length > 2); ``` -You should use two `+` operators to build `myStr` with `myName` inside it. +Debes usar dos operadores `+` para construir `myStr` con `myName` dentro de él. ```js assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md index 9edc5f1cb9..d679a51ea2 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md @@ -1,6 +1,6 @@ --- id: 56105e7b514f539506016a5e -title: Count Backwards With a For Loop +title: Cuenta hacia atrás con un bucle "for" challengeType: 1 videoUrl: 'https://scrimba.com/c/c2R6BHa' forumTopicId: 16808 @@ -9,11 +9,11 @@ dashedName: count-backwards-with-a-for-loop # --description-- -A for loop can also count backwards, so long as we can define the right conditions. +Un bucle for también puede contar hacia atrás, siempre que definamos las condiciones adecuadas. -In order to decrement by two each iteration, we'll need to change our `initialization`, `condition`, and `final-expression`. +Para poder disminuirle dos cada iteración, necesitaremos cambiar nuestra inicialización, condición, y expresión final. -We'll start at `i = 10` and loop while `i > 0`. We'll decrement `i` by 2 each loop with `i -= 2`. +Empezaremos en `i = 10` e iteraremos mientras `i > 0`. Disminuiremos `i` en 2 por cada bucle con `i -= 2`. ```js var ourArray = []; @@ -22,27 +22,27 @@ for (var i = 10; i > 0; i -= 2) { } ``` -`ourArray` will now contain `[10,8,6,4,2]`. Let's change our `initialization` and `final-expression` so we can count backward by twos by odd numbers. +`ourArray` ahora contendrá `[10,8,6,4,2]`. Cambiemos nuestra inicialización y expresión final para que podamos contar hacia atrás por dos números impares. # --instructions-- -Push the odd numbers from 9 through 1 to `myArray` using a `for` loop. +Inserta los números impares desde el 9 hasta el 1 en `myArray` utilizando un bucle `for`. # --hints-- -You should be using a `for` loop for this. +Debes utilizar un bucle `for` para esto. ```js assert(/for\s*\([^)]+?\)/.test(code)); ``` -You should be using the array method `push`. +Debes utilizar el método de arreglo `push`. ```js assert(code.match(/myArray.push/)); ``` -`myArray` should equal `[9,7,5,3,1]`. +`myArray` debe ser igual a `[9,7,5,3,1]`. ```js assert.deepEqual(myArray, [9, 7, 5, 3, 1]); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md index 4d98fdecfb..8c88443d07 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md @@ -1,6 +1,6 @@ --- id: 565bbe00e9cc8ac0725390f4 -title: Counting Cards +title: Conteo de cartas challengeType: 1 videoUrl: 'https://scrimba.com/c/c6KE7ty' forumTopicId: 16809 @@ -9,25 +9,25 @@ dashedName: counting-cards # --description-- -In the casino game Blackjack, a player can gain an advantage over the house by keeping track of the relative number of high and low cards remaining in the deck. This is called [Card Counting](https://en.wikipedia.org/wiki/Card_counting). +En el juego de casino Blackjack el jugador puede sacarle ventaja a la casa llevando un registro del numero relativo de cartas altas y bajas que quedan en la baraja. Esto es llamado [conteo de cartas](https://es.wikipedia.org/wiki/Conteo_de_cartas). -Having more high cards remaining in the deck favors the player. Each card is assigned a value according to the table below. When the count is positive, the player should bet high. When the count is zero or negative, the player should bet low. +Tener más cartas altas en la baraja es una ventaja para el jugador. Se le asigna una valor a cada carta de acuerdo a la siguiente tabla. Cuando el conteo es positivo, el jugador debería apostar alto. Cuando el conteo da 0 o negativo, el jugador debería apostar bajo. -
Count ChangeCards
+12, 3, 4, 5, 6
07, 8, 9
-110, 'J', 'Q', 'K', 'A'
+
Cambios del conteoCartas
+12, 3, 4, 5, 6
07, 8, 9
-110, 'J', 'Q', 'K', 'A'
-You will write a card counting function. It will receive a `card` parameter, which can be a number or a string, and increment or decrement the global `count` variable according to the card's value (see table). The function will then return a string with the current count and the string `Bet` if the count is positive, or `Hold` if the count is zero or negative. The current count and the player's decision (`Bet` or `Hold`) should be separated by a single space. +Escribirás una función para contar cartas. Recibirá un parámetro `card` (carta) que puede ser un número o una cadena y aumentar o reducir la variable global `count` (conteo) de acuerdo al valor de la carta (observa la tabla). La función devolverá una cadena con el conteo actual y la cadena `Bet` (Apuesta) si el conteo es positivo, o `Hold` (Espera) si el conteo es cero o negativo. El conteo actual y la decisión del jugador (`Bet` o `Hold`) deben estar separados por un solo espacio. -**Example Output** +**Ejemplo de salida** `-3 Hold` `5 Bet` -**Hint** -Do NOT reset `count` to 0 when value is 7, 8, or 9. Do NOT return an array. -Do NOT include quotes (single or double) in the output. +**Sugerencia** +NO reinicies `count` a 0 cuando el valor sea 7, 8 o 9. NO devuelvas un arreglo. +NO incluyas comillas (individuales o dobles) en el resultado. # --hints-- -Cards Sequence 2, 3, 4, 5, 6 should return `5 Bet` +La secuencia de cartas 2, 3, 4, 5, 6 debe devolver `5 Bet` ```js assert( @@ -46,7 +46,7 @@ assert( ); ``` -Cards Sequence 7, 8, 9 should return `0 Hold` +La secuencia de cartas 7, 8, 9 debe devolver la cadena `0 Hold` ```js assert( @@ -63,7 +63,7 @@ assert( ); ``` -Cards Sequence 10, J, Q, K, A should return `-5 Hold` +La secuencia de cartas 10, J, Q, K, A debe devolver la cadena `-5 Hold` ```js assert( @@ -82,7 +82,7 @@ assert( ); ``` -Cards Sequence 3, 7, Q, 8, A should return `-1 Hold` +La secuencia de cartas 3, 7, Q, 8, A debe devolver la cadena `-1 Hold` ```js assert( @@ -101,7 +101,7 @@ assert( ); ``` -Cards Sequence 2, J, 9, 2, 7 should return `1 Bet` +La secuencia de cartas 2, J, 9, 2, 7 debe devolver la cadena `1 Bet` ```js assert( @@ -120,7 +120,7 @@ assert( ); ``` -Cards Sequence 2, 2, 10 should return `1 Bet` +La secuencia de cartas 2, 2, 10 debe devolver la cadena `1 Bet` ```js assert( @@ -137,7 +137,7 @@ assert( ); ``` -Cards Sequence 3, 2, A, 10, K should return `-1 Hold` +La secuencia de cartas 3, 2, A, 10, K debe devolver la cadena `-1 Hold` ```js assert( diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md index 1a14b1c4f5..fa571c8ae1 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md @@ -11,8 +11,7 @@ dashedName: create-decimal-numbers-with-javascript También podemos almacenar números decimales en variables. Los números decimales a veces se denominan números de coma flotante o flotantes. -**Nota** -No todos los números reales pueden representarse con precisión en coma flotante. Esto puede llevar a errores de redondeo. [Detalles aquí](https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems). +**Nota:** No todos los números reales pueden representarse con precisión en coma flotante. Esto puede llevar a errores de redondeo. [Detalles aquí](https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems). # --instructions-- diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md index 440fa546fc..be76f9adb7 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md @@ -1,6 +1,6 @@ --- id: bd7123c9c444eddfaeb5bdef -title: Declare String Variables +title: Declara variables de cadena challengeType: 1 videoUrl: 'https://scrimba.com/c/c2QvWU6' forumTopicId: 17557 @@ -9,19 +9,19 @@ dashedName: declare-string-variables # --description-- -Previously we have used the code +Anteriormente hemos usado el código `var myName = "your name";` -`"your name"` is called a string literal. It is a string because it is a series of zero or more characters enclosed in single or double quotes. +`"your name"` es llamada una cadena literal. Es una cadena porque es una serie de cero o más caracteres encerrados entre comillas simples o dobles. # --instructions-- -Create two new `string` variables: `myFirstName` and `myLastName` and assign them the values of your first and last name, respectively. +Crea dos nuevas variables de cadena: `myFirstName` y `myLastName` y asígnales los valores de tu nombre y apellido, respectivamente. # --hints-- -`myFirstName` should be a string with at least one character in it. +`myFirstName` debe ser una cadena con al menos un carácter en ella. ```js assert( @@ -39,7 +39,7 @@ assert( ); ``` -`myLastName` should be a string with at least one character in it. +`myLastName` debe ser una cadena con al menos un carácter en ella. ```js assert( @@ -66,7 +66,9 @@ if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(fun ``` ## --seed-contents-- + ```js + ``` # --solutions-- diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md index fd4892d93f..5d43991d1d 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md @@ -17,8 +17,7 @@ es equivalente a `i = i - 1;` -**Nota** -Toda la línea se convierte en `i--;`, eliminando la necesidad del signo de igualdad. +**Nota:** Toda la línea se convierte en `i--;`, eliminando la necesidad del signo de igualdad. # --instructions-- diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md index 21c8366962..e6969a25b7 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md @@ -1,6 +1,6 @@ --- id: 56bbb991ad1ed5201cd392d3 -title: Delete Properties from a JavaScript Object +title: Elimina propiedades en un objeto de JavaScript challengeType: 1 videoUrl: 'https://scrimba.com/c/cDqKdTv' forumTopicId: 17560 @@ -9,11 +9,11 @@ dashedName: delete-properties-from-a-javascript-object # --description-- -We can also delete properties from objects like this: +También podemos eliminar propiedades de objetos de esta forma: `delete ourDog.bark;` -Example: +Ejemplo: ```js var ourDog = { @@ -27,7 +27,7 @@ var ourDog = { delete ourDog.bark; ``` -After the last line shown above, `ourDog` looks like: +Después de la última línea mostrada anteriormente, `ourDog` se ve así: ```js { @@ -40,17 +40,17 @@ After the last line shown above, `ourDog` looks like: # --instructions-- -Delete the `"tails"` property from `myDog`. You may use either dot or bracket notation. +Elimina la propiedad `tails` de `myDog`. Puedes usar tanto la notación de puntos como la notación de corchetes. # --hints-- -You should delete the property `"tails"` from `myDog`. +Debes eliminar la propiedad `tails` de `myDog`. ```js assert(typeof myDog === 'object' && myDog.tails === undefined); ``` -You should not modify the `myDog` setup. +No debes modificar la disposición de `myDog`. ```js assert(code.match(/"tails": 1/g).length > 0); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md index cb96b3ff71..084ee38e9f 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md @@ -1,6 +1,6 @@ --- id: bd7993c9ca9feddfaeb7bdef -title: Divide One Decimal by Another with JavaScript +title: Divide un decimal entre otro con JavaScript challengeType: 1 videoUrl: 'https://scrimba.com/c/cBZe9AW' forumTopicId: 18255 @@ -9,27 +9,27 @@ dashedName: divide-one-decimal-by-another-with-javascript # --description-- -Now let's divide one decimal by another. +Ahora dividamos un decimal entre otro. # --instructions-- -Change the `0.0` so that `quotient` will equal to `2.2`. +Cambia el `0.0` para que el cociente (`quotient`) sea igual a `2.2`. # --hints-- -The variable `quotient` should equal `2.2` +La variable `quotient` debe ser igual a `2.2` ```js assert(quotient === 2.2); ``` -You should use the `/` operator to divide 4.4 by 2 +Debes usar el operador `/` para dividir 4.4 entre 2 ```js assert(/4\.40*\s*\/\s*2\.*0*/.test(code)); ``` -The quotient variable should only be assigned once +La variable quotient debe ser asignada solo una vez ```js assert(code.match(/quotient/g).length === 1); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md index ac6559de3d..dd54212715 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md @@ -16,9 +16,10 @@ JavaScript utiliza el símbolo `/` para la división. **Ejemplo** ```js -myVar = 16 / 2; // assigned 8 +myVar = 16 / 2; ``` +`myVar` ahora tiene el valor `8`. # --instructions-- Cambia el `0` para que el `quotient` (cociente) sea igual a `2`. diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md index 03bc3f0071..601bb8e161 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md @@ -1,6 +1,6 @@ --- id: bd7123c9c448eddfaeb5bdef -title: Find the Length of a String +title: Encuentra la longitud de una cadena challengeType: 1 videoUrl: 'https://scrimba.com/c/cvmqEAd' forumTopicId: 18182 @@ -9,19 +9,23 @@ dashedName: find-the-length-of-a-string # --description-- -You can find the length of a `String` value by writing `.length` after the string variable or string literal. +Puedes encontrar la longitud de un valor de cadena (`String`) escribiendo `.length` después de la variable de cadena o literal de cadena. -`"Alan Peter".length; // 10` +```js +console.log("Alan Peter".length); +``` -For example, if we created a variable `var firstName = "Charles"`, we could find out how long the string `"Charles"` is by using the `firstName.length` property. +El valor `10` se mostrará en la consola. + +Por ejemplo, si creamos una variable `var firstName = "Charles"`, podríamos averiguar la longitud de la cadena `Charles` usando la propiedad `firstName.length`. # --instructions-- -Use the `.length` property to count the number of characters in the `lastName` variable and assign it to `lastNameLength`. +Usa la propiedad `.length` para contar el número de caracteres en la variable `lastName` y asignarla a `lastNameLength`. # --hints-- -You should not change the variable declarations in the `// Setup` section. +No debes cambiar las declaraciones de variables en la sección `// Setup`. ```js assert( @@ -30,13 +34,13 @@ assert( ); ``` -`lastNameLength` should be equal to eight. +`lastNameLength` debe ser igual a ocho. ```js assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8); ``` -You should be getting the length of `lastName` by using `.length` like this: `lastName.length`. +Debes obtener la longitud de `lastName` usando `.length` de esta forma: `lastName.length`. ```js assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/)); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md index c811162a83..4b8339fc95 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244ae -title: Finding a Remainder in JavaScript +title: Encuentra un resto en JavaScript challengeType: 1 videoUrl: 'https://scrimba.com/c/cWP24Ub' forumTopicId: 18184 @@ -9,39 +9,38 @@ dashedName: finding-a-remainder-in-javascript # --description-- -The remainder operator `%` gives the remainder of the division of two numbers. +El operador de resto `%` entrega el resto de la división entre dos números. -**Example** +**Ejemplo** -
5 % 2 = 1 because
Math.floor(5 / 2) = 2 (Quotient)
2 * 2 = 4
5 - 4 = 1 (Remainder)
+
5 % 2 = 1 porque
Math.floor(5 / 2) = 2 (Cociente)
2 * 2 = 4
5 - 4 = 1 (Resto)
-**Usage** -In mathematics, a number can be checked to be even or odd by checking the remainder of the division of the number by `2`. +**Uso** +En matemáticas, un número se puede comprobar para saber si es par o impar revisando el resto de la división del número por `2`. -
17 % 2 = 1 (17 is Odd)
48 % 2 = 0 (48 is Even)
+
17 % 2 = 1 (17 es impar)
48 % 2 = 0 (48 es par)
-**Note** -The remainder operator is sometimes incorrectly referred to as the "modulus" operator. It is very similar to modulus, but does not work properly with negative numbers. +**Nota:** El operador de resto es a veces incorrectamente referido como el operador módulo. Es muy similar al módulo, pero no funciona adecuadamente con números negativos. # --instructions-- -Set `remainder` equal to the remainder of `11` divided by `3` using the remainder (`%`) operator. +Establece `remainder` igual al resto de `11` dividido entre `3` usando el operador de resto (`%`). # --hints-- -The variable `remainder` should be initialized +La variable `remainder` debe inicializarse ```js assert(/var\s+?remainder/.test(code)); ``` -The value of `remainder` should be `2` +El valor de `remainder` debe ser `2` ```js assert(remainder === 2); ``` -You should use the `%` operator +Debes usar el operador `%` ```js assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code)); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md index 7565d935ad..057997ce46 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md @@ -1,6 +1,6 @@ --- id: cf1111c1c11feddfaeb9bdef -title: Generate Random Fractions with JavaScript +title: Genera fracciones aleatorias con JavaScript challengeType: 1 videoUrl: 'https://scrimba.com/c/cyWJJs3' forumTopicId: 18185 @@ -9,32 +9,31 @@ dashedName: generate-random-fractions-with-javascript # --description-- -Random numbers are useful for creating random behavior. +Los números aleatorios son útiles para crear comportamientos aleatorios. -JavaScript has a `Math.random()` function that generates a random decimal number between `0` (inclusive) and not quite up to `1` (exclusive). Thus `Math.random()` can return a `0` but never quite return a `1` +JavaScript tiene una función `Math.random()` que genera un número decimal aleatorio entre `0` (inclusivo) y `1` (exclusivo). Así que `Math.random()` puede devolver un `0` pero nunca devuelve un `1` -**Note** -Like [Storing Values with the Equal Operator](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), all function calls will be resolved before the `return` executes, so we can `return` the value of the `Math.random()` function. +**Nota:** Así como aprendimos en [almacenando valores con el operador de igualdad](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), todas las llamadas de funciones se resolverán antes de que el `return` se ejecute, así que podemos devolver (`return`) el valor de la función `Math.random()`. # --instructions-- -Change `randomFraction` to return a random number instead of returning `0`. +Cambia `randomFraction` para que devuelva un número aleatorio en lugar de devolver `0`. # --hints-- -`randomFraction` should return a random number. +`randomFraction` debe devolver un número aleatorio. ```js assert(typeof randomFraction() === 'number'); ``` -The number returned by `randomFraction` should be a decimal. +El número devuelto por `randomFraction` debe ser un decimal. ```js assert((randomFraction() + '').match(/\./g)); ``` -You should be using `Math.random` to generate the random decimal number. +Debes usar `Math.random` para generar el número decimal aleatorio. ```js assert(code.match(/Math\.random/g).length >= 0); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md index 72306dcf1d..8bebf29c5f 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244be -title: Global Scope and Functions +title: Ámbito global y funciones challengeType: 1 videoUrl: 'https://scrimba.com/c/cQM7mCN' forumTopicId: 18193 @@ -9,37 +9,37 @@ dashedName: global-scope-and-functions # --description-- -In JavaScript, scope refers to the visibility of variables. Variables which are defined outside of a function block have Global scope. This means, they can be seen everywhere in your JavaScript code. +En JavaScript, el ámbito se refiere a la visibilidad de las variables. Las variables definidas fuera de un bloque de función tienen un ámbito Global. Esto significa que pueden ser observadas desde cualquier lugar en tu código JavaScript. -Variables which are used without the `var` keyword are automatically created in the `global` scope. This can create unintended consequences elsewhere in your code or when running a function again. You should always declare your variables with `var`. +Las variables que se usan sin la palabra clave `var` se crean automáticamente en el ámbito `global`. Esto puede crear consecuencias no intencionadas en cualquier lugar de tu código o al volver a ejecutar una función. Siempre debes declarar tus variables con `var`. # --instructions-- -Using `var`, declare a global variable named `myGlobal` outside of any function. Initialize it with a value of `10`. +Usando `var`, declara una variable global llamada `myGlobal` fuera de cualquier función. Inicialízala con un valor de `10`. -Inside function `fun1`, assign `5` to `oopsGlobal` ***without*** using the `var` keyword. +Dentro de la función `fun1`, asigna `5` a `oopsGlobal` ***sin*** usar la palabra clave `var`. # --hints-- -`myGlobal` should be defined +`myGlobal` debe ser definida ```js assert(typeof myGlobal != 'undefined'); ``` -`myGlobal` should have a value of `10` +`myGlobal` debe tener un valor de `10` ```js assert(myGlobal === 10); ``` -`myGlobal` should be declared using the `var` keyword +`myGlobal` debe declararse usando la palabra clave `var` ```js assert(/var\s+myGlobal/.test(code)); ``` -`oopsGlobal` should be a global variable and have a value of `5` +`oopsGlobal` debe ser una variable global y tener un valor de `5` ```js assert(typeof oopsGlobal != 'undefined' && oopsGlobal === 5); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md index 4aa4e70ab0..ed7f022fb3 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244c0 -title: Global vs. Local Scope in Functions +title: Ámbito global vs. local en funciones challengeType: 1 videoUrl: 'https://scrimba.com/c/c2QwKH2' forumTopicId: 18194 @@ -9,9 +9,9 @@ dashedName: global-vs--local-scope-in-functions # --description-- -It is possible to have both local and global variables with the same name. When you do this, the `local` variable takes precedence over the `global` variable. +Es posible tener variables locales y globales con el mismo nombre. Cuando haces esto, la variable `local` tiene precedencia sobre la variable `global`. -In this example: +En este ejemplo: ```js var someVar = "Hat"; @@ -21,27 +21,27 @@ function myFun() { } ``` -The function `myFun` will return `"Head"` because the `local` version of the variable is present. +La función `myFun` devolverá la cadena `Head` porque está presente la versión `local` de la variable. # --instructions-- -Add a local variable to `myOutfit` function to override the value of `outerWear` with `"sweater"`. +Añade una variable local a la función `myOutfit` para sobrescribir el valor de `outerWear` con la cadena `sweater`. # --hints-- -You should not change the value of the global `outerWear`. +No debes cambiar el valor del `outerWear` global. ```js assert(outerWear === 'T-Shirt'); ``` -`myOutfit` should return `"sweater"`. +`myOutfit` debe devolver la cadena `sweater`. ```js assert(myOutfit() === 'sweater'); ``` -You should not change the return statement. +No debes cambiar la declaración de devolución. ```js assert(/return outerWear/.test(code)); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md index c53081daa9..9b4d455f52 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md @@ -1,6 +1,6 @@ --- id: 5664820f61c48e80c9fa476c -title: Golf Code +title: Código de golf challengeType: 1 videoUrl: 'https://scrimba.com/c/c9ykNUR' forumTopicId: 18195 @@ -9,77 +9,77 @@ dashedName: golf-code # --description-- -In the game of [golf](https://en.wikipedia.org/wiki/Golf) each hole has a `par` meaning the average number of `strokes` a golfer is expected to make in order to sink the ball in a hole to complete the play. Depending on how far above or below `par` your `strokes` are, there is a different nickname. +En el juego de [golf](https://en.wikipedia.org/wiki/Golf) cada hoyo tiene un `par` que significa el número promedio de `strokes` (golpes) que se espera que haga un golfista para introducir la pelota en un hoyo para completar la jugada. Dependiendo de qué tan por encima o por debajo del `par` estén tus `strokes`, hay un nombre diferente. -Your function will be passed `par` and `strokes` arguments. Return the correct string according to this table which lists the strokes in order of priority; top (highest) to bottom (lowest): +Tu función recibirá los argumentos `par` y `strokes`. Devuelve la cadena correcta según esta tabla que muestra los golpes en orden de prioridad; superior (más alto) a inferior (más bajo): -
StrokesReturn
1"Hole-in-one!"
<= par - 2"Eagle"
par - 1"Birdie"
par"Par"
par + 1"Bogey"
par + 2"Double Bogey"
>= par + 3"Go Home!"
+
Strokes (golpes)Devuelve
1"Hole-in-one!"
<= par - 2"Eagle"
par - 1"Birdie"
par"Par"
par + 1"Bogey"
par + 2"Double Bogey"
>= par + 3"Go Home!"
-`par` and `strokes` will always be numeric and positive. We have added an array of all the names for your convenience. +`par` y `strokes` siempre serán numéricos y positivos. Hemos añadido un arreglo de todos los nombres para tu conveniencia. # --hints-- -`golfScore(4, 1)` should return "Hole-in-one!" +`golfScore(4, 1)` debe devolver la cadena `Hole-in-one!` ```js assert(golfScore(4, 1) === 'Hole-in-one!'); ``` -`golfScore(4, 2)` should return "Eagle" +`golfScore(4, 2)` debe devolver la cadena `Eagle` ```js assert(golfScore(4, 2) === 'Eagle'); ``` -`golfScore(5, 2)` should return "Eagle" +`golfScore(5, 2)` debe devolver la cadena `Eagle` ```js assert(golfScore(5, 2) === 'Eagle'); ``` -`golfScore(4, 3)` should return "Birdie" +`golfScore(4, 3)` debe devolver la cadena `Birdie` ```js assert(golfScore(4, 3) === 'Birdie'); ``` -`golfScore(4, 4)` should return "Par" +`golfScore(4, 4)` debe devolver la cadena `Par` ```js assert(golfScore(4, 4) === 'Par'); ``` -`golfScore(1, 1)` should return "Hole-in-one!" +`golfScore(1, 1)` debe devolver la cadena `Hole-in-one!` ```js assert(golfScore(1, 1) === 'Hole-in-one!'); ``` -`golfScore(5, 5)` should return "Par" +`golfScore(5, 5)` debe devolver la cadena `Par` ```js assert(golfScore(5, 5) === 'Par'); ``` -`golfScore(4, 5)` should return "Bogey" +`golfScore(4, 5)` debe devolver la cadena `Bogey` ```js assert(golfScore(4, 5) === 'Bogey'); ``` -`golfScore(4, 6)` should return "Double Bogey" +`golfScore(4, 6)` debe devolver la cadena `Double Bogey` ```js assert(golfScore(4, 6) === 'Double Bogey'); ``` -`golfScore(4, 7)` should return "Go Home!" +`golfScore(4, 7)` debe devolver la cadena `Go Home!` ```js assert(golfScore(4, 7) === 'Go Home!'); ``` -`golfScore(5, 9)` should return "Go Home!" +`golfScore(5, 9)` debe devolver la cadena `Go Home!` ```js assert(golfScore(5, 9) === 'Go Home!'); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md index f2d9b91295..b9726deb55 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244ac -title: Increment a Number with JavaScript +title: Incrementa un número con JavaScript challengeType: 1 videoUrl: 'https://scrimba.com/c/ca8GLT9' forumTopicId: 18201 @@ -9,30 +9,29 @@ dashedName: increment-a-number-with-javascript # --description-- -You can easily increment or add one to a variable with the `++` operator. +Puedes fácilmente incrementar o sumar uno a una variable con el operador `++`. `i++;` -is the equivalent of +es equivalente a `i = i + 1;` -**Note** -The entire line becomes `i++;`, eliminating the need for the equal sign. +**Nota:** Toda la línea se convierte en `i++;`, eliminando la necesidad del signo de igualdad. # --instructions-- -Change the code to use the `++` operator on `myVar`. +Cambia el código para usar el operador `++` en `myVar`. # --hints-- -`myVar` should equal `88`. +`myVar` debe ser igual a `88`. ```js assert(myVar === 88); ``` -You should not use the assignment operator. +No debes utilizar el operador de asignación. ```js assert( @@ -40,13 +39,13 @@ assert( ); ``` -You should use the `++` operator. +Debes usar el operador `++`. ```js assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code)); ``` -You should not change code above the specified comment. +No debes cambiar el código por encima del comentario especificado. ```js assert(/var myVar = 87;/.test(code)); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md index 7e933ed620..0fd7c2afde 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244a9 -title: Initializing Variables with the Assignment Operator +title: Inicializa variables con el operador de asignación challengeType: 1 videoUrl: 'https://scrimba.com/c/cWJ4Bfb' forumTopicId: 301171 @@ -9,19 +9,19 @@ dashedName: initializing-variables-with-the-assignment-operator # --description-- -It is common to initialize a variable to an initial value in the same line as it is declared. +Es común inicializar una variable a un valor inicial en la misma línea que es declarada. `var myVar = 0;` -Creates a new variable called `myVar` and assigns it an initial value of `0`. +Crea una nueva variable llamada `myVar` y le asigna un valor inicial de `0`. # --instructions-- -Define a variable `a` with `var` and initialize it to a value of `9`. +Define una variable `a` con `var` e inicialízala con un valor de `9`. # --hints-- -You should initialize `a` to a value of `9`. +Debes inicializar `a` con un valor de `9`. ```js assert(/var\s+a\s*=\s*9(\s*;?\s*)$/.test(code)); @@ -36,7 +36,9 @@ if(typeof a !== 'undefined') {(function(a){return "a = " + a;})(a);} else { (fun ``` ## --seed-contents-- + ```js + ``` # --solutions-- diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md index 9ce7a4d8c6..e5b6cee691 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244db -title: Introducing Else If Statements +title: Introducción a las sentencias "Else If" challengeType: 1 videoUrl: 'https://scrimba.com/c/caeJ2hm' forumTopicId: 18206 @@ -9,7 +9,7 @@ dashedName: introducing-else-if-statements # --description-- -If you have multiple conditions that need to be addressed, you can chain `if` statements together with `else if` statements. +Si tienes múltiples condiciones que necesitan ser resueltas, puedes encadenar sentencias `if` junto con sentencias `else if`. ```js if (num > 15) { @@ -23,23 +23,23 @@ if (num > 15) { # --instructions-- -Convert the logic to use `else if` statements. +Transforma la lógica para utilizar la sentencia `else if`. # --hints-- -You should have at least two `else` statements +Debes tener al menos dos sentencias `else` ```js assert(code.match(/else/g).length > 1); ``` -You should have at least two `if` statements +Debes tener al menos dos sentencias `if` ```js assert(code.match(/if/g).length > 1); ``` -You should have closing and opening curly braces for each `if else` code block. +Debes utilizar llaves de apertura y cierre para cada bloque de código `if else`. ```js assert( @@ -49,31 +49,31 @@ assert( ); ``` -`testElseIf(0)` should return "Smaller than 5" +`testElseIf(0)` debe devolver la cadena `Smaller than 5` ```js assert(testElseIf(0) === 'Smaller than 5'); ``` -`testElseIf(5)` should return "Between 5 and 10" +`testElseIf(5)` debe devolver la cadena `Between 5 and 10` ```js assert(testElseIf(5) === 'Between 5 and 10'); ``` -`testElseIf(7)` should return "Between 5 and 10" +`testElseIf(7)` debe devolver la cadena `Between 5 and 10` ```js assert(testElseIf(7) === 'Between 5 and 10'); ``` -`testElseIf(10)` should return "Between 5 and 10" +`testElseIf(10)` debe devolver la cadena `Between 5 and 10` ```js assert(testElseIf(10) === 'Between 5 and 10'); ``` -`testElseIf(12)` should return "Greater than 10" +`testElseIf(12)` debe devolver la cadena `Greater than 10` ```js assert(testElseIf(12) === 'Greater than 10'); diff --git a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md index 24e5b17225..44dc5c4988 100644 --- a/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md +++ b/curriculum/challenges/espanol/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md @@ -1,6 +1,6 @@ --- id: 56533eb9ac21ba0edf2244da -title: Introducing Else Statements +title: Introducción a las sentencias "Else" challengeType: 1 videoUrl: 'https://scrimba.com/c/cek4Efq' forumTopicId: 18207 @@ -9,7 +9,7 @@ dashedName: introducing-else-statements # --description-- -When a condition for an `if` statement is true, the block of code following it is executed. What about when that condition is false? Normally nothing would happen. With an `else` statement, an alternate block of code can be executed. +Cuando la condición en una sentencia `if` es verdadera, se ejecutará el bloque de código que va a continuación. ¿Qué sucede cuando la condición es falsa? Normalmente no debería ocurrir nada. Con la sentencia `else`, se puede ejecutar un bloque alternativo de código. ```js if (num > 10) { @@ -21,47 +21,47 @@ if (num > 10) { # --instructions-- -Combine the `if` statements into a single `if/else` statement. +Combina la sentencia `if` en una sola sentencia `if/else`. # --hints-- -You should only have one `if` statement in the editor +Sólo debes tener una sentencia `if` en el editor ```js assert(code.match(/if/g).length === 1); ``` -You should use an `else` statement +Debes usar una sentencia `else` ```js assert(/else/g.test(code)); ``` -`testElse(4)` should return "5 or Smaller" +`testElse(4)` debe devolver la cadena `5 or Smaller` ```js assert(testElse(4) === '5 or Smaller'); ``` -`testElse(5)` should return "5 or Smaller" +`testElse(5)` debe devolver la cadena `5 or Smaller` ```js assert(testElse(5) === '5 or Smaller'); ``` -`testElse(6)` should return "Bigger than 5" +`testElse(6)` debe devolver la cadena `Bigger than 5` ```js assert(testElse(6) === 'Bigger than 5'); ``` -`testElse(10)` should return "Bigger than 5". +`testElse(10)` debe devolver la cadena `Bigger than 5` ```js assert(testElse(10) === 'Bigger than 5'); ``` -You should not change the code above or below the specified comments. +No debes cambiar el código por encima o por debajo de los comentarios especificados. ```js assert(/var result = "";/.test(code) && /return result;/.test(code));