From c2a45b58beec01b25bab38be13ab40db8df07a8a Mon Sep 17 00:00:00 2001
From: Bouncey <staylor1012@gmail.com>
Date: Tue, 9 Oct 2018 20:28:15 +0100
Subject: [PATCH] fix(spanish-md): Address some formatting issues for Spanish
 md

---
 ...visually-impaired-accessibility.spanish.md |  16 +-
 ...th-the-html5-datetime-attribute.spanish.md |  14 +-
 ...ckground-color-property-of-text.spanish.md |  18 +-
 ...lements-to-complementary-colors.spanish.md |  16 +-
 ...he-hover-state-of-an-anchor-tag.spanish.md |  14 +-
 .../create-a-graphic-using-css.spanish.md     |  16 +-
 ...omplex-shape-using-css-and-html.spanish.md |  24 +-
 ...arent-with-absolute-positioning.spanish.md |  16 +-
 ...r-window-with-fixed-positioning.spanish.md |  16 +-
 ...re-natural-using-a-bezier-curve.spanish.md |  18 +-
 ...odify-fill-mode-of-an-animation.spanish.md |  14 +-
 ...tioned-element-with-css-offsets.spanish.md |  10 +-
 ...-bezier-curve-to-move-a-graphic.spanish.md |  16 +-
 ...o-change-the-size-of-an-element.spanish.md |  12 +-
 ...the-s-tag-to-strikethrough-text.spanish.md |  10 +-
 ...nded-corners-with-border-radius.spanish.md |  12 +-
 .../cascading-css-variables.spanish.md        |  14 +-
 ...nge-the-font-size-of-an-element.spanish.md |  12 +-
 ...other-styles-by-using-important.spanish.md |  20 +-
 ...ioritize-one-style-over-another.spanish.md |  16 +-
 ...pecify-how-fonts-should-degrade.spanish.md |  24 +-
 ...a-css-class-to-style-an-element.spanish.md |  24 +-
 ...edia-query-to-change-a-variable.spanish.md |  14 +-
 .../use-abbreviated-hex-code.spanish.md       |  22 +-
 .../add-a-submit-button-to-a-form.spanish.md  |  14 +-
 .../comment-out-html.spanish.md               |  12 +-
 ...rnal-pages-with-anchor-elements.spanish.md |  18 +-
 ...-of-a-page-with-anchor-elements.spanish.md |  24 +-
 ...ead-links-using-the-hash-symbol.spanish.md |  14 +-
 ...chor-element-within-a-paragraph.spanish.md |  26 +-
 .../turn-an-image-into-a-link.spanish.md      |  18 +-
 .../uncomment-html.spanish.md                 |  14 +-
 ...-using-the-align-items-property.spanish.md |  20 +-
 ...ng-the-justify-content-property.spanish.md |  20 +-
 ...play-flex-to-position-two-boxes.spanish.md |  12 +-
 .../use-the-align-self-property.spanish.md    |  14 +-
 ...set-the-initial-size-of-an-item.spanish.md |  18 +-
 ...ction-property-to-make-a-column.spanish.md |  10 +-
 ...irection-property-to-make-a-row.spanish.md |  14 +-
 ...x-grow-property-to-expand-items.spanish.md |  14 +-
 ...use-the-flex-shorthand-property.spanish.md |  20 +-
 ...shrink-property-to-shrink-items.spanish.md |  16 +-
 ...roperty-to-wrap-a-row-or-column.spanish.md |  16 +-
 ...ent-property-in-the-tweet-embed.spanish.md |  10 +-
 ...der-property-to-rearrange-items.spanish.md |  12 +-
 ...ge-the-size-of-columns-and-rows.spanish.md |  22 +-
 .../boo-who.spanish.md                        |  16 +-
 .../chunky-monkey.spanish.md                  |  22 +-
 .../confirm-the-ending.spanish.md             |  30 +-
 .../falsy-bouncer.spanish.md                  |  20 +-
 .../finders-keepers.spanish.md                |  12 +-
 .../mutations.spanish.md                      |  32 +-
 ...repeat-a-string-repeat-a-string.spanish.md |  20 +-
 ...eturn-largest-numbers-in-arrays.spanish.md |  18 +-
 .../slice-and-splice.spanish.md               |  20 +-
 .../title-case-a-sentence.spanish.md          |  14 +-
 .../truncate-a-string.spanish.md              |  20 +-
 .../where-do-i-belong.spanish.md              |  44 +--
 ...contents-using-bracket-notation.spanish.md |  34 +-
 ...rty-names-with-bracket-notation.spanish.md |  14 +-
 ...-an-array-with-push-and-unshift.spanish.md |  16 +-
 .../add-items-using-splice.spanish.md         |  14 +-
 ...ence-of-an-element-with-indexof.spanish.md |  20 +-
 ...eck-if-an-object-has-a-property.spanish.md |  16 +-
 ...arrays-with-the-spread-operator.spanish.md |  14 +-
 ...-array-with-the-spread-operator.spanish.md |  20 +-
 .../copy-array-items-using-slice.spanish.md   |  14 +-
 ...omplex-multi-dimensional-arrays.spanish.md |  24 +-
 ...ll-object-keys-with-object.keys.spanish.md |  10 +-
 ...an-arrays-items-using-for-loops.spanish.md |  22 +-
 ...fy-an-array-stored-in-an-object.spanish.md |  12 +-
 ...-object-nested-within-an-object.spanish.md |  14 +-
 ...rom-an-array-with-pop-and-shift.spanish.md |  18 +-
 ...ord-to-remove-object-properties.spanish.md |  18 +-
 ...count-backwards-with-a-for-loop.spanish.md |  20 +-
 .../counting-cards.spanish.md                 |  30 +-
 .../declare-javascript-variables.spanish.md   |  26 +-
 .../escape-sequences-in-strings.spanish.md    |  22 +-
 ...aping-literal-quotes-in-strings.spanish.md |  22 +-
 .../find-the-length-of-a-string.spanish.md    |  14 +-
 ...om-whole-numbers-within-a-range.spanish.md |  20 +-
 .../basic-javascript/golf-code.spanish.md     |  34 +-
 ...ate-odd-numbers-with-a-for-loop.spanish.md |  18 +-
 ...ith-javascript-do...while-loops.spanish.md |  32 +-
 ...erate-with-javascript-for-loops.spanish.md |  28 +-
 ...ate-with-javascript-while-loops.spanish.md |  16 +-
 .../manipulate-arrays-with-pop.spanish.md     |  18 +-
 .../manipulate-arrays-with-push.spanish.md    |  14 +-
 .../manipulate-arrays-with-shift.spanish.md   |  14 +-
 .../manipulate-arrays-with-unshift.spanish.md |  12 +-
 .../manipulating-complex-objects.spanish.md   |  34 +-
 .../modify-array-data-with-indexes.spanish.md |  16 +-
 .../nesting-for-loops.spanish.md              |  18 +-
 ...ues-to-functions-with-arguments.spanish.md |  22 +-
 ...tice-comparing-different-values.spanish.md |  22 +-
 .../profile-lookup.spanish.md                 |  28 +-
 ...ting-strings-with-single-quotes.spanish.md |  26 +-
 .../record-collection.spanish.md              |  40 +--
 ...cing-if-else-chains-with-switch.spanish.md |  16 +-
 ...urn-early-pattern-for-functions.spanish.md |  28 +-
 ...g-boolean-values-from-functions.spanish.md |  20 +-
 .../basic-javascript/stand-in-line.spanish.md |  22 +-
 .../understanding-boolean-values.spanish.md   |  12 +-
 ...-value-returned-from-a-function.spanish.md |  16 +-
 ...tional-logic-with-if-statements.spanish.md |  24 +-
 ...he-conditional-ternary-operator.spanish.md |  26 +-
 .../using-objects-for-lookups.spanish.md      |  14 +-
 .../basic-javascript/word-blanks.spanish.md   |  24 +-
 ...g-order-when-calling-a-function.spanish.md |  10 +-
 ...led-variable-and-function-names.spanish.md |  12 +-
 ...age-of-single-and-double-quotes.spanish.md |  20 +-
 ...eses-brackets-braces-and-quotes.spanish.md |  12 +-
 ...or-instead-of-equality-operator.spanish.md |  18 +-
 ...te-an-array-declared-with-const.spanish.md |  18 +-
 ...t-parameters-for-your-functions.spanish.md |  16 +-
 ...to-assign-variables-from-arrays.spanish.md |  24 +-
 ...ator-to-reassign-array-elements.spanish.md |  18 +-
 ...erator-with-function-parameters.spanish.md |  18 +-
 ...eclarations-using-simple-fields.spanish.md |  24 +-
 ...te-higher-order-arrow-functions.spanish.md |  24 +-
 ...ay-using-concat-instead-of-push.spanish.md |  16 +-
 ...-a-string-using-the-join-method.spanish.md |  14 +-
 ...-arrays-using-the-concat-method.spanish.md |  12 +-
 .../implement-map-on-a-prototype.spanish.md   |  16 +-
 ...he-filter-method-on-a-prototype.spanish.md |  12 +-
 ...obal-variables-out-of-functions.spanish.md |  22 +-
 ...y-using-slice-instead-of-splice.spanish.md |  16 +-
 ...out-changing-the-original-array.spanish.md |  10 +-
 ...an-array-using-the-slice-method.spanish.md |  18 +-
 ...betically-using-the-sort-method.spanish.md |  20 +-
 ...an-array-using-the-split-method.spanish.md |  20 +-
 ...nt-in-an-array-meets-a-criteria.spanish.md |  18 +-
 ...d-to-extract-data-from-an-array.spanish.md |  12 +-
 ...d-to-extract-data-from-an-array.spanish.md |  18 +-
 ...nts-in-an-array-meet-a-criteria.spanish.md |  18 +-
 .../arguments-optional.spanish.md             |  26 +-
 .../binary-agents.spanish.md                  |  12 +-
 .../convert-html-entities.spanish.md          |  20 +-
 .../diff-two-arrays.spanish.md                |  40 +--
 .../dna-pairing.spanish.md                    |  22 +-
 .../drop-it.spanish.md                        |  22 +-
 .../everything-be-true.spanish.md             |  55 +--
 .../map-the-debris.spanish.md                 |  20 +-
 .../search-and-replace.spanish.md             |  26 +-
 .../seek-and-destroy.spanish.md               |  22 +-
 .../smallest-common-multiple.spanish.md       |  24 +-
 .../sorted-union.spanish.md                   |  22 +-
 .../steamroller.spanish.md                    |  16 +-
 .../sum-all-numbers-in-a-range.spanish.md     |  20 +-
 .../wherefore-art-thou.spanish.md             |  22 +-
 .../cash-register.spanish.md                  |  32 +-
 .../palindrome-checker.spanish.md             |  22 +-
 .../telephone-number-validator.spanish.md     |  16 +-
 .../override-inherited-methods.spanish.md     |  32 +-
 .../check-for-all-or-none.spanish.md          |  16 +-
 .../match-all-non-numbers.spanish.md          |  12 +-
 ...s-that-occur-zero-or-more-times.spanish.md |  16 +-
 ...rything-but-letters-and-numbers.spanish.md |  14 +-
 ...e-whitespace-from-start-and-end.spanish.md |  12 +-
 ...ome-icons-to-all-of-our-buttons.spanish.md |  16 +-
 .../create-a-bootstrap-button.spanish.md      |  10 +-
 .../label-bootstrap-buttons.spanish.md        |  20 +-
 .../label-bootstrap-wells.spanish.md          |  16 +-
 ...le-text-inputs-as-form-controls.spanish.md |  12 +-
 .../use-comments-to-clarify-code.spanish.md   |  16 +-
 .../delete-your-jquery-functions.spanish.md   |  12 +-
 ...pt-tags-and-document-ready-work.spanish.md |  22 +-
 ...hild-of-an-element-using-jquery.spanish.md |  18 +-
 ...-elements-by-class-using-jquery.spanish.md |  20 +-
 ...get-elements-by-id-using-jquery.spanish.md |  20 +-
 ...rget-even-elements-using-jquery.spanish.md |  16 +-
 ...nts-with-selectors-using-jquery.spanish.md |  18 +-
 ...dren-of-an-element-using-jquery.spanish.md |  18 +-
 ...rent-of-an-element-using-jquery.spanish.md |  20 +-
 ...-with-multiple-jquery-selectors.spanish.md |  26 +-
 ...nnect-redux-to-the-messages-app.spanish.md |  14 +-
 .../extract-local-state-into-redux.spanish.md |  16 +-
 ...etting-started-with-react-redux.spanish.md |  16 +-
 .../manage-state-locally-first.spanish.md     |  14 +-
 ...vider-to-connect-redux-to-react.spanish.md |  18 +-
 .../bind-this-to-a-class-method.spanish.md    |  18 +-
 .../create-a-controlled-input.spanish.md      |  18 +-
 .../react/override-default-props.spanish.md   |  12 +-
 ...render-conditionally-from-props.spanish.md |  22 +-
 ...-the-user-interface-another-way.spanish.md |  12 +-
 ...ender-with-an-if-else-condition.spanish.md |  14 +-
 .../set-state-with-this.setstate.spanish.md   |  16 +-
 ...-for-a-more-concise-conditional.spanish.md |  16 +-
 ...ssion-for-conditional-rendering.spanish.md |  20 +-
 ...-to-dynamically-filter-an-array.spanish.md |  12 +-
 .../react/use-default-props.spanish.md        |  10 +-
 .../react/write-a-simple-counter.spanish.md   |  12 +-
 .../combine-multiple-reducers.spanish.md      |  18 +-
 .../handle-an-action-in-the-store.spanish.md  |  12 +-
 .../remove-an-item-from-an-array.spanish.md   |  10 +-
 ...e-the-spread-operator-on-arrays.spanish.md |  14 +-
 ...create-reusable-css-with-mixins.spanish.md |  26 +-
 ...to-smaller-chunks-with-partials.spanish.md |  18 +-
 ...lse-to-add-logic-to-your-styles.spanish.md |  22 +-
 ...tributes-to-the-circle-elements.spanish.md |  34 +-
 .../add-axes-to-a-visualization.spanish.md    |  28 +-
 ...-labels-to-scatter-plot-circles.spanish.md |  32 +-
 ...ect-a-group-of-elements-with-d3.spanish.md |  14 +-
 ...a-domain-and-a-range-on-a-scale.spanish.md |  24 +-
 .../use-dynamic-scales.spanish.md             |  24 +-
 ...to-find-a-users-gps-coordinates.spanish.md |  28 +-
 .../anonymous-message-board.spanish.md        |  12 +-
 .../issue-tracker.spanish.md                  |  16 +-
 .../personal-library.spanish.md               |  16 +-
 .../stock-price-checker.spanish.md            |  12 +-
 .../find-the-symmetric-difference.spanish.md  |  38 +--
 .../algorithms/inventory-update.spanish.md    |  18 +-
 .../algorithms/pairwise.spanish.md            |  28 +-
 .../breadth-first-search.spanish.md           |  34 +-
 .../create-a-map-data-structure.spanish.md    |  30 +-
 .../create-and-add-to-sets-in-es6.spanish.md  |  30 +-
 ...af-node-in-a-binary-search-tree.spanish.md |  20 +-
 ...e-child-in-a-binary-search-tree.spanish.md |  10 +-
 ...hildren-in-a-binary-search-tree.spanish.md |  12 +-
 .../depth-first-search.spanish.md             |  36 +-
 ...ubset-check-on-two-sets-of-data.spanish.md |  16 +-
 ...se-.has-and-.size-on-an-es6-set.spanish.md |  22 +-
 ...pressed-as-a-sum-of-powers-of-2.spanish.md |  22 +-
 .../problem-19-counting-sundays.spanish.md    |  16 +-
 .../problem-220-heighway-dragon.spanish.md    |  22 +-
 .../problem-34-digit-factorials.spanish.md    |  12 +-
 ...99-squarefree-fibonacci-numbers.spanish.md |  34 +-
 ...oblem-419-look-and-say-sequence.spanish.md |  34 +-
 ...blem-43-sub-string-divisibility.spanish.md |  26 +-
 ...blem-47-distinct-primes-factors.spanish.md |  26 +-
 .../problem-48-self-powers.spanish.md         |  16 +-
 ...-perfect-number-classifications.spanish.md |  24 +-
 .../accumulator-factory.spanish.md            |  16 +-
 .../ackermann-function.spanish.md             |  30 +-
 .../rosetta-code/align-columns.spanish.md     |  52 +--
 .../rosetta-code/amicable-pairs.spanish.md    |  32 +-
 .../rosetta-code/averages-mode.spanish.md     |  10 +-
 .../averages-pythagorean-means.spanish.md     |  32 +-
 .../averages-root-mean-square.spanish.md      |  12 +-
 .../rosetta-code/babbage-problem.spanish.md   |  18 +-
 .../rosetta-code/balanced-brackets.spanish.md |  56 ++--
 ...given-radius-through-two-points.spanish.md |  58 ++--
 .../rosetta-code/combinations.spanish.md      |  40 +--
 .../rosetta-code/comma-quibbling.spanish.md   |  38 +--
 .../compare-a-list-of-strings.spanish.md      |  28 +-
 ...rt-seconds-to-compound-duration.spanish.md | 134 ++++----
 ...ount-occurrences-of-a-substring.spanish.md |  22 +-
 .../rosetta-code/cramers-rule.spanish.md      |  40 +--
 .../rosetta-code/date-manipulation.spanish.md |  28 +-
 .../rosetta-code/day-of-the-week.spanish.md   |  16 +-
 .../deal-cards-for-freecell.spanish.md        | 104 +++---
 .../rosetta-code/deepcopy.spanish.md          |  26 +-
 .../define-a-primitive-data-type.spanish.md   |  28 +-
 .../department-numbers.spanish.md             |  52 +--
 .../rosetta-code/discordian-date.spanish.md   |  22 +-
 .../element-wise-operations.spanish.md        |  32 +-
 .../rosetta-code/emirp-primes.spanish.md      |  14 +-
 .../rosetta-code/equilibrium-index.spanish.md |  34 +-
 .../ethiopian-multiplication.spanish.md       |  98 +++---
 .../rosetta-code/euler-method.spanish.md      |  46 +--
 .../evaluate-binomial-coefficients.spanish.md |  18 +-
 .../execute-a-markov-algorithm.spanish.md     | 224 ++++++-------
 .../rosetta-code/execute-brain.spanish.md     |  56 ++--
 .../rosetta-code/factorial.spanish.md         |  28 +-
 .../factors-of-an-integer.spanish.md          |  14 +-
 .../rosetta-code/farey-sequence.spanish.md    |  36 +-
 ...bonacci-n-step-number-sequences.spanish.md |  76 ++---
 .../rosetta-code/fractran.spanish.md          |  30 +-
 .../rosetta-code/gamma-function.spanish.md    |  22 +-
 ...erate-lower-case-ascii-alphabet.spanish.md |  16 +-
 .../hailstone-sequence.spanish.md             |  26 +-
 .../rosetta-code/happy-numbers.spanish.md     |  12 +-
 .../harshad-or-niven-series.spanish.md        |  14 +-
 .../hash-from-two-arrays.spanish.md           |  24 +-
 .../rosetta-code/hash-join.spanish.md         | 312 +++++++++---------
 .../heronian-triangles.spanish.md             |  26 +-
 .../rosetta-code/s-expressions.spanish.md     |  84 ++---
 .../rosetta-code/taxicab-numbers.spanish.md   |  46 +--
 ...tokenize-a-string-with-escaping.spanish.md |  58 ++--
 .../top-rank-per-group.spanish.md             |  76 ++---
 .../rosetta-code/towers-of-hanoi.spanish.md   |  34 +-
 281 files changed, 3413 insertions(+), 3402 deletions(-)

diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/add-a-text-alternative-to-images-for-visually-impaired-accessibility.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/add-a-text-alternative-to-images-for-visually-impaired-accessibility.spanish.md
index 6f224dc930..f18f579dc4 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/add-a-text-alternative-to-images-for-visually-impaired-accessibility.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/add-a-text-alternative-to-images-for-visually-impaired-accessibility.spanish.md
@@ -8,16 +8,16 @@ guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/add-alt-text-to-a
 ---
 
 ## Description
-<section id='description'> 
-Es probable que haya visto un atributo <code>alt</code> en una etiqueta <code>img</code> en otros desafíos. <code>Alt</code> texto alternativo describe el contenido de la imagen y proporciona una alternativa de texto. Esto ayuda en caso de que la imagen no se cargue o no pueda ser vista por un usuario. También es utilizado por los motores de búsqueda para comprender qué contiene una imagen para incluirla en los resultados de búsqueda. Aquí hay un ejemplo: 
-<code>&lt;img src=&quot;importantLogo.jpeg&quot; alt=&quot;Company logo&quot;&gt;</code> 
-personas con discapacidades visuales confían en los lectores de pantalla para convertir el contenido web a una interfaz de audio. No obtendrán información si solo se presenta visualmente. Para las imágenes, los lectores de pantalla pueden acceder al atributo <code>alt</code> y leer su contenido para entregar información clave. 
-buen texto <code>alt</code> es breve pero descriptivo, y está pensado para transmitir brevemente el significado de la imagen. Siempre debes incluir un atributo <code>alt</code> en tu imagen. Por especificación de HTML5, esto ahora se considera obligatorio. 
+<section id='description'>
+Es probable que haya visto un atributo <code>alt</code> en una etiqueta <code>img</code> en otros desafíos. <code>Alt</code> texto alternativo describe el contenido de la imagen y proporciona una alternativa de texto. Esto ayuda en caso de que la imagen no se cargue o no pueda ser vista por un usuario. También es utilizado por los motores de búsqueda para comprender qué contiene una imagen para incluirla en los resultados de búsqueda. Aquí hay un ejemplo:
+<code>&lt;img src=&quot;importantLogo.jpeg&quot; alt=&quot;Company logo&quot;&gt;</code>
+personas con discapacidades visuales confían en los lectores de pantalla para convertir el contenido web a una interfaz de audio. No obtendrán información si solo se presenta visualmente. Para las imágenes, los lectores de pantalla pueden acceder al atributo <code>alt</code> y leer su contenido para entregar información clave.
+buen texto <code>alt</code> es breve pero descriptivo, y está pensado para transmitir brevemente el significado de la imagen. Siempre debes incluir un atributo <code>alt</code> en tu imagen. Por especificación de HTML5, esto ahora se considera obligatorio.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Camper Cat es tanto un ninja codificador como un ninja real, y está construyendo un sitio web para compartir sus conocimientos. La imagen de perfil que desea usar muestra sus habilidades y debe ser apreciada por todos los visitantes del sitio. Agregue un atributo <code>alt</code> en la etiqueta <code>img</code> , que explica que Camper Cat está haciendo karate. (La imagen <code>src</code> no se vincula a un archivo real, por lo que debería ver el texto <code>alt</code> en la pantalla). 
+<section id='instructions'>
+Camper Cat es tanto un ninja codificador como un ninja real, y está construyendo un sitio web para compartir sus conocimientos. La imagen de perfil que desea usar muestra sus habilidades y debe ser apreciada por todos los visitantes del sitio. Agregue un atributo <code>alt</code> en la etiqueta <code>img</code> , que explica que Camper Cat está haciendo karate. (La imagen <code>src</code> no se vincula a un archivo real, por lo que debería ver el texto <code>alt</code> en la pantalla).
 </section>
 
 ## Tests
@@ -25,7 +25,7 @@ Camper Cat es tanto un ninja codificador como un ninja real, y está construyend
 
 ```yml
 tests:
-  - text: &#39;Su etiqueta <code>img</code> debe tener un atributo <code>alt</code> , y no debe estar vacío&#39;.
+  - text: 'Su etiqueta <code>img</code> debe tener un atributo <code>alt</code> , y no debe estar vacío'
     testString: 'assert($("img").attr("alt"), "Your <code>img</code> tag should have an <code>alt</code> attribute, and it should not be empty.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/standardize-times-with-the-html5-datetime-attribute.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/standardize-times-with-the-html5-datetime-attribute.spanish.md
index caf23d2a35..41a3913970 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/standardize-times-with-the-html5-datetime-attribute.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-accessibility/standardize-times-with-the-html5-datetime-attribute.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Continuando con el tema de la fecha, HTML5 también introdujo el elemento de <code>time</code> junto con un atributo de <code>datetime</code> y <code>datetime</code> para estandarizar los tiempos. Este es un elemento en línea que puede ajustar una fecha u hora en una página. Un formato válido de esa fecha se mantiene en el atributo <code>datetime</code> . Este es el valor al que acceden los dispositivos de asistencia. Ayuda a evitar confusiones al indicar una versión estandarizada de un tiempo, incluso si está escrito de manera informal o coloquial en el texto. 
-Aquí hay un ejemplo: 
-<code>&lt;p&gt;Master Camper Cat officiated the cage match between Goro and Scorpion &lt;time datetime=&quot;2013-02-13&quot;&gt;last Wednesday&lt;/time&gt;, which ended in a draw.&lt;/p&gt;</code> 
+<section id='description'>
+Continuando con el tema de la fecha, HTML5 también introdujo el elemento de <code>time</code> junto con un atributo de <code>datetime</code> y <code>datetime</code> para estandarizar los tiempos. Este es un elemento en línea que puede ajustar una fecha u hora en una página. Un formato válido de esa fecha se mantiene en el atributo <code>datetime</code> . Este es el valor al que acceden los dispositivos de asistencia. Ayuda a evitar confusiones al indicar una versión estandarizada de un tiempo, incluso si está escrito de manera informal o coloquial en el texto.
+Aquí hay un ejemplo:
+<code>&lt;p&gt;Master Camper Cat officiated the cage match between Goro and Scorpion &lt;time datetime=&quot;2013-02-13&quot;&gt;last Wednesday&lt;/time&gt;, which ended in a draw.&lt;/p&gt;</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-encuentran los resultados de la encuesta de Mortal Kombat de Camper Cat! Envuelva una etiqueta de <code>time</code> alrededor del texto &quot;Jueves, 15 de septiembre &lt;sup&gt; th &lt;/sup&gt;&quot; y agregue un atributo de <code>datetime</code> y <code>datetime</code> establecido en &quot;2016-09-15&quot;. 
+<section id='instructions'>
+encuentran los resultados de la encuesta de Mortal Kombat de Camper Cat! Envuelva una etiqueta de <code>time</code> alrededor del texto &quot;Jueves, 15 de septiembre &lt;sup&gt; th &lt;/sup&gt;&quot; y agregue un atributo de <code>datetime</code> y <code>datetime</code> establecido en &quot;2016-09-15&quot;.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ encuentran los resultados de la encuesta de Mortal Kombat de Camper Cat! Envuelv
 
 ```yml
 tests:
-  - text: &#39;Sus etiquetas de <code>time</code> deben rodear el texto &quot;Jueves 15 de septiembre &lt;sup&gt; th &lt;/sup&gt;&quot;.&#39;
+  - text: 'Sus etiquetas de <code>time</code> deben rodear el texto &quot;Jueves 15 de septiembre &lt;sup&gt; th &lt;/sup&gt;&quot;.'
     testString: 'assert($("time").text().match(/Thursday, September 15th/g), "Your <code>time</code> tags should wrap around the text "Thursday, September 15&lt;sup&gt;th&lt;/sup&gt;".");'
   - text: Su etiqueta de <code>time</code> debe tener un atributo de <code>datetime</code> y <code>datetime</code> que no esté vacío.
     testString: 'assert($("time").attr("datetime"), "Your <code>time</code> tag should have a <code>datetime</code> attribute that is not empty.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-background-color-property-of-text.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-background-color-property-of-text.spanish.md
index 51bbd79caf..fea027dfd6 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-background-color-property-of-text.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-background-color-property-of-text.spanish.md
@@ -7,17 +7,17 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-En lugar de ajustar el fondo general o el color del texto para que el primer plano sea fácil de leer, puede agregar un <code>background-color</code> al elemento que contiene el texto que desea enfatizar. Este desafío utiliza <code>rgba()</code> lugar de códigos <code>hex</code> o <code>rgb()</code> normal. 
-<blockquote>rgba stands for:<br>&nbsp;&nbsp;r = red<br>&nbsp;&nbsp;g = green<br>&nbsp;&nbsp;b = blue<br>&nbsp;&nbsp;a = alpha/level of opacity</blockquote> 
-Los valores RGB pueden variar de 0 a 255. El valor alfa puede variar de 1, que es totalmente opaco o de color sólido, a 0, que es completamente transparente o claro. <code>rgba()</code> es excelente para usar en este caso, ya que le permite ajustar la opacidad. Esto significa que no tienes que bloquear completamente el fondo. 
-<code>background-color: rgba(45, 45, 45, 0.1)</code> para este desafío. Produce un color gris oscuro que es casi transparente dado el bajo valor de opacidad de 0.1. 
+<section id='description'>
+En lugar de ajustar el fondo general o el color del texto para que el primer plano sea fácil de leer, puede agregar un <code>background-color</code> al elemento que contiene el texto que desea enfatizar. Este desafío utiliza <code>rgba()</code> lugar de códigos <code>hex</code> o <code>rgb()</code> normal.
+<blockquote>rgba stands for:<br>&nbsp;&nbsp;r = red<br>&nbsp;&nbsp;g = green<br>&nbsp;&nbsp;b = blue<br>&nbsp;&nbsp;a = alpha/level of opacity</blockquote>
+Los valores RGB pueden variar de 0 a 255. El valor alfa puede variar de 1, que es totalmente opaco o de color sólido, a 0, que es completamente transparente o claro. <code>rgba()</code> es excelente para usar en este caso, ya que le permite ajustar la opacidad. Esto significa que no tienes que bloquear completamente el fondo.
+<code>background-color: rgba(45, 45, 45, 0.1)</code> para este desafío. Produce un color gris oscuro que es casi transparente dado el bajo valor de opacidad de 0.1.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Para hacer que el texto destaque más, ajuste el <code>background-color</code> de <code>background-color</code> del elemento <code>h4</code> al valor <code>rgba()</code> dado. 
-También para el <code>h4</code> , elimine la propiedad de <code>height</code> y agregue <code>padding</code> de 10px. 
+<section id='instructions'>
+Para hacer que el texto destaque más, ajuste el <code>background-color</code> de <code>background-color</code> del elemento <code>h4</code> al valor <code>rgba()</code> dado.
+También para el <code>h4</code> , elimine la propiedad de <code>height</code> y agregue <code>padding</code> de 10px.
 </section>
 
 ## Tests
@@ -25,7 +25,7 @@ También para el <code>h4</code> , elimine la propiedad de <code>height</code> y
 
 ```yml
 tests:
-  - text: &#39;Su código debe agregar una propiedad de <code>background-color</code> al conjunto de elementos <code>h4</code> en <code>rgba(45, 45, 45, 0.1)</code> .&#39;
+  - text: 'Su código debe agregar una propiedad de <code>background-color</code> al conjunto de elementos <code>h4</code> en <code>rgba(45, 45, 45, 0.1)</code> .'
     testString: 'assert(code.match(/background-color:\s*?rgba\(\s*?45\s*?,\s*?45\s*?,\s*?45\s*?,\s*?0?\.1\s*?\)/gi), "Your code should add a <code>background-color</code> property to the <code>h4</code> element set to <code>rgba(45, 45, 45, 0.1)</code>.");'
   - text: Su código debe agregar una propiedad de <code>padding</code> al elemento <code>h4</code> y establecerlo en 10 píxeles.
     testString: 'assert($("h4").css("padding-top") == "10px" && $("h4").css("padding-right") == "10px" && $("h4").css("padding-bottom") == "10px" && $("h4").css("padding-left") == "10px", "Your code should add a <code>padding</code> property to the <code>h4</code> element and set it to 10 pixels.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-color-of-various-elements-to-complementary-colors.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-color-of-various-elements-to-complementary-colors.spanish.md
index 1cb5506e4c..1e43dcaf48 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-color-of-various-elements-to-complementary-colors.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-color-of-various-elements-to-complementary-colors.spanish.md
@@ -7,13 +7,13 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-El desafío de los colores complementarios mostró que los colores opuestos en la rueda de colores pueden hacer que cada uno se vea más vibrante cuando se colocan lado a lado. Sin embargo, el fuerte contraste visual puede ser discordante si se usa en exceso en un sitio web, y algunas veces puede hacer que el texto sea más difícil de leer si se coloca sobre un fondo de color complementario. En la práctica, uno de los colores suele ser dominante y el complemento se utiliza para atraer la atención visual a cierto contenido de la página. 
+<section id='description'>
+El desafío de los colores complementarios mostró que los colores opuestos en la rueda de colores pueden hacer que cada uno se vea más vibrante cuando se colocan lado a lado. Sin embargo, el fuerte contraste visual puede ser discordante si se usa en exceso en un sitio web, y algunas veces puede hacer que el texto sea más difícil de leer si se coloca sobre un fondo de color complementario. En la práctica, uno de los colores suele ser dominante y el complemento se utiliza para atraer la atención visual a cierto contenido de la página.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Esta página utilizará un tono de verde azulado ( <code>#09A7A1</code> ) como color dominante, y su complemento naranja ( <code>#FF790E</code> ) para resaltar visualmente los botones de <code>#FF790E</code> . Cambie el <code>background-color</code> de <code>background-color</code> del <code>header</code> y del <code>footer</code> de <code>footer</code> de negro al color verde azulado. Luego cambia el <code>color</code> texto <code>h2</code> a teal también. Finalmente, cambie el <code>background-color</code> de <code>background-color</code> del <code>button</code> al color naranja. 
+<section id='instructions'>
+Esta página utilizará un tono de verde azulado ( <code>#09A7A1</code> ) como color dominante, y su complemento naranja ( <code>#FF790E</code> ) para resaltar visualmente los botones de <code>#FF790E</code> . Cambie el <code>background-color</code> de <code>background-color</code> del <code>header</code> y del <code>footer</code> de <code>footer</code> de negro al color verde azulado. Luego cambia el <code>color</code> texto <code>h2</code> a teal también. Finalmente, cambie el <code>background-color</code> de <code>background-color</code> del <code>button</code> al color naranja.
 </section>
 
 ## Tests
@@ -21,13 +21,13 @@ Esta página utilizará un tono de verde azulado ( <code>#09A7A1</code> ) como c
 
 ```yml
 tests:
-  - text: &#39;El elemento del <code>header</code> debe tener un <code>background-color</code> de <code>background-color</code> de # 09A7A1.&#39;
+  - text: 'El elemento del <code>header</code> debe tener un <code>background-color</code> de <code>background-color</code> de # 09A7A1.'
     testString: 'assert($("header").css("background-color") == "rgb(9, 167, 161)", "The <code>header</code> element should have a <code>background-color</code> of #09A7A1.");'
-  - text: &#39;El elemento de <code>footer</code> debe tener un <code>background-color</code> de <code>background-color</code> de # 09A7A1.&#39;
+  - text: 'El elemento de <code>footer</code> debe tener un <code>background-color</code> de <code>background-color</code> de # 09A7A1.'
     testString: 'assert($("footer").css("background-color") == "rgb(9, 167, 161)", "The <code>footer</code> element should have a <code>background-color</code> of #09A7A1.");'
-  - text: &#39;El elemento <code>h2</code> debe tener un <code>color</code> de # 09A7A1.&#39;
+  - text: 'El elemento <code>h2</code> debe tener un <code>color</code> de # 09A7A1.'
     testString: 'assert($("h2").css("color") == "rgb(9, 167, 161)", "The <code>h2</code> element should have a <code>color</code> of #09A7A1.");'
-  - text: &#39;El elemento del <code>button</code> debe tener un <code>background-color</code> de <code>background-color</code> de # FF790E.&#39;
+  - text: 'El elemento del <code>button</code> debe tener un <code>background-color</code> de <code>background-color</code> de # FF790E.'
     testString: 'assert($("button").css("background-color") == "rgb(255, 121, 14)", "The <code>button</code> element should have a <code>background-color</code> of #FF790E.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-hover-state-of-an-anchor-tag.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-hover-state-of-an-anchor-tag.spanish.md
index 18801b152a..0c4c4a85d4 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-hover-state-of-an-anchor-tag.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/adjust-the-hover-state-of-an-anchor-tag.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Este reto tocará el uso de pseudo-clases. Una pseudo-clase es una palabra clave que se puede agregar a los selectores para seleccionar un estado específico del elemento. 
-Por ejemplo, el estilo de una etiqueta de anclaje se puede cambiar para su estado de activación mediante el uso del selector de pseudo-clase <code>:hover</code> . Aquí está el CSS para cambiar el <code>color</code> de la etiqueta de anclaje a rojo durante su estado de desplazamiento: 
-<blockquote>a:hover {<br>&nbsp;&nbsp;color: red;<br>}</blockquote> 
+<section id='description'>
+Este reto tocará el uso de pseudo-clases. Una pseudo-clase es una palabra clave que se puede agregar a los selectores para seleccionar un estado específico del elemento.
+Por ejemplo, el estilo de una etiqueta de anclaje se puede cambiar para su estado de activación mediante el uso del selector de pseudo-clase <code>:hover</code> . Aquí está el CSS para cambiar el <code>color</code> de la etiqueta de anclaje a rojo durante su estado de desplazamiento:
+<blockquote>a:hover {<br>&nbsp;&nbsp;color: red;<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene una regla CSS para el estilo de todo <code>a</code> negro etiquetas. Añadir una regla de modo que cuando el usuario se desplaza sobre la <code>a</code> etiqueta, el <code>color</code> es de color azul. 
+<section id='instructions'>
+El editor de código tiene una regla CSS para el estilo de todo <code>a</code> negro etiquetas. Añadir una regla de modo que cuando el usuario se desplaza sobre la <code>a</code> etiqueta, el <code>color</code> es de color azul.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ El editor de código tiene una regla CSS para el estilo de todo <code>a</code> n
 
 ```yml
 tests:
-  - text: &#39;El <code>color</code> etiqueta de anclaje debe permanecer en negro, solo agregue reglas CSS para el <code>:hover</code> estado de <code>:hover</code> &#39;.
+  - text: 'El <code>color</code> etiqueta de anclaje debe permanecer en negro, solo agregue reglas CSS para el <code>:hover</code> estado de <code>:hover</code> '
     testString: 'assert($("a").css("color") == "rgb(0, 0, 0)", "The anchor tag <code>color</code> should remain black, only add CSS rules for the <code>:hover</code> state.");'
   - text: La etiqueta de anclaje debe tener un <code>color</code> azul en el hover.
     testString: 'assert(code.match(/a:hover\s*?{\s*?color:\s*?blue;\s*?}/gi), "The anchor tag should have a <code>color</code> of blue on hover.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.spanish.md
index 87aed65ee1..bb526888ce 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-graphic-using-css.spanish.md
@@ -7,16 +7,16 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Al manipular diferentes selectores y propiedades, puedes hacer formas interesantes. Uno de los más fáciles de probar es una forma de luna creciente. Para este desafío, necesitas trabajar con la propiedad <code>box-shadow</code> que establece la sombra de un elemento, junto con la propiedad <code>border-radius</code> que controla la redondez de las esquinas del elemento. 
-Creará un objeto redondo y transparente con una sombra nítida que está ligeramente desplazada hacia el lado: la sombra realmente será la forma de la luna que ve. 
-Para crear un objeto redondo, la propiedad <code>border-radius</code> debe establecerse en un valor de 50%. 
-Puede recordar de un desafío anterior que la propiedad <code>box-shadow</code> toma valores para <code>offset-x</code> , <code>offset-y</code> , <code>blur-radius</code> , <code>spread-radius</code> y un valor de color en ese orden. Los valores de <code>spread-radius</code> <code>blur-radius</code> <code>spread-radius</code> son opcionales. 
+<section id='description'>
+Al manipular diferentes selectores y propiedades, puedes hacer formas interesantes. Uno de los más fáciles de probar es una forma de luna creciente. Para este desafío, necesitas trabajar con la propiedad <code>box-shadow</code> que establece la sombra de un elemento, junto con la propiedad <code>border-radius</code> que controla la redondez de las esquinas del elemento.
+Creará un objeto redondo y transparente con una sombra nítida que está ligeramente desplazada hacia el lado: la sombra realmente será la forma de la luna que ve.
+Para crear un objeto redondo, la propiedad <code>border-radius</code> debe establecerse en un valor de 50%.
+Puede recordar de un desafío anterior que la propiedad <code>box-shadow</code> toma valores para <code>offset-x</code> , <code>offset-y</code> , <code>blur-radius</code> , <code>spread-radius</code> y un valor de color en ese orden. Los valores de <code>spread-radius</code> <code>blur-radius</code> <code>spread-radius</code> son opcionales.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Manipule el elemento cuadrado en el editor para crear la forma de la luna. Primero, cambie el <code>background-color</code> a transparente, luego establezca la propiedad de <code>border-radius</code> en 50% para hacer la forma circular. Finalmente, cambie la propiedad <code>box-shadow</code> para establecer <code>offset-x</code> en 25px, <code>offset-y</code> en 10px, <code>blur-radius</code> en 0, <code>spread-radius</code> en 0 y color en azul. 
+<section id='instructions'>
+Manipule el elemento cuadrado en el editor para crear la forma de la luna. Primero, cambie el <code>background-color</code> a transparente, luego establezca la propiedad de <code>border-radius</code> en 50% para hacer la forma circular. Finalmente, cambie la propiedad <code>box-shadow</code> para establecer <code>offset-x</code> en 25px, <code>offset-y</code> en 10px, <code>blur-radius</code> en 0, <code>spread-radius</code> en 0 y color en azul.
 </section>
 
 ## Tests
@@ -28,7 +28,7 @@ tests:
     testString: 'assert(code.match(/background-color:\s*?transparent;/gi), "The value of the <code>background-color</code> property should be set to <code>transparent</code>.");'
   - text: El valor de la propiedad <code>border-radius</code> debe establecer en <code>50%</code> .
     testString: 'assert(code.match(/border-radius:\s*?50%;/gi), "The value of the <code>border-radius</code> property should be set to <code>50%</code>.");'
-  - text: &#39;El valor de la propiedad <code>box-shadow</code> debe establecerse en 25px para <code>offset-x</code> , 10px para <code>offset-y</code> , 0 para <code>blur-radius</code> de <code>blur-radius</code> , 0 para <code>spread-radius</code> de <code>spread-radius</code> y finalmente azul para el color.&#39;
+  - text: 'El valor de la propiedad <code>box-shadow</code> debe establecerse en 25px para <code>offset-x</code> , 10px para <code>offset-y</code> , 0 para <code>blur-radius</code> de <code>blur-radius</code> , 0 para <code>spread-radius</code> de <code>spread-radius</code> y finalmente azul para el color.'
     testString: 'assert(code.match(/box-shadow:\s*?25px\s+?10px\s+?0(px)?\s+?0(px)?\s+?blue\s*?;/gi), "The value of the <code>box-shadow</code> property should be set to 25px for <code>offset-x</code>, 10px for <code>offset-y</code>, 0 for <code>blur-radius</code>, 0 for <code>spread-radius</code>, and finally blue for the color.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.spanish.md
index 608943d3ad..58cc88ee87 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/create-a-more-complex-shape-using-css-and-html.spanish.md
@@ -7,18 +7,18 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Una de las formas más populares del mundo es la forma de corazón, y en este desafío creará una utilizando CSS puro. Pero primero, debe comprender los elementos pseudoelementos <code>::before</code> y <code>::after</code> . Estos pseudo-elementos se usan para agregar algo antes o después de un elemento seleccionado. En el siguiente ejemplo, un <code>::before</code> pseudo-elemento se usa para agregar un rectángulo a un elemento con el <code>heart</code> la clase: 
-<blockquote>.heart::before {<br>&nbsp;&nbsp;content: "";<br>&nbsp;&nbsp;background-color: yellow;<br>&nbsp;&nbsp;border-radius: 25%;<br>&nbsp;&nbsp;position: absolute;<br>&nbsp;&nbsp;height: 50px;<br>&nbsp;&nbsp;width: 70px;<br>&nbsp;&nbsp;top: -50px;<br>&nbsp;&nbsp;left: 5px;<br>}</blockquote> 
-Para que los elementos de pseudo-elementos <code>::before</code> y <code>::after</code> funcionen correctamente, deben tener una propiedad de <code>content</code> definida. Esta propiedad se usa generalmente para agregar elementos como una foto o texto al elemento seleccionado. Cuando los pseudo-elementos <code>::before</code> y <code>::after</code> se usan para hacer formas, la propiedad de <code>content</code> sigue siendo necesaria, pero se establece en una cadena vacía. 
-En el ejemplo anterior, el elemento con la clase de <code>heart</code> tiene un pseudoelemento <code>::before</code> del que produce un rectángulo amarillo con <code>height</code> y <code>width</code> de 50 px y 70 px, respectivamente. Este rectángulo tiene esquinas redondeadas debido a su radio de borde del 25% y está posicionado absolutamente a 5px desde la <code>left</code> y 50px por encima de la <code>top</code> del elemento. 
+<section id='description'>
+Una de las formas más populares del mundo es la forma de corazón, y en este desafío creará una utilizando CSS puro. Pero primero, debe comprender los elementos pseudoelementos <code>::before</code> y <code>::after</code> . Estos pseudo-elementos se usan para agregar algo antes o después de un elemento seleccionado. En el siguiente ejemplo, un <code>::before</code> pseudo-elemento se usa para agregar un rectángulo a un elemento con el <code>heart</code> la clase:
+<blockquote>.heart::before {<br>&nbsp;&nbsp;content: "";<br>&nbsp;&nbsp;background-color: yellow;<br>&nbsp;&nbsp;border-radius: 25%;<br>&nbsp;&nbsp;position: absolute;<br>&nbsp;&nbsp;height: 50px;<br>&nbsp;&nbsp;width: 70px;<br>&nbsp;&nbsp;top: -50px;<br>&nbsp;&nbsp;left: 5px;<br>}</blockquote>
+Para que los elementos de pseudo-elementos <code>::before</code> y <code>::after</code> funcionen correctamente, deben tener una propiedad de <code>content</code> definida. Esta propiedad se usa generalmente para agregar elementos como una foto o texto al elemento seleccionado. Cuando los pseudo-elementos <code>::before</code> y <code>::after</code> se usan para hacer formas, la propiedad de <code>content</code> sigue siendo necesaria, pero se establece en una cadena vacía.
+En el ejemplo anterior, el elemento con la clase de <code>heart</code> tiene un pseudoelemento <code>::before</code> del que produce un rectángulo amarillo con <code>height</code> y <code>width</code> de 50 px y 70 px, respectivamente. Este rectángulo tiene esquinas redondeadas debido a su radio de borde del 25% y está posicionado absolutamente a 5px desde la <code>left</code> y 50px por encima de la <code>top</code> del elemento.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Transforma el elemento en la pantalla a un corazón. En el <code>heart::after</code> selector, cambie el <code>background-color</code> a rosa y el <code>border-radius</code> del <code>border-radius</code> a 50%. 
-A continuación, apunte el elemento con el <code>heart</code> la clase (solo el <code>heart</code> ) y complete la propiedad de <code>transform</code> . Utilice la función <code>rotate()</code> con -45 grados. ( <code>rotate()</code> funciona de la misma manera que <code>skewX()</code> y <code>skewY()</code> hacen). 
-Finalmente, en el <code>heart::before</code> selector, establece su propiedad de <code>content</code> en una cadena vacía. 
+<section id='instructions'>
+Transforma el elemento en la pantalla a un corazón. En el <code>heart::after</code> selector, cambie el <code>background-color</code> a rosa y el <code>border-radius</code> del <code>border-radius</code> a 50%.
+A continuación, apunte el elemento con el <code>heart</code> la clase (solo el <code>heart</code> ) y complete la propiedad de <code>transform</code> . Utilice la función <code>rotate()</code> con -45 grados. ( <code>rotate()</code> funciona de la misma manera que <code>skewX()</code> y <code>skewY()</code> hacen).
+Finalmente, en el <code>heart::before</code> selector, establece su propiedad de <code>content</code> en una cadena vacía.
 </section>
 
 ## Tests
@@ -26,13 +26,13 @@ Finalmente, en el <code>heart::before</code> selector, establece su propiedad de
 
 ```yml
 tests:
-  - text: &#39;La propiedad de <code>background-color</code> de fondo del <code>heart::after</code> selector debe ser rosa.&#39;
+  - text: 'La propiedad de <code>background-color</code> de fondo del <code>heart::after</code> selector debe ser rosa.'
     testString: 'assert(code.match(/\.heart::after\s*?{\s*?background-color\s*?:\s*?pink\s*?;/gi), "The <code>background-color</code> property of the <code>heart::after</code> selector should be pink.");'
-  - text: &#39;El <code>border-radius</code> del <code>border-radius</code> del <code>heart::after</code> selector debe ser del 50%.&#39;
+  - text: 'El <code>border-radius</code> del <code>border-radius</code> del <code>heart::after</code> selector debe ser del 50%.'
     testString: 'assert(code.match(/border-radius\s*?:\s*?50%/gi).length == 2, "The <code>border-radius</code> of the <code>heart::after</code> selector should be 50%.");'
   - text: La propiedad de <code>transform</code> para la clase de <code>heart</code> debe usar una función <code>rotate()</code> establecida en -45 grados.
     testString: 'assert(code.match(/transform\s*?:\s*?rotate\(\s*?-45deg\s*?\)/gi), "The <code>transform</code> property for the <code>heart</code> class should use a <code>rotate()</code> function set to -45 degrees.");'
-  - text: &#39;El <code>content</code> del <code>heart::before</code> selector debe ser una cadena vacía.&#39;
+  - text: 'El <code>content</code> del <code>heart::before</code> selector debe ser una cadena vacía.'
     testString: 'assert(code.match(/\.heart::before\s*?{\s*?content\s*?:\s*?("|")\1\s*?;/gi), "The <code>content</code> of the <code>heart::before</code> selector should be an empty string.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-its-parent-with-absolute-positioning.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-its-parent-with-absolute-positioning.spanish.md
index 65a1dc473b..d88e410360 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-its-parent-with-absolute-positioning.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-its-parent-with-absolute-positioning.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-La siguiente opción para la propiedad de <code>position</code> CSS es <code>absolute</code> , que bloquea el elemento en su lugar en relación con su contenedor principal. A diferencia de la posición <code>relative</code> , esto elimina el elemento del flujo normal del documento, por lo que los elementos circundantes lo ignoran. Las propiedades de desplazamiento de CSS (superior o inferior e izquierda o derecha) se utilizan para ajustar la posición. 
-Un matiz con posicionamiento absoluto es que se bloqueará en relación con su antepasado <em>posicionado</em> más cercano. Si olvida agregar una regla de posición al elemento principal, (esto generalmente se hace usando <code>position: relative;</code> ), el navegador seguirá buscando la cadena y, por último, usará la etiqueta del cuerpo de forma predeterminada. 
+<section id='description'>
+La siguiente opción para la propiedad de <code>position</code> CSS es <code>absolute</code> , que bloquea el elemento en su lugar en relación con su contenedor principal. A diferencia de la posición <code>relative</code> , esto elimina el elemento del flujo normal del documento, por lo que los elementos circundantes lo ignoran. Las propiedades de desplazamiento de CSS (superior o inferior e izquierda o derecha) se utilizan para ajustar la posición.
+Un matiz con posicionamiento absoluto es que se bloqueará en relación con su antepasado <em>posicionado</em> más cercano. Si olvida agregar una regla de posición al elemento principal, (esto generalmente se hace usando <code>position: relative;</code> ), el navegador seguirá buscando la cadena y, por último, usará la etiqueta del cuerpo de forma predeterminada.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Bloquee el elemento <code>#searchbar</code> en la parte superior derecha de su <code>section</code> principal declarando su <code>position</code> como <code>absolute</code> . Dale las compensaciones <code>top</code> y <code>right</code> de 50 píxeles cada una. 
+<section id='instructions'>
+Bloquee el elemento <code>#searchbar</code> en la parte superior derecha de su <code>section</code> principal declarando su <code>position</code> como <code>absolute</code> . Dale las compensaciones <code>top</code> y <code>right</code> de 50 píxeles cada una.
 </section>
 
 ## Tests
@@ -22,11 +22,11 @@ Bloquee el elemento <code>#searchbar</code> en la parte superior derecha de su <
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#searchbar</code> debería tener una <code>position</code> establecida en <code>absolute</code> .&#39;
+  - text: 'El elemento <code>#searchbar</code> debería tener una <code>position</code> establecida en <code>absolute</code> .'
     testString: 'assert($("#searchbar").css("position") == "absolute", "The <code>#searchbar</code> element should have a <code>position</code> set to <code>absolute</code>.");'
-  - text: &#39;Su código debe usar el desplazamiento de CSS <code>top</code> de 50 píxeles en el elemento <code>#searchbar</code> &#39;.
+  - text: 'Su código debe usar el desplazamiento de CSS <code>top</code> de 50 píxeles en el elemento <code>#searchbar</code> '
     testString: 'assert($("#searchbar").css("top") == "50px", "Your code should use the <code>top</code> CSS offset of 50 pixels on the <code>#searchbar</code> element.");'
-  - text: &#39;Su código debe usar el desplazamiento de CSS <code>right</code> de 50 píxeles en el elemento <code>#searchbar</code> &#39;.
+  - text: 'Su código debe usar el desplazamiento de CSS <code>right</code> de 50 píxeles en el elemento <code>#searchbar</code> '
     testString: 'assert($("#searchbar").css("right") == "50px", "Your code should use the <code>right</code> CSS offset of 50 pixels on the <code>#searchbar</code> element.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-the-browser-window-with-fixed-positioning.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-the-browser-window-with-fixed-positioning.spanish.md
index 50f660f05f..5665a5dd16 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-the-browser-window-with-fixed-positioning.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/lock-an-element-to-the-browser-window-with-fixed-positioning.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-El siguiente esquema de diseño que ofrece CSS es la posición <code>fixed</code> , que es un tipo de posicionamiento absoluto que bloquea un elemento relativo a la ventana del navegador. Similar al posicionamiento absoluto, se usa con las propiedades de desplazamiento de CSS y también elimina el elemento del flujo normal del documento. Otros elementos ya no se &quot;dan cuenta&quot; de dónde se coloca, lo que puede requerir algunos ajustes de diseño en otros lugares. 
-Una diferencia clave entre las posiciones <code>fixed</code> y <code>absolute</code> es que un elemento con una posición fija no se moverá cuando el usuario se desplace. 
+<section id='description'>
+El siguiente esquema de diseño que ofrece CSS es la posición <code>fixed</code> , que es un tipo de posicionamiento absoluto que bloquea un elemento relativo a la ventana del navegador. Similar al posicionamiento absoluto, se usa con las propiedades de desplazamiento de CSS y también elimina el elemento del flujo normal del documento. Otros elementos ya no se &quot;dan cuenta&quot; de dónde se coloca, lo que puede requerir algunos ajustes de diseño en otros lugares.
+Una diferencia clave entre las posiciones <code>fixed</code> y <code>absolute</code> es que un elemento con una posición fija no se moverá cuando el usuario se desplace.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-La barra de navegación en el código está etiquetada con un ID de <code>navbar</code> de <code>navbar</code> . Cambie su <code>position</code> a <code>fixed</code> , y desplace 0 píxeles desde la <code>top</code> y 0 píxeles desde la <code>left</code> . Observe el (falta de) impacto en la posición <code>h1</code> , no se ha empujado hacia abajo para acomodar la barra de navegación y debería ajustarse por separado. 
+<section id='instructions'>
+La barra de navegación en el código está etiquetada con un ID de <code>navbar</code> de <code>navbar</code> . Cambie su <code>position</code> a <code>fixed</code> , y desplace 0 píxeles desde la <code>top</code> y 0 píxeles desde la <code>left</code> . Observe el (falta de) impacto en la posición <code>h1</code> , no se ha empujado hacia abajo para acomodar la barra de navegación y debería ajustarse por separado.
 </section>
 
 ## Tests
@@ -22,11 +22,11 @@ La barra de navegación en el código está etiquetada con un ID de <code>navbar
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#navbar</code> debería tener una <code>position</code> establecida como <code>fixed</code> .&#39;
+  - text: 'El elemento <code>#navbar</code> debería tener una <code>position</code> establecida como <code>fixed</code> .'
     testString: 'assert($("#navbar").css("position") == "fixed", "The <code>#navbar</code> element should have a <code>position</code> set to <code>fixed</code>.");'
-  - text: &#39;Su código debe usar el desplazamiento de CSS <code>top</code> de 0 píxeles en el elemento <code>#navbar</code> &#39;.
+  - text: 'Su código debe usar el desplazamiento de CSS <code>top</code> de 0 píxeles en el elemento <code>#navbar</code> '
     testString: 'assert($("#navbar").css("top") == "0px", "Your code should use the <code>top</code> CSS offset of 0 pixels on the <code>#navbar</code> element.");'
-  - text: &#39;Tu código debe usar el desplazamiento de CSS <code>left</code> de 0 píxeles en el elemento <code>#navbar</code> &#39;.
+  - text: 'Tu código debe usar el desplazamiento de CSS <code>left</code> de 0 píxeles en el elemento <code>#navbar</code> '
     testString: 'assert($("#navbar").css("left") == "0px", "Your code should use the <code>left</code> CSS offset of 0 pixels on the <code>#navbar</code> element.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/make-motion-more-natural-using-a-bezier-curve.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/make-motion-more-natural-using-a-bezier-curve.spanish.md
index e154cbe1b4..fa58d77c2f 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/make-motion-more-natural-using-a-bezier-curve.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/make-motion-more-natural-using-a-bezier-curve.spanish.md
@@ -7,17 +7,17 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Este desafío anima un elemento para replicar el movimiento de una bola que se hace malabarismo. Los desafíos anteriores cubrieron las curvas Bezier cúbicas <code>linear</code> y de <code>ease-out</code> desahogo, sin embargo, ninguno de ellos describe con precisión el movimiento de los malabares. Necesitas personalizar una curva Bezier para esto. 
-La <code>animation-timing-function</code> automáticamente en cada fotograma clave cuando el <code>animation-iteration-count</code> se establece en infinito. Dado que hay una regla de fotogramas clave establecida en la mitad de la duración de la animación (al <code>50%</code> ), produce dos progresiones de animación idénticas en el movimiento ascendente y descendente de la bola. 
-La siguiente curva de Bezier cúbica simula un movimiento de malabarismo: 
-<code>cubic-bezier(0.3, 0.4, 0.5, 1.6);</code> 
-Observe que el valor de y2 es mayor que 1. Aunque la curva de Bézier cúbica se asigna en un sistema de coordenadas 1 por 1, y solo puede aceptar valores de x de 1 a 1, el valor de y se puede configurar en números mayores que uno . Esto resulta en un movimiento de rebote que es ideal para simular la bola de malabarismo. 
+<section id='description'>
+Este desafío anima un elemento para replicar el movimiento de una bola que se hace malabarismo. Los desafíos anteriores cubrieron las curvas Bezier cúbicas <code>linear</code> y de <code>ease-out</code> desahogo, sin embargo, ninguno de ellos describe con precisión el movimiento de los malabares. Necesitas personalizar una curva Bezier para esto.
+La <code>animation-timing-function</code> automáticamente en cada fotograma clave cuando el <code>animation-iteration-count</code> se establece en infinito. Dado que hay una regla de fotogramas clave establecida en la mitad de la duración de la animación (al <code>50%</code> ), produce dos progresiones de animación idénticas en el movimiento ascendente y descendente de la bola.
+La siguiente curva de Bezier cúbica simula un movimiento de malabarismo:
+<code>cubic-bezier(0.3, 0.4, 0.5, 1.6);</code>
+Observe que el valor de y2 es mayor que 1. Aunque la curva de Bézier cúbica se asigna en un sistema de coordenadas 1 por 1, y solo puede aceptar valores de x de 1 a 1, el valor de y se puede configurar en números mayores que uno . Esto resulta en un movimiento de rebote que es ideal para simular la bola de malabarismo.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambie el valor de la <code>animation-timing-function</code> de <code>animation-timing-function</code> del elemento con el id de <code>green</code> a una función <code>cubic-bezier</code> con x1, y1, x2, y2 valores establecidos respectivamente en 0.311, 0.441, 0.444, 1.649. 
+<section id='instructions'>
+Cambie el valor de la <code>animation-timing-function</code> de <code>animation-timing-function</code> del elemento con el id de <code>green</code> a una función <code>cubic-bezier</code> con x1, y1, x2, y2 valores establecidos respectivamente en 0.311, 0.441, 0.444, 1.649.
 </section>
 
 ## Tests
@@ -25,7 +25,7 @@ Cambie el valor de la <code>animation-timing-function</code> de <code>animation-
 
 ```yml
 tests:
-  - text: &#39;El valor de la propiedad <code>animation-timing-function</code> para el elemento con el id <code>green</code> debe ser una función de <code>cubic-bezier</code> con los valores de x1, y1, x2, y2 según lo especificado.&#39;
+  - text: 'El valor de la propiedad <code>animation-timing-function</code> para el elemento con el id <code>green</code> debe ser una función de <code>cubic-bezier</code> con los valores de x1, y1, x2, y2 según lo especificado.'
     testString: 'assert($("#green").css("animation-timing-function") == "cubic-bezier(0.311, 0.441, 0.444, 1.649)", "The value of the <code>animation-timing-function</code> property for the element with the id <code>green</code> should be a <code>cubic-bezier</code> function with x1, y1, x2, y2 values as specified.'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/modify-fill-mode-of-an-animation.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/modify-fill-mode-of-an-animation.spanish.md
index 2be9e73b3f..fd8da5db03 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/modify-fill-mode-of-an-animation.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/modify-fill-mode-of-an-animation.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Eso es genial, pero no funciona bien todavía. Observe cómo se restablece la animación después de que hayan transcurrido <code>500ms</code> , lo que hace que el botón vuelva al color original. Desea que el botón quede resaltado. 
-Esto se puede hacer configurando la propiedad de <code>animation-fill-mode</code> en <code>forwards</code> . La <code>animation-fill-mode</code> especifica el estilo aplicado a un elemento cuando la animación ha finalizado. Puedes configurarlo así: 
-<code>animation-fill-mode: forwards;</code> 
+<section id='description'>
+Eso es genial, pero no funciona bien todavía. Observe cómo se restablece la animación después de que hayan transcurrido <code>500ms</code> , lo que hace que el botón vuelva al color original. Desea que el botón quede resaltado.
+Esto se puede hacer configurando la propiedad de <code>animation-fill-mode</code> en <code>forwards</code> . La <code>animation-fill-mode</code> especifica el estilo aplicado a un elemento cuando la animación ha finalizado. Puedes configurarlo así:
+<code>animation-fill-mode: forwards;</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Establezca la propiedad de <code>animation-fill-mode</code> del <code>button:hover</code> hacia <code>forwards</code> para que el botón permanezca resaltado cuando un usuario se desplace sobre él. 
+<section id='instructions'>
+Establezca la propiedad de <code>animation-fill-mode</code> del <code>button:hover</code> hacia <code>forwards</code> para que el botón permanezca resaltado cuando un usuario se desplace sobre él.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Establezca la propiedad de <code>animation-fill-mode</code> del <code>button:hov
 
 ```yml
 tests:
-  - text: &#39; <code>button:hover</code> debería tener una propiedad de <code>animation-fill-mode</code> con un valor de <code>forwards</code> .&#39;
+  - text: ' <code>button:hover</code> debería tener una propiedad de <code>animation-fill-mode</code> con un valor de <code>forwards</code> .'
     testString: 'assert(code.match(/button\s*?:\s*?hover\s*?{[\s\S]*animation-fill-mode\s*?:\s*?forwards\s*?;[\s\S]*}/gi) && code.match(/button\s*?:\s*?hover\s*?{[\s\S]*animation-name\s*?:\s*?background-color\s*?;[\s\S]*}/gi) && code.match(/button\s*?:\s*?hover\s*?{[\s\S]*animation-duration\s*?:\s*?500ms\s*?;[\s\S]*}/gi), "<code>button:hover</code> should have a <code>animation-fill-mode</code> property with a value of <code>forwards</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/move-a-relatively-positioned-element-with-css-offsets.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/move-a-relatively-positioned-element-with-css-offsets.spanish.md
index ab8261c433..f5cd413d78 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/move-a-relatively-positioned-element-with-css-offsets.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/move-a-relatively-positioned-element-with-css-offsets.spanish.md
@@ -7,12 +7,12 @@ videoUrl: ''
 ---
 
 ## Description
-<html><section id='description'> 
+<html><section id='description'>
 Las compensaciones de CSS de la <code>top</code> o <code>bottom</code> , y de la <code>left</code> o la <code>right</code> indican al navegador la distancia a la que se debe desplazar un elemento en relación con el lugar donde se ubicaría en el flujo normal del documento. Está desplazando un elemento lejos de un punto dado, lo que lo aleja del lado al que se hace referencia (efectivamente, en la dirección opuesta). Como viste en el último desafío, usando el desplazamiento superior movió el <code>h2</code> hacia abajo. Del mismo modo, utilizando un desplazamiento a la izquierda mueve un elemento a la derecha. <code>0</code>
 
 ## Instructions
-<section id='instructions'> 
-Use las compensaciones de CSS para mover el <code>h2</code> 15 píxeles a la derecha y 10 píxeles hacia arriba. 
+<section id='instructions'>
+Use las compensaciones de CSS para mover el <code>h2</code> 15 píxeles a la derecha y 10 píxeles hacia arriba.
 </section>
 
 ## Tests
@@ -20,9 +20,9 @@ Use las compensaciones de CSS para mover el <code>h2</code> 15 píxeles a la der
 
 ```yml
 tests:
-  - text: &#39;Su código debe usar un desplazamiento de CSS para posicionar relativamente el <code>h2</code> 10px hacia arriba. En otras palabras, aléjelo 10px de la <code>bottom</code> de donde normalmente se sienta. &#39;
+  - text: 'Su código debe usar un desplazamiento de CSS para posicionar relativamente el <code>h2</code> 10px hacia arriba. En otras palabras, aléjelo 10px de la <code>bottom</code> de donde normalmente se sienta. '
     testString: 'assert($("h2").css("bottom") == "10px", "Your code should use a CSS offset to relatively position the <code>h2</code> 10px upwards. In other words, move it 10px away from the <code>bottom</code> of where it normally sits.");'
-  - text: &#39;Su código debe usar un desplazamiento de CSS para posicionar relativamente el <code>h2</code> 15px hacia la derecha. En otras palabras, aléjelo a 15px de la <code>left</code> de donde normalmente se encuentra.
+  - text: 'Su código debe usar un desplazamiento de CSS para posicionar relativamente el <code>h2</code> 15px hacia la derecha. En otras palabras, aléjelo a 15px de la <code>left</code> de donde normalmente se encuentra.
     testString: 'assert($("h2").css("left") == "15px", "Your code should use a CSS offset to relatively position the <code>h2</code> 15px towards the right. In other words, move it 15px away from the <code>left</code> of where it normally sits.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.spanish.md
index a039abded6..dafa6167b3 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-a-bezier-curve-to-move-a-graphic.spanish.md
@@ -7,16 +7,16 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Un desafío anterior discutió la palabra clave de <code>ease-out</code> que describe un cambio de animación que se acelera primero y luego se ralentiza al final de la animación. A la derecha, se muestra la diferencia entre la palabra clave de <code>ease-out</code> (para el elemento azul) y <code>linear</code> palabra clave <code>linear</code> (para el elemento rojo). Se pueden lograr progresiones de animación similares a la palabra clave de <code>ease-out</code> de uso utilizando una función de curva Bezier cúbica personalizada. 
-En general, el cambio de los puntos de anclaje <code>p1</code> y <code>p2</code> impulsa la creación de diferentes curvas Bezier, que controlan cómo avanza la animación a través del tiempo. Este es un ejemplo de una curva de Bezier que utiliza valores para imitar el estilo de relajación: 
-<code>animation-timing-function: cubic-bezier(0, 0, 0.58, 1);</code> 
-Recuerde que todas <code>cubic-bezier</code> funciones de <code>cubic-bezier</code> comienzan con <code>p0</code> en (0, 0) y terminan con <code>p3</code> en (1, 1). En este ejemplo, la curva se mueve más rápido a través del eje Y (comienza en 0, va a <code>p1</code> y el valor de 0, luego va a <code>p2</code> y el valor de 1) que se mueve a través del eje X (0 para comenzar, luego 0 para <code>p1</code> , hasta 0.58 para <code>p2</code> ). Como resultado, el cambio en el elemento animado progresa más rápido que el tiempo de la animación para ese segmento. Hacia el final de la curva, la relación entre el cambio en los valores de x e y se invierte: el valor de y se mueve de 1 a 1 (sin cambio), y los valores de x se mueven de 0.58 a 1, lo que hace que los cambios de animación progresen más lentamente en comparación La duración de la animación. 
+<section id='description'>
+Un desafío anterior discutió la palabra clave de <code>ease-out</code> que describe un cambio de animación que se acelera primero y luego se ralentiza al final de la animación. A la derecha, se muestra la diferencia entre la palabra clave de <code>ease-out</code> (para el elemento azul) y <code>linear</code> palabra clave <code>linear</code> (para el elemento rojo). Se pueden lograr progresiones de animación similares a la palabra clave de <code>ease-out</code> de uso utilizando una función de curva Bezier cúbica personalizada.
+En general, el cambio de los puntos de anclaje <code>p1</code> y <code>p2</code> impulsa la creación de diferentes curvas Bezier, que controlan cómo avanza la animación a través del tiempo. Este es un ejemplo de una curva de Bezier que utiliza valores para imitar el estilo de relajación:
+<code>animation-timing-function: cubic-bezier(0, 0, 0.58, 1);</code>
+Recuerde que todas <code>cubic-bezier</code> funciones de <code>cubic-bezier</code> comienzan con <code>p0</code> en (0, 0) y terminan con <code>p3</code> en (1, 1). En este ejemplo, la curva se mueve más rápido a través del eje Y (comienza en 0, va a <code>p1</code> y el valor de 0, luego va a <code>p2</code> y el valor de 1) que se mueve a través del eje X (0 para comenzar, luego 0 para <code>p1</code> , hasta 0.58 para <code>p2</code> ). Como resultado, el cambio en el elemento animado progresa más rápido que el tiempo de la animación para ese segmento. Hacia el final de la curva, la relación entre el cambio en los valores de x e y se invierte: el valor de y se mueve de 1 a 1 (sin cambio), y los valores de x se mueven de 0.58 a 1, lo que hace que los cambios de animación progresen más lentamente en comparación La duración de la animación.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Para ver el efecto de esta curva de Bezier en acción, cambie la <code>animation-timing-function</code> de <code>animation-timing-function</code> del elemento con id de <code>red</code> a una función de <code>cubic-bezier</code> con x1, y1, x2, y2 valores establecidos respectivamente en 0, 0, 0.58, 1. Esto hará que ambos elementos progresen a través de la animación de manera similar. 
+<section id='instructions'>
+Para ver el efecto de esta curva de Bezier en acción, cambie la <code>animation-timing-function</code> de <code>animation-timing-function</code> del elemento con id de <code>red</code> a una función de <code>cubic-bezier</code> con x1, y1, x2, y2 valores establecidos respectivamente en 0, 0, 0.58, 1. Esto hará que ambos elementos progresen a través de la animación de manera similar.
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Para ver el efecto de esta curva de Bezier en acción, cambie la <code>animation
 
 ```yml
 tests:
-  - text: &#39;El valor de la propiedad <code>animation-timing-function</code> del elemento con el id <code>red</code> debe ser una función de <code>cubic-bezier</code> con x1, y1, x2, y2 valores establecidos respectivamente en 0, 0, 0.58, 1.&#39;
+  - text: 'El valor de la propiedad <code>animation-timing-function</code> del elemento con el id <code>red</code> debe ser una función de <code>cubic-bezier</code> con x1, y1, x2, y2 valores establecidos respectivamente en 0, 0, 0.58, 1.'
     testString: 'assert($("#red").css("animation-timing-function") == "cubic-bezier(0, 0, 0.58, 1)", "The value of the <code>animation-timing-function</code> property of the element with the id <code>red</code> should be a <code>cubic-bezier</code> function with x1, y1, x2, y2 values set respectively to 0, 0, 0.58, 1 .");'
   - text: El elemento con el ID <code>red</code> ya no debería tener la propiedad de <code>animation-timing-function</code> lineal.
     testString: 'assert($("#red").css("animation-timing-function") !== "linear", "The element with the id <code>red</code> should no longer have the <code>animation-timing-function</code> property of linear.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-css-transform-scale-property-to-change-the-size-of-an-element.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-css-transform-scale-property-to-change-the-size-of-an-element.spanish.md
index 3319732f7f..0340972ffd 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-css-transform-scale-property-to-change-the-size-of-an-element.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-css-transform-scale-property-to-change-the-size-of-an-element.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Para cambiar la escala de un elemento, CSS tiene la propiedad de <code>transform</code> , junto con su función <code>scale()</code> . El siguiente ejemplo de código duplica el tamaño de todos los elementos de párrafo en la página: 
-<blockquote>p {<br>&nbsp;&nbsp;transform:scale(2);<br>}</blockquote> 
+<section id='description'>
+Para cambiar la escala de un elemento, CSS tiene la propiedad de <code>transform</code> , junto con su función <code>scale()</code> . El siguiente ejemplo de código duplica el tamaño de todos los elementos de párrafo en la página:
+<blockquote>p {<br>&nbsp;&nbsp;transform:scale(2);<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Aumente el tamaño del elemento con el id de <code>ball2</code> a 1.5 veces su tamaño original. 
+<section id='instructions'>
+Aumente el tamaño del elemento con el id de <code>ball2</code> a 1.5 veces su tamaño original.
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Aumente el tamaño del elemento con el id de <code>ball2</code> a 1.5 veces su t
 
 ```yml
 tests:
-  - text: &#39;Establezca la propiedad de <code>transform</code> para <code>#ball2</code> para escalarla 1.5 veces su tamaño.&#39;
+  - text: 'Establezca la propiedad de <code>transform</code> para <code>#ball2</code> para escalarla 1.5 veces su tamaño.'
     testString: 'assert(code.match(/#ball2\s*?{\s*?left:\s*?65%;\s*?transform:\s*?scale\(1\.5\);\s*?}|#ball2\s*?{\s*?transform:\s*?scale\(1\.5\);\s*?left:\s*?65%;\s*?}/gi), "Set the <code>transform</code> property for <code>#ball2</code> to scale it 1.5 times its size.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-s-tag-to-strikethrough-text.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-s-tag-to-strikethrough-text.spanish.md
index 87d7fe225f..7df68c6cd6 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-s-tag-to-strikethrough-text.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/applied-visual-design/use-the-s-tag-to-strikethrough-text.spanish.md
@@ -7,13 +7,13 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Para tachar el texto, que es cuando una línea horizontal corta los caracteres, puede usar la etiqueta <code>s</code> . Muestra que una sección de texto ya no es válida. Con la etiqueta <code>s</code> , el navegador aplica el CSS de <code>text-decoration: line-through;</code> al elemento. 
+<section id='description'>
+Para tachar el texto, que es cuando una línea horizontal corta los caracteres, puede usar la etiqueta <code>s</code> . Muestra que una sección de texto ya no es válida. Con la etiqueta <code>s</code> , el navegador aplica el CSS de <code>text-decoration: line-through;</code> al elemento.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Envuelva la etiqueta <code>s</code> alrededor de &quot;Google&quot; dentro de la etiqueta <code>h4</code> y luego agregue la palabra Alfabeto a su lado, que no debería tener el formato tachado. 
+<section id='instructions'>
+Envuelva la etiqueta <code>s</code> alrededor de &quot;Google&quot; dentro de la etiqueta <code>h4</code> y luego agregue la palabra Alfabeto a su lado, que no debería tener el formato tachado.
 </section>
 
 ## Tests
@@ -25,7 +25,7 @@ tests:
     testString: 'assert($("s").length == 1, "Your code should add one <code>s</code> tag to the markup.");'
   - text: La etiqueta <code>s</code> debe envolver el texto de Google en la etiqueta <code>h4</code> . No debe contener la palabra Alfabeto.
     testString: 'assert($("s").text().match(/Google/gi) && !$("s").text().match(/Alphabet/gi), "A <code>s</code> tag should wrap around the Google text in the <code>h4</code> tag. It should not contain the word Alphabet.");'
-  - text: &#39;Incluya la palabra Alfabeto en la etiqueta <code>h4</code> , sin tachar el formato.&#39;
+  - text: 'Incluya la palabra Alfabeto en la etiqueta <code>h4</code> , sin tachar el formato.'
     testString: 'assert($("h4").html().match(/Alphabet/gi), "Include the word Alphabet in the <code>h4</code> tag, without strikethrough formatting.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/add-rounded-corners-with-border-radius.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/add-rounded-corners-with-border-radius.spanish.md
index 74b77a7ee5..790c656a04 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/add-rounded-corners-with-border-radius.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/add-rounded-corners-with-border-radius.spanish.md
@@ -8,14 +8,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Tu foto de gato tiene actualmente esquinas afiladas. Podemos redondear esas esquinas con una propiedad CSS llamada <code>border-radius</code> . 
+<section id='description'>
+Tu foto de gato tiene actualmente esquinas afiladas. Podemos redondear esas esquinas con una propiedad CSS llamada <code>border-radius</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Puede especificar un <code>border-radius</code> con píxeles. Dale a tu foto de gato un <code>border-radius</code> de <code>10px</code> de <code>10px</code> . 
-Nota: este desafío permite múltiples soluciones posibles. Por ejemplo, puede agregar <code>border-radius</code> <code>.thick-green-border</code> clase <code>.thick-green-border</code> o a la clase <code>.smaller-image</code> . 
+<section id='instructions'>
+Puede especificar un <code>border-radius</code> con píxeles. Dale a tu foto de gato un <code>border-radius</code> de <code>10px</code> de <code>10px</code> .
+Nota: este desafío permite múltiples soluciones posibles. Por ejemplo, puede agregar <code>border-radius</code> <code>.thick-green-border</code> clase <code>.thick-green-border</code> o a la clase <code>.smaller-image</code> .
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Nota: este desafío permite múltiples soluciones posibles. Por ejemplo, puede a
 
 ```yml
 tests:
-  - text: El elemento de su imagen debe tener la clase "borde verde grueso".
+  - text: El elemento de su imagen debe tener la clase "borde verde grueso."
     testString: 'assert($("img").hasClass("thick-green-border"), "Your image element should have the class "thick-green-border".");'
   - text: Su imagen debe tener un radio de borde de <code clase = "notranslate"> 10px </code>
     testString: 'assert(parseInt($("img").css("border-top-left-radius")) > 8, "Your image should have a border radius of <code>10px</code>");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/cascading-css-variables.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/cascading-css-variables.spanish.md
index 4d73969331..5e6a1569e9 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/cascading-css-variables.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/cascading-css-variables.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Cuando crea una variable, queda disponible para que la use dentro del elemento en el que la creó. También está disponible dentro de cualquier elemento anidado dentro de él. Este efecto se conoce como <dfn>cascada</dfn> . 
-Debido a la cascada, las variables CSS a menudo se definen en el elemento <dfn>: raíz</dfn> . 
-<code>:root</code> es un selector de <dfn>pseudo-clase</dfn> que coincide con el elemento raíz del documento, generalmente el <html> elemento. Al crear sus variables en <code>:root</code> , estarán disponibles globalmente y se podrá acceder a ellas desde cualquier otro selector más adelante en la hoja de estilo. 
+<section id='description'>
+Cuando crea una variable, queda disponible para que la use dentro del elemento en el que la creó. También está disponible dentro de cualquier elemento anidado dentro de él. Este efecto se conoce como <dfn>cascada</dfn> .
+Debido a la cascada, las variables CSS a menudo se definen en el elemento <dfn>: raíz</dfn> .
+<code>:root</code> es un selector de <dfn>pseudo-clase</dfn> que coincide con el elemento raíz del documento, generalmente el <html> elemento. Al crear sus variables en <code>:root</code> , estarán disponibles globalmente y se podrá acceder a ellas desde cualquier otro selector más adelante en la hoja de estilo.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Defina una variable llamada <code>--penguin-belly</code> en el selector de <code>:root</code> y déle el valor de <code>pink</code> . Luego puede ver cómo el valor caerá en cascada para cambiar el valor a rosa, en cualquier lugar donde se use esa variable. 
+<section id='instructions'>
+Defina una variable llamada <code>--penguin-belly</code> en el selector de <code>:root</code> y déle el valor de <code>pink</code> . Luego puede ver cómo el valor caerá en cascada para cambiar el valor a rosa, en cualquier lugar donde se use esa variable.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Defina una variable llamada <code>--penguin-belly</code> en el selector de <code
 
 ```yml
 tests:
-  - text: &#39;declara la variable <code>--penguin-belly</code> en la <code>:root</code> y <code>--penguin-belly</code> a <code>pink</code> &#39;.
+  - text: 'declara la variable <code>--penguin-belly</code> en la <code>:root</code> y <code>--penguin-belly</code> a <code>pink</code> '
     testString: 'assert(code.match(/:root\s*?{[\s\S]*--penguin-belly\s*?:\s*?pink\s*?;[\s\S]*}/gi), "declare the <code>--penguin-belly</code> variable in the <code>:root</code> and assign it to <code>pink</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/change-the-font-size-of-an-element.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/change-the-font-size-of-an-element.spanish.md
index 119e75b80f..caabbdf7b8 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/change-the-font-size-of-an-element.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/change-the-font-size-of-an-element.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-El tamaño de fuente se controla mediante la propiedad CSS de <code>font-size</code> , como esta: 
-<blockquote>h1 {<br>&nbsp;&nbsp;font-size: 30px;<br>}</blockquote> 
+<section id='description'>
+El tamaño de fuente se controla mediante la propiedad CSS de <code>font-size</code> , como esta:
+<blockquote>h1 {<br>&nbsp;&nbsp;font-size: 30px;<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Dentro de la misma etiqueta <code>&lt;style&gt;</code> que contiene su clase de <code>red-text</code> , cree una entrada para los elementos <code>p</code> y establezca el <code>font-size</code> en 16 píxeles ( <code>16px</code> ). 
+<section id='instructions'>
+Dentro de la misma etiqueta <code>&lt;style&gt;</code> que contiene su clase de <code>red-text</code> , cree una entrada para los elementos <code>p</code> y establezca el <code>font-size</code> en 16 píxeles ( <code>16px</code> ).
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Dentro de la misma etiqueta <code>&lt;style&gt;</code> que contiene su clase de
 
 ```yml
 tests:
-  - text: &#39;Entre las etiquetas de <code>style</code> , <code>16px</code> elementos <code>p</code> <code>font-size</code> de <code>font-size</code> de <code>16px</code> . El navegador y el zoom de texto deben estar al 100% &quot;.
+  - text: 'Entre las etiquetas de <code>style</code> , <code>16px</code> elementos <code>p</code> <code>font-size</code> de <code>font-size</code> de <code>16px</code> . El navegador y el zoom de texto deben estar al 100% &quot;.
     testString: 'assert(code.match(/p\s*{\s*font-size\s*:\s*16\s*px\s*;\s*}/i), "Between the <code>style</code> tags, give the <code>p</code> elements <code>font-size</code> of <code>16px</code>. Browser and Text zoom should be at 100%.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/override-all-other-styles-by-using-important.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/override-all-other-styles-by-using-important.spanish.md
index 2f2bd663bc..8ce099eec8 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/override-all-other-styles-by-using-important.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/override-all-other-styles-by-using-important.spanish.md
@@ -7,18 +7,18 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Yay! Acabamos de demostrar que los estilos en línea anularán todas las declaraciones de CSS en su elemento de <code>style</code> . 
-Pero espera. Hay una última forma de anular CSS. Este es el método más poderoso de todos. Pero antes de hacerlo, hablemos de por qué querría anular CSS. 
-En muchas situaciones, usarás bibliotecas CSS. Estos pueden anular accidentalmente su propio CSS. Entonces, cuando necesite estar absolutamente seguro de que un elemento tiene un CSS específico, puede usar <code>!important</code> 
-Volvamos a nuestra declaración de clase de <code>pink-text</code> . Recuerde que nuestra clase de <code>pink-text</code> fue anulada por las siguientes declaraciones de clase, declaraciones de id y estilos en línea. 
+<section id='description'>
+Yay! Acabamos de demostrar que los estilos en línea anularán todas las declaraciones de CSS en su elemento de <code>style</code> .
+Pero espera. Hay una última forma de anular CSS. Este es el método más poderoso de todos. Pero antes de hacerlo, hablemos de por qué querría anular CSS.
+En muchas situaciones, usarás bibliotecas CSS. Estos pueden anular accidentalmente su propio CSS. Entonces, cuando necesite estar absolutamente seguro de que un elemento tiene un CSS específico, puede usar <code>!important</code>
+Volvamos a nuestra declaración de clase de <code>pink-text</code> . Recuerde que nuestra clase de <code>pink-text</code> fue anulada por las siguientes declaraciones de clase, declaraciones de id y estilos en línea.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-¡Agreguemos la palabra clave <code>!important</code> para la declaración de color de su elemento de texto rosado para asegurarnos al 100% de que su elemento <code>h1</code> será rosa. 
-Un ejemplo de cómo hacer esto es: 
-<code>color: red !important;</code> 
+<section id='instructions'>
+¡Agreguemos la palabra clave <code>!important</code> para la declaración de color de su elemento de texto rosado para asegurarnos al 100% de que su elemento <code>h1</code> será rosa.
+Un ejemplo de cómo hacer esto es:
+<code>color: red !important;</code>
 </section>
 
 ## Tests
@@ -32,7 +32,7 @@ tests:
     testString: 'assert($("h1").hasClass("blue-text"), "Your <code>h1</code> element should have the class <code>blue-text</code>.");'
   - text: Su elemento <code>h1</code> debe tener el ID de <code>orange-text</code> .
     testString: 'assert($("h1").attr("id") === "orange-text", "Your <code>h1</code> element should have the id of <code>orange-text</code>.");'
-  - text: &#39;Su elemento <code>h1</code> debe tener el estilo de <code>color: white</code> &#39;.
+  - text: 'Su elemento <code>h1</code> debe tener el estilo de <code>color: white</code> '
     testString: 'assert(code.match(/<h1.*style/gi) && code.match(/<h1.*style.*color\s*?:/gi), "Your <code>h1</code> element should have the inline style of <code>color&#58; white</code>.");'
   - text: Su declaración de clase de <code>pink-text</code> debe tener la palabra clave <code>!important</code> para anular todas las demás declaraciones.
     testString: 'assert(code.match(/\.pink-text\s*?\{[\s\S]*?color:.*pink.*!important\s*;?[^\.]*\}/g), "Your <code>pink-text</code> class declaration should have the <code>!important</code> keyword to override all other declarations.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/prioritize-one-style-over-another.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/prioritize-one-style-over-another.spanish.md
index dfedf3d3fb..9f4ea92c89 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/prioritize-one-style-over-another.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/prioritize-one-style-over-another.spanish.md
@@ -7,16 +7,16 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-A veces, sus elementos HTML recibirán múltiples estilos que entren en conflicto entre sí. 
-Por ejemplo, su elemento <code>h1</code> no puede ser verde y rosa al mismo tiempo. 
-Veamos qué sucede cuando creamos una clase que hace que el texto sea rosa, luego lo aplicamos a un elemento. ¿Nuestra clase <em>anulará</em> el <code>color: green;</code> del elemento del <code>body</code> <code>color: green;</code> Propiedad CSS? 
+<section id='description'>
+A veces, sus elementos HTML recibirán múltiples estilos que entren en conflicto entre sí.
+Por ejemplo, su elemento <code>h1</code> no puede ser verde y rosa al mismo tiempo.
+Veamos qué sucede cuando creamos una clase que hace que el texto sea rosa, luego lo aplicamos a un elemento. ¿Nuestra clase <em>anulará</em> el <code>color: green;</code> del elemento del <code>body</code> <code>color: green;</code> Propiedad CSS?
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Crea una clase CSS llamada <code>pink-text</code> que le da a un elemento el color rosa. 
-Dale a tu elemento <code>h1</code> la clase de <code>pink-text</code> . 
+<section id='instructions'>
+Crea una clase CSS llamada <code>pink-text</code> que le da a un elemento el color rosa.
+Dale a tu elemento <code>h1</code> la clase de <code>pink-text</code> .
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ Dale a tu elemento <code>h1</code> la clase de <code>pink-text</code> .
 tests:
   - text: Su elemento <code>h1</code> debe tener la clase <code>pink-text</code> .
     testString: 'assert($("h1").hasClass("pink-text"), "Your <code>h1</code> element should have the class <code>pink-text</code>.");'
-  - text: &#39;Tu <code>&lt;style&gt;</code> debe tener una clase de CSS de <code>pink-text</code> que cambie el <code>color</code> .&#39;
+  - text: 'Tu <code>&lt;style&gt;</code> debe tener una clase de CSS de <code>pink-text</code> que cambie el <code>color</code> .'
     testString: 'assert(code.match(/\.pink-text\s*\{\s*color\s*:\s*.+\s*;\s*\}/g), "Your <code>&#60;style&#62;</code> should have a <code>pink-text</code> CSS class that changes the <code>color</code>.");'
   - text: Tu elemento <code>h1</code> debe ser rosa.
     testString: 'assert($("h1").css("color") === "rgb(255, 192, 203)", "Your <code>h1</code> element should be pink.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/specify-how-fonts-should-degrade.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/specify-how-fonts-should-degrade.spanish.md
index e3f9b3c295..70e47881a8 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/specify-how-fonts-should-degrade.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/specify-how-fonts-should-degrade.spanish.md
@@ -7,19 +7,19 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Hay varias fuentes predeterminadas que están disponibles en todos los navegadores. Estas familias de fuentes genéricas incluyen <code>monospace</code> , <code>serif</code> y <code>sans-serif</code> 
-Cuando una fuente no está disponible, puede indicar al navegador que se &quot;degrade&quot; a otra fuente. 
-Por ejemplo, si deseaba que un elemento usara la fuente <code>Helvetica</code> , pero se degradara a la <code>sans-serif</code> cuando <code>Helvetica</code> no estaba disponible, la especificará de la siguiente manera: 
-<blockquote>p {<br>&nbsp;&nbsp;font-family: Helvetica, sans-serif;<br>}</blockquote> 
-Los nombres genéricos de familia de fuentes no distinguen entre mayúsculas y minúsculas. Además, no necesitan comillas porque son palabras clave CSS. 
+<section id='description'>
+Hay varias fuentes predeterminadas que están disponibles en todos los navegadores. Estas familias de fuentes genéricas incluyen <code>monospace</code> , <code>serif</code> y <code>sans-serif</code>
+Cuando una fuente no está disponible, puede indicar al navegador que se &quot;degrade&quot; a otra fuente.
+Por ejemplo, si deseaba que un elemento usara la fuente <code>Helvetica</code> , pero se degradara a la <code>sans-serif</code> cuando <code>Helvetica</code> no estaba disponible, la especificará de la siguiente manera:
+<blockquote>p {<br>&nbsp;&nbsp;font-family: Helvetica, sans-serif;<br>}</blockquote>
+Los nombres genéricos de familia de fuentes no distinguen entre mayúsculas y minúsculas. Además, no necesitan comillas porque son palabras clave CSS.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Para empezar, aplique la fuente <code>monospace</code> al elemento <code>h2</code> , de modo que ahora tenga dos fuentes: <code>Lobster</code> y <code>monospace</code> . 
-En el último desafío, importó la fuente <code>Lobster</code> usando la etiqueta de <code>link</code> . Ahora comente la importación de la fuente <code>Lobster</code> (utilizando los comentarios HTML que aprendió anteriormente) de Google Fonts para que ya no esté disponible. Observe cómo su elemento <code>h2</code> se degrada a la fuente <code>monospace</code> . 
-<strong>Nota</strong> <br> Si tiene la fuente Lobster instalada en su computadora, no verá la degradación porque su navegador puede encontrar la fuente. 
+<section id='instructions'>
+Para empezar, aplique la fuente <code>monospace</code> al elemento <code>h2</code> , de modo que ahora tenga dos fuentes: <code>Lobster</code> y <code>monospace</code> .
+En el último desafío, importó la fuente <code>Lobster</code> usando la etiqueta de <code>link</code> . Ahora comente la importación de la fuente <code>Lobster</code> (utilizando los comentarios HTML que aprendió anteriormente) de Google Fonts para que ya no esté disponible. Observe cómo su elemento <code>h2</code> se degrada a la fuente <code>monospace</code> .
+<strong>Nota</strong> <br> Si tiene la fuente Lobster instalada en su computadora, no verá la degradación porque su navegador puede encontrar la fuente.
 </section>
 
 ## Tests
@@ -31,9 +31,9 @@ tests:
     testString: 'assert($("h2").css("font-family").match(/^"?lobster/i), "Your h2 element should use the font <code>Lobster</code>.");'
   - text: Su elemento h2 debería degradarse a la fuente <code>monospace</code> cuando <code>Lobster</code> no está disponible.
     testString: 'assert(/\s*h2\s*\{\s*font-family\:\s*(\"|")?Lobster(\"|")?,\s*monospace\s*;\s*\}/gi.test(code), "Your h2 element should degrade to the font <code>monospace</code> when <code>Lobster</code> is not available.");'
-  - text: Comente su llamada a Google para la fuente <code>Lobster</code> colocando <code>&lt;!--</code> delante de ella. &#39;
+  - text: Comente su llamada a Google para la fuente <code>Lobster</code> colocando <code>&lt;!--</code> delante de ella. '
     testString: 'assert(new RegExp("<!--[^fc]", "gi").test(code), "Comment out your call to Google for the <code>Lobster</code> font by putting <code>&#60!--</code> in front of it.");'
-  - text: &#39;Asegúrate de cerrar tu comentario agregando <code>--&gt;</code> .&#39;
+  - text: 'Asegúrate de cerrar tu comentario agregando <code>--&gt;</code> .'
     testString: 'assert(new RegExp("[^fc]-->", "gi").test(code), "Be sure to close your comment by adding <code>--&#62;</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-css-class-to-style-an-element.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-css-class-to-style-an-element.spanish.md
index 58429be0e6..cd691b9680 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-css-class-to-style-an-element.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-css-class-to-style-an-element.spanish.md
@@ -7,20 +7,20 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Las clases son estilos reutilizables que se pueden agregar a elementos HTML. 
-Aquí hay un ejemplo de declaración de clase CSS: 
-<blockquote>&#60;style&#62;<br>&nbsp;&nbsp;.blue-text {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: blue;<br>&nbsp;&nbsp;}<br>&#60;/style&#62;</blockquote> 
-Puede ver que hemos creado una clase CSS llamada <code>blue-text</code> dentro de la etiqueta <code>&lt;style&gt;</code> . 
-Puede aplicar una clase a un elemento HTML como este: 
-<code>&lt;h2 class=&quot;blue-text&quot;&gt;CatPhotoApp&lt;/h2&gt;</code> 
-Tenga en cuenta que en su elemento de <code>style</code> CSS, los nombres de clase comienzan con un punto. En el atributo de clase de los elementos HTML, el nombre de la clase no incluye el período. 
+<section id='description'>
+Las clases son estilos reutilizables que se pueden agregar a elementos HTML.
+Aquí hay un ejemplo de declaración de clase CSS:
+<blockquote>&#60;style&#62;<br>&nbsp;&nbsp;.blue-text {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: blue;<br>&nbsp;&nbsp;}<br>&#60;/style&#62;</blockquote>
+Puede ver que hemos creado una clase CSS llamada <code>blue-text</code> dentro de la etiqueta <code>&lt;style&gt;</code> .
+Puede aplicar una clase a un elemento HTML como este:
+<code>&lt;h2 class=&quot;blue-text&quot;&gt;CatPhotoApp&lt;/h2&gt;</code>
+Tenga en cuenta que en su elemento de <code>style</code> CSS, los nombres de clase comienzan con un punto. En el atributo de clase de los elementos HTML, el nombre de la clase no incluye el período.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Dentro de su elemento de <code>style</code> , cambie el selector <code>h2</code> a <code>.red-text</code> y actualice el valor del <code>blue</code> de <code>blue</code> a <code>red</code> . 
-Asigne a su elemento <code>h2</code> el atributo de <code>class</code> con un valor de <code>&#39;red-text&#39;</code> . 
+<section id='instructions'>
+Dentro de su elemento de <code>style</code> , cambie el selector <code>h2</code> a <code>.red-text</code> y actualice el valor del <code>blue</code> de <code>blue</code> a <code>red</code> .
+Asigne a su elemento <code>h2</code> el atributo de <code>class</code> con un valor de <code>&#39;red-text&#39;</code> .
 </section>
 
 ## Tests
@@ -34,7 +34,7 @@ tests:
     testString: 'assert($("h2").hasClass("red-text"), "Your <code>h2</code> element should have the class <code>red-text</code>.");'
   - text: Su hoja de estilo debe declarar una clase de <code>red-text</code> y tener su color establecido en rojo.
     testString: 'assert(code.match(/\.red-text\s*\{\s*color\s*:\s*red;\s*\}/g), "Your stylesheet should declare a <code>red-text</code> class and have its color set to red.");'
-  - text: &#39;No utilice declaraciones de estilo en línea como <code>style=&quot;color: red&quot;</code> en su elemento <code>h2</code> .&#39;
+  - text: 'No utilice declaraciones de estilo en línea como <code>style=&quot;color: red&quot;</code> en su elemento <code>h2</code> .'
     testString: 'assert($("h2").attr("style") === undefined, "Do not use inline style declarations like <code>style="color&#58; red"</code> in your <code>h2</code> element.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.spanish.md
index 7684b8c00f..a7fcf0d791 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-a-media-query-to-change-a-variable.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Las variables CSS pueden simplificar la forma en que utiliza las consultas de medios. 
-Por ejemplo, cuando su pantalla es más pequeña o más grande que el punto de interrupción de su consulta de medios, puede cambiar el valor de una variable y aplicará su estilo donde sea que se use. 
+<section id='description'>
+Las variables CSS pueden simplificar la forma en que utiliza las consultas de medios.
+Por ejemplo, cuando su pantalla es más pequeña o más grande que el punto de interrupción de su consulta de medios, puede cambiar el valor de una variable y aplicará su estilo donde sea que se use.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-En el <code>:root</code> selector de <code>:root</code> de la <code>media query</code> , cámbielo para que <code>--penguin-size</code> se redefina y se le dé un valor de <code>200px</code> . Además, redefine <code>--penguin-skin</code> y dale un valor de <code>black</code> . Luego cambie el tamaño de la vista previa para ver este cambio en acción. 
+<section id='instructions'>
+En el <code>:root</code> selector de <code>:root</code> de la <code>media query</code> , cámbielo para que <code>--penguin-size</code> se redefina y se le dé un valor de <code>200px</code> . Además, redefine <code>--penguin-skin</code> y dale un valor de <code>black</code> . Luego cambie el tamaño de la vista previa para ver este cambio en acción.
 </section>
 
 ## Tests
@@ -22,9 +22,9 @@ En el <code>:root</code> selector de <code>:root</code> de la <code>media query<
 
 ```yml
 tests:
-  - text: &#39; <code>:root</code> debe reasignar la variable <code>--penguin-size</code> a <code>200px</code> .&#39;
+  - text: ' <code>:root</code> debe reasignar la variable <code>--penguin-size</code> a <code>200px</code> .'
     testString: 'assert(code.match(/media\s*?\(\s*?max-width\s*?:\s*?350px\s*?\)\s*?{[\s\S]*:root\s*?{[\s\S]*--penguin-size\s*?:\s*?200px\s*?;[\s\S]*}[\s\S]*}/gi), "<code>:root</code> should reassign the <code>--penguin-size</code> variable to <code>200px</code>.");'
-  - text: &#39; <code>:root</code> debería reasignar la variable <code>--penguin-skin</code> a <code>black</code> &#39;.
+  - text: ' <code>:root</code> debería reasignar la variable <code>--penguin-skin</code> a <code>black</code> '
     testString: 'assert(code.match(/media\s*?\(\s*?max-width\s*?:\s*?350px\s*?\)\s*?{[\s\S]*:root\s*?{[\s\S]*--penguin-skin\s*?:\s*?black\s*?;[\s\S]*}[\s\S]*}/gi), "<code>:root</code> should reassign the <code>--penguin-skin</code> variable to <code>black</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-abbreviated-hex-code.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-abbreviated-hex-code.spanish.md
index 091adf2a3b..d0c5add338 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-abbreviated-hex-code.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-css/use-abbreviated-hex-code.spanish.md
@@ -7,16 +7,16 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Muchas personas se sienten abrumadas por las posibilidades de más de 16 millones de colores. Y es difícil recordar el código hexadecimal. Afortunadamente, puedes acortarlo. 
-Por ejemplo, el código hexadecimal de rojo <code>#FF0000</code> se puede acortar a <code>#F00</code> . Esta forma abreviada proporciona un dígito para el rojo, un dígito para el verde y un dígito para el azul. 
-Esto reduce el número total de colores posibles a alrededor de 4.000. Pero los navegadores interpretarán <code>#FF0000</code> y <code>#F00</code> como exactamente del mismo color. 
+<section id='description'>
+Muchas personas se sienten abrumadas por las posibilidades de más de 16 millones de colores. Y es difícil recordar el código hexadecimal. Afortunadamente, puedes acortarlo.
+Por ejemplo, el código hexadecimal de rojo <code>#FF0000</code> se puede acortar a <code>#F00</code> . Esta forma abreviada proporciona un dígito para el rojo, un dígito para el verde y un dígito para el azul.
+Esto reduce el número total de colores posibles a alrededor de 4.000. Pero los navegadores interpretarán <code>#FF0000</code> y <code>#F00</code> como exactamente del mismo color.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Adelante, intente usar los códigos hexadecimales abreviados para colorear los elementos correctos. 
-<table class='table table-striped'><tr><th> Color </th><th> Código hexadecimal corto </th></tr><tr><td> Cian </td><td> <code>#0FF</code> </td> </tr><tr><td> Verde </td><td> <code>#0F0</code> </td> </tr><tr><td> rojo </td><td> <code>#F00</code> </td> </tr><tr><td> Fucsia </td><td> <code>#F0F</code> </td> </tr></table> 
+<section id='instructions'>
+Adelante, intente usar los códigos hexadecimales abreviados para colorear los elementos correctos.
+<table class='table table-striped'><tr><th> Color </th><th> Código hexadecimal corto </th></tr><tr><td> Cian </td><td> <code>#0FF</code> </td> </tr><tr><td> Verde </td><td> <code>#0F0</code> </td> </tr><tr><td> rojo </td><td> <code>#F00</code> </td> </tr><tr><td> Fucsia </td><td> <code>#F0F</code> </td> </tr></table>
 </section>
 
 ## Tests
@@ -26,19 +26,19 @@ Adelante, intente usar los códigos hexadecimales abreviados para colorear los e
 tests:
   - text: ¡Da tu elemento <code>h1</code> con el texto <code>I am red!</code> El <code>color</code> rojo.
     testString: 'assert($(".red-text").css("color") === "rgb(255, 0, 0)", "Give your <code>h1</code> element with the text <code>I am red!</code> the <code>color</code> red.");'
-  - text: &#39;Use el <code>hex code</code> abreviado para el color rojo en lugar del código hexadecimal <code>#FF0000</code> .&#39;
+  - text: 'Use el <code>hex code</code> abreviado para el color rojo en lugar del código hexadecimal <code>#FF0000</code> .'
     testString: 'assert(code.match(/\.red-text\s*?{\s*?color:\s*?#F00\s*?;\s*?}/gi), "Use the abbreviate <code>hex code</code> for the color red instead of the hex code <code>#FF0000</code>.");'
   - text: ¡Da tu elemento <code>h1</code> con el texto <code>I am green!</code> El <code>color</code> verde.
     testString: 'assert($(".green-text").css("color") === "rgb(0, 255, 0)", "Give your <code>h1</code> element with the text <code>I am green!</code> the <code>color</code> green.");'
-  - text: &#39;Use el <code>hex code</code> abreviado para el color verde en lugar del código hexadecimal <code>#00FF00</code> .&#39;
+  - text: 'Use el <code>hex code</code> abreviado para el color verde en lugar del código hexadecimal <code>#00FF00</code> .'
     testString: 'assert(code.match(/\.green-text\s*?{\s*?color:\s*?#0F0\s*?;\s*?}/gi), "Use the abbreviated <code>hex code</code> for the color green instead of the hex code <code>#00FF00</code>.");'
   - text: ¡Da tu elemento <code>h1</code> con el texto <code>I am cyan!</code> El <code>color</code> cian.
     testString: 'assert($(".cyan-text").css("color") === "rgb(0, 255, 255)", "Give your <code>h1</code> element with the text <code>I am cyan!</code> the <code>color</code> cyan.");'
-  - text: &#39;Use el <code>hex code</code> abreviado para el color cian en lugar del código hexadecimal <code>#00FFFF</code> &#39;.
+  - text: 'Use el <code>hex code</code> abreviado para el color cian en lugar del código hexadecimal <code>#00FFFF</code> '
     testString: 'assert(code.match(/\.cyan-text\s*?{\s*?color:\s*?#0FF\s*?;\s*?}/gi), "Use the abbreviated <code>hex code</code> for the color cyan instead of the hex code <code>#00FFFF</code>.");'
   - text: ¡Da tu elemento <code>h1</code> con el texto <code>I am fuchsia!</code> El <code>color</code> fucsia.
     testString: 'assert($(".fuchsia-text").css("color") === "rgb(255, 0, 255)", "Give your <code>h1</code> element with the text <code>I am fuchsia!</code> the <code>color</code> fuchsia.");'
-  - text: &#39;Use el <code>hex code</code> abreviado para el color fucsia en lugar del código hexadecimal <code>#FF00FF</code> &#39;.
+  - text: 'Use el <code>hex code</code> abreviado para el color fucsia en lugar del código hexadecimal <code>#FF00FF</code> '
     testString: 'assert(code.match(/\.fuchsia-text\s*?{\s*?color:\s*?#F0F\s*?;\s*?}/gi), "Use the abbreviated <code>hex code</code> for the color fuchsia instead of the hex code <code>#FF00FF</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/add-a-submit-button-to-a-form.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/add-a-submit-button-to-a-form.spanish.md
index dd8585837e..6a69451230 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/add-a-submit-button-to-a-form.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/add-a-submit-button-to-a-form.spanish.md
@@ -8,15 +8,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Agreguemos un botón de <code>submit</code> a su formulario. Al hacer clic en este botón, los datos de su formulario se enviarán a la URL que especificó con el atributo de <code>action</code> su formulario. 
-Aquí hay un ejemplo de botón de envío: 
-<code>&lt;button type=&quot;submit&quot;&gt;this button submits the form&lt;/button&gt;</code> 
+<section id='description'>
+Agreguemos un botón de <code>submit</code> a su formulario. Al hacer clic en este botón, los datos de su formulario se enviarán a la URL que especificó con el atributo de <code>action</code> su formulario.
+Aquí hay un ejemplo de botón de envío:
+<code>&lt;button type=&quot;submit&quot;&gt;this button submits the form&lt;/button&gt;</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue un botón como el último elemento de su elemento de <code>form</code> con un tipo de <code>submit</code> y &quot;Enviar&quot; como texto. 
+<section id='instructions'>
+Agregue un botón como el último elemento de su elemento de <code>form</code> con un tipo de <code>submit</code> y &quot;Enviar&quot; como texto.
 </section>
 
 ## Tests
@@ -28,7 +28,7 @@ tests:
     testString: 'assert($("form").children("button").length > 0, "Your form should have a button inside it.");'
   - text: El botón de envío debe tener el atributo <code class = "notranslate"> type </code> establecido en <code class = "notranslate"> submit </code>.
     testString: 'assert($("button").attr("type") === "submit", "Your submit button should have the attribute <code>type</code> set to <code>submit</code>.");'
-  - text: Su botón de enviar solo debe tener el texto "Enviar".
+  - text: Su botón de enviar solo debe tener el texto "Enviar."
     testString: 'assert($("button").text().match(/^\s*submit\s*$/gi), "Your submit button should only have the text "Submit".");'
   - text: Asegúrese de que su elemento <code class = "notranslate"> button </code> tenga una etiqueta de cierre.
     testString: 'assert(code.match(/<\/button>/g) && code.match(/<button/g) && code.match(/<\/button>/g).length === code.match(/<button/g).length, "Make sure your <code>button</code> element has a closing tag.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/comment-out-html.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/comment-out-html.spanish.md
index feb79097a9..ce96f21766 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/comment-out-html.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/comment-out-html.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Recuerde que para iniciar un comentario, debe usar <code>&lt;!--</code> y para finalizar un comentario, debe usar <code>--&gt;</code> 
-Aquí deberá finalizar el comentario antes de que comience su elemento <code>h2</code> . 
+<section id='description'>
+Recuerde que para iniciar un comentario, debe usar <code>&lt;!--</code> y para finalizar un comentario, debe usar <code>--&gt;</code>
+Aquí deberá finalizar el comentario antes de que comience su elemento <code>h2</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Comente su elemento <code>h1</code> y su elemento <code>p</code> , pero no su elemento <code>h2</code> . 
+<section id='instructions'>
+Comente su elemento <code>h1</code> y su elemento <code>p</code> , pero no su elemento <code>h2</code> .
 </section>
 
 ## Tests
@@ -28,7 +28,7 @@ tests:
     testString: 'assert(($("h2").length > 0), "Leave your <code>h2</code> element uncommented so that it is visible on your page.");'
   - text: Comenta tu elemento <code>p</code> para que no se vea en tu página.
     testString: 'assert(($("p").length === 0), "Comment out your <code>p</code> element so that it is not visible on your page.");'
-  - text: &#39;Asegúrese de cerrar cada uno de sus comentarios con <code>--&gt;</code> .&#39;
+  - text: 'Asegúrese de cerrar cada uno de sus comentarios con <code>--&gt;</code> .'
     testString: 'assert(code.match(/[^fc]-->/g).length > 1, "Be sure to close each of your comments with <code>--&#62;</code>.");'
   - text: No cambie el orden de <code>h1</code> <code>h2</code> o <code>p</code> en el código.
     testString: 'assert((code.match(/<([a-z0-9]){1,2}>/g)[0]==="<h1>" && code.match(/<([a-z0-9]){1,2}>/g)[1]==="<h2>" && code.match(/<([a-z0-9]){1,2}>/g)[2]==="<p>") , "Do not change the order of the <code>h1</code> <code>h2</code> or <code>p</code> in the code.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-external-pages-with-anchor-elements.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-external-pages-with-anchor-elements.spanish.md
index 48d03d0473..57feba60b8 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-external-pages-with-anchor-elements.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-external-pages-with-anchor-elements.spanish.md
@@ -7,17 +7,17 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Puede usar elementos de <code>anchor</code> para vincular contenido fuera de su página web. 
-elementos de <code>anchor</code> 
-necesitan una dirección web de destino denominada atributo <code>href</code> . También necesitan texto de anclaje. Aquí hay un ejemplo: 
-<code>&lt;a href=&quot;https://freecodecamp.org&quot;&gt;this links to freecodecamp.org&lt;/a&gt;</code> 
-Entonces su navegador mostrará el texto <strong>&quot;esto enlaza a freecodecamp.org&quot;</strong> como un enlace que puede hacer clic. Y ese enlace lo llevará a la dirección web <strong>https://spanish.freecodecamp.org</strong> . 
+<section id='description'>
+Puede usar elementos de <code>anchor</code> para vincular contenido fuera de su página web.
+elementos de <code>anchor</code>
+necesitan una dirección web de destino denominada atributo <code>href</code> . También necesitan texto de anclaje. Aquí hay un ejemplo:
+<code>&lt;a href=&quot;https://freecodecamp.org&quot;&gt;this links to freecodecamp.org&lt;/a&gt;</code>
+Entonces su navegador mostrará el texto <strong>&quot;esto enlaza a freecodecamp.org&quot;</strong> como un enlace que puede hacer clic. Y ese enlace lo llevará a la dirección web <strong>https://spanish.freecodecamp.org</strong> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Crear una <code>a</code> elemento que une a <code>http://freecatphotoapp.com</code> y tiene &quot;fotos del gato&quot; como su <code>anchor text</code> . 
+<section id='instructions'>
+Crear una <code>a</code> elemento que une a <code>http://freecatphotoapp.com</code> y tiene &quot;fotos del gato&quot; como su <code>anchor text</code> .
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ Crear una <code>a</code> elemento que une a <code>http://freecatphotoapp.com</co
 tests:
   - text: Su <code>a</code> elemento debe tener el <code>anchor text</code> de fotos &quot;gato&quot;.
     testString: 'assert((/cat photos/gi).test($("a").text()), "Your <code>a</code> element should have the <code>anchor text</code> of "cat photos".");'
-  - text: &#39;Es necesario un <code>a</code> elemento que une a <code>http://freecatphotoapp .com</code> &#39;
+  - text: 'Es necesario un <code>a</code> elemento que une a <code>http://freecatphotoapp .com</code> '
     testString: 'assert(/http:\/\/(www\.)?freecatphotoapp\.com/gi.test($("a").attr("href")), "You need an <code>a</code> element that links to <code>http&#58;//freecatphotoapp<wbr>.com</code>");'
   - text: Asegúrese de que su <code>a</code> elemento tiene una etiqueta de cierre.
     testString: 'assert(code.match(/<\/a>/g) && code.match(/<\/a>/g).length === code.match(/<a/g).length, "Make sure your <code>a</code> element has a closing tag.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-internal-sections-of-a-page-with-anchor-elements.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-internal-sections-of-a-page-with-anchor-elements.spanish.md
index 5b37b61ece..f091623d98 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-internal-sections-of-a-page-with-anchor-elements.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/link-to-internal-sections-of-a-page-with-anchor-elements.spanish.md
@@ -7,19 +7,19 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Los elementos de anclaje también se pueden usar para crear enlaces internos para saltar a diferentes secciones dentro de una página web. 
-Para crear un enlace interno, asigna el atributo <code>href</code> un enlace a un símbolo de hash <code>#</code> más el valor del atributo <code>id</code> para el elemento al que desea enlazar internamente, generalmente más abajo en la página. A continuación, deberá agregar el mismo atributo de <code>id</code> al elemento al que se está vinculando. Un <code>id</code> es un atributo que describe de forma única un elemento. 
-A continuación se muestra un ejemplo de un enlace de anclaje interno y su elemento de destino: 
-<blockquote>&lt;a href="#contacts-header"&gt;Contacts&lt;/a&gt;<br>...<br>&lt;h2 id="contacts-header"&gt;Contacts&lt;/h2&gt;</blockquote> 
-Cuando los usuarios hacen clic en el enlace de Contactos, serán llevados a la sección de la página web con el elemento del encabezado de <b>Contactos</b> . 
+<section id='description'>
+Los elementos de anclaje también se pueden usar para crear enlaces internos para saltar a diferentes secciones dentro de una página web.
+Para crear un enlace interno, asigna el atributo <code>href</code> un enlace a un símbolo de hash <code>#</code> más el valor del atributo <code>id</code> para el elemento al que desea enlazar internamente, generalmente más abajo en la página. A continuación, deberá agregar el mismo atributo de <code>id</code> al elemento al que se está vinculando. Un <code>id</code> es un atributo que describe de forma única un elemento.
+A continuación se muestra un ejemplo de un enlace de anclaje interno y su elemento de destino:
+<blockquote>&lt;a href="#contacts-header"&gt;Contacts&lt;/a&gt;<br>...<br>&lt;h2 id="contacts-header"&gt;Contacts&lt;/h2&gt;</blockquote>
+Cuando los usuarios hacen clic en el enlace de Contactos, serán llevados a la sección de la página web con el elemento del encabezado de <b>Contactos</b> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambie su enlace externo a un enlace interno cambiando el atributo <code>href</code> a &quot;# footer&quot; y el texto de &quot;fotos del gato&quot; a &quot;Saltar a la parte inferior&quot;. 
-Elimine el atributo <code>target=&quot;_blank&quot;</code> de la etiqueta de anclaje ya que esto hace que el documento vinculado se abra en una nueva pestaña de ventana. 
-Luego agregue un atributo <code>id</code> con un valor de &quot;pie de página&quot; al elemento <code>&lt;footer&gt;</code> en la parte inferior de la página. 
+<section id='instructions'>
+Cambie su enlace externo a un enlace interno cambiando el atributo <code>href</code> a &quot;# footer&quot; y el texto de &quot;fotos del gato&quot; a &quot;Saltar a la parte inferior&quot;.
+Elimine el atributo <code>target=&quot;_blank&quot;</code> de la etiqueta de anclaje ya que esto hace que el documento vinculado se abra en una nueva pestaña de ventana.
+Luego agregue un atributo <code>id</code> con un valor de &quot;pie de página&quot; al elemento <code>&lt;footer&gt;</code> en la parte inferior de la página.
 </section>
 
 ## Tests
@@ -35,9 +35,9 @@ tests:
     testString: 'assert($("a").eq(0).attr("href") == "#footer", "The <code>a</code> tag should have an <code>href</code> attribute set to "#footer".");'
   - text: La etiqueta <code class = "notranslate"> a </code> no debe tener el atributo <code class = "notranslate"> target </code>
     testString: 'assert(typeof $("a").eq(0).attr("target") == typeof undefined || $("a").eq(0).attr("target") == true, "The <code>a</code> tag should not have a <code>target</code> attribute");'
-  - text: El <code class = "notranslate"> un texto </code> debe ser "Jump to Bottom".
+  - text: El <code class = "notranslate"> un texto </code> debe ser "Jump to Bottom."
     testString: 'assert($("a").eq(0).text().match(/Jump to Bottom/gi), "The <code>a</code> text should be "Jump to Bottom".");'
-  - text: La etiqueta <code class = "notranslate"> footer </code> debe tener un atributo <code class = "notranslate"> id </code> establecido en "footer".
+  - text: La etiqueta <code class = "notranslate"> footer </code> debe tener un atributo <code class = "notranslate"> id </code> establecido en "footer."
     testString: 'assert($("footer").eq(0).attr("id") == "footer", "The <code>footer</code> tag should have an <code>id</code> attribute set to "footer".");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/make-dead-links-using-the-hash-symbol.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/make-dead-links-using-the-hash-symbol.spanish.md
index b1f24f6694..a5ebd0a641 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/make-dead-links-using-the-hash-symbol.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/make-dead-links-using-the-hash-symbol.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-veces que desea agregar <code>a</code> los elementos a su sitio web antes de saber donde van a unir. 
-Esto también es útil cuando está cambiando el comportamiento de un enlace usando <code>JavaScript</code> , que conoceremos más adelante. 
+<section id='description'>
+veces que desea agregar <code>a</code> los elementos a su sitio web antes de saber donde van a unir.
+Esto también es útil cuando está cambiando el comportamiento de un enlace usando <code>JavaScript</code> , que conoceremos más adelante.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El valor actual del atributo <code>href</code> es un enlace que apunta a &quot;http://freecatphotoapp.com&quot;. Reemplace el valor del atributo <code>href</code> con un <code>#</code> , también conocido como símbolo de hash, para crear un enlace muerto. 
-Por ejemplo: <code>href=&quot;#&quot;</code> 
+<section id='instructions'>
+El valor actual del atributo <code>href</code> es un enlace que apunta a &quot;http://freecatphotoapp.com&quot;. Reemplace el valor del atributo <code>href</code> con un <code>#</code> , también conocido como símbolo de hash, para crear un enlace muerto.
+Por ejemplo: <code>href=&quot;#&quot;</code>
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Por ejemplo: <code>href=&quot;#&quot;</code>
 
 ```yml
 tests:
-  - text: &#39;Su <code>a</code> elemento debe ser un vínculo roto con el valor de la <code>href</code> atributo establecido en &#39;#&#39;.&#39;
+  - text: 'Su <code>a</code> elemento debe ser un vínculo roto con el valor de la <code>href</code> atributo establecido en &#39;#&#39;.'
     testString: 'assert($("a").attr("href") === "#", "Your <code>a</code> element should be a dead link with the value of the <code>href</code> attribute set to "#".");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/nest-an-anchor-element-within-a-paragraph.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/nest-an-anchor-element-within-a-paragraph.spanish.md
index f90e691e42..0062986721 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/nest-an-anchor-element-within-a-paragraph.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/nest-an-anchor-element-within-a-paragraph.spanish.md
@@ -7,21 +7,21 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Puede anidar enlaces dentro de otros elementos de texto. 
-<blockquote>&#60;p&#62;<br> Here's a &#60;a target="_blank" href="http://freecodecamp.org"&#62; link to freecodecamp.org&#60;/a&#62; for you to follow.<br>&#60;/p&#62;</blockquote> 
-Desglosemos el ejemplo: 
-El texto normal se ajusta en el elemento <code>p</code> : <br> <code>&lt;p&gt; Here&#39;s a ... for you to follow. &lt;/p&gt;</code> 
-siguiente es el elemento de <code>anchor</code> <code>&lt;a&gt;</code> (que requiere una etiqueta de cierre <code>&lt;/a&gt;</code> ): <br> <code>&lt;a&gt; ... &lt;/a&gt;</code> 
-<code>target</code> es un atributo de etiqueta de anclaje que especifica dónde abrir el enlace y el valor <code>&quot;_blank&quot;</code> especifica que se abra el enlace en una nueva pestaña 
-<code>href</code> es un atributo de etiqueta de anclaje que contiene la URL Dirección del enlace: <br> <code>&lt;a href=&quot;http://freecodecamp.org&quot;&gt; ... &lt;/a&gt;</code> 
-El texto, <strong>&quot;link to freecodecamp.org&quot;</strong> , dentro del elemento de <code>anchor text</code> llamado <code>anchor text</code> , mostrará un enlace para hacer clic: <br> <code>&lt;a href=&quot; ... &quot;&gt;link to freecodecamp.org&lt;/a&gt;</code> 
-La salida final del ejemplo se verá así: <br><p> Aquí hay un <a target="_blank" href="http://freecodecamp.org">enlace a freecodecamp.org</a> para que lo sigas. </p> 
+<section id='description'>
+Puede anidar enlaces dentro de otros elementos de texto.
+<blockquote>&#60;p&#62;<br> Here's a &#60;a target="_blank" href="http://freecodecamp.org"&#62; link to freecodecamp.org&#60;/a&#62; for you to follow.<br>&#60;/p&#62;</blockquote>
+Desglosemos el ejemplo:
+El texto normal se ajusta en el elemento <code>p</code> : <br> <code>&lt;p&gt; Here&#39;s a ... for you to follow. &lt;/p&gt;</code>
+siguiente es el elemento de <code>anchor</code> <code>&lt;a&gt;</code> (que requiere una etiqueta de cierre <code>&lt;/a&gt;</code> ): <br> <code>&lt;a&gt; ... &lt;/a&gt;</code>
+<code>target</code> es un atributo de etiqueta de anclaje que especifica dónde abrir el enlace y el valor <code>&quot;_blank&quot;</code> especifica que se abra el enlace en una nueva pestaña
+<code>href</code> es un atributo de etiqueta de anclaje que contiene la URL Dirección del enlace: <br> <code>&lt;a href=&quot;http://freecodecamp.org&quot;&gt; ... &lt;/a&gt;</code>
+El texto, <strong>&quot;link to freecodecamp.org&quot;</strong> , dentro del elemento de <code>anchor text</code> llamado <code>anchor text</code> , mostrará un enlace para hacer clic: <br> <code>&lt;a href=&quot; ... &quot;&gt;link to freecodecamp.org&lt;/a&gt;</code>
+La salida final del ejemplo se verá así: <br><p> Aquí hay un <a target="_blank" href="http://freecodecamp.org">enlace a freecodecamp.org</a> para que lo sigas. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Ahora nido de su actual <code>a</code> elemento dentro de un nuevo <code>p</code> elemento (justo a continuación de la <code>main</code> elemento). El nuevo párrafo debe tener un texto que diga &quot;Ver más fotos de gatos&quot;, donde &quot;fotos de gatos&quot; es un enlace, y el resto del texto es texto sin formato. 
+<section id='instructions'>
+Ahora nido de su actual <code>a</code> elemento dentro de un nuevo <code>p</code> elemento (justo a continuación de la <code>main</code> elemento). El nuevo párrafo debe tener un texto que diga &quot;Ver más fotos de gatos&quot;, donde &quot;fotos de gatos&quot; es un enlace, y el resto del texto es texto sin formato.
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ Ahora nido de su actual <code>a</code> elemento dentro de un nuevo <code>p</code
 
 ```yml
 tests:
-  - text: &#39;Es necesario un <code>a</code> elemento que une a &#39;http://freecatphotoapp.com&#39;.&#39;
+  - text: 'Es necesario un <code>a</code> elemento que une a &#39;http://freecatphotoapp.com&#39;.'
     testString: 'assert(($("a[href=\"http://freecatphotoapp.com\"]").length > 0 || $("a[href=\"http://www.freecatphotoapp.com\"]").length > 0), "You need an <code>a</code> element that links to "http://freecatphotoapp.com".");'
   - text: Su <code>a</code> elemento debe tener el texto de anclaje de fotos &quot;gato&quot;
     testString: 'assert($("a").text().match(/cat\sphotos/gi), "Your <code>a</code> element should have the anchor text of "cat photos"");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.spanish.md
index a0c8b48ef3..d91ae7ebac 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.spanish.md
@@ -7,17 +7,17 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Se puede hacer elementos en enlaces anidando dentro de un <code>a</code> elemento. 
-Nido de su imagen dentro de un <code>a</code> elemento. Aquí hay un ejemplo: 
-<code>&lt;a href=&quot;#&quot;&gt;&lt;img src=&quot;https://bit.ly/fcc-running-cats&quot; alt=&quot;Three kittens running towards the camera.&quot;&gt;&lt;/a&gt;</code> 
-Recuerda usar <code>#</code> como la propiedad <code>href</code> <code>a</code> elemento para convertirlo en un enlace muerto. 
+<section id='description'>
+Se puede hacer elementos en enlaces anidando dentro de un <code>a</code> elemento.
+Nido de su imagen dentro de un <code>a</code> elemento. Aquí hay un ejemplo:
+<code>&lt;a href=&quot;#&quot;&gt;&lt;img src=&quot;https://bit.ly/fcc-running-cats&quot; alt=&quot;Three kittens running towards the camera.&quot;&gt;&lt;/a&gt;</code>
+Recuerda usar <code>#</code> como la propiedad <code>href</code> <code>a</code> elemento para convertirlo en un enlace muerto.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Coloque el elemento de imagen existente dentro de un elemento de anclaje. 
-Una vez que hayas hecho esto, desplázate sobre tu imagen con el cursor. El puntero normal de su cursor debe convertirse en el enlace que hace clic en el puntero. La foto es ahora un enlace. 
+<section id='instructions'>
+Coloque el elemento de imagen existente dentro de un elemento de anclaje.
+Una vez que hayas hecho esto, desplázate sobre tu imagen con el cursor. El puntero normal de su cursor debe convertirse en el enlace que hace clic en el puntero. La foto es ahora un enlace.
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ Una vez que hayas hecho esto, desplázate sobre tu imagen con el cursor. El punt
 tests:
   - text: Nido el vigente <code>img</code> elemento dentro de un <code>a</code> elemento.
     testString: 'assert($("a").children("img").length > 0, "Nest the existing <code>img</code> element within an <code>a</code> element.");'
-  - text: &#39;Su <code>a</code> elemento debe ser un vínculo roto con un <code>href</code> atributo establecido en <code>#</code> .&#39;
+  - text: 'Su <code>a</code> elemento debe ser un vínculo roto con un <code>href</code> atributo establecido en <code>#</code> .'
     testString: 'assert(new RegExp("#").test($("a").children("img").parent().attr("href")), "Your <code>a</code> element should be a dead link with a <code>href</code> attribute set to <code>#</code>.");'
   - text: Asegúrese de que cada uno de sus <code>a</code> elementos tiene una etiqueta de cierre.
     testString: 'assert(code.match(/<\/a>/g) && code.match(/<a/g) && code.match(/<\/a>/g).length === code.match(/<a/g).length, "Make sure each of your <code>a</code> elements has a closing tag.");'
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/uncomment-html.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/uncomment-html.spanish.md
index 25883d997c..7f764c3280 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/uncomment-html.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/basic-html-and-html5/uncomment-html.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-comentarios son una forma en la que puede dejar comentarios para otros desarrolladores dentro de su código sin afectar el resultado resultante que se muestra al usuario final. 
-comentarios también son una forma conveniente de desactivar el código sin tener que eliminarlo por completo. 
-comentarios en HTML comienzan con <code>&lt;!--</code> , y terminan con un <code>--&gt;</code> 
+<section id='description'>
+comentarios son una forma en la que puede dejar comentarios para otros desarrolladores dentro de su código sin afectar el resultado resultante que se muestra al usuario final.
+comentarios también son una forma conveniente de desactivar el código sin tener que eliminarlo por completo.
+comentarios en HTML comienzan con <code>&lt;!--</code> , y terminan con un <code>--&gt;</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Descomenta tus elementos <code>h1</code> , <code>h2</code> <code>p</code> . 
+<section id='instructions'>
+Descomenta tus elementos <code>h1</code> , <code>h2</code> <code>p</code> .
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ tests:
     testString: 'assert($("h2").length > 0, "Make your <code>h2</code> element visible on your page by uncommenting it.");'
   - text: Haz que tu elemento <code>p</code> visible en tu página descomprimiéndolo.
     testString: 'assert($("p").length > 0, "Make your <code>p</code> element visible on your page by uncommenting it.");'
-  - text: &#39;Asegúrese de eliminar todas las etiquetas de comentarios finales, es decir, <code>--&gt;</code> .&#39;
+  - text: 'Asegúrese de eliminar todas las etiquetas de comentarios finales, es decir, <code>--&gt;</code> .'
     testString: 'assert(!/[^fc]-->/gi.test(code.replace(/ *<!--[^fc]*\n/g,"")), "Be sure to delete all trailing comment tags&#44; i.e. <code>--&#62;</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-align-items-property.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-align-items-property.spanish.md
index 6baad054e8..9956adc74e 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-align-items-property.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-align-items-property.spanish.md
@@ -7,18 +7,18 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-La propiedad <code>align-items</code> es similar a <code>justify-content</code> . Recuerde que la propiedad justify <code>justify-content</code> alineaba elementos flexibles a lo largo del eje principal. Para las filas, el eje principal es una línea horizontal y para las columnas es una línea vertical. 
-Los contenedores Flex también tienen un <strong>eje transversal</strong> que es el opuesto al eje principal. Para las filas, el eje transversal es vertical y para las columnas, el eje transversal es horizontal. 
-CSS ofrece la propiedad <code>align-items</code> para alinear elementos flexibles a lo largo del eje transversal. Para una fila, le dice a CSS cómo empujar los elementos en toda la fila hacia arriba o hacia abajo dentro del contenedor. Y para una columna, cómo empujar todos los elementos a la izquierda o derecha dentro del contenedor. 
-Los diferentes valores disponibles para <code>align-items</code> de <code>align-items</code> incluyen: 
-<ul><li> <code>flex-start</code> : alinea los elementos con el inicio del contenedor flexible. Para las filas, esto alinea los elementos con la parte superior del contenedor. Para las columnas, esto alinea los elementos a la izquierda del contenedor. </li><li> <code>flex-end</code> : alinea los elementos con el extremo del contenedor flexible. Para las filas, esto alinea los elementos con la parte inferior del contenedor. Para las columnas, esto alinea los elementos a la derecha del contenedor. </li><li> <code>center</code> : alinea los elementos al centro. Para las filas, esto alinea los elementos verticalmente (espacio igual por encima y por debajo de los elementos). Para las columnas, esto los alinea horizontalmente (espacio igual a la izquierda y derecha de los elementos). </li><li> <code>stretch</code> : estirar los elementos para llenar el contenedor flexible. Por ejemplo, los elementos de las filas se estiran para llenar el contenedor flexible de arriba a abajo. </li><li> <code>baseline</code> : alinear los elementos a sus líneas de base. La línea de base es un concepto de texto, piénselo como la línea en la que se encuentran las letras. </li></ul> 
+<section id='description'>
+La propiedad <code>align-items</code> es similar a <code>justify-content</code> . Recuerde que la propiedad justify <code>justify-content</code> alineaba elementos flexibles a lo largo del eje principal. Para las filas, el eje principal es una línea horizontal y para las columnas es una línea vertical.
+Los contenedores Flex también tienen un <strong>eje transversal</strong> que es el opuesto al eje principal. Para las filas, el eje transversal es vertical y para las columnas, el eje transversal es horizontal.
+CSS ofrece la propiedad <code>align-items</code> para alinear elementos flexibles a lo largo del eje transversal. Para una fila, le dice a CSS cómo empujar los elementos en toda la fila hacia arriba o hacia abajo dentro del contenedor. Y para una columna, cómo empujar todos los elementos a la izquierda o derecha dentro del contenedor.
+Los diferentes valores disponibles para <code>align-items</code> de <code>align-items</code> incluyen:
+<ul><li> <code>flex-start</code> : alinea los elementos con el inicio del contenedor flexible. Para las filas, esto alinea los elementos con la parte superior del contenedor. Para las columnas, esto alinea los elementos a la izquierda del contenedor. </li><li> <code>flex-end</code> : alinea los elementos con el extremo del contenedor flexible. Para las filas, esto alinea los elementos con la parte inferior del contenedor. Para las columnas, esto alinea los elementos a la derecha del contenedor. </li><li> <code>center</code> : alinea los elementos al centro. Para las filas, esto alinea los elementos verticalmente (espacio igual por encima y por debajo de los elementos). Para las columnas, esto los alinea horizontalmente (espacio igual a la izquierda y derecha de los elementos). </li><li> <code>stretch</code> : estirar los elementos para llenar el contenedor flexible. Por ejemplo, los elementos de las filas se estiran para llenar el contenedor flexible de arriba a abajo. </li><li> <code>baseline</code> : alinear los elementos a sus líneas de base. La línea de base es un concepto de texto, piénselo como la línea en la que se encuentran las letras. </li></ul>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Un ejemplo ayuda a mostrar esta propiedad en acción. Agregue la propiedad CSS <code>align-items</code> al <code>align-items</code> <code>#box-container</code> y asígnele un valor de center. 
-<strong>Bonus</strong> <br> Pruebe las otras opciones para la propiedad <code>align-items</code> en el editor de código para ver sus diferencias. Pero tenga en cuenta que un valor de centro es el único que pasará este desafío. 
+<section id='instructions'>
+Un ejemplo ayuda a mostrar esta propiedad en acción. Agregue la propiedad CSS <code>align-items</code> al <code>align-items</code> <code>#box-container</code> y asígnele un valor de center.
+<strong>Bonus</strong> <br> Pruebe las otras opciones para la propiedad <code>align-items</code> en el editor de código para ver sus diferencias. Pero tenga en cuenta que un valor de centro es el único que pasará este desafío.
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ Un ejemplo ayuda a mostrar esta propiedad en acción. Agregue la propiedad CSS <
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-container</code> debería tener una propiedad <code>align-items</code> establecida en un valor de center.&#39;
+  - text: 'El elemento <code>#box-container</code> debería tener una propiedad <code>align-items</code> establecida en un valor de center.'
     testString: 'assert($("#box-container").css("align-items") == "center", "The <code>#box-container</code> element should have an <code>align-items</code> property set to a value of center.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.spanish.md
index 633bfc56d5..6f5c2b892c 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/align-elements-using-the-justify-content-property.spanish.md
@@ -7,18 +7,18 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-A veces, los elementos flexibles dentro de un contenedor flexible no llenan todo el espacio en el contenedor. Es común querer decirle a CSS cómo alinear y espaciar los elementos flexibles de una determinada manera. Afortunadamente, la propiedad <code>justify-content</code> tiene varias opciones para hacer esto. Pero primero, hay una terminología importante que entender antes de revisar esas opciones. 
-<a href="https://www.w3.org/TR/css-flexbox-1/images/flex-direction-terms.svg" target="_blank">Aquí hay una imagen útil que muestra una fila para ilustrar los conceptos a continuación.</a> 
-Recuerde que la configuración de un contenedor flexible como una fila coloca los elementos flexibles uno al lado del otro de izquierda a derecha. Un contenedor flexible configurado como una columna coloca los elementos flexibles en una pila vertical de arriba a abajo. Para cada uno, la dirección en la que se disponen los elementos flexibles se denomina <strong>eje principal</strong> . Para una fila, esta es una línea horizontal que corta cada elemento. Y para una columna, el eje principal es una línea vertical a través de los elementos. 
-Hay varias opciones sobre cómo espaciar los elementos flexibles a lo largo de la línea que es el eje principal. Uno de los más utilizados es <code>justify-content: center;</code> , que alinea todos los elementos flexibles con el centro dentro del contenedor flexible. Otras opciones incluyen: 
-<ul><li> <code>flex-start</code> : alinea los elementos con el inicio del contenedor flexible. Para una fila, esto empuja los artículos a la izquierda del contenedor. Para una columna, esto empuja los elementos a la parte superior del contenedor. </li><li> <code>flex-end</code> : alinea los elementos con el extremo del contenedor flexible. Para una fila, esto empuja los artículos a la derecha del contenedor. Para una columna, esto empuja los artículos a la parte inferior del contenedor. </li><li> <code>space-between</code> : alinea elementos al centro del eje principal, con espacio adicional colocado entre los elementos. Los primeros y últimos elementos se empujan hasta el borde del contenedor flexible. Por ejemplo, en una fila, el primer elemento está contra el lado izquierdo del contenedor, el último elemento está contra el lado derecho del contenedor, luego los otros elementos entre ellos están espaciados uniformemente. </li><li> <code>space-around</code> : similar al <code>space-between</code> pero los elementos primero y último no están bloqueados en los bordes del contenedor, el espacio se distribuye alrededor de todos los elementos </li></ul> 
+<section id='description'>
+A veces, los elementos flexibles dentro de un contenedor flexible no llenan todo el espacio en el contenedor. Es común querer decirle a CSS cómo alinear y espaciar los elementos flexibles de una determinada manera. Afortunadamente, la propiedad <code>justify-content</code> tiene varias opciones para hacer esto. Pero primero, hay una terminología importante que entender antes de revisar esas opciones.
+<a href="https://www.w3.org/TR/css-flexbox-1/images/flex-direction-terms.svg" target="_blank">Aquí hay una imagen útil que muestra una fila para ilustrar los conceptos a continuación.</a>
+Recuerde que la configuración de un contenedor flexible como una fila coloca los elementos flexibles uno al lado del otro de izquierda a derecha. Un contenedor flexible configurado como una columna coloca los elementos flexibles en una pila vertical de arriba a abajo. Para cada uno, la dirección en la que se disponen los elementos flexibles se denomina <strong>eje principal</strong> . Para una fila, esta es una línea horizontal que corta cada elemento. Y para una columna, el eje principal es una línea vertical a través de los elementos.
+Hay varias opciones sobre cómo espaciar los elementos flexibles a lo largo de la línea que es el eje principal. Uno de los más utilizados es <code>justify-content: center;</code> , que alinea todos los elementos flexibles con el centro dentro del contenedor flexible. Otras opciones incluyen:
+<ul><li> <code>flex-start</code> : alinea los elementos con el inicio del contenedor flexible. Para una fila, esto empuja los artículos a la izquierda del contenedor. Para una columna, esto empuja los elementos a la parte superior del contenedor. </li><li> <code>flex-end</code> : alinea los elementos con el extremo del contenedor flexible. Para una fila, esto empuja los artículos a la derecha del contenedor. Para una columna, esto empuja los artículos a la parte inferior del contenedor. </li><li> <code>space-between</code> : alinea elementos al centro del eje principal, con espacio adicional colocado entre los elementos. Los primeros y últimos elementos se empujan hasta el borde del contenedor flexible. Por ejemplo, en una fila, el primer elemento está contra el lado izquierdo del contenedor, el último elemento está contra el lado derecho del contenedor, luego los otros elementos entre ellos están espaciados uniformemente. </li><li> <code>space-around</code> : similar al <code>space-between</code> pero los elementos primero y último no están bloqueados en los bordes del contenedor, el espacio se distribuye alrededor de todos los elementos </li></ul>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Un ejemplo ayuda a mostrar esta propiedad en acción. Agregue la propiedad CSS <code>justify-content</code> al elemento <code>#box-container</code> y asígnele un valor de center. 
-<strong>Bonus</strong> <br> Pruebe las otras opciones para la propiedad <code>justify-content</code> en el editor de código para ver sus diferencias. Pero tenga en cuenta que un valor de centro es el único que pasará este desafío. 
+<section id='instructions'>
+Un ejemplo ayuda a mostrar esta propiedad en acción. Agregue la propiedad CSS <code>justify-content</code> al elemento <code>#box-container</code> y asígnele un valor de center.
+<strong>Bonus</strong> <br> Pruebe las otras opciones para la propiedad <code>justify-content</code> en el editor de código para ver sus diferencias. Pero tenga en cuenta que un valor de centro es el único que pasará este desafío.
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ Un ejemplo ayuda a mostrar esta propiedad en acción. Agregue la propiedad CSS <
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-container</code> debería tener una propiedad <code>justify-content</code> establecida en un valor de center&#39;.
+  - text: 'El elemento <code>#box-container</code> debería tener una propiedad <code>justify-content</code> establecida en un valor de center'
     testString: 'assert($("#box-container").css("justify-content") == "center", "The <code>#box-container</code> element should have a <code>justify-content</code> property set to a value of center.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.spanish.md
index 94f57aed71..2202b6225b 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-display-flex-to-position-two-boxes.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Esta sección utiliza estilos de desafío alternativos para mostrar cómo usar CSS para posicionar elementos de una manera flexible. Primero, un desafío explicará la teoría, luego un desafío práctico utilizando un componente de tweet simple aplicará el concepto flexbox. 
-Colocación de la <code>display: flex;</code> propiedades CSS <code>display: flex;</code> en un elemento le permite usar otras propiedades de flexión para construir una página receptiva. 
+<section id='description'>
+Esta sección utiliza estilos de desafío alternativos para mostrar cómo usar CSS para posicionar elementos de una manera flexible. Primero, un desafío explicará la teoría, luego un desafío práctico utilizando un componente de tweet simple aplicará el concepto flexbox.
+Colocación de la <code>display: flex;</code> propiedades CSS <code>display: flex;</code> en un elemento le permite usar otras propiedades de flexión para construir una página receptiva.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la <code>display</code> propiedades CSS a <code>#box-container</code> y establezca su valor en flex. 
+<section id='instructions'>
+Agregue la <code>display</code> propiedades CSS a <code>#box-container</code> y establezca su valor en flex.
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Agregue la <code>display</code> propiedades CSS a <code>#box-container</code> y
 
 ```yml
 tests:
-  - text: &#39; <code>#box-container</code> debería tener la propiedad de <code>display</code> establecida en un valor de flex&#39;.
+  - text: ' <code>#box-container</code> debería tener la propiedad de <code>display</code> establecida en un valor de flex'
     testString: 'assert($("#box-container").css("display") == "flex", "<code>#box-container</code> should have the <code>display</code> property set to a value of flex.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-align-self-property.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-align-self-property.spanish.md
index bb70639f3b..a7c4dee955 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-align-self-property.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-align-self-property.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-La propiedad final para elementos flexibles es <code>align-self</code> . Esta propiedad le permite ajustar la alineación de cada elemento individualmente, en lugar de configurarlos todos a la vez. Esto es útil ya que otras técnicas de ajuste comunes que utilizan las propiedades CSS <code>float</code> , <code>clear</code> y <code>vertical-align</code> no funcionan en elementos flexibles. 
-<code>align-self</code> acepta los mismos valores que <code>align-items</code> y anulará cualquier valor establecido por la propiedad <code>align-items</code> . 
+<section id='description'>
+La propiedad final para elementos flexibles es <code>align-self</code> . Esta propiedad le permite ajustar la alineación de cada elemento individualmente, en lugar de configurarlos todos a la vez. Esto es útil ya que otras técnicas de ajuste comunes que utilizan las propiedades CSS <code>float</code> , <code>clear</code> y <code>vertical-align</code> no funcionan en elementos flexibles.
+<code>align-self</code> acepta los mismos valores que <code>align-items</code> y anulará cualquier valor establecido por la propiedad <code>align-items</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la propiedad CSS <code>align-self</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de centro y a <code>#box-2</code> un valor de flex-end. 
+<section id='instructions'>
+Agregue la propiedad CSS <code>align-self</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de centro y a <code>#box-2</code> un valor de flex-end.
 </section>
 
 ## Tests
@@ -22,9 +22,9 @@ Agregue la propiedad CSS <code>align-self</code> a <code>#box-1</code> y <code>#
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-1</code> debe tener la propiedad <code>align-self</code> establecida en un valor de center.&#39;
+  - text: 'El elemento <code>#box-1</code> debe tener la propiedad <code>align-self</code> establecida en un valor de center.'
     testString: 'assert($("#box-1").css("align-self") == "center", "The <code>#box-1</code> element should have the <code>align-self</code> property set to a value of center.");'
-  - text: &#39;El elemento <code>#box-2</code> debe tener la propiedad <code>align-self</code> establecida en un valor de flex-end.&#39;
+  - text: 'El elemento <code>#box-2</code> debe tener la propiedad <code>align-self</code> establecida en un valor de flex-end.'
     testString: 'assert($("#box-2").css("align-self") == "flex-end", "The <code>#box-2</code> element should have the <code>align-self</code> property set to a value of flex-end.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.spanish.md
index d3531e2dd0..58345afc64 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-basis-property-to-set-the-initial-size-of-an-item.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-La propiedad de <code>flex-basis</code> especifica el tamaño inicial del elemento antes de que CSS realice ajustes con <code>flex-shrink</code> o <code>flex-grow</code> . 
-Las unidades utilizadas por la propiedad de <code>flex-basis</code> son las mismas que otras propiedades de tamaño ( <code>px</code> , <code>em</code> , <code>%</code> , etc.). El valor <code>auto</code> dimensiona los elementos en función del contenido. 
+<section id='description'>
+La propiedad de <code>flex-basis</code> especifica el tamaño inicial del elemento antes de que CSS realice ajustes con <code>flex-shrink</code> o <code>flex-grow</code> .
+Las unidades utilizadas por la propiedad de <code>flex-basis</code> son las mismas que otras propiedades de tamaño ( <code>px</code> , <code>em</code> , <code>%</code> , etc.). El valor <code>auto</code> dimensiona los elementos en función del contenido.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Establezca el tamaño inicial de las cajas utilizando <code>flex-basis</code> . Agregue la propiedad CSS <code>flex-basis</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de <code>10em</code> y <code>#box-2</code> un valor de <code>20em</code> . 
+<section id='instructions'>
+Establezca el tamaño inicial de las cajas utilizando <code>flex-basis</code> . Agregue la propiedad CSS <code>flex-basis</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de <code>10em</code> y <code>#box-2</code> un valor de <code>20em</code> .
 </section>
 
 ## Tests
@@ -22,13 +22,13 @@ Establezca el tamaño inicial de las cajas utilizando <code>flex-basis</code> .
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-1</code> debería tener una propiedad de <code>flex-basis</code> .&#39;
+  - text: 'El elemento <code>#box-1</code> debería tener una propiedad de <code>flex-basis</code> .'
     testString: 'assert($("#box-1").css("flex-basis") != "auto", "The <code>#box-1</code> element should have a <code>flex-basis</code> property.");'
-  - text: &#39;El elemento <code>#box-1</code> debe tener un valor de <code>flex-basis</code> de <code>10em</code> &#39;.
+  - text: 'El elemento <code>#box-1</code> debe tener un valor de <code>flex-basis</code> de <code>10em</code> '
     testString: 'assert(code.match(/#box-1\s*?{\s*?.*?\s*?.*?\s*?flex-basis:\s*?10em;/g), "The <code>#box-1</code> element should have a <code>flex-basis</code> value of <code>10em</code>.");'
-  - text: &#39;El elemento <code>#box-2</code> debería tener la propiedad de <code>flex-basis</code> .&#39;
+  - text: 'El elemento <code>#box-2</code> debería tener la propiedad de <code>flex-basis</code> .'
     testString: 'assert($("#box-2").css("flex-basis") != "auto", "The <code>#box-2</code> element should have the <code>flex-basis</code> property.");'
-  - text: &#39;El elemento <code>#box-2</code> debe tener un valor de <code>flex-basis</code> de <code>20em</code> &#39;.
+  - text: 'El elemento <code>#box-2</code> debe tener un valor de <code>flex-basis</code> de <code>20em</code> '
     testString: 'assert(code.match(/#box-2\s*?{\s*?.*?\s*?.*?\s*?flex-basis:\s*?20em;/g), "The <code>#box-2</code> element should have a <code>flex-basis</code> value of <code>20em</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.spanish.md
index 17c01aded1..30cebf4d2a 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-column.spanish.md
@@ -7,13 +7,13 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Los dos últimos desafíos utilizaron la propiedad de <code>flex-direction</code> establecida en fila. Esta propiedad también puede crear una columna apilando verticalmente los hijos de un contenedor flexible. 
+<section id='description'>
+Los dos últimos desafíos utilizaron la propiedad de <code>flex-direction</code> establecida en fila. Esta propiedad también puede crear una columna apilando verticalmente los hijos de un contenedor flexible.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la propiedad CSS <code>flex-direction</code> al elemento <code>#box-container</code> y asígnele un valor de columna. 
+<section id='instructions'>
+Agregue la propiedad CSS <code>flex-direction</code> al elemento <code>#box-container</code> y asígnele un valor de columna.
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Agregue la propiedad CSS <code>flex-direction</code> al elemento <code>#box-cont
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-container</code> debería tener una propiedad de <code>flex-direction</code> configurada en columna.&#39;
+  - text: 'El elemento <code>#box-container</code> debería tener una propiedad de <code>flex-direction</code> configurada en columna.'
     testString: 'assert($("#box-container").css("flex-direction") == "column", "The <code>#box-container</code> element should have a <code>flex-direction</code> property set to column.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.spanish.md
index 51e369633a..9584454bb8 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-direction-property-to-make-a-row.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Agregar <code>display: flex</code> a un elemento lo convierte en un contenedor flexible. Esto hace posible alinear cualquier elemento secundario de ese elemento en filas o columnas. Para ello, agregue la propiedad de <code>flex-direction</code> al elemento principal y configúrelo en fila o columna. La creación de una fila alineará a los hijos horizontalmente, y la creación de una columna alineará a los hijos verticalmente. 
-Otras opciones para <code>flex-direction</code> son la fila-reversa y la columna-reversa. 
-<strong>Nota</strong> <br> El valor predeterminado para la propiedad de <code>flex-direction</code> es fila. 
+<section id='description'>
+Agregar <code>display: flex</code> a un elemento lo convierte en un contenedor flexible. Esto hace posible alinear cualquier elemento secundario de ese elemento en filas o columnas. Para ello, agregue la propiedad de <code>flex-direction</code> al elemento principal y configúrelo en fila o columna. La creación de una fila alineará a los hijos horizontalmente, y la creación de una columna alineará a los hijos verticalmente.
+Otras opciones para <code>flex-direction</code> son la fila-reversa y la columna-reversa.
+<strong>Nota</strong> <br> El valor predeterminado para la propiedad de <code>flex-direction</code> es fila.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la propiedad CSS <code>flex-direction</code> al elemento <code>#box-container</code> y asígnele un valor de fila-reversa. 
+<section id='instructions'>
+Agregue la propiedad CSS <code>flex-direction</code> al elemento <code>#box-container</code> y asígnele un valor de fila-reversa.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Agregue la propiedad CSS <code>flex-direction</code> al elemento <code>#box-cont
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-container</code> debería tener una propiedad de <code>flex-direction</code> configurada para invertir la fila.&#39;
+  - text: 'El elemento <code>#box-container</code> debería tener una propiedad de <code>flex-direction</code> configurada para invertir la fila.'
     testString: 'assert($("#box-container").css("flex-direction") == "row-reverse", "The <code>#box-container</code> element should have a <code>flex-direction</code> property set to row-reverse.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.spanish.md
index 6fc61e6e78..3538f408a1 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-grow-property-to-expand-items.spanish.md
@@ -7,14 +7,14 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Lo opuesto a <code>flex-shrink</code> es la propiedad de <code>flex-grow</code> . Recuerde que <code>flex-shrink</code> controla el tamaño de los elementos cuando el contenedor se reduce. La propiedad <code>flex-grow</code> controla el tamaño de los elementos cuando el contenedor principal se expande. 
-Usando un ejemplo similar del último desafío, si un elemento tiene un valor de <code>flex-grow</code> de 1 y el otro tiene un valor de <code>flex-grow</code> de 3, el valor de 3 crecerá tres veces más que el otro. 
+<section id='description'>
+Lo opuesto a <code>flex-shrink</code> es la propiedad de <code>flex-grow</code> . Recuerde que <code>flex-shrink</code> controla el tamaño de los elementos cuando el contenedor se reduce. La propiedad <code>flex-grow</code> controla el tamaño de los elementos cuando el contenedor principal se expande.
+Usando un ejemplo similar del último desafío, si un elemento tiene un valor de <code>flex-grow</code> de 1 y el otro tiene un valor de <code>flex-grow</code> de 3, el valor de 3 crecerá tres veces más que el otro.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la propiedad CSS <code>flex-grow</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de 1 y <code>#box-2</code> un valor de 2. 
+<section id='instructions'>
+Agregue la propiedad CSS <code>flex-grow</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de 1 y <code>#box-2</code> un valor de 2.
 </section>
 
 ## Tests
@@ -22,9 +22,9 @@ Agregue la propiedad CSS <code>flex-grow</code> a <code>#box-1</code> y <code>#b
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-1</code> debe tener la propiedad <code>flex-grow</code> establecida en un valor de 1.&#39;
+  - text: 'El elemento <code>#box-1</code> debe tener la propiedad <code>flex-grow</code> establecida en un valor de 1.'
     testString: 'assert($("#box-1").css("flex-grow") == "1", "The <code>#box-1</code> element should have the <code>flex-grow</code> property set to a value of 1.");'
-  - text: &#39;El elemento <code>#box-2</code> debe tener la propiedad <code>flex-grow</code> establecida en un valor de 2.&#39;
+  - text: 'El elemento <code>#box-2</code> debe tener la propiedad <code>flex-grow</code> establecida en un valor de 2.'
     testString: 'assert($("#box-2").css("flex-grow") == "2", "The <code>#box-2</code> element should have the <code>flex-grow</code> property set to a value of 2.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.spanish.md
index 598d04781b..5be3ab8795 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shorthand-property.spanish.md
@@ -7,16 +7,16 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Hay un acceso directo disponible para configurar varias propiedades de flexión a la vez. Las propiedades <code>flex-grow</code> , <code>flex-shrink</code> y <code>flex-basis</code> pueden establecerse mediante el uso de la propiedad <code>flex</code> . 
-Por ejemplo, <code>flex: 1 0 10px;</code> establecerá el elemento para <code>flex-grow: 1;</code> , <code>flex-shrink: 0;</code> , y <code>flex-basis: 10px;</code> . 
-La configuración predeterminada de las propiedades es <code>flex: 0 1 auto;</code> . 
+<section id='description'>
+Hay un acceso directo disponible para configurar varias propiedades de flexión a la vez. Las propiedades <code>flex-grow</code> , <code>flex-shrink</code> y <code>flex-basis</code> pueden establecerse mediante el uso de la propiedad <code>flex</code> .
+Por ejemplo, <code>flex: 1 0 10px;</code> establecerá el elemento para <code>flex-grow: 1;</code> , <code>flex-shrink: 0;</code> , y <code>flex-basis: 10px;</code> .
+La configuración predeterminada de las propiedades es <code>flex: 0 1 auto;</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la propiedad CSS <code>flex</code> tanto a <code>#box-1</code> como <code>#box-2</code> . Dé a <code>#box-1</code> los valores para que su <code>flex-grow</code> sea ​​2, <code>flex-shrink</code> sea ​​2, y su <code>flex-basis</code> sea ​​150px. Dé a <code>#box-2</code> los valores para que su <code>flex-grow</code> sea ​​1, <code>flex-shrink</code> sea ​​1, y su <code>flex-basis</code> sea ​​150px. 
-Estos valores harán que <code>#box-1</code> crezca para llenar el espacio adicional al doble de la tasa de <code>#box-2</code> cuando el contenedor es mayor que 300px y se contraerá al doble de la tasa de <code>#box-2</code> cuando el contenedor sea menor de 300px . 300px es el tamaño combinado de los valores de <code>flex-basis</code> de las dos cajas. 
+<section id='instructions'>
+Agregue la propiedad CSS <code>flex</code> tanto a <code>#box-1</code> como <code>#box-2</code> . Dé a <code>#box-1</code> los valores para que su <code>flex-grow</code> sea ​​2, <code>flex-shrink</code> sea ​​2, y su <code>flex-basis</code> sea ​​150px. Dé a <code>#box-2</code> los valores para que su <code>flex-grow</code> sea ​​1, <code>flex-shrink</code> sea ​​1, y su <code>flex-basis</code> sea ​​150px.
+Estos valores harán que <code>#box-1</code> crezca para llenar el espacio adicional al doble de la tasa de <code>#box-2</code> cuando el contenedor es mayor que 300px y se contraerá al doble de la tasa de <code>#box-2</code> cuando el contenedor sea menor de 300px . 300px es el tamaño combinado de los valores de <code>flex-basis</code> de las dos cajas.
 </section>
 
 ## Tests
@@ -24,11 +24,11 @@ Estos valores harán que <code>#box-1</code> crezca para llenar el espacio adici
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-1</code> debe tener la propiedad <code>flex</code> establecida en un valor de 2 2 150px.&#39;
+  - text: 'El elemento <code>#box-1</code> debe tener la propiedad <code>flex</code> establecida en un valor de 2 2 150px.'
     testString: 'assert($("#box-1").css("flex-grow") == "2" && $("#box-1").css("flex-shrink") == "2" && $("#box-1").css("flex-basis") == "150px", "The <code>#box-1</code> element should have the <code>flex</code> property set to a value of 2 2 150px.");'
-  - text: &#39;El elemento <code>#box-2</code> debe tener la propiedad <code>flex</code> establecida en un valor de 1 1 150px.&#39;
+  - text: 'El elemento <code>#box-2</code> debe tener la propiedad <code>flex</code> establecida en un valor de 1 1 150px.'
     testString: 'assert($("#box-2").css("flex-grow") == "1" && $("#box-2").css("flex-shrink") == "1" && $("#box-2").css("flex-basis") == "150px", "The <code>#box-2</code> element should have the <code>flex</code> property set to a value of 1 1 150px.");'
-  - text: &#39;Su código debe usar la propiedad <code>flex</code> para <code>#box-1</code> y <code>#box-2</code> .&#39;
+  - text: 'Su código debe usar la propiedad <code>flex</code> para <code>#box-1</code> y <code>#box-2</code> .'
     testString: 'assert(code.match(/flex:\s*?\d\s+?\d\s+?150px;/g).length == 2, "Your code should use the <code>flex</code> property for <code>#box-1</code> and <code>#box-2</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.spanish.md
index 34f62a3e1a..a138dd4658 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-shrink-property-to-shrink-items.spanish.md
@@ -7,15 +7,15 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Hasta ahora, todas las propiedades en los desafíos se aplican al contenedor de flexión (el elemento principal de los elementos de flexión). Sin embargo, hay varias propiedades útiles para los elementos flexibles. 
-La primera es la propiedad <code>flex-shrink</code> . Cuando se usa, permite que un elemento se encoja si el contenedor flexible es demasiado pequeño. Los elementos se reducen cuando el ancho del contenedor principal es menor que el ancho combinado de todos los elementos flexibles dentro de él. 
-La propiedad <code>flex-shrink</code> toma números como valores. Cuanto mayor sea el número, más se reducirá en comparación con los otros elementos del contenedor. Por ejemplo, si un elemento tiene un valor de <code>flex-shrink</code> de 1 y el otro tiene un valor de <code>flex-shrink</code> de 3, el valor de 3 se contraerá tres veces más que el otro. 
+<section id='description'>
+Hasta ahora, todas las propiedades en los desafíos se aplican al contenedor de flexión (el elemento principal de los elementos de flexión). Sin embargo, hay varias propiedades útiles para los elementos flexibles.
+La primera es la propiedad <code>flex-shrink</code> . Cuando se usa, permite que un elemento se encoja si el contenedor flexible es demasiado pequeño. Los elementos se reducen cuando el ancho del contenedor principal es menor que el ancho combinado de todos los elementos flexibles dentro de él.
+La propiedad <code>flex-shrink</code> toma números como valores. Cuanto mayor sea el número, más se reducirá en comparación con los otros elementos del contenedor. Por ejemplo, si un elemento tiene un valor de <code>flex-shrink</code> de 1 y el otro tiene un valor de <code>flex-shrink</code> de 3, el valor de 3 se contraerá tres veces más que el otro.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue la propiedad CSS <code>flex-shrink</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de 1 y <code>#box-2</code> un valor de 2. 
+<section id='instructions'>
+Agregue la propiedad CSS <code>flex-shrink</code> a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de 1 y <code>#box-2</code> un valor de 2.
 </section>
 
 ## Tests
@@ -23,9 +23,9 @@ Agregue la propiedad CSS <code>flex-shrink</code> a <code>#box-1</code> y <code>
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-1</code> debe tener la propiedad <code>flex-shrink</code> establecida en un valor de 1&#39;.
+  - text: 'El elemento <code>#box-1</code> debe tener la propiedad <code>flex-shrink</code> establecida en un valor de 1'
     testString: 'assert($("#box-1").css("flex-shrink") == "1", "The <code>#box-1</code> element should have the <code>flex-shrink</code> property set to a value of 1.");'
-  - text: &#39;El elemento <code>#box-2</code> debe tener la propiedad <code>flex-shrink</code> establecida en un valor de 2&#39;.
+  - text: 'El elemento <code>#box-2</code> debe tener la propiedad <code>flex-shrink</code> establecida en un valor de 2'
     testString: 'assert($("#box-2").css("flex-shrink") == "2", "The <code>#box-2</code> element should have the <code>flex-shrink</code> property set to a value of 2.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.spanish.md
index 44d2d21339..fd3920a3e3 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-flex-wrap-property-to-wrap-a-row-or-column.spanish.md
@@ -7,16 +7,16 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-CSS flexbox tiene una función para dividir un elemento flexible en varias filas (o columnas). Por defecto, un contenedor flexible encajará todos los elementos flexibles juntos. Por ejemplo, una fila estará en una sola línea. 
-Sin embargo, al usar la propiedad <code>flex-wrap</code> , le dice a CSS que envuelva los elementos. Esto significa que los elementos adicionales se mueven a una nueva fila o columna. El punto de ruptura de donde ocurre la envoltura depende del tamaño de los artículos y del tamaño del contenedor. 
-CSS también tiene opciones para la dirección de la envoltura: 
-<ul><li> <code>nowrap</code> : esta es la configuración predeterminada y no envuelve los elementos. </li><li> <code>wrap</code> : envuelve los elementos de izquierda a derecha si están en una fila, o de arriba a abajo si están en una columna. </li><li> <code>wrap-reverse</code> : envuelve los elementos de abajo a arriba si están en una fila, o de derecha a izquierda si están en una columna. </li></ul> 
+<section id='description'>
+CSS flexbox tiene una función para dividir un elemento flexible en varias filas (o columnas). Por defecto, un contenedor flexible encajará todos los elementos flexibles juntos. Por ejemplo, una fila estará en una sola línea.
+Sin embargo, al usar la propiedad <code>flex-wrap</code> , le dice a CSS que envuelva los elementos. Esto significa que los elementos adicionales se mueven a una nueva fila o columna. El punto de ruptura de donde ocurre la envoltura depende del tamaño de los artículos y del tamaño del contenedor.
+CSS también tiene opciones para la dirección de la envoltura:
+<ul><li> <code>nowrap</code> : esta es la configuración predeterminada y no envuelve los elementos. </li><li> <code>wrap</code> : envuelve los elementos de izquierda a derecha si están en una fila, o de arriba a abajo si están en una columna. </li><li> <code>wrap-reverse</code> : envuelve los elementos de abajo a arriba si están en una fila, o de derecha a izquierda si están en una columna. </li></ul>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El diseño actual tiene demasiados cuadros para una fila. Agregue la propiedad CSS <code>flex-wrap</code> al elemento <code>#box-container</code> y asígnele un valor de wrap. 
+<section id='instructions'>
+El diseño actual tiene demasiados cuadros para una fila. Agregue la propiedad CSS <code>flex-wrap</code> al elemento <code>#box-container</code> y asígnele un valor de wrap.
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ El diseño actual tiene demasiados cuadros para una fila. Agregue la propiedad C
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-container</code> debería tener la propiedad <code>flex-wrap</code> establecida en un valor de wrap.&#39;
+  - text: 'El elemento <code>#box-container</code> debería tener la propiedad <code>flex-wrap</code> establecida en un valor de wrap.'
     testString: 'assert($("#box-container").css("flex-wrap") == "wrap", "The <code>#box-container</code> element should have the <code>flex-wrap</code> property set to a value of wrap.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.spanish.md
index b1b1692468..705017b00e 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-justify-content-property-in-the-tweet-embed.spanish.md
@@ -7,13 +7,13 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-El último desafío mostró un ejemplo de la propiedad <code>justify-content</code> . Para la inserción de tweets, esta propiedad se puede aplicar para alinear los elementos en el elemento <code>.profile-name</code> . 
+<section id='description'>
+El último desafío mostró un ejemplo de la propiedad <code>justify-content</code> . Para la inserción de tweets, esta propiedad se puede aplicar para alinear los elementos en el elemento <code>.profile-name</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Añadir la propiedad CSS <code>justify-content</code> de la cabecera del <code>.profile-name</code> del elemento y establezca el valor en cualquiera de las opciones desde el último desafío. 
+<section id='instructions'>
+Añadir la propiedad CSS <code>justify-content</code> de la cabecera del <code>.profile-name</code> del elemento y establezca el valor en cualquiera de las opciones desde el último desafío.
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Añadir la propiedad CSS <code>justify-content</code> de la cabecera del <code>.
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>.profile-name</code> debe tener la propiedad <code>.profile-name</code> <code>justify-content</code> establecida en cualquiera de estos valores: centro, inicio flexible, extremo flexible, espacio intermedio o espacio-alrededor.&#39;
+  - text: 'El elemento <code>.profile-name</code> debe tener la propiedad <code>.profile-name</code> <code>justify-content</code> establecida en cualquiera de estos valores: centro, inicio flexible, extremo flexible, espacio intermedio o espacio-alrededor.'
     testString: 'assert(code.match(/header\s.profile-name\s*{\s*?.*?\s*?.*?\s*?\s*?.*?\s*?justify-content\s*:\s*(center|flex-start|flex-end|space-between|space-around)\s*;/g), "The <code>.profile-name</code> element should have the <code>justify-content</code> property set to any of these values: center, flex-start, flex-end, space-between, or space-around.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.spanish.md
index 6d48ebd4da..1005946cf4 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-flexbox/use-the-order-property-to-rearrange-items.spanish.md
@@ -7,13 +7,13 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-La propiedad <code>order</code> se usa para decirle a CSS el orden en que aparecen los elementos flexibles en el contenedor flex. De forma predeterminada, los elementos aparecerán en el mismo orden en que vienen en el código fuente HTML. La propiedad toma números como valores y se pueden usar números negativos. 
+<section id='description'>
+La propiedad <code>order</code> se usa para decirle a CSS el orden en que aparecen los elementos flexibles en el contenedor flex. De forma predeterminada, los elementos aparecerán en el mismo orden en que vienen en el código fuente HTML. La propiedad toma números como valores y se pueden usar números negativos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue el <code>order</code> propiedades CSS a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de 2 y a <code>#box-2</code> un valor de 1. 
+<section id='instructions'>
+Agregue el <code>order</code> propiedades CSS a <code>#box-1</code> y <code>#box-2</code> . Dé a <code>#box-1</code> un valor de 2 y a <code>#box-2</code> un valor de 1.
 </section>
 
 ## Tests
@@ -21,9 +21,9 @@ Agregue el <code>order</code> propiedades CSS a <code>#box-1</code> y <code>#box
 
 ```yml
 tests:
-  - text: &#39;El elemento <code>#box-1</code> debe tener la propiedad de <code>order</code> establecida en un valor de 2.&#39;
+  - text: 'El elemento <code>#box-1</code> debe tener la propiedad de <code>order</code> establecida en un valor de 2.'
     testString: 'assert($("#box-1").css("order") == "2", "The <code>#box-1</code> element should have the <code>order</code> property set to a value of 2.");'
-  - text: &#39;El elemento <code>#box-2</code> debe tener la propiedad de <code>order</code> establecida en un valor de 1.&#39;
+  - text: 'El elemento <code>#box-2</code> debe tener la propiedad de <code>order</code> establecida en un valor de 1.'
     testString: 'assert($("#box-2").css("order") == "1", "The <code>#box-2</code> element should have the <code>order</code> property set to a value of 1.");'
 
 ```
diff --git a/curriculum/challenges/spanish/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.spanish.md b/curriculum/challenges/spanish/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.spanish.md
index 05d2071052..97a4963ea5 100644
--- a/curriculum/challenges/spanish/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.spanish.md
+++ b/curriculum/challenges/spanish/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.spanish.md
@@ -7,19 +7,19 @@ videoUrl: ''
 ---
 
 ## Description
-<section id='description'> 
-Puede usar unidades absolutas y relativas como <code>px</code> y <code>em</code> en CSS Grid para definir el tamaño de las filas y columnas. También puede usar estos: 
-<code>fr</code> : establece la columna o fila a una fracción del espacio disponible, 
-<code>auto</code> : establece la columna o fila al ancho o alto de su contenido automáticamente, 
-<code>%</code> : ajusta la columna o fila a El porcentaje de ancho de su contenedor. 
-Aquí está el código que genera el resultado en la vista previa: 
-<blockquote>grid-template-columns: auto 50px 10% 2fr 1fr;</blockquote> 
-Este fragmento crea cinco columnas. La primera columna es tan ancha como su contenido, la segunda columna es 50px, la tercera columna es el 10% de su contenedor, y para las dos últimas columnas; El espacio restante se divide en tres secciones, dos se asignan para la cuarta columna y una para la quinta. 
+<section id='description'>
+Puede usar unidades absolutas y relativas como <code>px</code> y <code>em</code> en CSS Grid para definir el tamaño de las filas y columnas. También puede usar estos:
+<code>fr</code> : establece la columna o fila a una fracción del espacio disponible,
+<code>auto</code> : establece la columna o fila al ancho o alto de su contenido automáticamente,
+<code>%</code> : ajusta la columna o fila a El porcentaje de ancho de su contenedor.
+Aquí está el código que genera el resultado en la vista previa:
+<blockquote>grid-template-columns: auto 50px 10% 2fr 1fr;</blockquote>
+Este fragmento crea cinco columnas. La primera columna es tan ancha como su contenido, la segunda columna es 50px, la tercera columna es el 10% de su contenedor, y para las dos últimas columnas; El espacio restante se divide en tres secciones, dos se asignan para la cuarta columna y una para la quinta.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Haz una cuadrícula con tres columnas cuyos anchos sean los siguientes: 1fr, 100px y 2fr. 
+<section id='instructions'>
+Haz una cuadrícula con tres columnas cuyos anchos sean los siguientes: 1fr, 100px y 2fr.
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ Haz una cuadrícula con tres columnas cuyos anchos sean los siguientes: 1fr, 100
 
 ```yml
 tests:
-  - text: &#39;la clase <code>container</code> debe tener una propiedad de <code>grid-template-columns</code> que tenga tres columnas con los siguientes anchos: <code>1fr, 100px, and 2fr</code> &#39;.
+  - text: 'la clase <code>container</code> debe tener una propiedad de <code>grid-template-columns</code> que tenga tres columnas con los siguientes anchos: <code>1fr, 100px, and 2fr</code> '
     testString: 'assert(code.match(/.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?1fr\s*?100px\s*?2fr\s*?;[\s\S]*}/gi), "<code>container</code> class should have a <code>grid-template-columns</code> property that has three columns with the following widths: <code>1fr, 100px, and 2fr</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.spanish.md
index 6812f3bcda..57b520b5a2 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Compruebe si un valor está clasificado como un primitivo booleano. Devuelve verdadero o falso. 
-Los primitivos booleanos son verdaderos y falsos. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Compruebe si un valor está clasificado como un primitivo booleano. Devuelve verdadero o falso.
+Los primitivos booleanos son verdaderos y falsos.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,11 +27,11 @@ tests:
     testString: 'assert.strictEqual(booWho(true), true, "<code>booWho(true)</code> should return true.");'
   - text: <code>booWho(false)</code> debe devolver verdadero.
     testString: 'assert.strictEqual(booWho(false), true, "<code>booWho(false)</code> should return true.");'
-  - text: &#39; <code>booWho([1, 2, 3])</code> debe devolver falso.&#39;
+  - text: ' <code>booWho([1, 2, 3])</code> debe devolver falso.'
     testString: 'assert.strictEqual(booWho([1, 2, 3]), false, "<code>booWho([1, 2, 3])</code> should return false.");'
-  - text: &#39; <code>booWho([].slice)</code> debe devolver falso.&#39;
+  - text: ' <code>booWho([].slice)</code> debe devolver falso.'
     testString: 'assert.strictEqual(booWho([].slice), false, "<code>booWho([].slice)</code> should return false.");'
-  - text: &#39; <code>booWho({ &quot;a&quot;: 1 })</code> debe devolver falso.&#39;
+  - text: ' <code>booWho({ &quot;a&quot;: 1 })</code> debe devolver falso.'
     testString: 'assert.strictEqual(booWho({ "a": 1 }), false, "<code>booWho({ "a": 1 })</code> should return false.");'
   - text: <code>booWho(1)</code> debe devolver falso.
     testString: 'assert.strictEqual(booWho(1), false, "<code>booWho(1)</code> should return false.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.spanish.md
index 78cbcaef23..a0d53a6b99 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.spanish.md
@@ -7,13 +7,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Escriba una función que divida una matriz (primer argumento) en grupos de la longitud del <code>size</code> (segundo argumento) y los devuelva como una matriz bidimensional. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Escriba una función que divida una matriz (primer argumento) en grupos de la longitud del <code>size</code> (segundo argumento) y los devuelva como una matriz bidimensional.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,19 +22,19 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>chunkArrayInGroups([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;], 2)</code> debe devolver <code>[[&quot;a&quot;, &quot;b&quot;], [&quot;c&quot;, &quot;d&quot;]]</code> .&#39;
+  - text: ' <code>chunkArrayInGroups([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;], 2)</code> debe devolver <code>[[&quot;a&quot;, &quot;b&quot;], [&quot;c&quot;, &quot;d&quot;]]</code> .'
     testString: 'assert.deepEqual(chunkArrayInGroups(["a", "b", "c", "d"], 2), [["a", "b"], ["c", "d"]], "<code>chunkArrayInGroups(["a", "b", "c", "d"], 2)</code> should return <code>[["a", "b"], ["c", "d"]]</code>.");'
-  - text: &#39; <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5]]</code> .&#39;
+  - text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5]]</code> .'
     testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [[0, 1, 2], [3, 4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> should return <code>[[0, 1, 2], [3, 4, 5]]</code>.");'
-  - text: &#39; <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5]]</code> .&#39;
+  - text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5]]</code> .'
     testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [[0, 1], [2, 3], [4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> should return <code>[[0, 1], [2, 3], [4, 5]]</code>.");'
-  - text: &#39; <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5]]</code> .&#39;
+  - text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5]]</code> .'
     testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [[0, 1, 2, 3], [4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> should return <code>[[0, 1, 2, 3], [4, 5]]</code>.");'
-  - text: &#39; <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5], [6]]</code> .&#39;
+  - text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> debe devolver <code>[[0, 1, 2], [3, 4, 5], [6]]</code> .'
     testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [[0, 1, 2], [3, 4, 5], [6]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> should return <code>[[0, 1, 2], [3, 4, 5], [6]]</code>.");'
-  - text: &#39; <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code> . &#39;
+  - text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> debe devolver <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code> . '
     testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [[0, 1, 2, 3], [4, 5, 6, 7], [8]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> should return <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code>.");'
-  - text: &#39; <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code> .
+  - text: ' <code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> debe devolver <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code> .
     testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [[0, 1], [2, 3], [4, 5], [6, 7], [8]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> should return <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.spanish.md
index e86fd561f5..9a85b16d34 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Compruebe si una cadena (primer argumento, <code>str</code> ) termina con la cadena de destino dada (segundo argumento, <code>target</code> ). 
-Este desafío <em>se</em> puede resolver con el método <code>.endsWith()</code> , que se introdujo en ES2015. Pero para el propósito de este desafío, nos gustaría que utilices uno de los métodos de subcadena de JavaScript. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Compruebe si una cadena (primer argumento, <code>str</code> ) termina con la cadena de destino dada (segundo argumento, <code>target</code> ).
+Este desafío <em>se</em> puede resolver con el método <code>.endsWith()</code> , que se introdujo en ES2015. Pero para el propósito de este desafío, nos gustaría que utilices uno de los métodos de subcadena de JavaScript.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,25 +23,25 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>confirmEnding(&quot;Bastian&quot;, &quot;n&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>confirmEnding(&quot;Bastian&quot;, &quot;n&quot;)</code> debe devolver verdadero.'
     testString: 'assert(confirmEnding("Bastian", "n") === true, "<code>confirmEnding("Bastian", "n")</code> should return true.");'
-  - text: &#39; <code>confirmEnding(&quot;Congratulation&quot;, &quot;on&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>confirmEnding(&quot;Congratulation&quot;, &quot;on&quot;)</code> debe devolver verdadero.'
     testString: 'assert(confirmEnding("Congratulation", "on") === true, "<code>confirmEnding("Congratulation", "on")</code> should return true.");'
-  - text: &#39; <code>confirmEnding(&quot;Connor&quot;, &quot;n&quot;)</code> debe devolver falso.&#39;
+  - text: ' <code>confirmEnding(&quot;Connor&quot;, &quot;n&quot;)</code> debe devolver falso.'
     testString: 'assert(confirmEnding("Connor", "n") === false, "<code>confirmEnding("Connor", "n")</code> should return false.");'
-  - text: &#39; <code>confirmEnding(&quot;Walking on water and developing software from a specification are easy if both are frozen&quot;, &quot;specification&quot;)</code> debe devolver falso.
+  - text: ' <code>confirmEnding(&quot;Walking on water and developing software from a specification are easy if both are frozen&quot;, &quot;specification&quot;)</code> debe devolver falso.
     testString: 'assert(confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification") === false, "<code>confirmEnding("Walking on water and developing software from a specification are easy if both are frozen"&#44; "specification"&#41;</code> should return false.");'
-  - text: &#39; <code>confirmEnding(&quot;He has to give me a new name&quot;, &quot;name&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>confirmEnding(&quot;He has to give me a new name&quot;, &quot;name&quot;)</code> debe devolver verdadero.'
     testString: 'assert(confirmEnding("He has to give me a new name", "name") === true, "<code>confirmEnding("He has to give me a new name", "name")</code> should return true.");'
-  - text: &#39; <code>confirmEnding(&quot;Open sesame&quot;, &quot;same&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>confirmEnding(&quot;Open sesame&quot;, &quot;same&quot;)</code> debe devolver verdadero.'
     testString: 'assert(confirmEnding("Open sesame", "same") === true, "<code>confirmEnding("Open sesame", "same")</code> should return true.");'
-  - text: &#39; <code>confirmEnding(&quot;Open sesame&quot;, &quot;pen&quot;)</code> debe devolver falso.
+  - text: ' <code>confirmEnding(&quot;Open sesame&quot;, &quot;pen&quot;)</code> debe devolver falso.
     testString: 'assert(confirmEnding("Open sesame", "pen") === false, "<code>confirmEnding("Open sesame", "pen")</code> should return false.");'
-  - text: &#39; <code>confirmEnding(&quot;Open sesame&quot;, &quot;game&quot;)</code> debe devolver falso.
+  - text: ' <code>confirmEnding(&quot;Open sesame&quot;, &quot;game&quot;)</code> debe devolver falso.
     testString: 'assert(confirmEnding("Open sesame", "game") === false, "<code>confirmEnding("Open sesame", "game")</code> should return false.");'
-  - text: &#39; <code>confirmEnding(&quot;If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing&quot;, &quot;mountain&quot;)</code> debería devolver el valor falso &quot;.
+  - text: ' <code>confirmEnding(&quot;If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing&quot;, &quot;mountain&quot;)</code> debería devolver el valor falso &quot;.
     testString: 'assert(confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain") === false, "<code>confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")</code> should return false.");'
-  - text: &#39; <code>confirmEnding(&quot;Abstraction&quot;, &quot;action&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>confirmEnding(&quot;Abstraction&quot;, &quot;action&quot;)</code> debe devolver verdadero.'
     testString: 'assert(confirmEnding("Abstraction", "action") === true, "<code>confirmEnding("Abstraction", "action")</code> should return true.");'
   - text: No use el método <code>.endsWith()</code> para resolver el desafío.
     testString: 'assert(!(/\.endsWith\(.*?\)\s*?;?/.test(code)) && !(/\["endsWith"\]/.test(code)), "Do not use the built-in method <code>.endsWith()</code> to solve the challenge.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.spanish.md
index 5eba2d8154..7137a12605 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.spanish.md
@@ -7,15 +7,15 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Eliminar todos los valores falsos de una matriz. 
-valores de <code>false</code> en JavaScript son <code>false</code> , <code>null</code> , <code>0</code> , <code>&quot;&quot;</code> , <code>undefined</code> y <code>NaN</code> . 
-Sugerencia: intente convertir cada valor a un booleano. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Eliminar todos los valores falsos de una matriz.
+valores de <code>false</code> en JavaScript son <code>false</code> , <code>null</code> , <code>0</code> , <code>&quot;&quot;</code> , <code>undefined</code> y <code>NaN</code> .
+Sugerencia: intente convertir cada valor a un booleano.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,13 +24,13 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>bouncer([7, &quot;ate&quot;, &quot;&quot;, false, 9])</code> debe devolver <code>[7, &quot;ate&quot;, 9]</code> .&#39;
+  - text: ' <code>bouncer([7, &quot;ate&quot;, &quot;&quot;, false, 9])</code> debe devolver <code>[7, &quot;ate&quot;, 9]</code> .'
     testString: 'assert.deepEqual(bouncer([7, "ate", "", false, 9]), [7, "ate", 9], "<code>bouncer([7, "ate", "", false, 9])</code> should return <code>[7, "ate", 9]</code>.");'
-  - text: &#39; <code>bouncer([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]</code> .&#39;
+  - text: ' <code>bouncer([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]</code> .'
     testString: 'assert.deepEqual(bouncer(["a", "b", "c"]), ["a", "b", "c"], "<code>bouncer(["a", "b", "c"])</code> should return <code>["a", "b", "c"]</code>.");'
-  - text: &#39; <code>bouncer([false, null, 0, NaN, undefined, &quot;&quot;])</code> debe devolver <code>[]</code> .&#39;
+  - text: ' <code>bouncer([false, null, 0, NaN, undefined, &quot;&quot;])</code> debe devolver <code>[]</code> .'
     testString: 'assert.deepEqual(bouncer([false, null, 0, NaN, undefined, ""]), [], "<code>bouncer([false, null, 0, NaN, undefined, ""])</code> should return <code>[]</code>.");'
-  - text: &#39; <code>bouncer([1, null, NaN, 2, undefined])</code> debe devolver <code>[1, 2]</code> .&#39;
+  - text: ' <code>bouncer([1, null, NaN, 2, undefined])</code> debe devolver <code>[1, 2]</code> .'
     testString: 'assert.deepEqual(bouncer([1, null, NaN, 2, undefined]), [1, 2], "<code>bouncer([1, null, NaN, 2, undefined])</code> should return <code>[1, 2]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.spanish.md
index 6164b8cda9..348df1f965 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.spanish.md
@@ -7,13 +7,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Cree una función que examine una matriz (primer argumento) y devuelva el primer elemento de la matriz que pase una prueba de verdad (segundo argumento). Si ningún elemento pasa la prueba, devuelva indefinido. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Cree una función que examine una matriz (primer argumento) y devuelva el primer elemento de la matriz que pase una prueba de verdad (segundo argumento). Si ningún elemento pasa la prueba, devuelva indefinido.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,9 +22,9 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> debe devolver 8.&#39;
+  - text: ' <code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> debe devolver 8.'
     testString: 'assert.strictEqual(findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }), 8, "<code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> should return 8.");'
-  - text: &#39; <code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> debe devolver undefined.&#39;
+  - text: ' <code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> debe devolver undefined.'
     testString: 'assert.strictEqual(findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; }), undefined, "<code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> should return undefined.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.spanish.md
index 9cf69fad9c..c18ffcbaf5 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.spanish.md
@@ -7,16 +7,16 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devuelva verdadero si la cadena en el primer elemento de la matriz contiene todas las letras de la cadena en el segundo elemento de la matriz. 
-Por ejemplo, <code>[&quot;hello&quot;, &quot;Hello&quot;]</code> , debería devolver verdadero porque todas las letras en la segunda cadena están presentes en el primer caso, ignorando el caso. 
-Los argumentos <code>[&quot;hello&quot;, &quot;hey&quot;]</code> deben devolver falso porque la cadena &quot;hola&quot; no contiene una &quot;y&quot;. 
-Por último, <code>[&quot;Alien&quot;, &quot;line&quot;]</code> , debe devolver verdadero porque todas las letras en &quot;line&quot; están presentes en &quot;Alien&quot;. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Devuelva verdadero si la cadena en el primer elemento de la matriz contiene todas las letras de la cadena en el segundo elemento de la matriz.
+Por ejemplo, <code>[&quot;hello&quot;, &quot;Hello&quot;]</code> , debería devolver verdadero porque todas las letras en la segunda cadena están presentes en el primer caso, ignorando el caso.
+Los argumentos <code>[&quot;hello&quot;, &quot;hey&quot;]</code> deben devolver falso porque la cadena &quot;hola&quot; no contiene una &quot;y&quot;.
+Por último, <code>[&quot;Alien&quot;, &quot;line&quot;]</code> , debe devolver verdadero porque todas las letras en &quot;line&quot; están presentes en &quot;Alien&quot;.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,23 +25,23 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>mutation([&quot;hello&quot;, &quot;hey&quot;])</code> debe devolver falso.&#39;
+  - text: ' <code>mutation([&quot;hello&quot;, &quot;hey&quot;])</code> debe devolver falso.'
     testString: 'assert(mutation(["hello", "hey"]) === false, "<code>mutation(["hello", "hey"])</code> should return false.");'
-  - text: &#39; <code>mutation([&quot;hello&quot;, &quot;Hello&quot;])</code> debe devolver verdadero.&#39;
+  - text: ' <code>mutation([&quot;hello&quot;, &quot;Hello&quot;])</code> debe devolver verdadero.'
     testString: 'assert(mutation(["hello", "Hello"]) === true, "<code>mutation(["hello", "Hello"])</code> should return true.");'
-  - text: &#39; <code>mutation([&quot;zyxwvutsrqponmlkjihgfedcba&quot;, &quot;qrstu&quot;])</code> debe devolver verdadero.&#39;
+  - text: ' <code>mutation([&quot;zyxwvutsrqponmlkjihgfedcba&quot;, &quot;qrstu&quot;])</code> debe devolver verdadero.'
     testString: 'assert(mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"]) === true, "<code>mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])</code> should return true.");'
-  - text: &#39;la <code>mutation([&quot;Mary&quot;, &quot;Army&quot;])</code> debería devolver la verdad.&#39;
+  - text: 'la <code>mutation([&quot;Mary&quot;, &quot;Army&quot;])</code> debería devolver la verdad.'
     testString: 'assert(mutation(["Mary", "Army"]) === true, "<code>mutation(["Mary", "Army"])</code> should return true.");'
-  - text: &#39;la <code>mutation([&quot;Mary&quot;, &quot;Aarmy&quot;])</code> debe devolver la verdad.&#39;
+  - text: 'la <code>mutation([&quot;Mary&quot;, &quot;Aarmy&quot;])</code> debe devolver la verdad.'
     testString: 'assert(mutation(["Mary", "Aarmy"]) === true, "<code>mutation(["Mary", "Aarmy"])</code> should return true.");'
-  - text: &#39; <code>mutation([&quot;Alien&quot;, &quot;line&quot;])</code> debe devolver true.&#39;
+  - text: ' <code>mutation([&quot;Alien&quot;, &quot;line&quot;])</code> debe devolver true.'
     testString: 'assert(mutation(["Alien", "line"]) === true, "<code>mutation(["Alien", "line"])</code> should return true.");'
-  - text: &#39; <code>mutation([&quot;floor&quot;, &quot;for&quot;])</code> debe devolver verdadero.&#39;
+  - text: ' <code>mutation([&quot;floor&quot;, &quot;for&quot;])</code> debe devolver verdadero.'
     testString: 'assert(mutation(["floor", "for"]) === true, "<code>mutation(["floor", "for"])</code> should return true.");'
-  - text: &#39; <code>mutation([&quot;hello&quot;, &quot;neo&quot;])</code> debe devolver falso.&#39;
+  - text: ' <code>mutation([&quot;hello&quot;, &quot;neo&quot;])</code> debe devolver falso.'
     testString: 'assert(mutation(["hello", "neo"]) === false, "<code>mutation(["hello", "neo"])</code> should return false.");'
-  - text: &#39; <code>mutation([&quot;voodoo&quot;, &quot;no&quot;])</code> debe devolver falso.&#39;
+  - text: ' <code>mutation([&quot;voodoo&quot;, &quot;no&quot;])</code> debe devolver falso.'
     testString: 'assert(mutation(["voodoo", "no"]) === false, "<code>mutation(["voodoo", "no"])</code> should return false.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.spanish.md
index 340aa8ae42..fbc7c1bbc9 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.spanish.md
@@ -7,13 +7,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Repetir una determinada cadena <code>str</code> (primer argumento) para <code>num</code> veces (segundo argumento). Devuelve una cadena vacía si <code>num</code> no es un número positivo. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Repetir una determinada cadena <code>str</code> (primer argumento) para <code>num</code> veces (segundo argumento). Devuelve una cadena vacía si <code>num</code> no es un número positivo.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,17 +22,17 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>repeatStringNumTimes(&quot;*&quot;, 3)</code> debe devolver <code>&quot;***&quot;</code> .&#39;
+  - text: ' <code>repeatStringNumTimes(&quot;*&quot;, 3)</code> debe devolver <code>&quot;***&quot;</code> .'
     testString: 'assert(repeatStringNumTimes("*", 3) === "***", "<code>repeatStringNumTimes("*", 3)</code> should return <code>"***"</code>.");'
-  - text: &#39; <code>repeatStringNumTimes(&quot;abc&quot;, 3)</code> debe devolver <code>&quot;abcabcabc&quot;</code> .&#39;
+  - text: ' <code>repeatStringNumTimes(&quot;abc&quot;, 3)</code> debe devolver <code>&quot;abcabcabc&quot;</code> .'
     testString: 'assert(repeatStringNumTimes("abc", 3) === "abcabcabc", "<code>repeatStringNumTimes("abc", 3)</code> should return <code>"abcabcabc"</code>.");'
-  - text: &#39; <code>repeatStringNumTimes(&quot;abc&quot;, 4)</code> debe devolver <code>&quot;abcabcabcabc&quot;</code> .&#39;
+  - text: ' <code>repeatStringNumTimes(&quot;abc&quot;, 4)</code> debe devolver <code>&quot;abcabcabcabc&quot;</code> .'
     testString: 'assert(repeatStringNumTimes("abc", 4) === "abcabcabcabc", "<code>repeatStringNumTimes("abc", 4)</code> should return <code>"abcabcabcabc"</code>.");'
-  - text: &#39; <code>repeatStringNumTimes(&quot;abc&quot;, 1)</code> debe devolver <code>&quot;abc&quot;</code> .&#39;
+  - text: ' <code>repeatStringNumTimes(&quot;abc&quot;, 1)</code> debe devolver <code>&quot;abc&quot;</code> .'
     testString: 'assert(repeatStringNumTimes("abc", 1) === "abc", "<code>repeatStringNumTimes("abc", 1)</code> should return <code>"abc"</code>.");'
-  - text: &#39; <code>repeatStringNumTimes(&quot;*&quot;, 8)</code> debe devolver <code>&quot;********&quot;</code> .&#39;
+  - text: ' <code>repeatStringNumTimes(&quot;*&quot;, 8)</code> debe devolver <code>&quot;********&quot;</code> .'
     testString: 'assert(repeatStringNumTimes("*", 8) === "********", "<code>repeatStringNumTimes("*", 8)</code> should return <code>"********"</code>.");'
-  - text: &#39; <code>repeatStringNumTimes(&quot;abc&quot;, -2)</code> debe devolver <code>&quot;&quot;</code> .&#39;
+  - text: ' <code>repeatStringNumTimes(&quot;abc&quot;, -2)</code> debe devolver <code>&quot;&quot;</code> .'
     testString: 'assert(repeatStringNumTimes("abc", -2) === "", "<code>repeatStringNumTimes("abc", -2)</code> should return <code>""</code>.");'
   - text: El método <code>repeat()</code> incorporado no debe utilizarse
     testString: 'assert(!/\.repeat/g.test(code), "The built-in <code>repeat()</code>-method should not be used");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.spanish.md
index a8d9c08a7a..3479116fab 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devolver una matriz que consiste en el número más grande de cada sub-matriz proporcionada. Por simplicidad, la matriz provista contendrá exactamente 4 sub-matrices. 
-Recuerde, puede recorrer una matriz con un simple bucle for, y acceder a cada miembro con sintaxis de matriz <code>arr[i]</code> . 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Devolver una matriz que consiste en el número más grande de cada sub-matriz proporcionada. Por simplicidad, la matriz provista contendrá exactamente 4 sub-matrices.
+Recuerde, puede recorrer una matriz con un simple bucle for, y acceder a cada miembro con sintaxis de matriz <code>arr[i]</code> .
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,13 +23,13 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver una matriz. &#39;
+  - text: ' <code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver una matriz. '
     testString: 'assert(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]).constructor === Array, "<code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> should return an array.");'
-  - text: &#39; <code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver <code>[27, 5, 39, 1001]</code> .
+  - text: ' <code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> debe devolver <code>[27, 5, 39, 1001]</code> .
     testString: 'assert.deepEqual(largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]), [27, 5, 39, 1001], "<code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> should return <code>[27, 5, 39, 1001]</code>.");'
-  - text: &#39; <code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> debe devolver <code>[9, 35, 97, 1000000]</code> .
+  - text: ' <code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> debe devolver <code>[9, 35, 97, 1000000]</code> .
     testString: 'assert.deepEqual(largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]]), [9, 35, 97, 1000000], "<code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> should return <code>[9, 35, 97, 1000000]</code>.");'
-  - text: &#39; <code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> debe devolver <code>[25, 48, 21, -3]</code> . &#39;
+  - text: ' <code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> debe devolver <code>[25, 48, 21, -3]</code> . '
     testString: 'assert.deepEqual(largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]]), [25, 48, 21, -3], "<code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> should return <code>[25, 48, 21, -3]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.spanish.md
index c8294976be..da3bdc3c82 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.spanish.md
@@ -8,16 +8,16 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Te dan dos matrices y un índice. 
-Utilice la matriz métodos <code>slice</code> y <code>splice</code> para copiar cada elemento de la primera matriz en la segunda matriz, en orden. 
-Comenzar a insertar elementos en el índice <code>n</code> de la segunda matriz. 
-Devuelve la matriz resultante. Las matrices de entrada deben permanecer iguales después de que se ejecute la función. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Te dan dos matrices y un índice.
+Utilice la matriz métodos <code>slice</code> y <code>splice</code> para copiar cada elemento de la primera matriz en la segunda matriz, en orden.
+Comenzar a insertar elementos en el índice <code>n</code> de la segunda matriz.
+Devuelve la matriz resultante. Las matrices de entrada deben permanecer iguales después de que se ejecute la función.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -26,11 +26,11 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>frankenSplice([1, 2, 3], [4, 5], 1)</code> debe devolver <code>[4, 1, 2, 3, 5]</code> .&#39;
+  - text: ' <code>frankenSplice([1, 2, 3], [4, 5], 1)</code> debe devolver <code>[4, 1, 2, 3, 5]</code> .'
     testString: 'assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5], "<code>frankenSplice([1, 2, 3], [4, 5], 1)</code> should return <code>[4, 1, 2, 3, 5]</code>.");'
-  - text: &#39; <code>frankenSplice([1, 2], [&quot;a&quot;, &quot;b&quot;], 1)</code> debe devolver <code>[&quot;a&quot;, 1, 2, &quot;b&quot;]</code> .&#39;
+  - text: ' <code>frankenSplice([1, 2], [&quot;a&quot;, &quot;b&quot;], 1)</code> debe devolver <code>[&quot;a&quot;, 1, 2, &quot;b&quot;]</code> .'
     testString: 'assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ["a", 1, 2, "b"], "<code>frankenSplice([1, 2], ["a", "b"], 1)</code> should return <code>["a", 1, 2, "b"]</code>.");'
-  - text: &#39; <code>frankenSplice([&quot;claw&quot;, &quot;tentacle&quot;], [&quot;head&quot;, &quot;shoulders&quot;, &quot;knees&quot;, &quot;toes&quot;], 2)</code> debe devolver <code>[&quot;head&quot;, &quot;shoulders&quot;, &quot;claw&quot;, &quot;tentacle&quot;, &quot;knees&quot;, &quot;toes&quot;]</code> . &#39;
+  - text: ' <code>frankenSplice([&quot;claw&quot;, &quot;tentacle&quot;], [&quot;head&quot;, &quot;shoulders&quot;, &quot;knees&quot;, &quot;toes&quot;], 2)</code> debe devolver <code>[&quot;head&quot;, &quot;shoulders&quot;, &quot;claw&quot;, &quot;tentacle&quot;, &quot;knees&quot;, &quot;toes&quot;]</code> . '
     testString: 'assert.deepEqual(frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2), ["head", "shoulders", "claw", "tentacle", "knees", "toes"], "<code>frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)</code> should return <code>["head", "shoulders", "claw", "tentacle", "knees", "toes"]</code>.");'
   - text: Todos los elementos de la primera matriz se deben agregar a la segunda matriz en su orden original.
     testString: 'assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4], "All elements from the first array should be added to the second array in their original order.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.spanish.md
index c884304c3a..d2f0db714a 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devuelva la cadena provista con la primera letra de cada palabra en mayúscula. Asegúrese de que el resto de la palabra esté en minúscula. 
-A los efectos de este ejercicio, también debe poner mayúsculas en las palabras de conexión como &quot;el&quot; y &quot;de&quot;. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Devuelva la cadena provista con la primera letra de cada palabra en mayúscula. Asegúrese de que el resto de la palabra esté en minúscula.
+A los efectos de este ejercicio, también debe poner mayúsculas en las palabras de conexión como &quot;el&quot; y &quot;de&quot;.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,9 +23,9 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>titleCase(&quot;I&#39;m a little tea pot&quot;)</code> debería devolver una cadena.&#39;
+  - text: ' <code>titleCase(&quot;I&#39;m a little tea pot&quot;)</code> debería devolver una cadena.'
     testString: 'assert(typeof titleCase("I"m a little tea pot") === "string", "<code>titleCase("I&#39;m a little tea pot")</code> should return a string.");'
-  - text: &#39; <code>titleCase(&quot;I&#39;m a little tea pot&quot;)</code> debería devolver <code>I&#39;m A Little Tea Pot</code> &#39;.
+  - text: ' <code>titleCase(&quot;I&#39;m a little tea pot&quot;)</code> debería devolver <code>I&#39;m A Little Tea Pot</code> '
     testString: 'assert(titleCase("I"m a little tea pot") === "I"m A Little Tea Pot", "<code>titleCase("I&#39;m a little tea pot")</code> should return <code>I&#39;m A Little Tea Pot</code>.");'
   - text: <code>titleCase(&quot;sHoRt AnD sToUt&quot;)</code> debe devolver <code>Short And Stout</code> .
     testString: 'assert(titleCase("sHoRt AnD sToUt") === "Short And Stout", "<code>titleCase("sHoRt AnD sToUt")</code> should return <code>Short And Stout</code>.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.spanish.md
index 26a0c309ce..711146add9 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.spanish.md
@@ -7,13 +7,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Truncar una cadena (primer argumento) si es más larga que la longitud de cadena máxima dada (segundo argumento). Devuelve la cadena truncada con un <code>...</code> final. 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Truncar una cadena (primer argumento) si es más larga que la longitud de cadena máxima dada (segundo argumento). Devuelve la cadena truncada con un <code>...</code> final.
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,17 +22,17 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>truncateString(&quot;A-tisket a-tasket A green and yellow basket&quot;, 8)</code> debe devolver &quot;A-tisket ...&quot;.&#39;
+  - text: ' <code>truncateString(&quot;A-tisket a-tasket A green and yellow basket&quot;, 8)</code> debe devolver &quot;A-tisket ...&quot;.'
     testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", 8) === "A-tisket...", "<code>truncateString("A-tisket a-tasket A green and yellow basket", 8)</code> should return "A-tisket...".");'
-  - text: &#39; <code>truncateString(&quot;Peter Piper picked a peck of pickled peppers&quot;, 11)</code> debería devolver &quot;Peter Piper ...&quot;.
+  - text: ' <code>truncateString(&quot;Peter Piper picked a peck of pickled peppers&quot;, 11)</code> debería devolver &quot;Peter Piper ...&quot;.
     testString: 'assert(truncateString("Peter Piper picked a peck of pickled peppers", 11) === "Peter Piper...", "<code>truncateString("Peter Piper picked a peck of pickled peppers", 11)</code> should return "Peter Piper...".");'
-  - text: &#39; <code>truncateString(&quot;A-tisket a-tasket A green and yellow basket&quot;, &quot;A-tisket a-tasket A green and yellow basket&quot;.length)</code> debe devolver &quot;A-tisket a-tasket Una canasta verde y amarilla&quot;.&#39;
+  - text: ' <code>truncateString(&quot;A-tisket a-tasket A green and yellow basket&quot;, &quot;A-tisket a-tasket A green and yellow basket&quot;.length)</code> debe devolver &quot;A-tisket a-tasket Una canasta verde y amarilla&quot;.'
     testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length) === "A-tisket a-tasket A green and yellow basket", "<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)</code> should return "A-tisket a-tasket A green and yellow basket".");'
-  - text: &#39; <code>truncateString(&quot;A-tisket a-tasket A green and yellow basket&quot;, &quot;A-tisket a-tasket A green and yellow basket&quot;.length + 2)</code> debe devolver &quot;A-tisket a-tasket Una canasta verde y amarilla&quot; .
+  - text: ' <code>truncateString(&quot;A-tisket a-tasket A green and yellow basket&quot;, &quot;A-tisket a-tasket A green and yellow basket&quot;.length + 2)</code> debe devolver &quot;A-tisket a-tasket Una canasta verde y amarilla&quot; .
     testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2) === "A-tisket a-tasket A green and yellow basket", "<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)</code> should return "A-tisket a-tasket A green and yellow basket".");'
-  - text: &#39; <code>truncateString(&quot;A-&quot;, 1)</code> debe devolver &quot;A ...&quot;.&#39;
+  - text: ' <code>truncateString(&quot;A-&quot;, 1)</code> debe devolver &quot;A ...&quot;.'
     testString: 'assert(truncateString("A-", 1) === "A...", "<code>truncateString("A-", 1)</code> should return "A...".");'
-  - text: &#39; <code>truncateString(&quot;Absolutely Longer&quot;, 2)</code> debe devolver &quot;Ab ...&quot;.&#39;
+  - text: ' <code>truncateString(&quot;Absolutely Longer&quot;, 2)</code> debe devolver &quot;Ab ...&quot;.'
     testString: 'assert(truncateString("Absolutely Longer", 2) === "Ab...", "<code>truncateString("Absolutely Longer", 2)</code> should return "Ab...".");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.spanish.md
index 69899c82b5..bba23f57ca 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.spanish.md
@@ -7,15 +7,15 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devuelva el índice más bajo en el que se debe insertar un valor (segundo argumento) en una matriz (primer argumento) una vez que se haya ordenado. El valor devuelto debe ser un número. 
-Por ejemplo, <code>getIndexToIns([1,2,3,4], 1.5)</code> debe devolver <code>1</code> porque es mayor que <code>1</code> (índice 0), pero menor que <code>2</code> (índice 1). 
-Del mismo modo, <code>getIndexToIns([20,3,5], 19)</code> debe devolver <code>2</code> porque una vez que se ha ordenado la matriz se verá como <code>[3,5,20]</code> y <code>19</code> es menor que <code>20</code> (índice 2) y mayor que <code>5</code> (índice 1). 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Devuelva el índice más bajo en el que se debe insertar un valor (segundo argumento) en una matriz (primer argumento) una vez que se haya ordenado. El valor devuelto debe ser un número.
+Por ejemplo, <code>getIndexToIns([1,2,3,4], 1.5)</code> debe devolver <code>1</code> porque es mayor que <code>1</code> (índice 0), pero menor que <code>2</code> (índice 1).
+Del mismo modo, <code>getIndexToIns([20,3,5], 19)</code> debe devolver <code>2</code> porque una vez que se ha ordenado la matriz se verá como <code>[3,5,20]</code> y <code>19</code> es menor que <code>20</code> (índice 2) y mayor que <code>5</code> (índice 1).
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,37 +24,37 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver <code>3</code> &#39;
+  - text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver <code>3</code> '
     testString: 'assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3, "<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> should return <code>3</code>.");'
-  - text: &#39; <code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver un número&#39;.
+  - text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> debe devolver un número'
     testString: 'assert(typeof(getIndexToIns([10, 20, 30, 40, 50], 35)) === "number", "<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver <code>2</code> &#39;
+  - text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver <code>2</code> '
     testString: 'assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2, "<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> should return <code>2</code>.");'
-  - text: &#39; <code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver un número&#39;.
+  - text: ' <code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> debe devolver un número'
     testString: 'assert(typeof(getIndexToIns([10, 20, 30, 40, 50], 30)) === "number", "<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([40, 60], 50)</code> debe devolver <code>1</code> &#39;
+  - text: ' <code>getIndexToIns([40, 60], 50)</code> debe devolver <code>1</code> '
     testString: 'assert(getIndexToIns([40, 60], 50) === 1, "<code>getIndexToIns([40, 60], 50)</code> should return <code>1</code>.");'
-  - text: &#39; <code>getIndexToIns([40, 60], 50)</code> debe devolver un número.&#39;
+  - text: ' <code>getIndexToIns([40, 60], 50)</code> debe devolver un número.'
     testString: 'assert(typeof(getIndexToIns([40, 60], 50)) === "number", "<code>getIndexToIns([40, 60], 50)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([3, 10, 5], 3)</code> debe devolver <code>0</code> &#39;
+  - text: ' <code>getIndexToIns([3, 10, 5], 3)</code> debe devolver <code>0</code> '
     testString: 'assert(getIndexToIns([3, 10, 5], 3) === 0, "<code>getIndexToIns([3, 10, 5], 3)</code> should return <code>0</code>.");'
-  - text: &#39; <code>getIndexToIns([3, 10, 5], 3)</code> debe devolver un número&#39;.
+  - text: ' <code>getIndexToIns([3, 10, 5], 3)</code> debe devolver un número'
     testString: 'assert(typeof(getIndexToIns([3, 10, 5], 3)) === "number", "<code>getIndexToIns([3, 10, 5], 3)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver <code>2</code> &#39;
+  - text: ' <code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver <code>2</code> '
     testString: 'assert(getIndexToIns([5, 3, 20, 3], 5) === 2, "<code>getIndexToIns([5, 3, 20, 3], 5)</code> should return <code>2</code>.");'
-  - text: &#39; <code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver un número&#39;.
+  - text: ' <code>getIndexToIns([5, 3, 20, 3], 5)</code> debe devolver un número'
     testString: 'assert(typeof(getIndexToIns([5, 3, 20, 3], 5)) === "number", "<code>getIndexToIns([5, 3, 20, 3], 5)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([2, 20, 10], 19)</code> debe devolver <code>2</code> &#39;
+  - text: ' <code>getIndexToIns([2, 20, 10], 19)</code> debe devolver <code>2</code> '
     testString: 'assert(getIndexToIns([2, 20, 10], 19) === 2, "<code>getIndexToIns([2, 20, 10], 19)</code> should return <code>2</code>.");'
-  - text: &#39; <code>getIndexToIns([2, 20, 10], 19)</code> debe devolver un número&#39;.
+  - text: ' <code>getIndexToIns([2, 20, 10], 19)</code> debe devolver un número'
     testString: 'assert(typeof(getIndexToIns([2, 20, 10], 19)) === "number", "<code>getIndexToIns([2, 20, 10], 19)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([2, 5, 10], 15)</code> debe devolver <code>3</code> &#39;
+  - text: ' <code>getIndexToIns([2, 5, 10], 15)</code> debe devolver <code>3</code> '
     testString: 'assert(getIndexToIns([2, 5, 10], 15) === 3, "<code>getIndexToIns([2, 5, 10], 15)</code> should return <code>3</code>.");'
-  - text: &#39; <code>getIndexToIns([2, 5, 10], 15)</code> debe devolver un número&#39;.
+  - text: ' <code>getIndexToIns([2, 5, 10], 15)</code> debe devolver un número'
     testString: 'assert(typeof(getIndexToIns([2, 5, 10], 15)) === "number", "<code>getIndexToIns([2, 5, 10], 15)</code> should return a number.");'
-  - text: &#39; <code>getIndexToIns([], 1)</code> debe devolver <code>0</code> &#39;
+  - text: ' <code>getIndexToIns([], 1)</code> debe devolver <code>0</code> '
     testString: 'assert(getIndexToIns([], 1) === 0, "<code>getIndexToIns([], 1)</code> should return <code>0</code>.");'
-  - text: &#39; <code>getIndexToIns([], 1)</code> debe devolver un número.&#39;
+  - text: ' <code>getIndexToIns([], 1)</code> debe devolver un número.'
     testString: 'assert(typeof(getIndexToIns([], 1)) === "number", "<code>getIndexToIns([], 1)</code> should return a number.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.spanish.md
index 05ba8bc091..56cb54f086 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.spanish.md
@@ -6,22 +6,22 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-La característica fundamental de cualquier estructura de datos es, por supuesto, la capacidad no solo de almacenar datos, sino también de poder recuperar esos datos en el comando. Entonces, ahora que hemos aprendido cómo crear una matriz, comencemos a pensar cómo podemos acceder a la información de esa matriz. 
-Cuando definimos una matriz simple como se ve a continuación, hay 3 elementos en ella: 
-<blockquote>let ourArray = ["a", "b", "c"];</blockquote> 
-En una matriz, cada elemento de la matriz tiene un <dfn>índice</dfn> . Este índice se duplica como la posición de ese elemento en la matriz y cómo se hace referencia a él. Sin embargo, es importante tener en cuenta que las matrices de JavaScript tienen <dfn>un índice de cero</dfn> , lo que significa que el primer elemento de una matriz está en realidad en la posición <em><strong>cero</strong></em> , no en el primero. 
-Para recuperar un elemento de una matriz, podemos encerrar un índice entre paréntesis y agregarlo al final de una matriz, o más comúnmente, a una variable que hace referencia a un objeto de matriz. Esto se conoce como <dfn>notación de corchete</dfn> . 
-Por ejemplo, si queremos recuperar la <code>&quot;a&quot;</code> de <code>ourArray</code> y asignarla a una variable, podemos hacerlo con el siguiente código: 
-<blockquote>let ourVariable = ourArray[0];<br>// ourVariable equals "a"</blockquote> 
-Además de acceder al valor asociado a un índice, también puede <em>establecer</em> un índice en un valor usando la misma notación: 
-<blockquote>ourArray[1] = "not b anymore";<br>// ourArray now equals ["a", "not b anymore", "c"];</blockquote> 
-Usando la notación de corchetes, ahora hemos restablecido el elemento en el índice 1 de <code>&quot;b&quot;</code> , a <code>&quot;not b anymore&quot;</code> . 
+<section id='description'>
+La característica fundamental de cualquier estructura de datos es, por supuesto, la capacidad no solo de almacenar datos, sino también de poder recuperar esos datos en el comando. Entonces, ahora que hemos aprendido cómo crear una matriz, comencemos a pensar cómo podemos acceder a la información de esa matriz.
+Cuando definimos una matriz simple como se ve a continuación, hay 3 elementos en ella:
+<blockquote>let ourArray = ["a", "b", "c"];</blockquote>
+En una matriz, cada elemento de la matriz tiene un <dfn>índice</dfn> . Este índice se duplica como la posición de ese elemento en la matriz y cómo se hace referencia a él. Sin embargo, es importante tener en cuenta que las matrices de JavaScript tienen <dfn>un índice de cero</dfn> , lo que significa que el primer elemento de una matriz está en realidad en la posición <em><strong>cero</strong></em> , no en el primero.
+Para recuperar un elemento de una matriz, podemos encerrar un índice entre paréntesis y agregarlo al final de una matriz, o más comúnmente, a una variable que hace referencia a un objeto de matriz. Esto se conoce como <dfn>notación de corchete</dfn> .
+Por ejemplo, si queremos recuperar la <code>&quot;a&quot;</code> de <code>ourArray</code> y asignarla a una variable, podemos hacerlo con el siguiente código:
+<blockquote>let ourVariable = ourArray[0];<br>// ourVariable equals "a"</blockquote>
+Además de acceder al valor asociado a un índice, también puede <em>establecer</em> un índice en un valor usando la misma notación:
+<blockquote>ourArray[1] = "not b anymore";<br>// ourArray now equals ["a", "not b anymore", "c"];</blockquote>
+Usando la notación de corchetes, ahora hemos restablecido el elemento en el índice 1 de <code>&quot;b&quot;</code> , a <code>&quot;not b anymore&quot;</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Para completar este desafío, establezca la segunda posición (índice <code>1</code> ) de <code>myArray</code> en cualquier cosa que desee, además de <code>&quot;b&quot;</code> . 
+<section id='instructions'>
+Para completar este desafío, establezca la segunda posición (índice <code>1</code> ) de <code>myArray</code> en cualquier cosa que desee, además de <code>&quot;b&quot;</code> .
 </section>
 
 ## Tests
@@ -29,13 +29,13 @@ Para completar este desafío, establezca la segunda posición (índice <code>1</
 
 ```yml
 tests:
-  - text: &#39; <code>myArray[0]</code> es igual a <code>&quot;a&quot;</code> &#39;
+  - text: ' <code>myArray[0]</code> es igual a <code>&quot;a&quot;</code> '
     testString: 'assert.strictEqual(myArray[0], "a", "<code>myArray[0]</code> is equal to <code>"a"</code>");'
-  - text: &#39; <code>myArray[1]</code> ya no está configurado en <code>&quot;b&quot;</code> &#39;
+  - text: ' <code>myArray[1]</code> ya no está configurado en <code>&quot;b&quot;</code> '
     testString: 'assert.notStrictEqual(myArray[1], "b", "<code>myArray[1]</code> is no longer set to <code>"b"</code>");'
-  - text: &#39; <code>myArray[2]</code> es igual a <code>&quot;c&quot;</code> &#39;
+  - text: ' <code>myArray[2]</code> es igual a <code>&quot;c&quot;</code> '
     testString: 'assert.strictEqual(myArray[2], "c", "<code>myArray[2]</code> is equal to <code>"c"</code>");'
-  - text: &#39; <code>myArray[3]</code> es igual a <code>&quot;d&quot;</code> &#39;
+  - text: ' <code>myArray[3]</code> es igual a <code>&quot;d&quot;</code> '
     testString: 'assert.strictEqual(myArray[3], "d", "<code>myArray[3]</code> is equal to <code>"d"</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.spanish.md
index dd97e921f3..eb14dcf71b 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En el primer desafío de objetos mencionamos el uso de la notación de corchetes como una forma de acceder a los valores de las propiedades mediante la evaluación de una variable. Por ejemplo, imagine que nuestro objeto de <code>foods</code> se está utilizando en un programa para una caja registradora de un supermercado. Tenemos alguna función que configura los <code>foods</code> <code>selectedFood</code> y queremos verificar el objeto de nuestros <code>foods</code> para detectar la presencia de ese alimento. Esto podría parecer: 
-<blockquote>let selectedFood = getCurrentFood(scannedItem);<br>let inventory = foods[selectedFood];</blockquote> 
-Este código evaluará el valor almacenado en la variable <code>selectedFood</code> y devolverá el valor de esa clave en el objeto de <code>foods</code> , o <code>undefined</code> si no está presente. La notación de corchetes es muy útil porque a veces las propiedades de los objetos no se conocen antes del tiempo de ejecución o necesitamos acceder a ellos de una manera más dinámica. 
+<section id='description'>
+En el primer desafío de objetos mencionamos el uso de la notación de corchetes como una forma de acceder a los valores de las propiedades mediante la evaluación de una variable. Por ejemplo, imagine que nuestro objeto de <code>foods</code> se está utilizando en un programa para una caja registradora de un supermercado. Tenemos alguna función que configura los <code>foods</code> <code>selectedFood</code> y queremos verificar el objeto de nuestros <code>foods</code> para detectar la presencia de ese alimento. Esto podría parecer:
+<blockquote>let selectedFood = getCurrentFood(scannedItem);<br>let inventory = foods[selectedFood];</blockquote>
+Este código evaluará el valor almacenado en la variable <code>selectedFood</code> y devolverá el valor de esa clave en el objeto de <code>foods</code> , o <code>undefined</code> si no está presente. La notación de corchetes es muy útil porque a veces las propiedades de los objetos no se conocen antes del tiempo de ejecución o necesitamos acceder a ellos de una manera más dinámica.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>checkInventory</code> , que recibe un elemento escaneado como un argumento. Devuelve el valor actual de la clave <code>scannedItem</code> en el objeto de <code>foods</code> . Puede suponer que solo se proporcionarán claves válidas como argumento para <code>checkInventory</code> . 
+<section id='instructions'>
+Hemos definido una función, <code>checkInventory</code> , que recibe un elemento escaneado como un argumento. Devuelve el valor actual de la clave <code>scannedItem</code> en el objeto de <code>foods</code> . Puede suponer que solo se proporcionarán claves válidas como argumento para <code>checkInventory</code> .
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Hemos definido una función, <code>checkInventory</code> , que recibe un element
 tests:
   - text: <code>checkInventory</code> es una función
     testString: 'assert.strictEqual(typeof checkInventory, "function", "<code>checkInventory</code> is a function");'
-  - text: &#39;El objeto de <code>foods</code> debe tener solo los siguientes pares clave-valor: <code>apples: 25</code> , <code>oranges: 32</code> , <code>plums: 28</code> , <code>bananas: 13</code> , <code>grapes: 35</code> , <code>strawberries: 27</code> &#39;
+  - text: 'El objeto de <code>foods</code> debe tener solo los siguientes pares clave-valor: <code>apples: 25</code> , <code>oranges: 32</code> , <code>plums: 28</code> , <code>bananas: 13</code> , <code>grapes: 35</code> , <code>strawberries: 27</code> '
     testString: 'assert.deepEqual(foods, {apples: 25, oranges: 32, plums: 28, bananas: 13, grapes: 35, strawberries: 27}, "The <code>foods</code> object should have only the following key-value pairs: <code>apples: 25</code>, <code>oranges: 32</code>, <code>plums: 28</code>, <code>bananas: 13</code>, <code>grapes: 35</code>, <code>strawberries: 27</code>");'
   - text: <code>checkInventory(&quot;apples&quot;)</code> debe devolver <code>25</code>
     testString: 'assert.strictEqual(checkInventory("apples"), 25, "<code>checkInventory("apples")</code> should return <code>25</code>");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.spanish.md
index 96e9f5f9e9..911ad1b245 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-La longitud de una matriz, como los tipos de datos que puede contener, no es fija. Las matrices se pueden definir con una longitud de cualquier número de elementos, y los elementos se pueden agregar o eliminar con el tiempo; en otras palabras, los arreglos son <dfn>mutables</dfn> . En este desafío, veremos dos métodos con los cuales podemos modificar mediante programación una matriz: <code>Array.push()</code> y <code>Array.unshift()</code> . 
-Ambos métodos toman uno o más elementos como parámetros y agregan esos elementos a la matriz en la que se está utilizando el método; el método <code>push()</code> agrega elementos al final de una matriz, y <code>unshift()</code> agrega elementos al principio. Considera lo siguiente: 
-<blockquote>let twentyThree = 'XXIII';<br>let romanNumerals = ['XXI', 'XXII'];<br><br>romanNumerals.unshift('XIX', 'XX');<br>// now equals ['XIX', 'XX', 'XXI', 'XXII']<br><br>romanNumerals.push(twentyThree);<br>// now equals ['XIX', 'XX', 'XXI', 'XXII', 'XXIII'] 
-Notice that we can also pass variables, which allows us even greater flexibility in dynamically modifying our array's data. 
+<section id='description'>
+La longitud de una matriz, como los tipos de datos que puede contener, no es fija. Las matrices se pueden definir con una longitud de cualquier número de elementos, y los elementos se pueden agregar o eliminar con el tiempo; en otras palabras, los arreglos son <dfn>mutables</dfn> . En este desafío, veremos dos métodos con los cuales podemos modificar mediante programación una matriz: <code>Array.push()</code> y <code>Array.unshift()</code> .
+Ambos métodos toman uno o más elementos como parámetros y agregan esos elementos a la matriz en la que se está utilizando el método; el método <code>push()</code> agrega elementos al final de una matriz, y <code>unshift()</code> agrega elementos al principio. Considera lo siguiente:
+<blockquote>let twentyThree = 'XXIII';<br>let romanNumerals = ['XXI', 'XXII'];<br><br>romanNumerals.unshift('XIX', 'XX');<br>// now equals ['XIX', 'XX', 'XXI', 'XXII']<br><br>romanNumerals.push(twentyThree);<br>// now equals ['XIX', 'XX', 'XXI', 'XXII', 'XXIII']
+Notice that we can also pass variables, which allows us even greater flexibility in dynamically modifying our array's data.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>mixedNumbers</code> , a la que le estamos pasando una matriz como argumento. Modifique la función utilizando <code>push()</code> y <code>unshift()</code> para agregar <code>&#39;I&#39;, 2, &#39;three&#39;</code> al principio de la matriz y <code>7, &#39;VIII&#39;, 9</code> al final para que la matriz devuelta contenga representaciones de los números 1-9 en orden. 
+<section id='instructions'>
+Hemos definido una función, <code>mixedNumbers</code> , a la que le estamos pasando una matriz como argumento. Modifique la función utilizando <code>push()</code> y <code>unshift()</code> para agregar <code>&#39;I&#39;, 2, &#39;three&#39;</code> al principio de la matriz y <code>7, &#39;VIII&#39;, 9</code> al final para que la matriz devuelta contenga representaciones de los números 1-9 en orden.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Hemos definido una función, <code>mixedNumbers</code> , a la que le estamos pas
 
 ```yml
 tests:
-  - text: &#39; <code>mixedNumbers([&quot;IV&quot;, 5, &quot;six&quot;])</code> ahora debe devolver <code>[&quot;I&quot;, 2, &quot;three&quot;, &quot;IV&quot;, 5, &quot;six&quot;, 7, &quot;VIII&quot;, 9]</code> &#39;
+  - text: ' <code>mixedNumbers([&quot;IV&quot;, 5, &quot;six&quot;])</code> ahora debe devolver <code>[&quot;I&quot;, 2, &quot;three&quot;, &quot;IV&quot;, 5, &quot;six&quot;, 7, &quot;VIII&quot;, 9]</code> '
     testString: 'assert.deepEqual(mixedNumbers(["IV", 5, "six"]), ["I", 2, "three", "IV", 5, "six", 7, "VIII", 9], "<code>mixedNumbers(["IV", 5, "six"])</code> should now return <code>["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]</code>");'
   - text: La función <code>mixedNumbers</code> debe utilizar el método <code>push()</code>
     testString: 'assert.notStrictEqual(mixedNumbers.toString().search(/\.push\(/), -1, "The <code>mixedNumbers</code> function should utilize the <code>push()</code> method");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.spanish.md
index ab2e3d2fcc..bed64e13ab 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Recuerda que en el último desafío mencionamos que <code>splice()</code> puede tomar hasta tres parámetros? Bueno, podemos ir un paso más allá con <code>splice()</code> ; además de eliminar elementos, podemos usar ese tercer parámetro, que representa uno o más elementos, para <em>agregarlos</em> también. Esto puede ser increíblemente útil para cambiar rápidamente un elemento, o un conjunto de elementos, por otro. Por ejemplo, supongamos que está almacenando una combinación de colores para un conjunto de elementos DOM en una matriz, y desea cambiar dinámicamente un color en función de alguna acción: 
-<blockquote>function colorChange(arr, index, newColor) {<br>&nbsp;&nbsp;arr.splice(index, 1, newColor);<br>&nbsp;&nbsp;return arr;<br>}<br><br>let colorScheme = ['#878787', '#a08794', '#bb7e8c', '#c9b6be', '#d1becf'];<br><br>colorScheme = colorChange(colorScheme, 2, '#332327');<br>// we have removed '#bb7e8c' and added '#332327' in its place<br>// colorScheme now equals ['#878787', '#a08794', '#332327', '#c9b6be', '#d1becf']</blockquote> 
-Esta función toma una matriz de valores hexadecimales, un índice para eliminar un elemento y el nuevo color para reemplazar el elemento eliminado. El valor de retorno es una matriz que contiene un esquema de color recién modificado. Si bien este ejemplo está un poco simplificado, podemos ver el valor que puede tener el uso de <code>splice()</code> en su potencial máximo. 
+<section id='description'>
+Recuerda que en el último desafío mencionamos que <code>splice()</code> puede tomar hasta tres parámetros? Bueno, podemos ir un paso más allá con <code>splice()</code> ; además de eliminar elementos, podemos usar ese tercer parámetro, que representa uno o más elementos, para <em>agregarlos</em> también. Esto puede ser increíblemente útil para cambiar rápidamente un elemento, o un conjunto de elementos, por otro. Por ejemplo, supongamos que está almacenando una combinación de colores para un conjunto de elementos DOM en una matriz, y desea cambiar dinámicamente un color en función de alguna acción:
+<blockquote>function colorChange(arr, index, newColor) {<br>&nbsp;&nbsp;arr.splice(index, 1, newColor);<br>&nbsp;&nbsp;return arr;<br>}<br><br>let colorScheme = ['#878787', '#a08794', '#bb7e8c', '#c9b6be', '#d1becf'];<br><br>colorScheme = colorChange(colorScheme, 2, '#332327');<br>// we have removed '#bb7e8c' and added '#332327' in its place<br>// colorScheme now equals ['#878787', '#a08794', '#332327', '#c9b6be', '#d1becf']</blockquote>
+Esta función toma una matriz de valores hexadecimales, un índice para eliminar un elemento y el nuevo color para reemplazar el elemento eliminado. El valor de retorno es una matriz que contiene un esquema de color recién modificado. Si bien este ejemplo está un poco simplificado, podemos ver el valor que puede tener el uso de <code>splice()</code> en su potencial máximo.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>htmlColorNames</code> , que toma una matriz de colores HTML como argumento. Modifique la función utilizando <code>splice()</code> para eliminar los dos primeros elementos de la matriz y agregue <code>&#39;DarkSalmon&#39;</code> y <code>&#39;BlanchedAlmond&#39;</code> en sus respectivos lugares. 
+<section id='instructions'>
+Hemos definido una función, <code>htmlColorNames</code> , que toma una matriz de colores HTML como argumento. Modifique la función utilizando <code>splice()</code> para eliminar los dos primeros elementos de la matriz y agregue <code>&#39;DarkSalmon&#39;</code> y <code>&#39;BlanchedAlmond&#39;</code> en sus respectivos lugares.
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Hemos definido una función, <code>htmlColorNames</code> , que toma una matriz d
 
 ```yml
 tests:
-  - text: &#39; <code>htmlColorNames</code> debería devolver <code>[&quot;DarkSalmon&quot;, &quot;BlanchedAlmond&quot;, &quot;LavenderBlush&quot;, &quot;PaleTurqoise&quot;, &quot;FireBrick&quot;]</code> &#39;
+  - text: ' <code>htmlColorNames</code> debería devolver <code>[&quot;DarkSalmon&quot;, &quot;BlanchedAlmond&quot;, &quot;LavenderBlush&quot;, &quot;PaleTurqoise&quot;, &quot;FireBrick&quot;]</code> '
     testString: 'assert.deepEqual(htmlColorNames(["DarkGoldenRod", "WhiteSmoke", "LavenderBlush", "PaleTurqoise", "FireBrick"]), ["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"], "<code>htmlColorNames</code> should return <code>["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]</code>");'
   - text: La función <code>htmlColorNames</code> debe utilizar el método <code>splice()</code>
     testString: 'assert(/.splice/.test(code), "The <code>htmlColorNames</code> function should utilize the <code>splice()</code> method");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.spanish.md
index 372c20f705..a9509b3b05 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Dado que las matrices se pueden cambiar, o <em>mutar</em> , en cualquier momento, no hay ninguna garantía sobre dónde estará una determinada pieza de datos en una matriz determinada, o si ese elemento aún existe. Afortunadamente, JavaScript nos proporciona otro método <code>indexOf()</code> , <code>indexOf()</code> , que nos permite verificar rápida y fácilmente la presencia de un elemento en una matriz. <code>indexOf()</code> toma un elemento como parámetro y, cuando se le llama, devuelve la posición o el índice de ese elemento, o <code>-1</code> si el elemento no existe en la matriz. 
-Por ejemplo: 
-<blockquote>let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];<br><br>fruits.indexOf('dates') // returns -1<br>fruits.indexOf('oranges') // returns 2<br>fruits.indexOf('pears') // returns 1, the first index at which the element exists</blockquote> 
+<section id='description'>
+Dado que las matrices se pueden cambiar, o <em>mutar</em> , en cualquier momento, no hay ninguna garantía sobre dónde estará una determinada pieza de datos en una matriz determinada, o si ese elemento aún existe. Afortunadamente, JavaScript nos proporciona otro método <code>indexOf()</code> , <code>indexOf()</code> , que nos permite verificar rápida y fácilmente la presencia de un elemento en una matriz. <code>indexOf()</code> toma un elemento como parámetro y, cuando se le llama, devuelve la posición o el índice de ese elemento, o <code>-1</code> si el elemento no existe en la matriz.
+Por ejemplo:
+<blockquote>let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];<br><br>fruits.indexOf('dates') // returns -1<br>fruits.indexOf('oranges') // returns 2<br>fruits.indexOf('pears') // returns 1, the first index at which the element exists</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-<code>indexOf()</code> puede ser increíblemente útil para verificar rápidamente la presencia de un elemento en una matriz. Hemos definido una función, <code>quickCheck</code> , que toma una matriz y un elemento como argumentos. Modifique la función utilizando <code>indexOf()</code> para que devuelva <code>true</code> si el elemento pasado existe en la matriz, y <code>false</code> si no lo hace. 
+<section id='instructions'>
+<code>indexOf()</code> puede ser increíblemente útil para verificar rápidamente la presencia de un elemento en una matriz. Hemos definido una función, <code>quickCheck</code> , que toma una matriz y un elemento como argumentos. Modifique la función utilizando <code>indexOf()</code> para que devuelva <code>true</code> si el elemento pasado existe en la matriz, y <code>false</code> si no lo hace.
 </section>
 
 ## Tests
@@ -22,13 +22,13 @@ Por ejemplo:
 
 ```yml
 tests:
-  - text: &#39; <code>quickCheck([&quot;squash&quot;, &quot;onions&quot;, &quot;shallots&quot;], &quot;mushrooms&quot;)</code> debe devolver <code>false</code> &#39;
+  - text: ' <code>quickCheck([&quot;squash&quot;, &quot;onions&quot;, &quot;shallots&quot;], &quot;mushrooms&quot;)</code> debe devolver <code>false</code> '
     testString: 'assert.strictEqual(quickCheck(["squash", "onions", "shallots"], "mushrooms"), false, "<code>quickCheck(["squash", "onions", "shallots"], "mushrooms")</code> should return <code>false</code>");'
-  - text: &#39; <code>quickCheck([&quot;squash&quot;, &quot;onions&quot;, &quot;shallots&quot;], &quot;onions&quot;)</code> debe devolver <code>true</code> &quot;
+  - text: ' <code>quickCheck([&quot;squash&quot;, &quot;onions&quot;, &quot;shallots&quot;], &quot;onions&quot;)</code> debe devolver <code>true</code> &quot;
     testString: 'assert.strictEqual(quickCheck(["squash", "onions", "shallots"], "onions"), true, "<code>quickCheck(["squash", "onions", "shallots"], "onions")</code> should return <code>true</code>");'
-  - text: &#39; <code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> debe devolver <code>true</code> &#39;
+  - text: ' <code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> debe devolver <code>true</code> '
     testString: 'assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true, "<code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> should return <code>true</code>");'
-  - text: &#39; <code>quickCheck([true, false, false], undefined)</code> debe devolver <code>false</code> &#39;
+  - text: ' <code>quickCheck([true, false, false], undefined)</code> debe devolver <code>false</code> '
     testString: 'assert.strictEqual(quickCheck([true, false, false], undefined), false, "<code>quickCheck([true, false, false], undefined)</code> should return <code>false</code>");'
   - text: La función <code>quickCheck</code> debe utilizar el método <code>indexOf()</code>
     testString: 'assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1, "The <code>quickCheck</code> function should utilize the <code>indexOf()</code> method");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.spanish.md
index 405f991260..1c61d0ac38 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora podemos agregar, modificar y eliminar claves de objetos. Pero, ¿y si solo quisiéramos saber si un objeto tiene una propiedad específica? JavaScript nos proporciona dos formas diferentes de hacer esto. Uno usa el método <code>hasOwnProperty()</code> y el otro usa la palabra clave <code>in</code> . Si tenemos un objeto <code>users</code> con una propiedad de <code>Alan</code> , podríamos verificar su presencia de una de las siguientes maneras: 
-<blockquote>users.hasOwnProperty('Alan');<br>'Alan' in users;<br>// both return true</blockquote> 
+<section id='description'>
+Ahora podemos agregar, modificar y eliminar claves de objetos. Pero, ¿y si solo quisiéramos saber si un objeto tiene una propiedad específica? JavaScript nos proporciona dos formas diferentes de hacer esto. Uno usa el método <code>hasOwnProperty()</code> y el otro usa la palabra clave <code>in</code> . Si tenemos un objeto <code>users</code> con una propiedad de <code>Alan</code> , podríamos verificar su presencia de una de las siguientes maneras:
+<blockquote>users.hasOwnProperty('Alan');<br>'Alan' in users;<br>// both return true</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos creado un objeto, <code>users</code> , con algunos usuarios en él y una función <code>isEveryoneHere</code> , a la que pasamos el objeto de los <code>users</code> como un argumento. Termine de escribir esta función de modo que devuelva <code>true</code> solo si el objeto de los <code>users</code> contiene los cuatro nombres, <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> , como claves, y en caso contrario, <code>false</code> . 
+<section id='instructions'>
+Hemos creado un objeto, <code>users</code> , con algunos usuarios en él y una función <code>isEveryoneHere</code> , a la que pasamos el objeto de los <code>users</code> como un argumento. Termine de escribir esta función de modo que devuelva <code>true</code> solo si el objeto de los <code>users</code> contiene los cuatro nombres, <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> , como claves, y en caso contrario, <code>false</code> .
 </section>
 
 ## Tests
@@ -21,11 +21,11 @@ Hemos creado un objeto, <code>users</code> , con algunos usuarios en él y una f
 
 ```yml
 tests:
-  - text: &#39;El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> &#39;
+  - text: 'El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> '
     testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The <code>users</code> object only contains the keys <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code>");'
-  - text: &#39;La función <code>isEveryoneHere</code> devuelve <code>true</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> son propiedades del objeto de los <code>users</code> &#39;
+  - text: 'La función <code>isEveryoneHere</code> devuelve <code>true</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> son propiedades del objeto de los <code>users</code> '
     testString: 'assert(isEveryoneHere(users) === true, "The function <code>isEveryoneHere</code> returns <code>true</code> if <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code> are properties on the <code>users</code> object");'
-  - text: &#39;La función <code>isEveryoneHere</code> devuelve <code>false</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> no son propiedades del objeto de los <code>users</code> &#39;
+  - text: 'La función <code>isEveryoneHere</code> devuelve <code>false</code> si <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> no son propiedades del objeto de los <code>users</code> '
     testString: 'assert((function() { delete users.Alan; delete users.Jeff; delete users.Sarah; delete users.Ryan; return isEveryoneHere(users) })() === false, "The function <code>isEveryoneHere</code> returns <code>false</code> if <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code> are not properties on the <code>users</code> object");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.spanish.md
index 7da17657cc..ee6f978a88 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Otra gran ventaja del operador de <dfn>difusión</dfn> , es la capacidad de combinar arreglos, o de insertar todos los elementos de un arreglo en otro, en cualquier índice. Con sintaxis más tradicionales, podemos concatenar matrices, pero esto solo nos permite combinar matrices al final de una y al comienzo de otra. La sintaxis de propagación hace que la siguiente operación sea extremadamente simple: 
-<blockquote>let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];<br><br>let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];<br>// thatArray now equals ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']</blockquote> 
-Usando la sintaxis de propagación, acabamos de lograr una operación que hubiera sido más compleja y más detallada si hubiéramos usado métodos tradicionales. 
+<section id='description'>
+Otra gran ventaja del operador de <dfn>difusión</dfn> , es la capacidad de combinar arreglos, o de insertar todos los elementos de un arreglo en otro, en cualquier índice. Con sintaxis más tradicionales, podemos concatenar matrices, pero esto solo nos permite combinar matrices al final de una y al comienzo de otra. La sintaxis de propagación hace que la siguiente operación sea extremadamente simple:
+<blockquote>let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];<br><br>let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];<br>// thatArray now equals ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']</blockquote>
+Usando la sintaxis de propagación, acabamos de lograr una operación que hubiera sido más compleja y más detallada si hubiéramos usado métodos tradicionales.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función <code>spreadOut</code> que devuelve la <code>sentence</code> variable, modifique la función usando el operador de <dfn>propagación</dfn> para que devuelva la matriz <code>[&#39;learning&#39;, &#39;to&#39;, &#39;code&#39;, &#39;is&#39;, &#39;fun&#39;]</code> . 
+<section id='instructions'>
+Hemos definido una función <code>spreadOut</code> que devuelve la <code>sentence</code> variable, modifique la función usando el operador de <dfn>propagación</dfn> para que devuelva la matriz <code>[&#39;learning&#39;, &#39;to&#39;, &#39;code&#39;, &#39;is&#39;, &#39;fun&#39;]</code> .
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Hemos definido una función <code>spreadOut</code> que devuelve la <code>sentenc
 
 ```yml
 tests:
-  - text: &#39; <code>spreadOut</code> debería devolver <code>[&quot;learning&quot;, &quot;to&quot;, &quot;code&quot;, &quot;is&quot;, &quot;fun&quot;]</code> &#39;
+  - text: ' <code>spreadOut</code> debería devolver <code>[&quot;learning&quot;, &quot;to&quot;, &quot;code&quot;, &quot;is&quot;, &quot;fun&quot;]</code> '
     testString: 'assert.deepEqual(spreadOut(), ["learning", "to", "code", "is", "fun"], "<code>spreadOut</code> should return <code>["learning", "to", "code", "is", "fun"]</code>");'
   - text: La función <code>spreadOut</code> debe utilizar la sintaxis de difusión
     testString: 'assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1, "The <code>spreadOut</code> function should utilize spread syntax");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.spanish.md
index e4c92a3ade..e64f9d33b6 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Mientras <code>slice()</code> nos permite ser selectivos sobre qué elementos de una matriz copiar, entre otras muchas tareas útiles, el nuevo <dfn>operador de difusión de</dfn> ES6 nos permite copiar fácilmente <em>todos</em> los elementos de una matriz, en orden, con una sintaxis simple y altamente legible . La sintaxis de propagación simplemente se ve así: <code>...</code> 
-En la práctica, podemos usar el operador de propagación para copiar una matriz de la siguiente manera: 
-<blockquote>let thisArray = [true, true, undefined, false, null];<br>let thatArray = [...thisArray];<br>// thatArray equals [true, true, undefined, false, null]<br>// thisArray remains unchanged, and is identical to thatArray</blockquote> 
+<section id='description'>
+Mientras <code>slice()</code> nos permite ser selectivos sobre qué elementos de una matriz copiar, entre otras muchas tareas útiles, el nuevo <dfn>operador de difusión de</dfn> ES6 nos permite copiar fácilmente <em>todos</em> los elementos de una matriz, en orden, con una sintaxis simple y altamente legible . La sintaxis de propagación simplemente se ve así: <code>...</code>
+En la práctica, podemos usar el operador de propagación para copiar una matriz de la siguiente manera:
+<blockquote>let thisArray = [true, true, undefined, false, null];<br>let thatArray = [...thisArray];<br>// thatArray equals [true, true, undefined, false, null]<br>// thisArray remains unchanged, and is identical to thatArray</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>copyMachine</code> que toma <code>arr</code> (una matriz) y <code>num</code> (un número) como argumentos. Se supone que la función devuelve una nueva matriz formada por <code>num</code> copias de <code>arr</code> . Hemos hecho la mayor parte del trabajo por usted, pero todavía no funciona del todo bien. Modifique la función utilizando la sintaxis de dispersión para que funcione correctamente (sugerencia: ¡otro método que ya hemos cubierto podría ser útil aquí!). 
+<section id='instructions'>
+Hemos definido una función, <code>copyMachine</code> que toma <code>arr</code> (una matriz) y <code>num</code> (un número) como argumentos. Se supone que la función devuelve una nueva matriz formada por <code>num</code> copias de <code>arr</code> . Hemos hecho la mayor parte del trabajo por usted, pero todavía no funciona del todo bien. Modifique la función utilizando la sintaxis de dispersión para que funcione correctamente (sugerencia: ¡otro método que ya hemos cubierto podría ser útil aquí!).
 </section>
 
 ## Tests
@@ -22,13 +22,13 @@ Hemos definido una función, <code>copyMachine</code> que toma <code>arr</code>
 
 ```yml
 tests:
-  - text: &#39; <code>copyMachine([true, false, true], 2)</code> debe devolver <code>[[true, false, true], [true, false, true]]</code> &#39;
+  - text: ' <code>copyMachine([true, false, true], 2)</code> debe devolver <code>[[true, false, true], [true, false, true]]</code> '
     testString: 'assert.deepEqual(copyMachine([true, false, true], 2), [[true, false, true], [true, false, true]], "<code>copyMachine([true, false, true], 2)</code> should return <code>[[true, false, true], [true, false, true]]</code>");'
-  - text: &#39; <code>copyMachine([1, 2, 3], 5)</code> debe devolver <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code> &#39;
+  - text: ' <code>copyMachine([1, 2, 3], 5)</code> debe devolver <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code> '
     testString: 'assert.deepEqual(copyMachine([1, 2, 3], 5), [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]], "<code>copyMachine([1, 2, 3], 5)</code> should return <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code>");'
-  - text: &#39; <code>copyMachine([true, true, null], 1)</code> debe devolver <code>[[true, true, null]]</code> &#39;
+  - text: ' <code>copyMachine([true, true, null], 1)</code> debe devolver <code>[[true, true, null]]</code> '
     testString: 'assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]], "<code>copyMachine([true, true, null], 1)</code> should return <code>[[true, true, null]]</code>");'
-  - text: &#39; <code>copyMachine([&quot;it works&quot;], 3)</code> debería devolver <code>[[&quot;it works&quot;], [&quot;it works&quot;], [&quot;it works&quot;]]</code> &#39;
+  - text: ' <code>copyMachine([&quot;it works&quot;], 3)</code> debería devolver <code>[[&quot;it works&quot;], [&quot;it works&quot;], [&quot;it works&quot;]]</code> '
     testString: 'assert.deepEqual(copyMachine(["it works"], 3), [["it works"], ["it works"], ["it works"]], "<code>copyMachine(["it works"], 3)</code> should return <code>[["it works"], ["it works"], ["it works"]]</code>");'
   - text: La función <code>copyMachine</code> debe utilizar el <code>spread operator</code> con array <code>arr</code>
     testString: 'assert.notStrictEqual(copyMachine.toString().indexOf(".concat(_toConsumableArray(arr))"), -1, "The <code>copyMachine</code> function should utilize the <code>spread operator</code> with array <code>arr</code>");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.spanish.md
index 71ba55b3e4..259f4dd197 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El siguiente método que cubriremos es <code>slice()</code> . <code>slice()</code> , en lugar de modificar una matriz, copia o <em>extrae</em> , un número dado de elementos a una nueva matriz, dejando la matriz a la que se llama sin tocar. <code>slice()</code> toma solo 2 parámetros: el primero es el índice para comenzar la extracción y el segundo es el índice para detener la extracción (la extracción ocurrirá hasta, pero sin incluir el elemento en este índice). Considera esto: 
-<blockquote>let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];<br><br>let todaysWeather = weatherConditions.slice(1, 3);<br>// todaysWeather equals ['snow', 'sleet'];<br>// weatherConditions still equals ['rain', 'snow', 'sleet', 'hail', 'clear']<br></blockquote> 
-En efecto, hemos creado una nueva matriz extrayendo elementos de una matriz existente. 
+<section id='description'>
+El siguiente método que cubriremos es <code>slice()</code> . <code>slice()</code> , en lugar de modificar una matriz, copia o <em>extrae</em> , un número dado de elementos a una nueva matriz, dejando la matriz a la que se llama sin tocar. <code>slice()</code> toma solo 2 parámetros: el primero es el índice para comenzar la extracción y el segundo es el índice para detener la extracción (la extracción ocurrirá hasta, pero sin incluir el elemento en este índice). Considera esto:
+<blockquote>let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];<br><br>let todaysWeather = weatherConditions.slice(1, 3);<br>// todaysWeather equals ['snow', 'sleet'];<br>// weatherConditions still equals ['rain', 'snow', 'sleet', 'hail', 'clear']<br></blockquote>
+En efecto, hemos creado una nueva matriz extrayendo elementos de una matriz existente.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>forecast</code> , que toma una matriz como argumento. Modifique la función utilizando <code>slice()</code> para extraer información de la matriz de argumentos y devuelva una nueva matriz que contenga los elementos <code>&#39;warm&#39;</code> y <code>&#39;sunny&#39;</code> . 
+<section id='instructions'>
+Hemos definido una función, <code>forecast</code> , que toma una matriz como argumento. Modifique la función utilizando <code>slice()</code> para extraer información de la matriz de argumentos y devuelva una nueva matriz que contenga los elementos <code>&#39;warm&#39;</code> y <code>&#39;sunny&#39;</code> .
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Hemos definido una función, <code>forecast</code> , que toma una matriz como ar
 
 ```yml
 tests:
-  - text: &#39; <code>forecast</code> debería devolver <code>[&quot;warm&quot;, &quot;sunny&quot;]&#39;</code>
+  - text: ' <code>forecast</code> debería devolver <code>[&quot;warm&quot;, &quot;sunny&quot;]&#39;</code>
     testString: 'assert.deepEqual(forecast(["cold", "rainy", "warm", "sunny", "cool", "thunderstorms"]), ["warm", "sunny"], "<code>forecast</code> should return <code>["warm", "sunny"]");'
   - text: La función de <code>forecast</code> debe utilizar el método <code>slice()</code>
     testString: 'assert(/\.slice\(/.test(code), "The <code>forecast</code> function should utilize the <code>slice()</code> method");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.spanish.md
index a4d226cfdd..ce0d892ea7 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.spanish.md
@@ -6,20 +6,20 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-impresionante! ¡Acabas de aprender un montón de arreglos! Este ha sido un resumen de nivel bastante alto, y hay mucho más que aprender sobre el trabajo con matrices, muchas de las cuales veremos en secciones posteriores. Pero antes de pasar a mirar <dfn>Objetos</dfn> , echemos un vistazo más y veamos cómo los arreglos pueden volverse un poco más complejos de lo que hemos visto en desafíos anteriores. 
-Una de las características más poderosas cuando se piensa en los arreglos como estructuras de datos, es que los arreglos pueden contener, o incluso estar completamente compuestos de otros arreglos. Hemos visto matrices que contienen matrices en desafíos anteriores, pero bastante simples. Sin embargo, las matrices pueden contener una profundidad infinita de matrices que pueden contener otras matrices, cada una con sus propios niveles arbitrarios de profundidad, y así sucesivamente. De esta manera, una matriz puede convertirse muy rápidamente en una estructura de datos muy compleja, conocida como una matriz <dfn>multidimensional</dfn> o anidada. Considera el siguiente ejemplo: 
-<blockquote>let nestedArray = [ // top, or first level - the outer most array<br>&nbsp;&nbsp;['deep'], // an array within an array, 2 levels of depth<br>&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;['deeper'], ['deeper'] // 2 arrays nested 3 levels deep<br>&nbsp;&nbsp;],<br>&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;['deepest'], ['deepest'] // 2 arrays nested 4 levels deep<br>&nbsp;&nbsp;&nbsp;&nbsp;],<br>&nbsp;&nbsp;&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;['deepest-est?'] // an array nested 5 levels deep<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;]<br>&nbsp;&nbsp;&nbsp;&nbsp;]<br>&nbsp;&nbsp;]<br>];</blockquote> 
-Si bien este ejemplo puede parecer complicado, este nivel de complejidad no es inaudito, o incluso inusual, cuando se trata de grandes cantidades de datos. 
-Sin embargo, aún podemos acceder fácilmente a los niveles más profundos de una matriz de este complejo con notación de corchete: 
-<blockquote>console.log(nestedArray[2][1][0][0][0]);<br>// logs: deepest-est?</blockquote> 
-Y ahora que sabemos dónde está ese dato, podemos restablecerlo si necesitamos: 
-<blockquote>nestedArray[2][1][0][0][0] = 'deeper still';<br><br>console.log(nestedArray[2][1][0][0][0]);<br>// now logs: deeper still</blockquote> 
+<section id='description'>
+impresionante! ¡Acabas de aprender un montón de arreglos! Este ha sido un resumen de nivel bastante alto, y hay mucho más que aprender sobre el trabajo con matrices, muchas de las cuales veremos en secciones posteriores. Pero antes de pasar a mirar <dfn>Objetos</dfn> , echemos un vistazo más y veamos cómo los arreglos pueden volverse un poco más complejos de lo que hemos visto en desafíos anteriores.
+Una de las características más poderosas cuando se piensa en los arreglos como estructuras de datos, es que los arreglos pueden contener, o incluso estar completamente compuestos de otros arreglos. Hemos visto matrices que contienen matrices en desafíos anteriores, pero bastante simples. Sin embargo, las matrices pueden contener una profundidad infinita de matrices que pueden contener otras matrices, cada una con sus propios niveles arbitrarios de profundidad, y así sucesivamente. De esta manera, una matriz puede convertirse muy rápidamente en una estructura de datos muy compleja, conocida como una matriz <dfn>multidimensional</dfn> o anidada. Considera el siguiente ejemplo:
+<blockquote>let nestedArray = [ // top, or first level - the outer most array<br>&nbsp;&nbsp;['deep'], // an array within an array, 2 levels of depth<br>&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;['deeper'], ['deeper'] // 2 arrays nested 3 levels deep<br>&nbsp;&nbsp;],<br>&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;['deepest'], ['deepest'] // 2 arrays nested 4 levels deep<br>&nbsp;&nbsp;&nbsp;&nbsp;],<br>&nbsp;&nbsp;&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;['deepest-est?'] // an array nested 5 levels deep<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;]<br>&nbsp;&nbsp;&nbsp;&nbsp;]<br>&nbsp;&nbsp;]<br>];</blockquote>
+Si bien este ejemplo puede parecer complicado, este nivel de complejidad no es inaudito, o incluso inusual, cuando se trata de grandes cantidades de datos.
+Sin embargo, aún podemos acceder fácilmente a los niveles más profundos de una matriz de este complejo con notación de corchete:
+<blockquote>console.log(nestedArray[2][1][0][0][0]);<br>// logs: deepest-est?</blockquote>
+Y ahora que sabemos dónde está ese dato, podemos restablecerlo si necesitamos:
+<blockquote>nestedArray[2][1][0][0][0] = 'deeper still';<br><br>console.log(nestedArray[2][1][0][0][0]);<br>// now logs: deeper still</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una variable, <code>myNestedArray</code> , igual a una matriz. Modifique <code>myNestedArray</code> , utilizando cualquier combinación de <dfn>cadenas</dfn> , <dfn>números</dfn> y <dfn>valores booleanos</dfn> para los elementos de datos, de modo que tenga exactamente cinco niveles de profundidad (recuerde, la matriz más externa es el nivel 1). En algún lugar en el tercer nivel, incluye la cadena <code>&#39;deep&#39;</code> , en el cuarto nivel, incluyen la cadena <code>&#39;deeper&#39;</code> , y en el quinto nivel, incluyen la cadena <code>&#39;deepest&#39;</code> . 
+<section id='instructions'>
+Hemos definido una variable, <code>myNestedArray</code> , igual a una matriz. Modifique <code>myNestedArray</code> , utilizando cualquier combinación de <dfn>cadenas</dfn> , <dfn>números</dfn> y <dfn>valores booleanos</dfn> para los elementos de datos, de modo que tenga exactamente cinco niveles de profundidad (recuerde, la matriz más externa es el nivel 1). En algún lugar en el tercer nivel, incluye la cadena <code>&#39;deep&#39;</code> , en el cuarto nivel, incluyen la cadena <code>&#39;deeper&#39;</code> , y en el quinto nivel, incluyen la cadena <code>&#39;deepest&#39;</code> .
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ Hemos definido una variable, <code>myNestedArray</code> , igual a una matriz. Mo
 
 ```yml
 tests:
-  - text: &#39; <code>myNestedArray</code> debe contener solo números, booleanos y cadenas como elementos de datos&#39;
+  - text: ' <code>myNestedArray</code> debe contener solo números, booleanos y cadenas como elementos de datos'
     testString: 'assert.strictEqual((function(arr) { let flattened = (function flatten(arr) { const flat = [].concat(...arr); return flat.some (Array.isArray) ? flatten(flat) : flat; })(arr); for (let i = 0; i < flattened.length; i++) { if ( typeof flattened[i] !== "number" && typeof flattened[i] !== "string" && typeof flattened[i] !== "boolean") { return false } } return true })(myNestedArray), true, "<code>myNestedArray</code> should contain only numbers, booleans, and strings as data elements");'
   - text: <code>myNestedArray</code> debe tener exactamente 5 niveles de profundidad
     testString: 'assert.strictEqual((function(arr) {let depth = 0;function arrayDepth(array, i, d) { if (Array.isArray(array[i])) {  arrayDepth(array[i], 0, d + 1);} else {  depth = (d > depth) ? d : depth;}if (i < array.length) {  arrayDepth(array, i + 1, d);}  }arrayDepth(arr, 0, 0);return depth;})(myNestedArray), 4, "<code>myNestedArray</code> should have exactly 5 levels of depth");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.spanish.md
index 00b7829c94..f25de372f8 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.spanish.md
@@ -6,13 +6,13 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-También podemos generar una matriz que contiene todas las claves almacenadas en un objeto usando el método <code>Object.keys()</code> y pasando un objeto como argumento. Esto devolverá una matriz con cadenas que representan cada propiedad en el objeto. Nuevamente, no habrá un orden específico para las entradas en la matriz. 
+<section id='description'>
+También podemos generar una matriz que contiene todas las claves almacenadas en un objeto usando el método <code>Object.keys()</code> y pasando un objeto como argumento. Esto devolverá una matriz con cadenas que representan cada propiedad en el objeto. Nuevamente, no habrá un orden específico para las entradas en la matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Termine de escribir la función <code>getArrayOfUsers</code> para que devuelva una matriz que contenga todas las propiedades en el objeto que recibe como argumento. 
+<section id='instructions'>
+Termine de escribir la función <code>getArrayOfUsers</code> para que devuelva una matriz que contenga todas las propiedades en el objeto que recibe como argumento.
 </section>
 
 ## Tests
@@ -20,7 +20,7 @@ Termine de escribir la función <code>getArrayOfUsers</code> para que devuelva u
 
 ```yml
 tests:
-  - text: &#39;El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> &#39;
+  - text: 'El objeto de los <code>users</code> solo contiene las claves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> y <code>Ryan</code> '
     testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The <code>users</code> object only contains the keys <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code>");'
   - text: La función <code>getArrayOfUsers</code> devuelve una matriz que contiene todas las claves en el objeto de los <code>users</code>
     testString: 'assert((function() { users.Sam = {}; users.Lewis = {}; let R = getArrayOfUsers(users); return (R.indexOf("Alan") !== -1 && R.indexOf("Jeff") !== -1 && R.indexOf("Sarah") !== -1 && R.indexOf("Ryan") !== -1 && R.indexOf("Sam") !== -1 && R.indexOf("Lewis") !== -1); })() === true, "The <code>getArrayOfUsers</code> function returns an array which contains all the keys in the <code>users</code> object");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.spanish.md
index 11356a8372..9527fade6e 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-A veces, cuando se trabaja con matrices, es muy útil poder recorrer cada elemento para encontrar uno o más elementos que podríamos necesitar, o manipular una matriz en función de qué elementos de datos cumplen un determinado conjunto de criterios. JavaScript ofrece varios métodos integrados que se repiten en matrices de maneras ligeramente diferentes para lograr resultados diferentes (como <code>every()</code> , para <code>forEach()</code> , <code>map()</code> , etc.), sin embargo, la técnica es más flexible y nos ofrece la mejor cantidad de control es un simple <code>for</code> bucle. 
-Considera lo siguiente: 
-<blockquote>function greaterThanTen(arr) {<br>&nbsp;&nbsp;let newArr = [];<br>&nbsp;&nbsp;for (let i = 0; i < arr.length; i++) {<br>&nbsp;&nbsp;&nbsp;&nbsp;if (arr[i] > 10) {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;newArr.push(arr[i]);<br>&nbsp;&nbsp;&nbsp;&nbsp;}<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;return newArr;<br>}<br><br>greaterThanTen([2, 12, 8, 14, 80, 0, 1]);<br>// returns [12, 14, 80]</blockquote> 
-Usando un bucle <code>for</code> , esta función recorre y accede a cada elemento de la matriz, y lo somete a una prueba simple que hemos creado. De esta manera, hemos determinado fácil y programáticamente qué elementos de datos son más grandes que <code>10</code> , y hemos devuelto una nueva matriz que contiene esos elementos. 
+<section id='description'>
+A veces, cuando se trabaja con matrices, es muy útil poder recorrer cada elemento para encontrar uno o más elementos que podríamos necesitar, o manipular una matriz en función de qué elementos de datos cumplen un determinado conjunto de criterios. JavaScript ofrece varios métodos integrados que se repiten en matrices de maneras ligeramente diferentes para lograr resultados diferentes (como <code>every()</code> , para <code>forEach()</code> , <code>map()</code> , etc.), sin embargo, la técnica es más flexible y nos ofrece la mejor cantidad de control es un simple <code>for</code> bucle.
+Considera lo siguiente:
+<blockquote>function greaterThanTen(arr) {<br>&nbsp;&nbsp;let newArr = [];<br>&nbsp;&nbsp;for (let i = 0; i < arr.length; i++) {<br>&nbsp;&nbsp;&nbsp;&nbsp;if (arr[i] > 10) {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;newArr.push(arr[i]);<br>&nbsp;&nbsp;&nbsp;&nbsp;}<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;return newArr;<br>}<br><br>greaterThanTen([2, 12, 8, 14, 80, 0, 1]);<br>// returns [12, 14, 80]</blockquote>
+Usando un bucle <code>for</code> , esta función recorre y accede a cada elemento de la matriz, y lo somete a una prueba simple que hemos creado. De esta manera, hemos determinado fácil y programáticamente qué elementos de datos son más grandes que <code>10</code> , y hemos devuelto una nueva matriz que contiene esos elementos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>filteredArray</code> , que toma <code>arr</code> , una matriz anidada, y <code>elem</code> como argumentos, y devuelve una nueva matriz. <code>elem</code> representa un elemento que puede o no estar presente en una o más de las matrices anidadas dentro de <code>arr</code> . Modifique la función, utilizando un bucle <code>for</code> , para devolver una versión filtrada de la matriz pasada de manera que se haya eliminado cualquier matriz anidada dentro de <code>arr</code> contenga <code>elem</code> . 
+<section id='instructions'>
+Hemos definido una función, <code>filteredArray</code> , que toma <code>arr</code> , una matriz anidada, y <code>elem</code> como argumentos, y devuelve una nueva matriz. <code>elem</code> representa un elemento que puede o no estar presente en una o más de las matrices anidadas dentro de <code>arr</code> . Modifique la función, utilizando un bucle <code>for</code> , para devolver una versión filtrada de la matriz pasada de manera que se haya eliminado cualquier matriz anidada dentro de <code>arr</code> contenga <code>elem</code> .
 </section>
 
 ## Tests
@@ -23,13 +23,13 @@ Hemos definido una función, <code>filteredArray</code> , que toma <code>arr</co
 
 ```yml
 tests:
-  - text: &#39; <code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> debe devolver <code>[ [10, 8, 3], [14, 6, 23] ]</code> &#39;
+  - text: ' <code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> debe devolver <code>[ [10, 8, 3], [14, 6, 23] ]</code> '
     testString: 'assert.deepEqual(filteredArray([ [10, 8, 3], [14, 6, 23], [3, 18, 6] ], 18), [[10, 8, 3], [14, 6, 23]], "<code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> should return <code>[ [10, 8, 3], [14, 6, 23] ]</code>");'
-  - text: &#39; <code>filteredArray([ [&quot;trumpets&quot;, 2], [&quot;flutes&quot;, 4], [&quot;saxophones&quot;, 2] ], 2)</code> debe devolver <code>[ [&quot;flutes&quot;, 4] ]</code> &#39;
+  - text: ' <code>filteredArray([ [&quot;trumpets&quot;, 2], [&quot;flutes&quot;, 4], [&quot;saxophones&quot;, 2] ], 2)</code> debe devolver <code>[ [&quot;flutes&quot;, 4] ]</code> '
     testString: 'assert.deepEqual(filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2), [["flutes", 4]], "<code>filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)</code> should return <code>[ ["flutes", 4] ]</code>");'
-  - text: &#39; <code>filteredArray([ [&quot;amy&quot;, &quot;beth&quot;, &quot;sam&quot;], [&quot;dave&quot;, &quot;sean&quot;, &quot;peter&quot;] ], &quot;peter&quot;)</code> debe devolver <code>[ [&quot;amy&quot;, &quot;beth&quot;, &quot;sam&quot;] ]</code> &#39;
+  - text: ' <code>filteredArray([ [&quot;amy&quot;, &quot;beth&quot;, &quot;sam&quot;], [&quot;dave&quot;, &quot;sean&quot;, &quot;peter&quot;] ], &quot;peter&quot;)</code> debe devolver <code>[ [&quot;amy&quot;, &quot;beth&quot;, &quot;sam&quot;] ]</code> '
     testString: 'assert.deepEqual(filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter"), [["amy", "beth", "sam"]], "<code>filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")</code> should return <code>[ ["amy", "beth", "sam"] ]</code>");'
-  - text: &#39; <code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> debe devolver <code>[ ]</code> &#39;
+  - text: ' <code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> debe devolver <code>[ ]</code> '
     testString: 'assert.deepEqual(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3), [], "<code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> should return <code>[ ]</code>");'
   - text: El <code>filteredArray</code> función debe utilizar un <code>for</code> bucle
     testString: 'assert.notStrictEqual(filteredArray.toString().search(/for/), -1, "The <code>filteredArray</code> function should utilize a <code>for</code> loop");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.spanish.md
index d851c1bdfe..9bcb9deef6 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.spanish.md
@@ -6,13 +6,13 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora has visto todas las operaciones básicas para objetos JavaScript. Puede agregar, modificar y eliminar pares clave-valor, verificar si existen claves e iterar sobre todas las claves en un objeto. A medida que continúe aprendiendo JavaScript, verá aplicaciones de objetos aún más versátiles. Además, las lecciones opcionales de Estructuras de datos avanzadas más adelante en el plan de estudios también cubren los objetos <dfn>Map</dfn> y <dfn>Set de</dfn> ES6, los cuales son similares a los objetos comunes pero ofrecen algunas características adicionales. ¡Ahora que ha aprendido los conceptos básicos de matrices y objetos, está completamente preparado para comenzar a abordar problemas más complejos utilizando JavaScript! 
+<section id='description'>
+Ahora has visto todas las operaciones básicas para objetos JavaScript. Puede agregar, modificar y eliminar pares clave-valor, verificar si existen claves e iterar sobre todas las claves en un objeto. A medida que continúe aprendiendo JavaScript, verá aplicaciones de objetos aún más versátiles. Además, las lecciones opcionales de Estructuras de datos avanzadas más adelante en el plan de estudios también cubren los objetos <dfn>Map</dfn> y <dfn>Set de</dfn> ES6, los cuales son similares a los objetos comunes pero ofrecen algunas características adicionales. ¡Ahora que ha aprendido los conceptos básicos de matrices y objetos, está completamente preparado para comenzar a abordar problemas más complejos utilizando JavaScript!
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Eche un vistazo al objeto que hemos proporcionado en el editor de código. El objeto de <code>user</code> contiene tres claves. La clave de <code>data</code> contiene cinco claves, una de las cuales contiene una gran variedad de <code>friends</code> . A partir de esto, puede ver cómo los objetos flexibles son como estructuras de datos. Hemos empezado a escribir una función <code>addFriend</code> . Termine de escribirlo para que tome un objeto de <code>user</code> y agregue el nombre del argumento de <code>friend</code> a la matriz almacenada en <code>user.data.friends</code> y devuelva esa matriz. 
+<section id='instructions'>
+Eche un vistazo al objeto que hemos proporcionado en el editor de código. El objeto de <code>user</code> contiene tres claves. La clave de <code>data</code> contiene cinco claves, una de las cuales contiene una gran variedad de <code>friends</code> . A partir de esto, puede ver cómo los objetos flexibles son como estructuras de datos. Hemos empezado a escribir una función <code>addFriend</code> . Termine de escribirlo para que tome un objeto de <code>user</code> y agregue el nombre del argumento de <code>friend</code> a la matriz almacenada en <code>user.data.friends</code> y devuelva esa matriz.
 </section>
 
 ## Tests
@@ -20,11 +20,11 @@ Eche un vistazo al objeto que hemos proporcionado en el editor de código. El ob
 
 ```yml
 tests:
-  - text: &#39;El objeto de <code>user</code> tiene <code>name</code> , <code>age</code> y claves de <code>data</code> &#39;
+  - text: 'El objeto de <code>user</code> tiene <code>name</code> , <code>age</code> y claves de <code>data</code> '
     testString: 'assert("name" in user && "age" in user && "data" in user, "The <code>user</code> object has <code>name</code>, <code>age</code>, and <code>data</code> keys");'
   - text: La función <code>addFriend</code> acepta un objeto de <code>user</code> y una cadena de <code>friend</code> como argumentos y agrega el amigo a la matriz de <code>friends</code> en el objeto de <code>user</code>
     testString: 'assert((function() { let L1 = user.data.friends.length; addFriend(user, "Sean"); let L2 = user.data.friends.length; return (L2 === L1 + 1); })(), "The <code>addFriend</code> function accepts a <code>user</code> object and a <code>friend</code> string as arguments and adds the friend to the array of <code>friends</code> in the <code>user</code> object");'
-  - text: &#39; <code>addFriend(user, &quot;Pete&quot;)</code> debe devolver <code>[&quot;Sam&quot;, &quot;Kira&quot;, &quot;Tomo&quot;, &quot;Pete&quot;]</code> &#39;
+  - text: ' <code>addFriend(user, &quot;Pete&quot;)</code> debe devolver <code>[&quot;Sam&quot;, &quot;Kira&quot;, &quot;Tomo&quot;, &quot;Pete&quot;]</code> '
     testString: 'assert.deepEqual((function() { delete user.data.friends; user.data.friends = ["Sam", "Kira", "Tomo"]; return addFriend(user, "Pete") })(), ["Sam", "Kira", "Tomo", "Pete"], "<code>addFriend(user, "Pete")</code> should return <code>["Sam", "Kira", "Tomo", "Pete"]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.spanish.md
index 61e7211b0e..68dcc8e1f1 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora veamos un objeto un poco más complejo. Las propiedades de los objetos se pueden anidar a una profundidad arbitraria, y sus valores pueden ser cualquier tipo de datos admitidos por JavaScript, incluidas las matrices e incluso otros objetos. Considera lo siguiente: 
-<blockquote>let nestedObject = {<br>&nbsp;&nbsp;id: 28802695164,<br>&nbsp;&nbsp;date: 'December 31, 2016',<br>&nbsp;&nbsp;data: {<br>&nbsp;&nbsp;&nbsp;&nbsp;totalUsers: 99,<br>&nbsp;&nbsp;&nbsp;&nbsp;online: 80,<br>&nbsp;&nbsp;&nbsp;&nbsp;onlineStatus: {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;active: 67,<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;away: 13<br>&nbsp;&nbsp;&nbsp;&nbsp;}<br>&nbsp;&nbsp;}<br>};</blockquote> 
-<code>nestedObject</code> tiene tres claves únicas: <code>id</code> , cuyo valor es un número, la <code>date</code> cuyo valor es una cadena y los <code>data</code> , cuyo valor es un objeto que tiene otro objeto anidado dentro de él. Si bien las estructuras pueden volverse complejas rápidamente, aún podemos usar las mismas notaciones para acceder a la información que necesitamos. 
+<section id='description'>
+Ahora veamos un objeto un poco más complejo. Las propiedades de los objetos se pueden anidar a una profundidad arbitraria, y sus valores pueden ser cualquier tipo de datos admitidos por JavaScript, incluidas las matrices e incluso otros objetos. Considera lo siguiente:
+<blockquote>let nestedObject = {<br>&nbsp;&nbsp;id: 28802695164,<br>&nbsp;&nbsp;date: 'December 31, 2016',<br>&nbsp;&nbsp;data: {<br>&nbsp;&nbsp;&nbsp;&nbsp;totalUsers: 99,<br>&nbsp;&nbsp;&nbsp;&nbsp;online: 80,<br>&nbsp;&nbsp;&nbsp;&nbsp;onlineStatus: {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;active: 67,<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;away: 13<br>&nbsp;&nbsp;&nbsp;&nbsp;}<br>&nbsp;&nbsp;}<br>};</blockquote>
+<code>nestedObject</code> tiene tres claves únicas: <code>id</code> , cuyo valor es un número, la <code>date</code> cuyo valor es una cadena y los <code>data</code> , cuyo valor es un objeto que tiene otro objeto anidado dentro de él. Si bien las estructuras pueden volverse complejas rápidamente, aún podemos usar las mismas notaciones para acceder a la información que necesitamos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Aquí hemos definido un objeto, <code>userActivity</code> , que incluye otro objeto anidado dentro de él. Puede modificar las propiedades de este objeto anidado de la misma manera que modificó las propiedades en el último desafío. Establezca el valor de la clave en <code>online</code> en <code>45</code> . 
+<section id='instructions'>
+Aquí hemos definido un objeto, <code>userActivity</code> , que incluye otro objeto anidado dentro de él. Puede modificar las propiedades de este objeto anidado de la misma manera que modificó las propiedades en el último desafío. Establezca el valor de la clave en <code>online</code> en <code>45</code> .
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Aquí hemos definido un objeto, <code>userActivity</code> , que incluye otro obj
 
 ```yml
 tests:
-  - text: &#39; <code>userActivity</code> tiene <code>id</code> , <code>date</code> y propiedades de <code>data</code> &#39;
+  - text: ' <code>userActivity</code> tiene <code>id</code> , <code>date</code> y propiedades de <code>data</code> '
     testString: 'assert("id" in userActivity && "date" in userActivity && "data" in userActivity, "<code>userActivity</code> has <code>id</code>, <code>date</code> and <code>data</code> properties");'
   - text: <code>userActivity</code> tiene una clave de <code>data</code> configurada para un objeto con las teclas <code>totalUsers</code> y en <code>online</code>
     testString: 'assert("totalUsers" in userActivity.data && "online" in userActivity.data, "<code>userActivity</code> has a <code>data</code> key set to an object with keys <code>totalUsers</code> and <code>online</code>");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.spanish.md
index 2b04ce4061..3475a6b7f1 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Tanto <code>push()</code> como <code>unshift()</code> tienen métodos correspondientes que son opuestos casi funcionales: <code>pop()</code> y <code>shift()</code> . Como ya habrá adivinado, en lugar de agregar, <code>pop()</code> <em>elimina</em> un elemento del final de una matriz, mientras que <code>shift()</code> elimina un elemento desde el principio. La diferencia clave entre <code>pop()</code> y <code>shift()</code> y sus primos <code>push()</code> y <code>unshift()</code> , es que ninguno de los dos métodos toma parámetros, y cada uno solo permite que una matriz sea modificada por un solo elemento a la vez. 
-Echemos un vistazo: 
-<blockquote>let greetings = ['whats up?', 'hello', 'see ya!'];<br><br>greetings.pop();<br>// now equals ['whats up?', 'hello']<br><br>greetings.shift();<br>// now equals ['hello']</blockquote> 
-También podemos devolver el valor del elemento eliminado con uno de estos métodos: 
-<blockquote>let popped = greetings.pop();<br>// returns 'hello'<br>// greetings now equals []</blockquote> 
+<section id='description'>
+Tanto <code>push()</code> como <code>unshift()</code> tienen métodos correspondientes que son opuestos casi funcionales: <code>pop()</code> y <code>shift()</code> . Como ya habrá adivinado, en lugar de agregar, <code>pop()</code> <em>elimina</em> un elemento del final de una matriz, mientras que <code>shift()</code> elimina un elemento desde el principio. La diferencia clave entre <code>pop()</code> y <code>shift()</code> y sus primos <code>push()</code> y <code>unshift()</code> , es que ninguno de los dos métodos toma parámetros, y cada uno solo permite que una matriz sea modificada por un solo elemento a la vez.
+Echemos un vistazo:
+<blockquote>let greetings = ['whats up?', 'hello', 'see ya!'];<br><br>greetings.pop();<br>// now equals ['whats up?', 'hello']<br><br>greetings.shift();<br>// now equals ['hello']</blockquote>
+También podemos devolver el valor del elemento eliminado con uno de estos métodos:
+<blockquote>let popped = greetings.pop();<br>// returns 'hello'<br>// greetings now equals []</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hemos definido una función, <code>popShift</code> , que toma una matriz como argumento y devuelve una nueva matriz. Modifique la función, utilizando <code>pop()</code> y <code>shift()</code> , para eliminar el primer y último elemento de la matriz de argumentos, y asigne los elementos eliminados a sus variables correspondientes, de modo que la matriz devuelta contenga sus valores. 
+<section id='instructions'>
+Hemos definido una función, <code>popShift</code> , que toma una matriz como argumento y devuelve una nueva matriz. Modifique la función, utilizando <code>pop()</code> y <code>shift()</code> , para eliminar el primer y último elemento de la matriz de argumentos, y asigne los elementos eliminados a sus variables correspondientes, de modo que la matriz devuelta contenga sus valores.
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Hemos definido una función, <code>popShift</code> , que toma una matriz como ar
 
 ```yml
 tests:
-  - text: &#39; <code>popShift([&quot;challenge&quot;, &quot;is&quot;, &quot;not&quot;, &quot;complete&quot;])</code> debe devolver <code>[&quot;challenge&quot;, &quot;complete&quot;]</code> &#39;
+  - text: ' <code>popShift([&quot;challenge&quot;, &quot;is&quot;, &quot;not&quot;, &quot;complete&quot;])</code> debe devolver <code>[&quot;challenge&quot;, &quot;complete&quot;]</code> '
     testString: 'assert.deepEqual(popShift(["challenge", "is", "not", "complete"]), ["challenge", "complete"], "<code>popShift(["challenge", "is", "not", "complete"])</code> should return <code>["challenge", "complete"]</code>");'
   - text: La función <code>popShift</code> debería utilizar el método <code>pop()</code>
     testString: 'assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1, "The <code>popShift</code> function should utilize the <code>pop()</code> method");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.spanish.md
index 7774f539c0..8b2a6ad1c7 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora ya sabes qué son los objetos y sus características y ventajas básicas. En resumen, son tiendas de valor clave que proporcionan una forma flexible e intuitiva de estructurar los datos <strong><em>y</em></strong> proporcionan un tiempo de búsqueda muy rápido. A lo largo del resto de estos desafíos, describiremos varias operaciones comunes que puede realizar en objetos para que pueda sentirse cómodo aplicando estas estructuras de datos útiles en sus programas. 
-En desafíos anteriores, hemos agregado y modificado los pares clave-valor de un objeto. Aquí veremos cómo podemos <em>eliminar</em> un par clave-valor de un objeto. 
-Repasemos nuestro ejemplo de objeto de <code>foods</code> una última vez. Si quisiéramos eliminar la clave de las <code>apples</code> , podemos eliminarla usando la palabra clave <code>delete</code> así: 
-<blockquote>delete foods.apples;</blockquote> 
+<section id='description'>
+Ahora ya sabes qué son los objetos y sus características y ventajas básicas. En resumen, son tiendas de valor clave que proporcionan una forma flexible e intuitiva de estructurar los datos <strong><em>y</em></strong> proporcionan un tiempo de búsqueda muy rápido. A lo largo del resto de estos desafíos, describiremos varias operaciones comunes que puede realizar en objetos para que pueda sentirse cómodo aplicando estas estructuras de datos útiles en sus programas.
+En desafíos anteriores, hemos agregado y modificado los pares clave-valor de un objeto. Aquí veremos cómo podemos <em>eliminar</em> un par clave-valor de un objeto.
+Repasemos nuestro ejemplo de objeto de <code>foods</code> una última vez. Si quisiéramos eliminar la clave de las <code>apples</code> , podemos eliminarla usando la palabra clave <code>delete</code> así:
+<blockquote>delete foods.apples;</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la palabra clave delete para eliminar las teclas de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> del objeto de <code>foods</code> . 
+<section id='instructions'>
+Use la palabra clave delete para eliminar las teclas de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> del objeto de <code>foods</code> .
 </section>
 
 ## Tests
@@ -23,9 +23,9 @@ Use la palabra clave delete para eliminar las teclas de <code>oranges</code> , <
 
 ```yml
 tests:
-  - text: &#39;El objeto de <code>foods</code> solo tiene tres claves: <code>apples</code> , <code>grapes</code> y <code>bananas</code> &#39;
+  - text: 'El objeto de <code>foods</code> solo tiene tres claves: <code>apples</code> , <code>grapes</code> y <code>bananas</code> '
     testString: 'assert(!foods.hasOwnProperty("oranges") && !foods.hasOwnProperty("plums") && !foods.hasOwnProperty("strawberries") && Object.keys(foods).length === 3, "The <code>foods</code> object only has three keys: <code>apples</code>, <code>grapes</code>, and <code>bananas</code>");'
-  - text: &#39;Las claves de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> se eliminan usando <code>delete</code> &#39;
+  - text: 'Las claves de <code>oranges</code> , <code>plums</code> y <code>strawberries</code> se eliminan usando <code>delete</code> '
     testString: 'assert(code.search(/oranges:/) !== -1 && code.search(/plums:/) !== -1 && code.search(/strawberries:/) !== -1, "The <code>oranges</code>, <code>plums</code>, and <code>strawberries</code> keys are removed using <code>delete</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.spanish.md
index 5be351d155..113b58fba2 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-A for loop también puede contar hacia atrás, siempre que podamos definir las condiciones correctas. 
-Para contar hacia atrás de dos en dos, necesitaremos cambiar nuestra <code>initialization</code> , <code>condition</code> y <code>final-expression</code> . 
-Comenzaremos en <code>i = 10</code> y haremos un bucle mientras <code>i &gt; 0</code> . Disminuiremos <code>i</code> en 2 cada bucle con <code>i -= 2</code> . 
-<blockquote>var ourArray = [];<br>for (var i=10; i &#62; 0; i-=2) {<br>&nbsp;&nbsp;ourArray.push(i);<br>}</blockquote> 
-<code>ourArray</code> ahora contendrá <code>[10,8,6,4,2]</code> . 
-Cambiemos nuestra <code>initialization</code> y <code>final-expression</code> para que podamos contar hacia atrás de dos en dos con números impares. 
+<section id='description'>
+A for loop también puede contar hacia atrás, siempre que podamos definir las condiciones correctas.
+Para contar hacia atrás de dos en dos, necesitaremos cambiar nuestra <code>initialization</code> , <code>condition</code> y <code>final-expression</code> .
+Comenzaremos en <code>i = 10</code> y haremos un bucle mientras <code>i &gt; 0</code> . Disminuiremos <code>i</code> en 2 cada bucle con <code>i -= 2</code> .
+<blockquote>var ourArray = [];<br>for (var i=10; i &#62; 0; i-=2) {<br>&nbsp;&nbsp;ourArray.push(i);<br>}</blockquote>
+<code>ourArray</code> ahora contendrá <code>[10,8,6,4,2]</code> .
+Cambiemos nuestra <code>initialization</code> y <code>final-expression</code> para que podamos contar hacia atrás de dos en dos con números impares.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Empuje los números impares del 9 al 1 a <code>myArray</code> usando un bucle <code>for</code> . 
+<section id='instructions'>
+Empuje los números impares del 9 al 1 a <code>myArray</code> usando un bucle <code>for</code> .
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ tests:
     testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
   - text: Deberías estar usando el método de matriz <code>push</code> .
     testString: 'assert(code.match(/myArray.push/), "You should be using the array method <code>push</code>.");'
-  - text: &#39; <code>myArray</code> debe ser igual a <code>[9,7,5,3,1]</code> .&#39;
+  - text: ' <code>myArray</code> debe ser igual a <code>[9,7,5,3,1]</code> .'
     testString: 'assert.deepEqual(myArray, [9,7,5,3,1], "<code>myArray</code> should equal <code>[9,7,5,3,1]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.spanish.md
index 2e9185a22b..25a95c711c 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En el juego de casino Blackjack, un jugador puede obtener una ventaja sobre la casa al hacer un seguimiento del número relativo de cartas altas y bajas que quedan en el mazo. Esto se llama <a href='https://en.wikipedia.org/wiki/Card_counting' target='_blank'>conteo de cartas</a> . 
-Tener más cartas altas en el mazo favorece al jugador. A cada tarjeta se le asigna un valor de acuerdo con la siguiente tabla. Cuando el conteo es positivo, el jugador debe apostar alto. Cuando el conteo es cero o negativo, el jugador debe apostar bajo. 
-<table class="table table-striped"><thead><tr><th> Cambio de cuenta </th><th> Tarjetas </th></tr></thead><tbody><tr><td> +1 </td><td> 2, 3, 4, 5, 6 </td></tr><tr><td> 0 </td><td> 7, 8, 9 </td></tr><tr><td> -1 </td><td> 10, &#39;J&#39;, &#39;Q&#39;, &#39;K&#39;, &#39;A&#39; </td></tr></tbody></table> 
-Escribirás una función de conteo de cartas. Recibirá un parámetro de <code>card</code> , que puede ser un número o una cadena, y aumentará o disminuirá la variable de <code>count</code> global según el valor de la tarjeta (consulte la tabla). La función devolverá una cadena con el recuento actual y la cadena <code>Bet</code> si el recuento es positivo, o <code>Hold</code> si el recuento es cero o negativo. El conteo actual y la decisión del jugador ( <code>Bet</code> o <code>Hold</code> ) deben estar separados por un solo espacio. 
-<strong>Ejemplo de salida</strong> <br> <code>-3 Hold</code> <br> <code>5 Bet</code> 
-<strong>Sugerencia</strong> <br> NO reinicie el <code>count</code> a 0 cuando el valor sea 7, 8 o 9. <br> NO devuelva una matriz. <br> NO incluya comillas (simples o dobles) en la salida. 
+<section id='description'>
+En el juego de casino Blackjack, un jugador puede obtener una ventaja sobre la casa al hacer un seguimiento del número relativo de cartas altas y bajas que quedan en el mazo. Esto se llama <a href='https://en.wikipedia.org/wiki/Card_counting' target='_blank'>conteo de cartas</a> .
+Tener más cartas altas en el mazo favorece al jugador. A cada tarjeta se le asigna un valor de acuerdo con la siguiente tabla. Cuando el conteo es positivo, el jugador debe apostar alto. Cuando el conteo es cero o negativo, el jugador debe apostar bajo.
+<table class="table table-striped"><thead><tr><th> Cambio de cuenta </th><th> Tarjetas </th></tr></thead><tbody><tr><td> +1 </td><td> 2, 3, 4, 5, 6 </td></tr><tr><td> 0 </td><td> 7, 8, 9 </td></tr><tr><td> -1 </td><td> 10, &#39;J&#39;, &#39;Q&#39;, &#39;K&#39;, &#39;A&#39; </td></tr></tbody></table>
+Escribirás una función de conteo de cartas. Recibirá un parámetro de <code>card</code> , que puede ser un número o una cadena, y aumentará o disminuirá la variable de <code>count</code> global según el valor de la tarjeta (consulte la tabla). La función devolverá una cadena con el recuento actual y la cadena <code>Bet</code> si el recuento es positivo, o <code>Hold</code> si el recuento es cero o negativo. El conteo actual y la decisión del jugador ( <code>Bet</code> o <code>Hold</code> ) deben estar separados por un solo espacio.
+<strong>Ejemplo de salida</strong> <br> <code>-3 Hold</code> <br> <code>5 Bet</code>
+<strong>Sugerencia</strong> <br> NO reinicie el <code>count</code> a 0 cuando el valor sea 7, 8 o 9. <br> NO devuelva una matriz. <br> NO incluya comillas (simples o dobles) en la salida.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,19 +25,19 @@ Escribirás una función de conteo de cartas. Recibirá un parámetro de <code>c
 
 ```yml
 tests:
-  - text: &#39;Las secuencias de cartas 2, 3, 4, 5, 6 deben devolver <code>5 Bet</code> &#39;
+  - text: 'Las secuencias de cartas 2, 3, 4, 5, 6 deben devolver <code>5 Bet</code> '
     testString: 'assert((function(){ count = 0; cc(2);cc(3);cc(4);cc(5);var out = cc(6); if(out === "5 Bet") {return true;} return false; })(), "Cards Sequence 2, 3, 4, 5, 6 should return <code>5 Bet</code>");'
-  - text: &#39;Las secuencias de cartas 7, 8, 9 deben devolver <code>0 Hold</code> &#39;
+  - text: 'Las secuencias de cartas 7, 8, 9 deben devolver <code>0 Hold</code> '
     testString: 'assert((function(){ count = 0; cc(7);cc(8);var out = cc(9); if(out === "0 Hold") {return true;} return false; })(), "Cards Sequence 7, 8, 9 should return <code>0 Hold</code>");'
-  - text: &#39;La secuencia de cartas 10, J, Q, K, A debería devolver <code>-5 Hold</code> &#39;
+  - text: 'La secuencia de cartas 10, J, Q, K, A debería devolver <code>-5 Hold</code> '
     testString: 'assert((function(){ count = 0; cc(10);cc("J");cc("Q");cc("K");var out = cc("A"); if(out === "-5 Hold") {return true;} return false; })(), "Cards Sequence 10, J, Q, K, A should return <code>-5 Hold</code>");'
-  - text: &#39;Las secuencias de cartas 3, 7, Q, 8, A deben devolver <code>-1 Hold</code> &#39;
+  - text: 'Las secuencias de cartas 3, 7, Q, 8, A deben devolver <code>-1 Hold</code> '
     testString: 'assert((function(){ count = 0; cc(3);cc(7);cc("Q");cc(8);var out = cc("A"); if(out === "-1 Hold") {return true;} return false; })(), "Cards Sequence 3, 7, Q, 8, A should return <code>-1 Hold</code>");'
-  - text: &#39;Las secuencias de cartas 2, J, 9, 2, 7 deben devolver <code>1 Bet</code> &#39;
+  - text: 'Las secuencias de cartas 2, J, 9, 2, 7 deben devolver <code>1 Bet</code> '
     testString: 'assert((function(){ count = 0; cc(2);cc("J");cc(9);cc(2);var out = cc(7); if(out === "1 Bet") {return true;} return false; })(), "Cards Sequence 2, J, 9, 2, 7 should return <code>1 Bet</code>");'
-  - text: &#39;Las secuencias de cartas 2, 2, 10 deben devolver <code>1 Bet</code> &#39;
+  - text: 'Las secuencias de cartas 2, 2, 10 deben devolver <code>1 Bet</code> '
     testString: 'assert((function(){ count = 0; cc(2);cc(2);var out = cc(10); if(out === "1 Bet") {return true;} return false; })(), "Cards Sequence 2, 2, 10 should return <code>1 Bet</code>");'
-  - text: &#39;Secuencia de cartas 3, 2, A, 10, K debería devolver <code>-1 Hold</code> &#39;
+  - text: 'Secuencia de cartas 3, 2, A, 10, K debería devolver <code>-1 Hold</code> '
     testString: 'assert((function(){ count = 0; cc(3);cc(2);cc("A");cc(10);var out = cc("K"); if(out === "-1 Hold") {return true;} return false; })(), "Cards Sequence 3, 2, A, 10, K should return <code>-1 Hold</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.spanish.md
index 36c6bcba77..e859dfbda1 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.spanish.md
@@ -6,21 +6,21 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En informática, los <dfn>datos</dfn> son cualquier cosa que sea significativa para la computadora. JavaScript proporciona siete <dfn>tipos de datos diferentes</dfn> que son <code>undefined</code> , <code>null</code> , <code>boolean</code> , <code>string</code> , <code>symbol</code> , <code>number</code> y <code>object</code> . 
-Por ejemplo, las computadoras distinguen entre los números, como el número <code>12</code> , y las <code>strings</code> , como <code>&quot;12&quot;</code> , <code>&quot;dog&quot;</code> o <code>&quot;123 cats&quot;</code> , que son colecciones de caracteres. Las computadoras pueden realizar operaciones matemáticas en un número, pero no en una cadena. 
-<dfn>Las variables</dfn> permiten que las computadoras almacenen y manipulen datos de una manera dinámica. Hacen esto usando una &quot;etiqueta&quot; para señalar los datos en lugar de usar los datos en sí. Cualquiera de los siete tipos de datos puede almacenarse en una variable. 
-<code>Variables</code> son similares a las variables x e y que usa en matemáticas, lo que significa que son un nombre simple para representar los datos a los que queremos referirnos. Las <code>variables</code> computadora difieren de las variables matemáticas en que pueden almacenar diferentes valores en diferentes momentos. 
-Le pedimos a JavaScript que cree o <dfn>declare</dfn> una variable poniendo la palabra clave <code>var</code> delante de ella, así: 
-<blockquote>var ourName;</blockquote> 
-crea una <code>variable</code> llamada <code>ourName</code> . En JavaScript terminamos las frases con punto y coma. 
-<code>Variable</code> nombres de las <code>Variable</code> pueden estar formados por números, letras y <code>$</code> o <code>_</code> , pero no pueden contener espacios ni comenzar con un número. 
+<section id='description'>
+En informática, los <dfn>datos</dfn> son cualquier cosa que sea significativa para la computadora. JavaScript proporciona siete <dfn>tipos de datos diferentes</dfn> que son <code>undefined</code> , <code>null</code> , <code>boolean</code> , <code>string</code> , <code>symbol</code> , <code>number</code> y <code>object</code> .
+Por ejemplo, las computadoras distinguen entre los números, como el número <code>12</code> , y las <code>strings</code> , como <code>&quot;12&quot;</code> , <code>&quot;dog&quot;</code> o <code>&quot;123 cats&quot;</code> , que son colecciones de caracteres. Las computadoras pueden realizar operaciones matemáticas en un número, pero no en una cadena.
+<dfn>Las variables</dfn> permiten que las computadoras almacenen y manipulen datos de una manera dinámica. Hacen esto usando una &quot;etiqueta&quot; para señalar los datos en lugar de usar los datos en sí. Cualquiera de los siete tipos de datos puede almacenarse en una variable.
+<code>Variables</code> son similares a las variables x e y que usa en matemáticas, lo que significa que son un nombre simple para representar los datos a los que queremos referirnos. Las <code>variables</code> computadora difieren de las variables matemáticas en que pueden almacenar diferentes valores en diferentes momentos.
+Le pedimos a JavaScript que cree o <dfn>declare</dfn> una variable poniendo la palabra clave <code>var</code> delante de ella, así:
+<blockquote>var ourName;</blockquote>
+crea una <code>variable</code> llamada <code>ourName</code> . En JavaScript terminamos las frases con punto y coma.
+<code>Variable</code> nombres de las <code>Variable</code> pueden estar formados por números, letras y <code>$</code> o <code>_</code> , pero no pueden contener espacios ni comenzar con un número.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la palabra clave <code>var</code> para crear una variable llamada <code>myName</code> . 
-<strong>Pista</strong> <br> Mira el ejemplo de <code>ourName</code> si te quedas atascado. 
+<section id='instructions'>
+Use la palabra clave <code>var</code> para crear una variable llamada <code>myName</code> .
+<strong>Pista</strong> <br> Mira el ejemplo de <code>ourName</code> si te quedas atascado.
 </section>
 
 ## Tests
@@ -28,7 +28,7 @@ Use la palabra clave <code>var</code> para crear una variable llamada <code>myNa
 
 ```yml
 tests:
-  - text: &#39;Debes declarar <code>myName</code> con la palabra clave <code>var</code> , que termina con un punto y coma&#39;
+  - text: 'Debes declarar <code>myName</code> con la palabra clave <code>var</code> , que termina con un punto y coma'
     testString: 'assert(/var\s+myName\s*;/.test(code), "You should declare <code>myName</code> with the <code>var</code> keyword, ending with a semicolon");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.spanish.md
index 244cd17937..5c2c7d41e6 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-comillas no son los únicos caracteres que pueden <dfn>escaparse</dfn> dentro de una cadena. Hay dos razones para usar caracteres que se escapan: primero es permitirle usar caracteres que de otra forma no podría escribir, como un retroceso. El segundo es permitirte representar múltiples citas en una cadena sin que JavaScript interprete mal lo que quieres decir. Aprendimos esto en el reto anterior. 
-<table class="table table-striped"><thead><tr><th> Código </th><th> Salida </th></tr></thead><tbody><tr><td> <code>\&#39;</code> </td> <td> una frase </td></tr><tr><td> <code>\&quot;</code> </td> <td> doble cita </td></tr><tr><td> <code>\\</code> </td> <td> barra invertida </td></tr><tr><td> <code>\n</code> </td> <td> nueva línea </td></tr><tr><td> <code>\r</code> </td> <td> retorno de carro </td></tr><tr><td> <code>\t</code> </td> <td> lengüeta </td></tr><tr><td> <code>\b</code> </td> <td> retroceso </td></tr><tr><td> <code>\f</code> </td> <td> form feed </td></tr></tbody></table> 
-<em>Tenga en cuenta que la barra invertida debe escaparse para que se muestre como una barra invertida.</em> 
+<section id='description'>
+comillas no son los únicos caracteres que pueden <dfn>escaparse</dfn> dentro de una cadena. Hay dos razones para usar caracteres que se escapan: primero es permitirle usar caracteres que de otra forma no podría escribir, como un retroceso. El segundo es permitirte representar múltiples citas en una cadena sin que JavaScript interprete mal lo que quieres decir. Aprendimos esto en el reto anterior.
+<table class="table table-striped"><thead><tr><th> Código </th><th> Salida </th></tr></thead><tbody><tr><td> <code>\&#39;</code> </td> <td> una frase </td></tr><tr><td> <code>\&quot;</code> </td> <td> doble cita </td></tr><tr><td> <code>\\</code> </td> <td> barra invertida </td></tr><tr><td> <code>\n</code> </td> <td> nueva línea </td></tr><tr><td> <code>\r</code> </td> <td> retorno de carro </td></tr><tr><td> <code>\t</code> </td> <td> lengüeta </td></tr><tr><td> <code>\b</code> </td> <td> retroceso </td></tr><tr><td> <code>\f</code> </td> <td> form feed </td></tr></tbody></table>
+<em>Tenga en cuenta que la barra invertida debe escaparse para que se muestre como una barra invertida.</em>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Asigne las siguientes tres líneas de texto a la única variable <code>myStr</code> usando secuencias de escape. 
-<blockquote>FirstLine<br/>&nbsp;&nbsp;&nbsp;&nbsp;\SecondLine<br/>ThirdLine</blockquote> 
-Necesitará usar secuencias de escape para insertar caracteres especiales correctamente. También deberá seguir el espaciado como se ve arriba, sin espacios entre las secuencias de escape o las palabras. 
-Aquí está el texto con las secuencias de escape escritas. 
-<q>FirstLine <code>newline</code> <code>tab</code> <code>backslash</code> SecondLine <code>newline</code> ThirdLine</q> 
+<section id='instructions'>
+Asigne las siguientes tres líneas de texto a la única variable <code>myStr</code> usando secuencias de escape.
+<blockquote>FirstLine<br/>&nbsp;&nbsp;&nbsp;&nbsp;\SecondLine<br/>ThirdLine</blockquote>
+Necesitará usar secuencias de escape para insertar caracteres especiales correctamente. También deberá seguir el espaciado como se ve arriba, sin espacios entre las secuencias de escape o las palabras.
+Aquí está el texto con las secuencias de escape escritas.
+<q>FirstLine <code>newline</code> <code>tab</code> <code>backslash</code> SecondLine <code>newline</code> ThirdLine</q>
 </section>
 
 ## Tests
@@ -28,7 +28,7 @@ Aquí está el texto con las secuencias de escape escritas.
 tests:
   - text: <code>myStr</code> no debe contener espacios
     testString: 'assert(!/ /.test(myStr), "<code>myStr</code> should not contain any spaces");'
-  - text: &#39; <code>myStr</code> debe contener las cadenas <code>FirstLine</code> , <code>SecondLine</code> y <code>ThirdLine</code> (recuerda la sensibilidad a los casos)&#39;
+  - text: ' <code>myStr</code> debe contener las cadenas <code>FirstLine</code> , <code>SecondLine</code> y <code>ThirdLine</code> (recuerda la sensibilidad a los casos)'
     testString: 'assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr), "<code>myStr</code> should contain the strings <code>FirstLine</code>, <code>SecondLine</code> and <code>ThirdLine</code> (remember case sensitivity)");'
   - text: <code>FirstLine</code> debe ir seguido del carácter de nueva línea <code>\n</code>
     testString: 'assert(/FirstLine\n/.test(myStr), "<code>FirstLine</code> should be followed by the newline character <code>\n</code>");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.spanish.md
index e2c95396cb..03898d6acc 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Cuando está definiendo una cadena, debe comenzar y terminar con una comilla simple o doble. ¿Qué sucede cuando necesita una cita literal: <code>&quot;</code> o <code>&#39;</code> dentro de su cadena? 
-En JavaScript, puede <dfn>evitar que</dfn> una cita la considere como un final de cadena de la cadena colocando una <dfn>barra invertida</dfn> ( <code>\</code> ) delante de la cita. 
-<code>var sampleStr = &quot;Alan said, \&quot;Peter is learning JavaScript\&quot;.&quot;;</code> 
-Esto indica a JavaScript que la siguiente cita no es el final de la cadena, sino que debería aparecer dentro de la cadena. Por lo tanto, si imprimiera esto en En la consola, obtendrías: 
-<code>Alan said, &quot;Peter is learning JavaScript&quot;.</code> 
+<section id='description'>
+Cuando está definiendo una cadena, debe comenzar y terminar con una comilla simple o doble. ¿Qué sucede cuando necesita una cita literal: <code>&quot;</code> o <code>&#39;</code> dentro de su cadena?
+En JavaScript, puede <dfn>evitar que</dfn> una cita la considere como un final de cadena de la cadena colocando una <dfn>barra invertida</dfn> ( <code>\</code> ) delante de la cita.
+<code>var sampleStr = &quot;Alan said, \&quot;Peter is learning JavaScript\&quot;.&quot;;</code>
+Esto indica a JavaScript que la siguiente cita no es el final de la cadena, sino que debería aparecer dentro de la cadena. Por lo tanto, si imprimiera esto en En la consola, obtendrías:
+<code>Alan said, &quot;Peter is learning JavaScript&quot;.</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use <dfn>barras diagonales inversas</dfn> para asignar una cadena a la variable <code>myStr</code> modo que si tuviera que imprimirla en la consola, verá: 
-<code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code> 
+<section id='instructions'>
+Use <dfn>barras diagonales inversas</dfn> para asignar una cadena a la variable <code>myStr</code> modo que si tuviera que imprimirla en la consola, verá:
+<code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code>
 </section>
 
 ## Tests
@@ -25,9 +25,9 @@ Use <dfn>barras diagonales inversas</dfn> para asignar una cadena a la variable
 
 ```yml
 tests:
-  - text: &#39;Debería usar dos comillas dobles ( <code>&quot;</code> ) y cuatro comillas dobles escapadas ( <code>\&quot;</code> ).&#39;
+  - text: 'Debería usar dos comillas dobles ( <code>&quot;</code> ) y cuatro comillas dobles escapadas ( <code>\&quot;</code> ).'
     testString: 'assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2, "You should use two double quotes (<code>&quot;</code>) and four escaped double quotes (<code>&#92;&quot;</code>).");'
-  - text: &#39;Variable myStr debe contener la cadena: <code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code> comilla <code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code> &#39;
+  - text: 'Variable myStr debe contener la cadena: <code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code> comilla <code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code> '
     testString: 'assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".", "Variable myStr should contain the string: <code>I am a "double quoted" string inside "double quotes".</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.spanish.md
index 27ce7c2080..624828f6b7 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Puede encontrar la longitud de un valor de <code>String</code> escribiendo <code>.length</code> después de la variable de cadena o el literal de cadena. 
-<code>&quot;Alan Peter&quot;.length; // 10</code> 
-Por ejemplo, si creamos una variable <code>var firstName = &quot;Charles&quot;</code> , podríamos averiguar cuánto tiempo dura la cadena <code>&quot;Charles&quot;</code> utilizando la propiedad <code>firstName.length</code> . 
+<section id='description'>
+Puede encontrar la longitud de un valor de <code>String</code> escribiendo <code>.length</code> después de la variable de cadena o el literal de cadena.
+<code>&quot;Alan Peter&quot;.length; // 10</code>
+Por ejemplo, si creamos una variable <code>var firstName = &quot;Charles&quot;</code> , podríamos averiguar cuánto tiempo dura la cadena <code>&quot;Charles&quot;</code> utilizando la propiedad <code>firstName.length</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la propiedad <code>.length</code> para contar el número de caracteres en la variable <code>lastName</code> y asignarla a <code>lastNameLength</code> . 
+<section id='instructions'>
+Use la propiedad <code>.length</code> para contar el número de caracteres en la variable <code>lastName</code> y asignarla a <code>lastNameLength</code> .
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Use la propiedad <code>.length</code> para contar el número de caracteres en la
 tests:
   - text: <code>lastNameLength</code> debe ser igual a ocho.
     testString: 'assert((function(){if(typeof lastNameLength !== "undefined" && typeof lastNameLength === "number" && lastNameLength === 8){return true;}else{return false;}})(), "<code>lastNameLength</code> should be equal to eight.");'
-  - text: &#39;Deberías obtener la longitud del <code>lastName</code> al usar <code>.length</code> esta manera: <code>lastName.length</code> &#39;.
+  - text: 'Deberías obtener la longitud del <code>lastName</code> al usar <code>.length</code> esta manera: <code>lastName.length</code> '
     testString: 'assert((function(){if(code.match(/\.length/gi) && code.match(/\.length/gi).length >= 2 && code.match(/var lastNameLength \= 0;/gi) && code.match(/var lastNameLength \= 0;/gi).length >= 1){return true;}else{return false;}})(), "You should be getting the length of <code>lastName</code> by using <code>.length</code> like this: <code>lastName.length</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.spanish.md
index feb1e64968..dd4837bf7a 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En lugar de generar un número aleatorio entre cero y un número dado como hicimos antes, podemos generar un número aleatorio que se encuentre dentro de un rango de dos números específicos. 
-Para hacer esto, definiremos un número mínimo <code>min</code> y un máximo número <code>max</code> . 
-Aquí está la fórmula que usaremos. Tómese un momento para leerlo e intente entender lo que hace este código: 
-<code>Math.floor(Math.random() * (max - min + 1)) + min</code> 
+<section id='description'>
+En lugar de generar un número aleatorio entre cero y un número dado como hicimos antes, podemos generar un número aleatorio que se encuentre dentro de un rango de dos números específicos.
+Para hacer esto, definiremos un número mínimo <code>min</code> y un máximo número <code>max</code> .
+Aquí está la fórmula que usaremos. Tómese un momento para leerlo e intente entender lo que hace este código:
+<code>Math.floor(Math.random() * (max - min + 1)) + min</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cree una función llamada <code>randomRange</code> que tome un rango <code>myMin</code> y <code>myMax</code> y devuelva un número aleatorio que sea mayor o igual que <code>myMin</code> , y que sea menor o igual que <code>myMax</code> , inclusive. 
+<section id='instructions'>
+Cree una función llamada <code>randomRange</code> que tome un rango <code>myMin</code> y <code>myMax</code> y devuelva un número aleatorio que sea mayor o igual que <code>myMin</code> , y que sea menor o igual que <code>myMax</code> , inclusive.
 </section>
 
 ## Tests
@@ -23,13 +23,13 @@ Cree una función llamada <code>randomRange</code> que tome un rango <code>myMin
 
 ```yml
 tests:
-  - text: &#39;El número aleatorio más bajo que puede ser generado por <code>randomRange</code> debería ser igual a tu número mínimo, <code>myMin</code> &#39;.
+  - text: 'El número aleatorio más bajo que puede ser generado por <code>randomRange</code> debería ser igual a tu número mínimo, <code>myMin</code> '
     testString: 'assert(calcMin === 5, "The lowest random number that can be generated by <code>randomRange</code> should be equal to your minimum number, <code>myMin</code>.");'
   - text: &quot;El número aleatorio más alto que puede ser generado por <code>randomRange</code> debería ser igual a tu número máximo, <code>myMax</code> &quot;.
     testString: 'assert(calcMax === 15, "The highest random number that can be generated by <code>randomRange</code> should be equal to your maximum number, <code>myMax</code>.");'
-  - text: &#39;El número aleatorio generado por <code>randomRange</code> debe ser un número entero, no un decimal&#39;.
+  - text: 'El número aleatorio generado por <code>randomRange</code> debe ser un número entero, no un decimal'
     testString: 'assert(randomRange(0,1) % 1 === 0 , "The random number generated by <code>randomRange</code> should be an integer, not a decimal.");'
-  - text: &#39; <code>randomRange</code> debe usar <code>myMax</code> y <code>myMin</code> , y devolver un número aleatorio en tu rango&#39;.
+  - text: ' <code>randomRange</code> debe usar <code>myMax</code> y <code>myMin</code> , y devolver un número aleatorio en tu rango'
     testString: 'assert((function(){if(code.match(/myMax/g).length > 1 && code.match(/myMin/g).length > 2 && code.match(/Math.floor/g) && code.match(/Math.random/g)){return true;}else{return false;}})(), "<code>randomRange</code> should use both <code>myMax</code> and <code>myMin</code>, and return a random number in your range.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.spanish.md
index 69c4bcdfae..01deb9a4f1 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En el juego de <a href="https://en.wikipedia.org/wiki/Golf" target="_blank">golf,</a> cada hoyo tiene un <code>par</code> significa el número promedio de <code>strokes</code> que se espera que un golfista realice para hundir la bola en un hoyo para completar el juego. Dependiendo de qué tan por encima o <code>par</code> debajo de tus <code>strokes</code> , hay un apodo diferente. 
-Su función se pasará <code>par</code> y <code>strokes</code> argumentos. Devuelva la cadena correcta de acuerdo con esta tabla que enumera los trazos en orden de prioridad; arriba (más alto) a abajo (más bajo): 
-<table class="table table-striped"><thead><tr><th> Trazos </th><th> Regreso </th></tr></thead><tbody><tr><td> 1 </td><td> &quot;¡Hoyo en uno!&quot; </td></tr><tr><td> &lt;= par - 2 </td><td> &quot;Águila&quot; </td></tr><tr><td> par - 1 </td><td> &quot;Pajarito&quot; </td></tr><tr><td> par </td><td> &quot;Par&quot; </td></tr><tr><td> par + 1 </td><td> &quot;Espectro&quot; </td></tr><tr><td> par + 2 </td><td> &quot;Doble Bogey&quot; </td></tr><tr><td> &gt; = par + 3 </td><td> &quot;¡Vete a casa!&quot; </td></tr></tbody></table> 
-<code>par</code> y <code>strokes</code> siempre serán numéricos y positivos. Hemos agregado una matriz de todos los nombres para su conveniencia. 
+<section id='description'>
+En el juego de <a href="https://en.wikipedia.org/wiki/Golf" target="_blank">golf,</a> cada hoyo tiene un <code>par</code> significa el número promedio de <code>strokes</code> que se espera que un golfista realice para hundir la bola en un hoyo para completar el juego. Dependiendo de qué tan por encima o <code>par</code> debajo de tus <code>strokes</code> , hay un apodo diferente.
+Su función se pasará <code>par</code> y <code>strokes</code> argumentos. Devuelva la cadena correcta de acuerdo con esta tabla que enumera los trazos en orden de prioridad; arriba (más alto) a abajo (más bajo):
+<table class="table table-striped"><thead><tr><th> Trazos </th><th> Regreso </th></tr></thead><tbody><tr><td> 1 </td><td> &quot;¡Hoyo en uno!&quot; </td></tr><tr><td> &lt;= par - 2 </td><td> &quot;Águila&quot; </td></tr><tr><td> par - 1 </td><td> &quot;Pajarito&quot; </td></tr><tr><td> par </td><td> &quot;Par&quot; </td></tr><tr><td> par + 1 </td><td> &quot;Espectro&quot; </td></tr><tr><td> par + 2 </td><td> &quot;Doble Bogey&quot; </td></tr><tr><td> &gt; = par + 3 </td><td> &quot;¡Vete a casa!&quot; </td></tr></tbody></table>
+<code>par</code> y <code>strokes</code> siempre serán numéricos y positivos. Hemos agregado una matriz de todos los nombres para su conveniencia.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,27 +23,27 @@ Su función se pasará <code>par</code> y <code>strokes</code> argumentos. Devue
 
 ```yml
 tests:
-  - text: &#39; <code>golfScore(4, 1)</code> debe devolver &quot;Hole-in-one!&quot;&#39;
+  - text: ' <code>golfScore(4, 1)</code> debe devolver &quot;Hole-in-one!&quot;'
     testString: 'assert(golfScore(4, 1) === "Hole-in-one!", "<code>golfScore(4, 1)</code> should return "Hole-in-one!"");'
-  - text: &#39; <code>golfScore(4, 2)</code> debe devolver &quot;Eagle&quot;&#39;
+  - text: ' <code>golfScore(4, 2)</code> debe devolver &quot;Eagle&quot;'
     testString: 'assert(golfScore(4, 2) === "Eagle", "<code>golfScore(4, 2)</code> should return "Eagle"");'
-  - text: &#39; <code>golfScore(5, 2)</code> debe devolver &quot;Eagle&quot;&#39;
+  - text: ' <code>golfScore(5, 2)</code> debe devolver &quot;Eagle&quot;'
     testString: 'assert(golfScore(5, 2) === "Eagle", "<code>golfScore(5, 2)</code> should return "Eagle"");'
-  - text: &#39; <code>golfScore(4, 3)</code> debe devolver &quot;Birdie&quot;&#39;
+  - text: ' <code>golfScore(4, 3)</code> debe devolver &quot;Birdie&quot;'
     testString: 'assert(golfScore(4, 3) === "Birdie", "<code>golfScore(4, 3)</code> should return "Birdie"");'
-  - text: &#39; <code>golfScore(4, 4)</code> debe devolver &quot;Par&quot;
+  - text: ' <code>golfScore(4, 4)</code> debe devolver &quot;Par&quot;
     testString: 'assert(golfScore(4, 4) === "Par", "<code>golfScore(4, 4)</code> should return "Par"");'
-  - text: &#39; <code>golfScore(1, 1)</code> debe devolver &quot;Hole-in-one!&quot;&#39;
+  - text: ' <code>golfScore(1, 1)</code> debe devolver &quot;Hole-in-one!&quot;'
     testString: 'assert(golfScore(1, 1) === "Hole-in-one!", "<code>golfScore(1, 1)</code> should return "Hole-in-one!"");'
-  - text: &#39; <code>golfScore(5, 5)</code> debe devolver &quot;Par&quot;
+  - text: ' <code>golfScore(5, 5)</code> debe devolver &quot;Par&quot;
     testString: 'assert(golfScore(5, 5) === "Par", "<code>golfScore(5, 5)</code> should return "Par"");'
-  - text: &#39; <code>golfScore(4, 5)</code> debería devolver &quot;Bogey&quot;&#39;
+  - text: ' <code>golfScore(4, 5)</code> debería devolver &quot;Bogey&quot;'
     testString: 'assert(golfScore(4, 5) === "Bogey", "<code>golfScore(4, 5)</code> should return "Bogey"");'
-  - text: &#39; <code>golfScore(4, 6)</code> debería devolver &quot;Double Bogey&quot;&#39;
+  - text: ' <code>golfScore(4, 6)</code> debería devolver &quot;Double Bogey&quot;'
     testString: 'assert(golfScore(4, 6) === "Double Bogey", "<code>golfScore(4, 6)</code> should return "Double Bogey"");'
-  - text: &#39; <code>golfScore(4, 7)</code> debe devolver &quot;Go Home!&quot;&#39;
+  - text: ' <code>golfScore(4, 7)</code> debe devolver &quot;Go Home!&quot;'
     testString: 'assert(golfScore(4, 7) === "Go Home!", "<code>golfScore(4, 7)</code> should return "Go Home!"");'
-  - text: &#39; <code>golfScore(5, 9)</code> debe devolver &quot;Go Home!&quot;&#39;
+  - text: ' <code>golfScore(5, 9)</code> debe devolver &quot;Go Home!&quot;'
     testString: 'assert(golfScore(5, 9) === "Go Home!", "<code>golfScore(5, 9)</code> should return "Go Home!"");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.spanish.md
index 5be5980846..0f2a69ec9c 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Para que los bucles no tengan que iterar uno a la vez. Al cambiar nuestra <code>final-expression</code> , podemos contar por números pares. 
-Comenzaremos en <code>i = 0</code> y haremos un bucle mientras que <code>i &lt; 10</code> . Incrementaremos <code>i</code> en 2 en cada bucle con <code>i += 2</code> . 
-<blockquote>var ourArray = [];<br>for (var i = 0; i &#60; 10; i += 2) {<br>&nbsp;&nbsp;ourArray.push(i);<br>}</blockquote> 
-<code>ourArray</code> ahora contendrá <code>[0,2,4,6,8]</code> . 
-Cambiemos nuestra <code>initialization</code> para que podamos contar por números impares. 
+<section id='description'>
+Para que los bucles no tengan que iterar uno a la vez. Al cambiar nuestra <code>final-expression</code> , podemos contar por números pares.
+Comenzaremos en <code>i = 0</code> y haremos un bucle mientras que <code>i &lt; 10</code> . Incrementaremos <code>i</code> en 2 en cada bucle con <code>i += 2</code> .
+<blockquote>var ourArray = [];<br>for (var i = 0; i &#60; 10; i += 2) {<br>&nbsp;&nbsp;ourArray.push(i);<br>}</blockquote>
+<code>ourArray</code> ahora contendrá <code>[0,2,4,6,8]</code> .
+Cambiemos nuestra <code>initialization</code> para que podamos contar por números impares.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <code>for</code> . 
+<section id='instructions'>
+Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <code>for</code> .
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ Empuje los números impares del 1 al 9 a <code>myArray</code> usando un bucle <c
 tests:
   - text: Usted debe estar usando una <code>for</code> bucle para esto.
     testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
-  - text: &#39; <code>myArray</code> debería ser igual a <code>[1,3,5,7,9]</code> .&#39;
+  - text: ' <code>myArray</code> debería ser igual a <code>[1,3,5,7,9]</code> .'
     testString: 'assert.deepEqual(myArray, [1,3,5,7,9], "<code>myArray</code> should equal <code>[1,3,5,7,9]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.spanish.md
index 5619db08da..2e6f6918dd 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.spanish.md
@@ -6,24 +6,24 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Puede ejecutar el mismo código varias veces utilizando un bucle. 
-El siguiente tipo de bucle que aprenderá se llama bucle &quot; <code>do...while</code> &quot; porque primero &quot; <code>do</code> &quot; una pasada del código dentro del bucle sin importar qué, y luego se ejecuta &quot; <code>while</code> &quot; una condición específica es verdadero y se detiene una vez que esa condición ya no es verdadera. Veamos un ejemplo. 
-<blockquote>var ourArray = [];<br>var i = 0;<br>do {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>} while (i < 5);</blockquote> 
-Esto se comporta como se esperaría con cualquier otro tipo de bucle, y la matriz resultante se verá como <code>[0, 1, 2, 3, 4]</code> . Sin embargo, lo que hace <code>do...while</code> diferente de otros bucles es cómo se comporta cuando la condición falla en la primera comprobación. Veamos esto en acción. 
-Aquí hay un bucle while común que ejecutará el código en el bucle siempre y cuando <code>i &lt; 5</code> . 
-<blockquote>var ourArray = []; <br>var i = 5;<br>while (i < 5) {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>}</blockquote> 
-Observe que inicializamos el valor de <code>i</code> en 5. Cuando ejecutamos la siguiente línea, notamos que <code>i</code> no es menor que 5. Por lo tanto, no ejecutamos el código dentro del bucle. El resultado es que <code>ourArray</code> no agregará nada, por lo que aún se verá así <code>[]</code> cuando todo el código del ejemplo anterior termine de ejecutarse. 
-Ahora, eche un vistazo a un <code>do...while</code> loop. 
-<blockquote>var ourArray = []; <br>var i = 5;<br>do {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>} while (i < 5);</blockquote> 
-En este caso, inicializamos el valor de <code>i</code> como 5, como hicimos con el bucle while. Cuando llegamos a la siguiente línea, no hay comprobación del valor de <code>i</code> , por lo que vamos al código dentro de las llaves y lo ejecutamos. Agregaremos un elemento a la matriz e incrementaremos <code>i</code> antes de llegar a la verificación de condición. Entonces, cuando se llega a comprobar si <code>i &lt; 5</code> ver que <code>i</code> es ahora de 6 años, que no pasa la comprobación condicional. Así que salimos del bucle y estamos listos. Al final del ejemplo anterior, el valor de <code>ourArray</code> es <code>[5]</code> . 
-Esencialmente, un bucle <code>do...while</code> while garantiza que el código dentro del bucle se ejecute al menos una vez. 
-Intentemos obtener un ciclo <code>do...while</code> while para que funcione presionando los valores en una matriz. 
+<section id='description'>
+Puede ejecutar el mismo código varias veces utilizando un bucle.
+El siguiente tipo de bucle que aprenderá se llama bucle &quot; <code>do...while</code> &quot; porque primero &quot; <code>do</code> &quot; una pasada del código dentro del bucle sin importar qué, y luego se ejecuta &quot; <code>while</code> &quot; una condición específica es verdadero y se detiene una vez que esa condición ya no es verdadera. Veamos un ejemplo.
+<blockquote>var ourArray = [];<br>var i = 0;<br>do {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>} while (i < 5);</blockquote>
+Esto se comporta como se esperaría con cualquier otro tipo de bucle, y la matriz resultante se verá como <code>[0, 1, 2, 3, 4]</code> . Sin embargo, lo que hace <code>do...while</code> diferente de otros bucles es cómo se comporta cuando la condición falla en la primera comprobación. Veamos esto en acción.
+Aquí hay un bucle while común que ejecutará el código en el bucle siempre y cuando <code>i &lt; 5</code> .
+<blockquote>var ourArray = []; <br>var i = 5;<br>while (i < 5) {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>}</blockquote>
+Observe que inicializamos el valor de <code>i</code> en 5. Cuando ejecutamos la siguiente línea, notamos que <code>i</code> no es menor que 5. Por lo tanto, no ejecutamos el código dentro del bucle. El resultado es que <code>ourArray</code> no agregará nada, por lo que aún se verá así <code>[]</code> cuando todo el código del ejemplo anterior termine de ejecutarse.
+Ahora, eche un vistazo a un <code>do...while</code> loop.
+<blockquote>var ourArray = []; <br>var i = 5;<br>do {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>} while (i < 5);</blockquote>
+En este caso, inicializamos el valor de <code>i</code> como 5, como hicimos con el bucle while. Cuando llegamos a la siguiente línea, no hay comprobación del valor de <code>i</code> , por lo que vamos al código dentro de las llaves y lo ejecutamos. Agregaremos un elemento a la matriz e incrementaremos <code>i</code> antes de llegar a la verificación de condición. Entonces, cuando se llega a comprobar si <code>i &lt; 5</code> ver que <code>i</code> es ahora de 6 años, que no pasa la comprobación condicional. Así que salimos del bucle y estamos listos. Al final del ejemplo anterior, el valor de <code>ourArray</code> es <code>[5]</code> .
+Esencialmente, un bucle <code>do...while</code> while garantiza que el código dentro del bucle se ejecute al menos una vez.
+Intentemos obtener un ciclo <code>do...while</code> while para que funcione presionando los valores en una matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambiar el <code>while</code> de bucle en el código a un <code>do...while</code> bucle de modo que el bucle empujará el número 10 a <code>myArray</code> , y <code>i</code> será igual a <code>11</code> cuando el código termina de ejecutarse. 
+<section id='instructions'>
+Cambiar el <code>while</code> de bucle en el código a un <code>do...while</code> bucle de modo que el bucle empujará el número 10 a <code>myArray</code> , y <code>i</code> será igual a <code>11</code> cuando el código termina de ejecutarse.
 </section>
 
 ## Tests
@@ -33,7 +33,7 @@ Cambiar el <code>while</code> de bucle en el código a un <code>do...while</code
 tests:
   - text: Deberías usar un bucle <code>do...while</code> while para esto.
     testString: 'assert(code.match(/do/g), "You should be using a <code>do...while</code> loop for this.");'
-  - text: &#39; <code>myArray</code> debería ser igual a <code>[10]</code> &#39;.
+  - text: ' <code>myArray</code> debería ser igual a <code>[10]</code> '
     testString: 'assert.deepEqual(myArray, [10], "<code>myArray</code> should equal <code>[10]</code>.");'
   - text: <code>i</code> debe ser igual a <code>11</code>
     testString: 'assert.deepEqual(i, 11, "<code>i</code> should equal <code>11</code>");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.spanish.md
index 7ca46ab306..ee1dd296c1 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.spanish.md
@@ -6,22 +6,22 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Puede ejecutar el mismo código varias veces utilizando un bucle. 
-El tipo más común de bucle de JavaScript se llama &quot; <code>for loop</code> &quot; porque se ejecuta &quot;por&quot; un número específico de veces. 
-Para los bucles se declaran con tres expresiones opcionales separadas por punto y coma: 
-<code>for ([initialization]; [condition]; [final-expression])</code> 
-La instrucción de <code>initialization</code> se ejecuta una sola vez antes de que comience el bucle. Normalmente se utiliza para definir y configurar su variable de bucle. 
-La declaración de <code>condition</code> se evalúa al comienzo de cada iteración de bucle y continuará mientras se evalúe como <code>true</code> . Cuando la <code>condition</code> es <code>false</code> al inicio de la iteración, el bucle dejará de ejecutarse. Esto significa que si la <code>condition</code> comienza como <code>false</code> , su bucle nunca se ejecutará. 
-La <code>final-expression</code> se ejecuta al final de cada iteración de bucle, antes de la siguiente verificación de <code>condition</code> y generalmente se usa para aumentar o disminuir su contador de bucle. 
-En el siguiente ejemplo, inicializamos con <code>i = 0</code> e iteramos mientras nuestra condición <code>i &lt; 5</code> es verdadera. Incrementaremos <code>i</code> en <code>1</code> en cada iteración de bucle con <code>i++</code> como nuestra <code>final-expression</code> . 
-<blockquote>var ourArray = [];<br>for (var i = 0; i &#60; 5; i++) {<br>&nbsp;&nbsp;ourArray.push(i);<br>}</blockquote> 
-<code>ourArray</code> ahora contendrá <code>[0,1,2,3,4]</code> . 
+<section id='description'>
+Puede ejecutar el mismo código varias veces utilizando un bucle.
+El tipo más común de bucle de JavaScript se llama &quot; <code>for loop</code> &quot; porque se ejecuta &quot;por&quot; un número específico de veces.
+Para los bucles se declaran con tres expresiones opcionales separadas por punto y coma:
+<code>for ([initialization]; [condition]; [final-expression])</code>
+La instrucción de <code>initialization</code> se ejecuta una sola vez antes de que comience el bucle. Normalmente se utiliza para definir y configurar su variable de bucle.
+La declaración de <code>condition</code> se evalúa al comienzo de cada iteración de bucle y continuará mientras se evalúe como <code>true</code> . Cuando la <code>condition</code> es <code>false</code> al inicio de la iteración, el bucle dejará de ejecutarse. Esto significa que si la <code>condition</code> comienza como <code>false</code> , su bucle nunca se ejecutará.
+La <code>final-expression</code> se ejecuta al final de cada iteración de bucle, antes de la siguiente verificación de <code>condition</code> y generalmente se usa para aumentar o disminuir su contador de bucle.
+En el siguiente ejemplo, inicializamos con <code>i = 0</code> e iteramos mientras nuestra condición <code>i &lt; 5</code> es verdadera. Incrementaremos <code>i</code> en <code>1</code> en cada iteración de bucle con <code>i++</code> como nuestra <code>final-expression</code> .
+<blockquote>var ourArray = [];<br>for (var i = 0; i &#60; 5; i++) {<br>&nbsp;&nbsp;ourArray.push(i);<br>}</blockquote>
+<code>ourArray</code> ahora contendrá <code>[0,1,2,3,4]</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en <code>myArray</code> . 
+<section id='instructions'>
+Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en <code>myArray</code> .
 </section>
 
 ## Tests
@@ -31,7 +31,7 @@ Use un bucle <code>for</code> para trabajar y empujar los valores del 1 al 5 en
 tests:
   - text: Usted debe estar usando una <code>for</code> bucle para esto.
     testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
-  - text: &#39; <code>myArray</code> debe ser igual a <code>[1,2,3,4,5]</code> .&#39;
+  - text: ' <code>myArray</code> debe ser igual a <code>[1,2,3,4,5]</code> .'
     testString: 'assert.deepEqual(myArray, [1,2,3,4,5], "<code>myArray</code> should equal <code>[1,2,3,4,5]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.spanish.md
index ecf890f5df..efacd0bfac 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Puede ejecutar el mismo código varias veces utilizando un bucle. 
-El primer tipo de bucle vamos a aprender se llama un &quot; <code>while</code> &quot; bucle porque funciona &quot;mientras que&quot; una condición especificada es verdadera y se detiene una vez que la condición ya no es cierto. 
-<blockquote>var ourArray = [];<br>var i = 0;<br>while(i &#60; 5) {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>}</blockquote> 
-Intentemos que funcione un bucle while empujando los valores a una matriz. 
+<section id='description'>
+Puede ejecutar el mismo código varias veces utilizando un bucle.
+El primer tipo de bucle vamos a aprender se llama un &quot; <code>while</code> &quot; bucle porque funciona &quot;mientras que&quot; una condición especificada es verdadera y se detiene una vez que la condición ya no es cierto.
+<blockquote>var ourArray = [];<br>var i = 0;<br>while(i &#60; 5) {<br>&nbsp;&nbsp;ourArray.push(i);<br>&nbsp;&nbsp;i++;<br>}</blockquote>
+Intentemos que funcione un bucle while empujando los valores a una matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</code> de bucle. 
+<section id='instructions'>
+Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</code> de bucle.
 </section>
 
 ## Tests
@@ -25,7 +25,7 @@ Empuje los números de 0 a 4 para <code>myArray</code> usando un <code>while</co
 tests:
   - text: Usted debe utilizar un <code>while</code> de bucle para esto.
     testString: 'assert(code.match(/while/g), "You should be using a <code>while</code> loop for this.");'
-  - text: &#39; <code>myArray</code> debe ser igual a <code>[0,1,2,3,4]</code> .&#39;
+  - text: ' <code>myArray</code> debe ser igual a <code>[0,1,2,3,4]</code> .'
     testString: 'assert.deepEqual(myArray, [0,1,2,3,4], "<code>myArray</code> should equal <code>[0,1,2,3,4]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.spanish.md
index a3d9689ff9..21ac1ffdce 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Otra forma de cambiar los datos en una matriz es con la función <code>.pop()</code> . 
-<code>.pop()</code> se usa para &quot; <code>.pop()</code> &quot; un valor del final de una matriz. Podemos almacenar este valor &quot;extraído&quot; asignándolo a una variable. En otras palabras, <code>.pop()</code> elimina el último elemento de una matriz y devuelve ese elemento. 
-Cualquier tipo de entrada se puede &quot;extraer&quot; de una matriz: números, cadenas, incluso matrices anidadas. 
-<blockquote> <code>var threeArr = [1, 4, 6];<br> var oneDown = threeArr.pop();<br> console.log(oneDown); // Returns 6<br> console.log(threeArr); // Returns [1, 4]</code> </blockquote> 
+<section id='description'>
+Otra forma de cambiar los datos en una matriz es con la función <code>.pop()</code> .
+<code>.pop()</code> se usa para &quot; <code>.pop()</code> &quot; un valor del final de una matriz. Podemos almacenar este valor &quot;extraído&quot; asignándolo a una variable. En otras palabras, <code>.pop()</code> elimina el último elemento de una matriz y devuelve ese elemento.
+Cualquier tipo de entrada se puede &quot;extraer&quot; de una matriz: números, cadenas, incluso matrices anidadas.
+<blockquote> <code>var threeArr = [1, 4, 6];<br> var oneDown = threeArr.pop();<br> console.log(oneDown); // Returns 6<br> console.log(threeArr); // Returns [1, 4]</code> </blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la función <code>.pop()</code> para eliminar el último elemento de <code>myArray</code> , asignando el valor de &quot;desprendimiento de&quot; a <code>removedFromMyArray</code> . 
+<section id='instructions'>
+Use la función <code>.pop()</code> para eliminar el último elemento de <code>myArray</code> , asignando el valor de &quot;desprendimiento de&quot; a <code>removedFromMyArray</code> .
 </section>
 
 ## Tests
@@ -23,11 +23,11 @@ Use la función <code>.pop()</code> para eliminar el último elemento de <code>m
 
 ```yml
 tests:
-  - text: &#39; <code>myArray</code> solo debe contener <code>[[&quot;John&quot;, 23]]</code> .&#39;
+  - text: ' <code>myArray</code> solo debe contener <code>[[&quot;John&quot;, 23]]</code> .'
     testString: 'assert((function(d){if(d[0][0] == "John" && d[0][1] === 23 && d[1] == undefined){return true;}else{return false;}})(myArray), "<code>myArray</code> should only contain <code>[["John", 23]]</code>.");'
   - text: Usa <code>pop()</code> en <code>myArray</code>
     testString: 'assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code), "Use <code>pop()</code> on <code>myArray</code>");'
-  - text: &#39; <code>removedFromMyArray</code> solo debe contener <code>[&quot;cat&quot;, 2]</code> .&#39;
+  - text: ' <code>removedFromMyArray</code> solo debe contener <code>[&quot;cat&quot;, 2]</code> .'
     testString: 'assert((function(d){if(d[0] == "cat" && d[1] === 2 && d[2] == undefined){return true;}else{return false;}})(removedFromMyArray), "<code>removedFromMyArray</code> should only contain <code>["cat", 2]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.spanish.md
index dcbe23fcb3..8a075ea2d0 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Una forma fácil de agregar datos al final de una matriz es a través de la función <code>push()</code> . 
-<code>.push()</code> toma uno o más <dfn>parámetros</dfn> y los &quot;empuja&quot; al final de la matriz. 
-<blockquote>var arr = [1,2,3];<br>arr.push(4);<br>// arr is now [1,2,3,4]</blockquote> 
+<section id='description'>
+Una forma fácil de agregar datos al final de una matriz es a través de la función <code>push()</code> .
+<code>.push()</code> toma uno o más <dfn>parámetros</dfn> y los &quot;empuja&quot; al final de la matriz.
+<blockquote>var arr = [1,2,3];<br>arr.push(4);<br>// arr is now [1,2,3,4]</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Presione <code>[&quot;dog&quot;, 3]</code> en el extremo de la variable <code>myArray</code> . 
+<section id='instructions'>
+Presione <code>[&quot;dog&quot;, 3]</code> en el extremo de la variable <code>myArray</code> .
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ Presione <code>[&quot;dog&quot;, 3]</code> en el extremo de la variable <code>my
 
 ```yml
 tests:
-  - text: &#39; <code>myArray</code> ahora debe ser igual a <code>[[&quot;John&quot;, 23], [&quot;cat&quot;, 2], [&quot;dog&quot;, 3]]</code> .&#39;
+  - text: ' <code>myArray</code> ahora debe ser igual a <code>[[&quot;John&quot;, 23], [&quot;cat&quot;, 2], [&quot;dog&quot;, 3]]</code> .'
     testString: 'assert((function(d){if(d[2] != undefined && d[0][0] == "John" && d[0][1] === 23 && d[2][0] == "dog" && d[2][1] === 3 && d[2].length == 2){return true;}else{return false;}})(myArray), "<code>myArray</code> should now equal <code>[["John", 23], ["cat", 2], ["dog", 3]]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.spanish.md
index 49e48d9d54..942dcf80af 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<code>pop()</code> siempre elimina el último elemento de una matriz. ¿Qué pasa si quieres eliminar el primero? 
-Ahí es donde <code>.shift()</code> en <code>.shift()</code> . Funciona igual que <code>.pop()</code> , excepto que elimina el primer elemento en lugar del último. 
+<section id='description'>
+<code>pop()</code> siempre elimina el último elemento de una matriz. ¿Qué pasa si quieres eliminar el primero?
+Ahí es donde <code>.shift()</code> en <code>.shift()</code> . Funciona igual que <code>.pop()</code> , excepto que elimina el primer elemento en lugar del último.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la función <code>.shift()</code> para eliminar el primer elemento de <code>myArray</code> , asignando el valor &quot;desviado&quot; a <code>removedFromMyArray</code> . 
+<section id='instructions'>
+Use la función <code>.shift()</code> para eliminar el primer elemento de <code>myArray</code> , asignando el valor &quot;desviado&quot; a <code>removedFromMyArray</code> .
 </section>
 
 ## Tests
@@ -21,9 +21,9 @@ Use la función <code>.shift()</code> para eliminar el primer elemento de <code>
 
 ```yml
 tests:
-  - text: &#39; <code>myArray</code> ahora debe ser igual a <code>[[&quot;dog&quot;, 3]]</code> .&#39;
+  - text: ' <code>myArray</code> ahora debe ser igual a <code>[[&quot;dog&quot;, 3]]</code> .'
     testString: 'assert((function(d){if(d[0][0] == "dog" && d[0][1] === 3 && d[1] == undefined){return true;}else{return false;}})(myArray), "<code>myArray</code> should now equal <code>[["dog", 3]]</code>.");'
-  - text: &#39; <code>removedFromMyArray</code> debe contener <code>[&quot;John&quot;, 23]</code> .&#39;
+  - text: ' <code>removedFromMyArray</code> debe contener <code>[&quot;John&quot;, 23]</code> .'
     testString: 'assert((function(d){if(d[0] == "John" && d[1] === 23 && typeof removedFromMyArray === "object"){return true;}else{return false;}})(removedFromMyArray), "<code>removedFromMyArray</code> should contain <code>["John", 23]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.spanish.md
index cb813bc690..70a71436f0 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-No solo puede <code>shift</code> elementos del principio de una matriz, <code>unshift</code> también puede <code>unshift</code> elementos al principio de una matriz, es decir, agregar elementos delante de la matriz. 
-<code>.unshift()</code> funciona exactamente como <code>.push()</code> , pero en lugar de agregar el elemento al final de la matriz, <code>unshift()</code> agrega el elemento al principio de la matriz. 
+<section id='description'>
+No solo puede <code>shift</code> elementos del principio de una matriz, <code>unshift</code> también puede <code>unshift</code> elementos al principio de una matriz, es decir, agregar elementos delante de la matriz.
+<code>.unshift()</code> funciona exactamente como <code>.push()</code> , pero en lugar de agregar el elemento al final de la matriz, <code>unshift()</code> agrega el elemento al principio de la matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Añadir <code>[&quot;Paul&quot;,35]</code> para el inicio de la <code>myArray</code> variable usando <code>unshift()</code> . 
+<section id='instructions'>
+Añadir <code>[&quot;Paul&quot;,35]</code> para el inicio de la <code>myArray</code> variable usando <code>unshift()</code> .
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Añadir <code>[&quot;Paul&quot;,35]</code> para el inicio de la <code>myArray</c
 
 ```yml
 tests:
-  - text: &#39; <code>myArray</code> debería tener ahora [[&quot;Paul&quot;, 35], [&quot;dog&quot;, 3]].&#39;
+  - text: ' <code>myArray</code> debería tener ahora [[&quot;Paul&quot;, 35], [&quot;dog&quot;, 3]].'
     testString: 'assert((function(d){if(typeof d[0] === "object" && d[0][0] == "Paul" && d[0][1] === 35 && d[1][0] != undefined && d[1][0] == "dog" && d[1][1] != undefined && d[1][1] == 3){return true;}else{return false;}})(myArray), "<code>myArray</code> should now have [["Paul", 35], ["dog", 3]].");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.spanish.md
index 0268df122c..033ec4111c 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.spanish.md
@@ -6,20 +6,20 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-A veces es posible que desee almacenar datos en una <dfn>estructura de datos</dfn> flexible. Un objeto JavaScript es una forma de manejar datos flexibles. Permiten combinaciones arbitrarias de <dfn>cadenas</dfn> , <dfn>números</dfn> , <dfn>booleanos</dfn> , <dfn>matrices</dfn> , <dfn>funciones</dfn> y <dfn>objetos</dfn> . 
-Aquí hay un ejemplo de una estructura de datos compleja: 
-<blockquote>var ourMusic = [<br>&nbsp;&nbsp;{<br>&nbsp;&nbsp;&nbsp;&nbsp;"artist": "Daft Punk",<br>&nbsp;&nbsp;&nbsp;&nbsp;"title": "Homework",<br>&nbsp;&nbsp;&nbsp;&nbsp;"release_year": 1997,<br>&nbsp;&nbsp;&nbsp;&nbsp;"formats": [ <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"CD", <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"Cassette", <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"LP"<br>&nbsp;&nbsp;&nbsp;&nbsp;],<br>&nbsp;&nbsp;&nbsp;&nbsp;"gold": true<br>&nbsp;&nbsp;}<br>];</blockquote> 
-Esta es una matriz que contiene un objeto dentro. El objeto tiene varias piezas de <dfn>metadatos</dfn> sobre un álbum. También tiene una matriz de <code>&quot;formats&quot;</code> anidados. Si desea agregar más registros de álbum, puede hacerlo agregando registros a la matriz de nivel superior. 
-objetos contienen datos en una propiedad, que tiene un formato de clave-valor. En el ejemplo anterior, <code>&quot;artist&quot;: &quot;Daft Punk&quot;</code> es una propiedad que tiene una clave de <code>&quot;artist&quot;</code> y un valor de <code>&quot;Daft Punk&quot;</code> . 
-<a href='http://www.json.org/' target=_blank>JavaScript Object Notation</a> o <code>JSON</code> es un formato de intercambio de datos relacionado que se utiliza para almacenar datos. 
-<blockquote>{<br>&nbsp;&nbsp;"artist": "Daft Punk",<br>&nbsp;&nbsp;"title": "Homework",<br>&nbsp;&nbsp;"release_year": 1997,<br>&nbsp;&nbsp;"formats": [ <br>&nbsp;&nbsp;&nbsp;&nbsp;"CD",<br>&nbsp;&nbsp;&nbsp;&nbsp;"Cassette",<br>&nbsp;&nbsp;&nbsp;&nbsp;"LP"<br>&nbsp;&nbsp;],<br>&nbsp;&nbsp;"gold": true<br>}</blockquote> 
-<strong>Nota</strong> <br> Deberá colocar una coma después de cada objeto de la matriz, a menos que sea el último objeto de la matriz. 
+<section id='description'>
+A veces es posible que desee almacenar datos en una <dfn>estructura de datos</dfn> flexible. Un objeto JavaScript es una forma de manejar datos flexibles. Permiten combinaciones arbitrarias de <dfn>cadenas</dfn> , <dfn>números</dfn> , <dfn>booleanos</dfn> , <dfn>matrices</dfn> , <dfn>funciones</dfn> y <dfn>objetos</dfn> .
+Aquí hay un ejemplo de una estructura de datos compleja:
+<blockquote>var ourMusic = [<br>&nbsp;&nbsp;{<br>&nbsp;&nbsp;&nbsp;&nbsp;"artist": "Daft Punk",<br>&nbsp;&nbsp;&nbsp;&nbsp;"title": "Homework",<br>&nbsp;&nbsp;&nbsp;&nbsp;"release_year": 1997,<br>&nbsp;&nbsp;&nbsp;&nbsp;"formats": [ <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"CD", <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"Cassette", <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"LP"<br>&nbsp;&nbsp;&nbsp;&nbsp;],<br>&nbsp;&nbsp;&nbsp;&nbsp;"gold": true<br>&nbsp;&nbsp;}<br>];</blockquote>
+Esta es una matriz que contiene un objeto dentro. El objeto tiene varias piezas de <dfn>metadatos</dfn> sobre un álbum. También tiene una matriz de <code>&quot;formats&quot;</code> anidados. Si desea agregar más registros de álbum, puede hacerlo agregando registros a la matriz de nivel superior.
+objetos contienen datos en una propiedad, que tiene un formato de clave-valor. En el ejemplo anterior, <code>&quot;artist&quot;: &quot;Daft Punk&quot;</code> es una propiedad que tiene una clave de <code>&quot;artist&quot;</code> y un valor de <code>&quot;Daft Punk&quot;</code> .
+<a href='http://www.json.org/' target=_blank>JavaScript Object Notation</a> o <code>JSON</code> es un formato de intercambio de datos relacionado que se utiliza para almacenar datos.
+<blockquote>{<br>&nbsp;&nbsp;"artist": "Daft Punk",<br>&nbsp;&nbsp;"title": "Homework",<br>&nbsp;&nbsp;"release_year": 1997,<br>&nbsp;&nbsp;"formats": [ <br>&nbsp;&nbsp;&nbsp;&nbsp;"CD",<br>&nbsp;&nbsp;&nbsp;&nbsp;"Cassette",<br>&nbsp;&nbsp;&nbsp;&nbsp;"LP"<br>&nbsp;&nbsp;],<br>&nbsp;&nbsp;"gold": true<br>}</blockquote>
+<strong>Nota</strong> <br> Deberá colocar una coma después de cada objeto de la matriz, a menos que sea el último objeto de la matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agrega un nuevo álbum a la matriz <code>myMusic</code> . Agregue cadenas de <code>artist</code> y <code>title</code> , número de año de <code>release_year</code> y una matriz de <code>formats</code> de cadenas. 
+<section id='instructions'>
+Agrega un nuevo álbum a la matriz <code>myMusic</code> . Agregue cadenas de <code>artist</code> y <code>title</code> , número de año de <code>release_year</code> y una matriz de <code>formats</code> de cadenas.
 </section>
 
 ## Tests
@@ -31,17 +31,17 @@ tests:
     testString: 'assert(Array.isArray(myMusic), "<code>myMusic</code> should be an array");'
   - text: <code>myMusic</code> debería tener al menos dos elementos
     testString: 'assert(myMusic.length > 1, "<code>myMusic</code> should have at least two elements");'
-  - text: &#39; <code>myMusic[1]</code> debería ser un objeto&#39;
+  - text: ' <code>myMusic[1]</code> debería ser un objeto'
     testString: 'assert(typeof myMusic[1] === "object", "<code>myMusic[1]</code> should be an object");'
-  - text: &#39; <code>myMusic[1]</code> debería tener al menos 4 propiedades&#39;
+  - text: ' <code>myMusic[1]</code> debería tener al menos 4 propiedades'
     testString: 'assert(Object.keys(myMusic[1]).length > 3, "<code>myMusic[1]</code> should have at least 4 properties");'
-  - text: &#39; <code>myMusic[1]</code> debe contener una propiedad de <code>artist</code> que es una cadena&#39;
+  - text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>artist</code> que es una cadena'
     testString: 'assert(myMusic[1].hasOwnProperty("artist") && typeof myMusic[1].artist === "string", "<code>myMusic[1]</code> should contain an <code>artist</code> property which is a string");'
-  - text: &#39; <code>myMusic[1]</code> debe contener una propiedad de <code>title</code> que es una cadena&#39;
+  - text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>title</code> que es una cadena'
     testString: 'assert(myMusic[1].hasOwnProperty("title") && typeof myMusic[1].title === "string", "<code>myMusic[1]</code> should  contain a <code>title</code> property which is a string");'
-  - text: &#39; <code>myMusic[1]</code> debe contener una propiedad <code>release_year</code> que es un número&#39;
+  - text: ' <code>myMusic[1]</code> debe contener una propiedad <code>release_year</code> que es un número'
     testString: 'assert(myMusic[1].hasOwnProperty("release_year") && typeof myMusic[1].release_year === "number", "<code>myMusic[1]</code> should contain a <code>release_year</code> property which is a number");'
-  - text: &#39; <code>myMusic[1]</code> debe contener una propiedad de <code>formats</code> que es una matriz&#39;
+  - text: ' <code>myMusic[1]</code> debe contener una propiedad de <code>formats</code> que es una matriz'
     testString: 'assert(myMusic[1].hasOwnProperty("formats") && Array.isArray(myMusic[1].formats), "<code>myMusic[1]</code> should contain a <code>formats</code> property which is an array");'
   - text: <code>formats</code> deben ser una matriz de cadenas con al menos dos elementos.
     testString: 'assert(myMusic[1].formats.every(function(item) { return (typeof item === "string")}) && myMusic[1].formats.length > 1, "<code>formats</code> should be an array of strings with at least two elements");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.spanish.md
index 13df009d56..8f707790e5 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-A diferencia de las cadenas, las entradas de matrices son <dfn>mutables</dfn> y se pueden cambiar libremente. 
-<strong>Ejemplo</strong> 
-<blockquote>var ourArray = [50,40,30];<br>ourArray[0] = 15; // equals [15,40,30]</blockquote> 
-<strong>Nota</strong> <br> No debe haber espacios entre el nombre de la matriz y los corchetes, como la <code>array [0]</code> . Aunque JavaScript puede procesar esto correctamente, esto puede confundir a otros programadores que leen su código. 
+<section id='description'>
+A diferencia de las cadenas, las entradas de matrices son <dfn>mutables</dfn> y se pueden cambiar libremente.
+<strong>Ejemplo</strong>
+<blockquote>var ourArray = [50,40,30];<br>ourArray[0] = 15; // equals [15,40,30]</blockquote>
+<strong>Nota</strong> <br> No debe haber espacios entre el nombre de la matriz y los corchetes, como la <code>array [0]</code> . Aunque JavaScript puede procesar esto correctamente, esto puede confundir a otros programadores que leen su código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Modifique los datos almacenados en el índice <code>0</code> de <code>myArray</code> a un valor de <code>45</code> . 
+<section id='instructions'>
+Modifique los datos almacenados en el índice <code>0</code> de <code>myArray</code> a un valor de <code>45</code> .
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Modifique los datos almacenados en el índice <code>0</code> de <code>myArray</c
 
 ```yml
 tests:
-  - text: &#39; <code>myArray</code> ahora debería ser [45,64,99].&#39;
+  - text: ' <code>myArray</code> ahora debería ser [45,64,99].'
     testString: 'assert((function(){if(typeof myArray != "undefined" && myArray[0] == 45 && myArray[1] == 64 && myArray[2] == 99){return true;}else{return false;}})(), "<code>myArray</code> should now be [45,64,99].");'
   - text: Debe utilizar el índice correcto para modificar el valor en <code>myArray</code> .
     testString: 'assert((function(){if(code.match(/myArray\[0\]\s*=\s*/g)){return true;}else{return false;}})(), "You should be using correct index to modify the value in <code>myArray</code>.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.spanish.md
index cb0dcb83d7..2103f486e9 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Si tiene una matriz multidimensional, puede usar la misma lógica que el punto de ruta anterior para recorrer tanto la matriz como cualquier subarreglo. Aquí hay un ejemplo: 
-<blockquote>var arr = [<br>&nbsp;&nbsp;[1,2], [3,4], [5,6]<br>];<br>for (var i=0; i &lt; arr.length; i++) {<br>&nbsp;&nbsp;for (var j=0; j &lt; arr[i].length; j++) {<br>&nbsp;&nbsp;&nbsp;&nbsp;console.log(arr[i][j]);<br>&nbsp;&nbsp;}<br>}</blockquote> 
-Esto genera cada subelemento en <code>arr</code> uno a la vez. Tenga en cuenta que para el bucle interno, estamos comprobando la <code>.length</code> de <code>arr[i]</code> , ya que <code>arr[i]</code> es en sí misma una matriz. 
+<section id='description'>
+Si tiene una matriz multidimensional, puede usar la misma lógica que el punto de ruta anterior para recorrer tanto la matriz como cualquier subarreglo. Aquí hay un ejemplo:
+<blockquote>var arr = [<br>&nbsp;&nbsp;[1,2], [3,4], [5,6]<br>];<br>for (var i=0; i &lt; arr.length; i++) {<br>&nbsp;&nbsp;for (var j=0; j &lt; arr[i].length; j++) {<br>&nbsp;&nbsp;&nbsp;&nbsp;console.log(arr[i][j]);<br>&nbsp;&nbsp;}<br>}</blockquote>
+Esto genera cada subelemento en <code>arr</code> uno a la vez. Tenga en cuenta que para el bucle interno, estamos comprobando la <code>.length</code> de <code>arr[i]</code> , ya que <code>arr[i]</code> es en sí misma una matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Modificar la función <code>multiplyAll</code> para que multiplique la variable del <code>product</code> por cada número en las subarreglas de <code>arr</code> 
+<section id='instructions'>
+Modificar la función <code>multiplyAll</code> para que multiplique la variable del <code>product</code> por cada número en las subarreglas de <code>arr</code>
 </section>
 
 ## Tests
@@ -22,11 +22,11 @@ Modificar la función <code>multiplyAll</code> para que multiplique la variable
 
 ```yml
 tests:
-  - text: &#39; <code>multiplyAll([[1],[2],[3]])</code> debe devolver <code>6</code> &#39;
+  - text: ' <code>multiplyAll([[1],[2],[3]])</code> debe devolver <code>6</code> '
     testString: 'assert(multiplyAll([[1],[2],[3]]) === 6, "<code>multiplyAll([[1],[2],[3]])</code> should return <code>6</code>");'
-  - text: &#39; <code>multiplyAll([[1,2],[3,4],[5,6,7]])</code> debe devolver <code>5040</code> &#39;
+  - text: ' <code>multiplyAll([[1,2],[3,4],[5,6,7]])</code> debe devolver <code>5040</code> '
     testString: 'assert(multiplyAll([[1,2],[3,4],[5,6,7]]) === 5040, "<code>multiplyAll([[1,2],[3,4],[5,6,7]])</code> should return <code>5040</code>");'
-  - text: &#39; <code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code> debe devolver <code>54</code> &#39;
+  - text: ' <code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code> debe devolver <code>54</code> '
     testString: 'assert(multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]]) === 54, "<code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code> should return <code>54</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.spanish.md
index a7d191a995..5462816895 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<dfn>parámetros</dfn> son variables que actúan como marcadores de posición para los valores que deben ingresarse en una función cuando se llama. Cuando se define una función, normalmente se define junto con uno o más parámetros. Los valores reales que se ingresan (o <dfn>&quot;pasan&quot;</dfn> ) en una función cuando se llama se conocen como <dfn>argumentos</dfn> . 
-Aquí hay una función con dos parámetros, <code>param1</code> y <code>param2</code> : 
-<blockquote>function testFun(param1, param2) {<br>&nbsp;&nbsp;console.log(param1, param2);<br>}</blockquote> 
-Entonces podemos llamar a <code>testFun</code> : 
-<code>testFun(&quot;Hello&quot;, &quot;World&quot;);</code> 
-Hemos pasado dos argumentos, <code>&quot;Hello&quot;</code> y <code>&quot;World&quot;</code> . Dentro de la función, <code>param1</code> será igual a &quot;Hello&quot; y <code>param2</code> será igual a &quot;World&quot;. Tenga en cuenta que podría <code>testFun</code> llamar a <code>testFun</code> con diferentes argumentos y los parámetros tomarían el valor de los nuevos argumentos. 
+<section id='description'>
+<dfn>parámetros</dfn> son variables que actúan como marcadores de posición para los valores que deben ingresarse en una función cuando se llama. Cuando se define una función, normalmente se define junto con uno o más parámetros. Los valores reales que se ingresan (o <dfn>&quot;pasan&quot;</dfn> ) en una función cuando se llama se conocen como <dfn>argumentos</dfn> .
+Aquí hay una función con dos parámetros, <code>param1</code> y <code>param2</code> :
+<blockquote>function testFun(param1, param2) {<br>&nbsp;&nbsp;console.log(param1, param2);<br>}</blockquote>
+Entonces podemos llamar a <code>testFun</code> :
+<code>testFun(&quot;Hello&quot;, &quot;World&quot;);</code>
+Hemos pasado dos argumentos, <code>&quot;Hello&quot;</code> y <code>&quot;World&quot;</code> . Dentro de la función, <code>param1</code> será igual a &quot;Hello&quot; y <code>param2</code> será igual a &quot;World&quot;. Tenga en cuenta que podría <code>testFun</code> llamar a <code>testFun</code> con diferentes argumentos y los parámetros tomarían el valor de los nuevos argumentos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-<ol> <li> Cree una función llamada <code>functionWithArgs</code> que acepte dos argumentos y envíe su suma a la consola dev. </li><li> Llame a la función con dos números como argumentos. </li></ol> 
+<section id='instructions'>
+<ol> <li> Cree una función llamada <code>functionWithArgs</code> que acepte dos argumentos y envíe su suma a la consola dev. </li><li> Llame a la función con dos números como argumentos. </li></ol>
 </section>
 
 ## Tests
@@ -27,9 +27,9 @@ Hemos pasado dos argumentos, <code>&quot;Hello&quot;</code> y <code>&quot;World&
 tests:
   - text: <code>functionWithArgs</code> debería ser una función
     testString: 'assert(typeof functionWithArgs === "function", "<code>functionWithArgs</code> should be a function");'
-  - text: &#39; <code>functionWithArgs(1,2)</code> debe generar <code>3</code> &#39;
+  - text: ' <code>functionWithArgs(1,2)</code> debe generar <code>3</code> '
     testString: 'if(typeof functionWithArgs === "function") { capture(); functionWithArgs(1,2); uncapture(); } assert(logOutput == 3, "<code>functionWithArgs(1,2)</code> should output <code>3</code>");'
-  - text: &#39; <code>functionWithArgs(7,9)</code> debe generar <code>16</code> &#39;
+  - text: ' <code>functionWithArgs(7,9)</code> debe generar <code>16</code> '
     testString: 'if(typeof functionWithArgs === "function") { capture(); functionWithArgs(7,9); uncapture(); } assert(logOutput == 16, "<code>functionWithArgs(7,9)</code> should output <code>16</code>");'
   - text: Llame a <code>functionWithArgs</code> con dos números después de definirlo.
     testString: 'assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*;/m.test(code), "Call <code>functionWithArgs</code> with two numbers after you define it.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.spanish.md
index 8fa0ad0eb5..b35dc56443 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En los últimos dos desafíos, aprendimos sobre el operador de igualdad ( <code>==</code> ) y el operador de igualdad estricta ( <code>===</code> ). Hagamos una revisión rápida y practiquemos el uso de estos operadores un poco más. 
-Si los valores que se comparan no son del mismo tipo, el operador de igualdad realizará una conversión de tipo y luego evaluará los valores. Sin embargo, el operador de igualdad estricta comparará tanto el tipo de datos como el valor tal como está, sin convertir un tipo en otro. 
-<strong>ejemplos</strong> 
-<blockquote>3 == '3'  // returns true because JavaScript performs type conversion from string to number<br>3 === '3' // returns false because the types are different and type conversion is not performed</blockquote> 
-<strong>Nota</strong> <br> En JavaScript, puede determinar el tipo de una variable o un valor con el operador <code>typeof</code> , de la siguiente manera: 
-<blockquote>typeof 3   // returns 'number'<br>typeof '3' // returns 'string'</blockquote> 
+<section id='description'>
+En los últimos dos desafíos, aprendimos sobre el operador de igualdad ( <code>==</code> ) y el operador de igualdad estricta ( <code>===</code> ). Hagamos una revisión rápida y practiquemos el uso de estos operadores un poco más.
+Si los valores que se comparan no son del mismo tipo, el operador de igualdad realizará una conversión de tipo y luego evaluará los valores. Sin embargo, el operador de igualdad estricta comparará tanto el tipo de datos como el valor tal como está, sin convertir un tipo en otro.
+<strong>ejemplos</strong>
+<blockquote>3 == '3'  // returns true because JavaScript performs type conversion from string to number<br>3 === '3' // returns false because the types are different and type conversion is not performed</blockquote>
+<strong>Nota</strong> <br> En JavaScript, puede determinar el tipo de una variable o un valor con el operador <code>typeof</code> , de la siguiente manera:
+<blockquote>typeof 3   // returns 'number'<br>typeof '3' // returns 'string'</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-La función <code>compareEquality</code> en el editor compara dos valores utilizando el <code>equality operator</code> . Modifique la función de modo que devuelva &quot;Igual&quot; solo cuando los valores sean estrictamente iguales. 
+<section id='instructions'>
+La función <code>compareEquality</code> en el editor compara dos valores utilizando el <code>equality operator</code> . Modifique la función de modo que devuelva &quot;Igual&quot; solo cuando los valores sean estrictamente iguales.
 </section>
 
 ## Tests
@@ -25,9 +25,9 @@ La función <code>compareEquality</code> en el editor compara dos valores utiliz
 
 ```yml
 tests:
-  - text: &#39; <code>compareEquality(10, &quot;10&quot;)</code> debe devolver &quot;Not Equal&quot;&#39;
+  - text: ' <code>compareEquality(10, &quot;10&quot;)</code> debe devolver &quot;Not Equal&quot;'
     testString: 'assert(compareEquality(10, "10") === "Not Equal", "<code>compareEquality(10, "10")</code> should return "Not Equal"");'
-  - text: &#39; <code>compareEquality(&quot;20&quot;, 20)</code> debe devolver &quot;Not Equal&quot;&#39;
+  - text: ' <code>compareEquality(&quot;20&quot;, 20)</code> debe devolver &quot;Not Equal&quot;'
     testString: 'assert(compareEquality("20", 20) === "Not Equal", "<code>compareEquality("20", 20)</code> should return "Not Equal"");'
   - text: Debes usar el operador <code>===</code>
     testString: 'assert(code.match(/===/g), "You should use the <code>===</code> operator");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.spanish.md
index 59cbf207ea..6d4f6906d3 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Tenemos una variedad de objetos que representan a diferentes personas en nuestras listas de contactos. 
-Se ha <code>lookUpProfile</code> función <code>lookUpProfile</code> que toma el <code>name</code> y una propiedad ( <code>prop</code> ) como argumentos. 
-La función debe comprobar si <code>name</code> es de un contacto real <code>firstName</code> y la propiedad dada ( <code>prop</code> ) es una propiedad de ese contacto. 
-Si ambos son verdaderos, devuelva el &quot;valor&quot; de esa propiedad. 
-Si el <code>name</code> no corresponde a ningún contacto, devuelva <code>&quot;No such contact&quot;</code> 
-Si la <code>prop</code> no corresponde a ninguna propiedad válida de un contacto encontrado para coincidir con el <code>name</code> entonces devuelva <code>&quot;No such property&quot;</code> existe <code>&quot;No such property&quot;</code> 
+<section id='description'>
+Tenemos una variedad de objetos que representan a diferentes personas en nuestras listas de contactos.
+Se ha <code>lookUpProfile</code> función <code>lookUpProfile</code> que toma el <code>name</code> y una propiedad ( <code>prop</code> ) como argumentos.
+La función debe comprobar si <code>name</code> es de un contacto real <code>firstName</code> y la propiedad dada ( <code>prop</code> ) es una propiedad de ese contacto.
+Si ambos son verdaderos, devuelva el &quot;valor&quot; de esa propiedad.
+Si el <code>name</code> no corresponde a ningún contacto, devuelva <code>&quot;No such contact&quot;</code>
+Si la <code>prop</code> no corresponde a ninguna propiedad válida de un contacto encontrado para coincidir con el <code>name</code> entonces devuelva <code>&quot;No such property&quot;</code> existe <code>&quot;No such property&quot;</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,17 +25,17 @@ Si la <code>prop</code> no corresponde a ninguna propiedad válida de un contact
 
 ```yml
 tests:
-  - text: &#39; <code>&quot;Kristian&quot;, &quot;lastName&quot;</code> debería devolver <code>&quot;Vos&quot;</code> &#39;
+  - text: ' <code>&quot;Kristian&quot;, &quot;lastName&quot;</code> debería devolver <code>&quot;Vos&quot;</code> '
     testString: 'assert(lookUpProfile("Kristian","lastName") === "Vos", "<code>"Kristian", "lastName"</code> should return <code>"Vos"</code>");'
-  - text: &#39; <code>&quot;Sherlock&quot;, &quot;likes&quot;</code> debería devolver <code>[&quot;Intriguing Cases&quot;, &quot;Violin&quot;]</code> &#39;
+  - text: ' <code>&quot;Sherlock&quot;, &quot;likes&quot;</code> debería devolver <code>[&quot;Intriguing Cases&quot;, &quot;Violin&quot;]</code> '
     testString: 'assert.deepEqual(lookUpProfile("Sherlock", "likes"), ["Intriguing Cases", "Violin"], "<code>"Sherlock", "likes"</code> should return <code>["Intriguing Cases", "Violin"]</code>");'
-  - text: &#39; <code>&quot;Harry&quot;,&quot;likes&quot;</code> debería devolver una matriz&#39;
+  - text: ' <code>&quot;Harry&quot;,&quot;likes&quot;</code> debería devolver una matriz'
     testString: 'assert(typeof lookUpProfile("Harry", "likes") === "object", "<code>"Harry","likes"</code> should return an array");'
-  - text: &#39; <code>&quot;Bob&quot;, &quot;number&quot;</code> debe devolver &quot;No existe tal contacto&quot;&#39;
+  - text: ' <code>&quot;Bob&quot;, &quot;number&quot;</code> debe devolver &quot;No existe tal contacto&quot;'
     testString: 'assert(lookUpProfile("Bob", "number") === "No such contact", "<code>"Bob", "number"</code> should return "No such contact"");'
-  - text: &#39; <code>&quot;Bob&quot;, &quot;potato&quot;</code> debe devolver &quot;No hay tal contacto&quot;&#39;
+  - text: ' <code>&quot;Bob&quot;, &quot;potato&quot;</code> debe devolver &quot;No hay tal contacto&quot;'
     testString: 'assert(lookUpProfile("Bob", "potato") === "No such contact", "<code>"Bob", "potato"</code> should return "No such contact"");'
-  - text: &#39; <code>&quot;Akira&quot;, &quot;address&quot;</code> debe devolver &quot;No existe tal propiedad&quot;
+  - text: ' <code>&quot;Akira&quot;, &quot;address&quot;</code> debe devolver &quot;No existe tal propiedad&quot;
     testString: 'assert(lookUpProfile("Akira", "address") === "No such property", "<code>"Akira", "address"</code> should return "No such property"");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.spanish.md
index 65d89ab652..2a4468a3cd 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.spanish.md
@@ -6,21 +6,21 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<dfn>Los</dfn> valores de <dfn>cadena</dfn> en JavaScript se pueden escribir con comillas simples o dobles, siempre y cuando comience y termine con el mismo tipo de comillas. A diferencia de otros lenguajes de programación, las comillas simples y dobles funcionan de la misma manera en JavaScript. 
-<blockquote>doubleQuoteStr = "This is a string"; <br/>singleQuoteStr = 'This is also a string';</blockquote> 
-La razón por la que podría querer usar un tipo de cita sobre la otra es si quiere usar ambos en una cadena. Esto puede suceder si desea guardar una conversación en una cadena y tener la conversación entre comillas. Otro uso sería guardar una etiqueta <code>&lt;a&gt;</code> con varios atributos entre comillas, todo dentro de una cadena. 
-<blockquote>conversation = 'Finn exclaims to Jake, "Algebraic!"';</blockquote> 
-Sin embargo, esto se convierte en un problema si necesita usar las citas más externas dentro de él. Recuerde, una cadena tiene el mismo tipo de cita al principio y al final. Pero si tiene la misma cita en algún punto intermedio, la cadena se detendrá antes y arrojará un error. 
-<blockquote>goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; <br/>badStr = 'Finn responds, "Let's go!"'; // Throws an error</blockquote> 
-En el <dfn>goodStr</dfn> anterior, puede usar ambas comillas de forma segura usando la barra invertida <code>\</code> como un carácter de escape. 
-<strong>Nota</strong> <br/> La barra invertida <code>\</code> no debe confundirse con la barra inclinada <code>/</code> . No hacen lo mismo. 
+<section id='description'>
+<dfn>Los</dfn> valores de <dfn>cadena</dfn> en JavaScript se pueden escribir con comillas simples o dobles, siempre y cuando comience y termine con el mismo tipo de comillas. A diferencia de otros lenguajes de programación, las comillas simples y dobles funcionan de la misma manera en JavaScript.
+<blockquote>doubleQuoteStr = "This is a string"; <br/>singleQuoteStr = 'This is also a string';</blockquote>
+La razón por la que podría querer usar un tipo de cita sobre la otra es si quiere usar ambos en una cadena. Esto puede suceder si desea guardar una conversación en una cadena y tener la conversación entre comillas. Otro uso sería guardar una etiqueta <code>&lt;a&gt;</code> con varios atributos entre comillas, todo dentro de una cadena.
+<blockquote>conversation = 'Finn exclaims to Jake, "Algebraic!"';</blockquote>
+Sin embargo, esto se convierte en un problema si necesita usar las citas más externas dentro de él. Recuerde, una cadena tiene el mismo tipo de cita al principio y al final. Pero si tiene la misma cita en algún punto intermedio, la cadena se detendrá antes y arrojará un error.
+<blockquote>goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; <br/>badStr = 'Finn responds, "Let's go!"'; // Throws an error</blockquote>
+En el <dfn>goodStr</dfn> anterior, puede usar ambas comillas de forma segura usando la barra invertida <code>\</code> como un carácter de escape.
+<strong>Nota</strong> <br/> La barra invertida <code>\</code> no debe confundirse con la barra inclinada <code>/</code> . No hacen lo mismo.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambie la cadena proporcionada por una cadena con comillas simples al principio y al final y sin caracteres de escape. 
-En este momento, la etiqueta <code>&lt;a&gt;</code> en la cadena usa comillas dobles en todas partes. Deberá cambiar las comillas externas a comillas simples para poder eliminar los caracteres de escape. 
+<section id='instructions'>
+Cambie la cadena proporcionada por una cadena con comillas simples al principio y al final y sin caracteres de escape.
+En este momento, la etiqueta <code>&lt;a&gt;</code> en la cadena usa comillas dobles en todas partes. Deberá cambiar las comillas externas a comillas simples para poder eliminar los caracteres de escape.
 </section>
 
 ## Tests
@@ -30,7 +30,7 @@ En este momento, la etiqueta <code>&lt;a&gt;</code> en la cadena usa comillas do
 tests:
   - text: Eliminar todas las <code>backslashes</code> ( <code>\</code> )
     testString: 'assert(!/\\/g.test(code) && myStr.match("\\s*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\s*"), "Remove all the <code>backslashes</code> (<code>\</code>)");'
-  - text: &#39;Debería tener dos comillas simples <code>&#39;</code> y cuatro comillas dobles <code>&quot;</code> &#39;
+  - text: 'Debería tener dos comillas simples <code>&#39;</code> y cuatro comillas dobles <code>&quot;</code> '
     testString: 'assert(code.match(/"/g).length === 4 && code.match(/"/g).length === 2, "You should have two single quotes <code>&#39;</code> and four double quotes <code>&quot;</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.spanish.md
index 21aa64cf37..6e73dd4eb3 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.spanish.md
@@ -6,22 +6,22 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Se le asigna un objeto JSON que representa una parte de su colección de álbumes musicales. Cada álbum tiene varias propiedades y un número de identificación único como clave. No todos los álbumes tienen información completa. 
-Escriba una función que tome la <code>id</code> un álbum (como <code>2548</code> ), una propiedad <code>prop</code> (como <code>&quot;artist&quot;</code> o <code>&quot;tracks&quot;</code> ), y un <code>value</code> (como <code>&quot;Addicted to Love&quot;</code> ) para modificar los datos de esta colección. 
-Si la <code>prop</code> no es <code>&quot;tracks&quot;</code> y el <code>value</code> no está vacío ( <code>&quot;&quot;</code> ), actualice o establezca el <code>value</code> para la propiedad del álbum de grabación. 
-Su función debe devolver siempre el objeto de colección completo. 
-Existen varias reglas para manejar datos incompletos: 
-Si <code>prop</code> es <code>&quot;tracks&quot;</code> pero el álbum no tiene una propiedad de <code>&quot;tracks&quot;</code> , cree una matriz vacía antes de agregar el nuevo valor a la propiedad correspondiente del álbum. 
-Si <code>prop</code> es <code>&quot;tracks&quot;</code> y el <code>value</code> no está vacío ( <code>&quot;&quot;</code> ), presione el <code>value</code> sobre el final de la matriz de <code>tracks</code> existente del <code>tracks</code> . 
-Si el <code>value</code> está vacío ( <code>&quot;&quot;</code> ), elimine la propiedad de <code>prop</code> determinada del álbum. 
-<strong>Consejos</strong> <br> Utilice la <code>bracket notation</code> cuando <a href="javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables" target="_blank">acceda a las propiedades de objetos con variables</a> . 
-Push es un método de matriz que puede leer sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push" target="_blank">Mozilla Developer Network</a> . 
-Puede volver a consultar <a href="javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects" target="_blank">Manipular objetos complejos</a> Presentando la notación de objetos de JavaScript (JSON) para obtener una actualización. 
+<section id='description'>
+Se le asigna un objeto JSON que representa una parte de su colección de álbumes musicales. Cada álbum tiene varias propiedades y un número de identificación único como clave. No todos los álbumes tienen información completa.
+Escriba una función que tome la <code>id</code> un álbum (como <code>2548</code> ), una propiedad <code>prop</code> (como <code>&quot;artist&quot;</code> o <code>&quot;tracks&quot;</code> ), y un <code>value</code> (como <code>&quot;Addicted to Love&quot;</code> ) para modificar los datos de esta colección.
+Si la <code>prop</code> no es <code>&quot;tracks&quot;</code> y el <code>value</code> no está vacío ( <code>&quot;&quot;</code> ), actualice o establezca el <code>value</code> para la propiedad del álbum de grabación.
+Su función debe devolver siempre el objeto de colección completo.
+Existen varias reglas para manejar datos incompletos:
+Si <code>prop</code> es <code>&quot;tracks&quot;</code> pero el álbum no tiene una propiedad de <code>&quot;tracks&quot;</code> , cree una matriz vacía antes de agregar el nuevo valor a la propiedad correspondiente del álbum.
+Si <code>prop</code> es <code>&quot;tracks&quot;</code> y el <code>value</code> no está vacío ( <code>&quot;&quot;</code> ), presione el <code>value</code> sobre el final de la matriz de <code>tracks</code> existente del <code>tracks</code> .
+Si el <code>value</code> está vacío ( <code>&quot;&quot;</code> ), elimine la propiedad de <code>prop</code> determinada del álbum.
+<strong>Consejos</strong> <br> Utilice la <code>bracket notation</code> cuando <a href="javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables" target="_blank">acceda a las propiedades de objetos con variables</a> .
+Push es un método de matriz que puede leer sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push" target="_blank">Mozilla Developer Network</a> .
+Puede volver a consultar <a href="javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects" target="_blank">Manipular objetos complejos</a> Presentando la notación de objetos de JavaScript (JSON) para obtener una actualización.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,19 +30,19 @@ Puede volver a consultar <a href="javascript-algorithms-and-data-structures/basi
 
 ```yml
 tests:
-  - text: &#39;Después de <code>updateRecords(5439, &quot;artist&quot;, &quot;ABBA&quot;)</code> , el <code>artist</code> debe ser <code>&quot;ABBA&quot;</code> &#39;
+  - text: 'Después de <code>updateRecords(5439, &quot;artist&quot;, &quot;ABBA&quot;)</code> , el <code>artist</code> debe ser <code>&quot;ABBA&quot;</code> '
     testString: 'collection = collectionCopy; assert(updateRecords(5439, "artist", "ABBA")[5439]["artist"] === "ABBA", "After <code>updateRecords(5439, "artist", "ABBA")</code>, <code>artist</code> should be <code>"ABBA"</code>");'
-  - text: &#39;Después de <code>updateRecords(5439, &quot;tracks&quot;, &quot;Take a Chance on Me&quot;)</code> , los <code>tracks</code> deberían tener <code>&quot;Take a Chance on Me&quot;</code> como el último elemento.&#39;
+  - text: 'Después de <code>updateRecords(5439, &quot;tracks&quot;, &quot;Take a Chance on Me&quot;)</code> , los <code>tracks</code> deberían tener <code>&quot;Take a Chance on Me&quot;</code> como el último elemento.'
     testString: 'assert(updateRecords(5439, "tracks", "Take a Chance on Me")[5439]["tracks"].pop() === "Take a Chance on Me", "After <code>updateRecords(5439, "tracks", "Take a Chance on Me")</code>, <code>tracks</code> should have <code>"Take a Chance on Me"</code> as the last element.");'
-  - text: &#39;Después de <code>updateRecords(2548, &quot;artist&quot;, &quot;&quot;)</code> , el <code>artist</code> no debe configurarse&#39;
+  - text: 'Después de <code>updateRecords(2548, &quot;artist&quot;, &quot;&quot;)</code> , el <code>artist</code> no debe configurarse'
     testString: 'updateRecords(2548, "artist", ""); assert(!collection[2548].hasOwnProperty("artist"), "After <code>updateRecords(2548, "artist", "")</code>, <code>artist</code> should not be set");'
-  - text: &#39;Después de <code>updateRecords(1245, &quot;tracks&quot;, &quot;Addicted to Love&quot;)</code> , las <code>tracks</code> deberían tener <code>&quot;Addicted to Love&quot;</code> como último elemento.&#39;
+  - text: 'Después de <code>updateRecords(1245, &quot;tracks&quot;, &quot;Addicted to Love&quot;)</code> , las <code>tracks</code> deberían tener <code>&quot;Addicted to Love&quot;</code> como último elemento.'
     testString: 'assert(updateRecords(1245, "tracks", "Addicted to Love")[1245]["tracks"].pop() === "Addicted to Love", "After <code>updateRecords(1245, "tracks", "Addicted to Love")</code>, <code>tracks</code> should have <code>"Addicted to Love"</code> as the last element.");'
-  - text: &#39;Después de <code>updateRecords(2468, &quot;tracks&quot;, &quot;Free&quot;)</code> , los <code>tracks</code> deberían tener <code>&quot;1999&quot;</code> como primer elemento.&#39;
+  - text: 'Después de <code>updateRecords(2468, &quot;tracks&quot;, &quot;Free&quot;)</code> , los <code>tracks</code> deberían tener <code>&quot;1999&quot;</code> como primer elemento.'
     testString: 'assert(updateRecords(2468, "tracks", "Free")[2468]["tracks"][0] === "1999", "After <code>updateRecords(2468, "tracks", "Free")</code>, <code>tracks</code> should have <code>"1999"</code> as the first element.");'
-  - text: &#39;Después de <code>updateRecords(2548, &quot;tracks&quot;, &quot;&quot;)</code> , no se deben establecer <code>tracks</code> &#39;
+  - text: 'Después de <code>updateRecords(2548, &quot;tracks&quot;, &quot;&quot;)</code> , no se deben establecer <code>tracks</code> '
     testString: 'updateRecords(2548, "tracks", ""); assert(!collection[2548].hasOwnProperty("tracks"), "After <code>updateRecords(2548, "tracks", "")</code>, <code>tracks</code> should not be set");'
-  - text: &#39;Después de <code>updateRecords(1245, &quot;album&quot;, &quot;Riptide&quot;)</code> , el <code>album</code> debería ser <code>&quot;Riptide&quot;</code> &#39;
+  - text: 'Después de <code>updateRecords(1245, &quot;album&quot;, &quot;Riptide&quot;)</code> , el <code>album</code> debería ser <code>&quot;Riptide&quot;</code> '
     testString: 'assert(updateRecords(1245, "album", "Riptide")[1245]["album"] === "Riptide", "After <code>updateRecords(1245, "album", "Riptide")</code>, <code>album</code> should be <code>"Riptide"</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.spanish.md
index 715605816e..bf49c19038 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Si tiene muchas opciones para elegir, una instrucción <code>switch</code> puede ser más fácil de escribir que muchas instrucciones encadenadas <code>if</code> / <code>else if</code> . Lo siguiente: 
-<blockquote>if (val === 1) {<br>&nbsp;&nbsp;answer = "a";<br>} else if (val === 2) {<br>&nbsp;&nbsp;answer = "b";<br>} else {<br>&nbsp;&nbsp;answer = "c";<br>}</blockquote> 
-puede ser reemplazado por: 
-<blockquote>switch(val) {<br>&nbsp;&nbsp;case 1:<br>&nbsp;&nbsp;&nbsp;&nbsp;answer = "a";<br>&nbsp;&nbsp;&nbsp;&nbsp;break;<br>&nbsp;&nbsp;case 2:<br>&nbsp;&nbsp;&nbsp;&nbsp;answer = "b";<br>&nbsp;&nbsp;&nbsp;&nbsp;break;<br>&nbsp;&nbsp;default:<br>&nbsp;&nbsp;&nbsp;&nbsp;answer = "c";<br>}</blockquote> 
+<section id='description'>
+Si tiene muchas opciones para elegir, una instrucción <code>switch</code> puede ser más fácil de escribir que muchas instrucciones encadenadas <code>if</code> / <code>else if</code> . Lo siguiente:
+<blockquote>if (val === 1) {<br>&nbsp;&nbsp;answer = "a";<br>} else if (val === 2) {<br>&nbsp;&nbsp;answer = "b";<br>} else {<br>&nbsp;&nbsp;answer = "c";<br>}</blockquote>
+puede ser reemplazado por:
+<blockquote>switch(val) {<br>&nbsp;&nbsp;case 1:<br>&nbsp;&nbsp;&nbsp;&nbsp;answer = "a";<br>&nbsp;&nbsp;&nbsp;&nbsp;break;<br>&nbsp;&nbsp;case 2:<br>&nbsp;&nbsp;&nbsp;&nbsp;answer = "b";<br>&nbsp;&nbsp;&nbsp;&nbsp;break;<br>&nbsp;&nbsp;default:<br>&nbsp;&nbsp;&nbsp;&nbsp;answer = "c";<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambie las sentencias <code>if</code> / <code>else if</code> encadenadas en una sentencia <code>switch</code> . 
+<section id='instructions'>
+Cambie las sentencias <code>if</code> / <code>else if</code> encadenadas en una sentencia <code>switch</code> .
 </section>
 
 ## Tests
@@ -33,7 +33,7 @@ tests:
     testString: 'assert(chainToSwitch("bob") === "Marley", "<code>chainToSwitch("bob")</code> should be "Marley"");'
   - text: <code>chainToSwitch(42)</code> debe ser &quot;La Respuesta&quot;
     testString: 'assert(chainToSwitch(42) === "The Answer", "<code>chainToSwitch(42)</code> should be "The Answer"");'
-  - text: &#39; <code>chainToSwitch(1)</code> debe ser &quot;No hay # 1&quot;&#39;
+  - text: ' <code>chainToSwitch(1)</code> debe ser &quot;No hay # 1&quot;'
     testString: 'assert(chainToSwitch(1) === "There is no #1", "<code>chainToSwitch(1)</code> should be "There is no #1"");'
   - text: <code>chainToSwitch(99)</code> debería ser &quot;¡Me <code>chainToSwitch(99)</code> por esto!&quot;
     testString: 'assert(chainToSwitch(99) === "Missed me by this much!", "<code>chainToSwitch(99)</code> should be "Missed me by this much!"");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.spanish.md
index beb2b0ead4..5d22a06952 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Cuando se alcanza una declaración de <code>return</code> , la ejecución de la función actual se detiene y el control vuelve a la ubicación de la llamada. 
-<strong>Ejemplo</strong> 
-<blockquote>function myFun() {<br>&nbsp;&nbsp;console.log("Hello");<br>&nbsp;&nbsp;return "World";<br>&nbsp;&nbsp;console.log("byebye")<br>}<br>myFun();</blockquote> 
-Lo anterior muestra &quot;Hola&quot; a la consola, devuelve &quot;Mundo&quot;, pero <code>&quot;byebye&quot;</code> nunca se <code>&quot;byebye&quot;</code> , porque la función sale de la instrucción de <code>return</code> . 
+<section id='description'>
+Cuando se alcanza una declaración de <code>return</code> , la ejecución de la función actual se detiene y el control vuelve a la ubicación de la llamada.
+<strong>Ejemplo</strong>
+<blockquote>function myFun() {<br>&nbsp;&nbsp;console.log("Hello");<br>&nbsp;&nbsp;return "World";<br>&nbsp;&nbsp;console.log("byebye")<br>}<br>myFun();</blockquote>
+Lo anterior muestra &quot;Hola&quot; a la consola, devuelve &quot;Mundo&quot;, pero <code>&quot;byebye&quot;</code> nunca se <code>&quot;byebye&quot;</code> , porque la función sale de la instrucción de <code>return</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Modifique la función <code>abTest</code> para que si <code>a</code> o <code>b</code> sean menores que <code>0</code> la función saldrá inmediatamente con un valor <code>undefined</code> . 
-<strong>Pista</strong> <br> Recuerde que <a href='http://www.freecodecamp.org/challenges/understanding-uninitialized-variables' target='_blank'><code>undefined</code> es una palabra clave</a> , no una cadena. 
+<section id='instructions'>
+Modifique la función <code>abTest</code> para que si <code>a</code> o <code>b</code> sean menores que <code>0</code> la función saldrá inmediatamente con un valor <code>undefined</code> .
+<strong>Pista</strong> <br> Recuerde que <a href='http://www.freecodecamp.org/challenges/understanding-uninitialized-variables' target='_blank'><code>undefined</code> es una palabra clave</a> , no una cadena.
 </section>
 
 ## Tests
@@ -24,17 +24,17 @@ Modifique la función <code>abTest</code> para que si <code>a</code> o <code>b</
 
 ```yml
 tests:
-  - text: &#39; <code>abTest(2,2)</code> debe devolver un número&#39;
+  - text: ' <code>abTest(2,2)</code> debe devolver un número'
     testString: 'assert(typeof abTest(2,2) === "number" , "<code>abTest(2,2)</code> should return a number");'
-  - text: &#39; <code>abTest(2,2)</code> debe devolver <code>8</code> &#39;
+  - text: ' <code>abTest(2,2)</code> debe devolver <code>8</code> '
     testString: 'assert(abTest(2,2) === 8 , "<code>abTest(2,2)</code> should return <code>8</code>");'
-  - text: &#39; <code>abTest(-2,2)</code> debe devolver <code>undefined</code> &#39;
+  - text: ' <code>abTest(-2,2)</code> debe devolver <code>undefined</code> '
     testString: 'assert(abTest(-2,2) === undefined , "<code>abTest(-2,2)</code> should return <code>undefined</code>");'
-  - text: &#39; <code>abTest(2,-2)</code> debe devolver <code>undefined</code> &#39;
+  - text: ' <code>abTest(2,-2)</code> debe devolver <code>undefined</code> '
     testString: 'assert(abTest(2,-2) === undefined , "<code>abTest(2,-2)</code> should return <code>undefined</code>");'
-  - text: &#39; <code>abTest(2,8)</code> debe devolver <code>18</code> &#39;
+  - text: ' <code>abTest(2,8)</code> debe devolver <code>18</code> '
     testString: 'assert(abTest(2,8) === 18 , "<code>abTest(2,8)</code> should return <code>18</code>");'
-  - text: &#39; <code>abTest(3,3)</code> debe devolver <code>12</code> &#39;
+  - text: ' <code>abTest(3,3)</code> debe devolver <code>12</code> '
     testString: 'assert(abTest(3,3) === 12 , "<code>abTest(3,3)</code> should return <code>12</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.spanish.md
index e8ccde9b7e..6dc10f415f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Puede recordar de la <a href="waypoint-comparison-with-the-equality-operator" target="_blank">comparación con el operador de igualdad</a> que todos los operadores de comparación devuelven un valor booleano <code>true</code> o <code>false</code> . 
-Algunas veces las personas usan una sentencia if / else para hacer una comparación, como esta: 
-<blockquote>function isEqual(a,b) {<br>&nbsp;&nbsp;if (a === b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return true;<br>&nbsp;&nbsp;} else {<br>&nbsp;&nbsp;&nbsp;&nbsp;return false;<br>&nbsp;&nbsp;}<br>}</blockquote> 
-Pero hay una mejor manera de hacer esto. Como <code>===</code> devuelve <code>true</code> o <code>false</code> , podemos devolver el resultado de la comparación: 
-<blockquote>function isEqual(a,b) {<br>&nbsp;&nbsp;return a === b;<br>}</blockquote> 
+<section id='description'>
+Puede recordar de la <a href="waypoint-comparison-with-the-equality-operator" target="_blank">comparación con el operador de igualdad</a> que todos los operadores de comparación devuelven un valor booleano <code>true</code> o <code>false</code> .
+Algunas veces las personas usan una sentencia if / else para hacer una comparación, como esta:
+<blockquote>function isEqual(a,b) {<br>&nbsp;&nbsp;if (a === b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return true;<br>&nbsp;&nbsp;} else {<br>&nbsp;&nbsp;&nbsp;&nbsp;return false;<br>&nbsp;&nbsp;}<br>}</blockquote>
+Pero hay una mejor manera de hacer esto. Como <code>===</code> devuelve <code>true</code> o <code>false</code> , podemos devolver el resultado de la comparación:
+<blockquote>function isEqual(a,b) {<br>&nbsp;&nbsp;return a === b;<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Arreglar la función <code>isLess</code> permite eliminar las sentencias <code>if/else</code> . 
+<section id='instructions'>
+Arreglar la función <code>isLess</code> permite eliminar las sentencias <code>if/else</code> .
 </section>
 
 ## Tests
@@ -24,9 +24,9 @@ Arreglar la función <code>isLess</code> permite eliminar las sentencias <code>i
 
 ```yml
 tests:
-  - text: &#39; <code>isLess(10,15)</code> debe devolver <code>true</code> &#39;
+  - text: ' <code>isLess(10,15)</code> debe devolver <code>true</code> '
     testString: 'assert(isLess(10,15) === true, "<code>isLess(10,15)</code> should return <code>true</code>");'
-  - text: &#39; <code>isLess(15,10)</code> debe devolver <code>false</code> &#39;
+  - text: ' <code>isLess(15,10)</code> debe devolver <code>false</code> '
     testString: 'assert(isLess(15, 10) === false, "<code>isLess(15,10)</code> should return <code>false</code>");'
   - text: No debes usar ninguna declaración <code>if</code> o <code>else</code>
     testString: 'assert(!/if|else/g.test(code), "You should not use any <code>if</code> or <code>else</code> statements");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.spanish.md
index 9ec4118446..f70906990a 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En informática, una <dfn>cola</dfn> es una <dfn>estructura de datos</dfn> abstracta donde los elementos se mantienen en orden. Los nuevos elementos se pueden agregar al final de la <code>queue</code> y los elementos antiguos se quitan de la parte delantera de la <code>queue</code> . 
-Escriba una función <code>nextInLine</code> que tome una matriz ( <code>arr</code> ) y un número ( <code>item</code> ) como argumentos. 
-Agregue el número al final de la matriz, luego elimine el primer elemento de la matriz. 
-La función <code>nextInLine</code> debe devolver el elemento que se eliminó. 
+<section id='description'>
+En informática, una <dfn>cola</dfn> es una <dfn>estructura de datos</dfn> abstracta donde los elementos se mantienen en orden. Los nuevos elementos se pueden agregar al final de la <code>queue</code> y los elementos antiguos se quitan de la parte delantera de la <code>queue</code> .
+Escriba una función <code>nextInLine</code> que tome una matriz ( <code>arr</code> ) y un número ( <code>item</code> ) como argumentos.
+Agregue el número al final de la matriz, luego elimine el primer elemento de la matriz.
+La función <code>nextInLine</code> debe devolver el elemento que se eliminó.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,15 +23,15 @@ La función <code>nextInLine</code> debe devolver el elemento que se eliminó.
 
 ```yml
 tests:
-  - text: &#39; <code>nextInLine([], 5)</code> debe devolver un número&#39;.
+  - text: ' <code>nextInLine([], 5)</code> debe devolver un número'
     testString: 'assert.isNumber(nextInLine([],5), "<code>nextInLine([], 5)</code> should return a number.");'
-  - text: &#39; <code>nextInLine([], 1)</code> debe devolver <code>1</code> &#39;
+  - text: ' <code>nextInLine([], 1)</code> debe devolver <code>1</code> '
     testString: 'assert(nextInLine([],1) === 1, "<code>nextInLine([], 1)</code> should return <code>1</code>");'
-  - text: &#39; <code>nextInLine([2], 1)</code> debe devolver <code>2</code> &#39;
+  - text: ' <code>nextInLine([2], 1)</code> debe devolver <code>2</code> '
     testString: 'assert(nextInLine([2],1) === 2, "<code>nextInLine([2], 1)</code> should return <code>2</code>");'
-  - text: &#39; <code>nextInLine([5,6,7,8,9], 1)</code> debe devolver <code>5</code> &#39;
+  - text: ' <code>nextInLine([5,6,7,8,9], 1)</code> debe devolver <code>5</code> '
     testString: 'assert(nextInLine([5,6,7,8,9],1) === 5, "<code>nextInLine([5,6,7,8,9], 1)</code> should return <code>5</code>");'
-  - text: &#39;Después de <code>nextInLine(testArr, 10)</code> , <code>testArr[4]</code> debería ser <code>10</code> &#39;
+  - text: 'Después de <code>nextInLine(testArr, 10)</code> , <code>testArr[4]</code> debería ser <code>10</code> '
     testString: 'nextInLine(testArr, 10); assert(testArr[4] === 10, "After <code>nextInLine(testArr, 10)</code>, <code>testArr[4]</code> should be <code>10</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.spanish.md
index c4c294182b..6c398b9750 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Otro tipo de datos es el <dfn>booleano</dfn> . <code>Booleans</code> solo pueden ser uno de dos valores: <code>true</code> o <code>false</code> . Básicamente son pequeños interruptores de encendido y apagado, donde <code>true</code> está &quot;encendido&quot; y <code>false</code> está &quot;apagado&quot;. Estos dos estados son mutuamente excluyentes. 
-<strong>Nota</strong> <br> <code>Boolean</code> valores <code>Boolean</code> nunca se escriben entre comillas. Las <code>strings</code> <code>&quot;true&quot;</code> y <code>&quot;false&quot;</code> no son <code>Boolean</code> y no tienen un significado especial en JavaScript. 
+<section id='description'>
+Otro tipo de datos es el <dfn>booleano</dfn> . <code>Booleans</code> solo pueden ser uno de dos valores: <code>true</code> o <code>false</code> . Básicamente son pequeños interruptores de encendido y apagado, donde <code>true</code> está &quot;encendido&quot; y <code>false</code> está &quot;apagado&quot;. Estos dos estados son mutuamente excluyentes.
+<strong>Nota</strong> <br> <code>Boolean</code> valores <code>Boolean</code> nunca se escriben entre comillas. Las <code>strings</code> <code>&quot;true&quot;</code> y <code>&quot;false&quot;</code> no son <code>Boolean</code> y no tienen un significado especial en JavaScript.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Modifique la función <code>welcomeToBooleans</code> para que devuelva <code>true</code> lugar de <code>false</code> cuando se haga clic en el botón Ejecutar. 
+<section id='instructions'>
+Modifique la función <code>welcomeToBooleans</code> para que devuelva <code>true</code> lugar de <code>false</code> cuando se haga clic en el botón Ejecutar.
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Modifique la función <code>welcomeToBooleans</code> para que devuelva <code>tru
 
 ```yml
 tests:
-  - text: &#39;La función <code>welcomeToBooleans()</code> debería devolver un valor booleano (verdadero / falso).&#39;
+  - text: 'La función <code>welcomeToBooleans()</code> debería devolver un valor booleano (verdadero / falso).'
     testString: 'assert(typeof welcomeToBooleans() === "boolean", "The <code>welcomeToBooleans()</code> function should return a boolean &#40;true/false&#41; value.");'
   - text: <code>welcomeToBooleans()</code> debe devolver true.
     testString: 'assert(welcomeToBooleans() === true, "<code>welcomeToBooleans()</code> should return true.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.spanish.md
index 6c6eb2faa3..621242d334 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Una función puede incluir la declaración de <code>return</code> , pero no tiene que hacerlo. En el caso de que la función no tenga una declaración de <code>return</code> , cuando la llame, la función procesa el código interno pero el valor devuelto <code>undefined</code> está <code>undefined</code> . 
-<strong>Ejemplo</strong> 
-<blockquote>var sum = 0;<br>function addSum(num) {<br>&nbsp;&nbsp;sum = sum + num;<br>}<br>var returnedValue = addSum(3); // sum will be modified but returned value is undefined</blockquote> 
-<code>addSum</code> es una función sin una declaración de <code>return</code> . La función cambiará la variable de <code>sum</code> global, pero el valor devuelto de la función es <code>undefined</code> 
+<section id='description'>
+Una función puede incluir la declaración de <code>return</code> , pero no tiene que hacerlo. En el caso de que la función no tenga una declaración de <code>return</code> , cuando la llame, la función procesa el código interno pero el valor devuelto <code>undefined</code> está <code>undefined</code> .
+<strong>Ejemplo</strong>
+<blockquote>var sum = 0;<br>function addSum(num) {<br>&nbsp;&nbsp;sum = sum + num;<br>}<br>var returnedValue = addSum(3); // sum will be modified but returned value is undefined</blockquote>
+<code>addSum</code> es una función sin una declaración de <code>return</code> . La función cambiará la variable de <code>sum</code> global, pero el valor devuelto de la función es <code>undefined</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Crear una función <code>addFive</code> sin ningún argumento. Esta función agrega 5 a la variable de <code>sum</code> , pero su valor devuelto <code>undefined</code> está <code>undefined</code> . 
+<section id='instructions'>
+Crear una función <code>addFive</code> sin ningún argumento. Esta función agrega 5 a la variable de <code>sum</code> , pero su valor devuelto <code>undefined</code> está <code>undefined</code> .
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ tests:
     testString: 'assert(sum === 8, "<code>sum</code> should be equal to 8");'
   - text: El valor devuelto de <code>addFive</code> debe estar <code>undefined</code>
     testString: 'assert(addFive() === undefined, "Returned value from <code>addFive</code> should be <code>undefined</code>");'
-  - text: &#39;Dentro de tus funciones, suma 5 a la variable de <code>sum</code> &#39;
+  - text: 'Dentro de tus funciones, suma 5 a la variable de <code>sum</code> '
     testString: 'assert(code.match(/(sum\s*\=\s*sum\s*\+\s*5)|(sum\s*\+\=\s*5)/g).length === 1, "Inside of your functions, add 5 to the <code>sum</code> variable");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.spanish.md
index 296fdd3ecc..f9b80fb17c 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<code>If</code> se usan sentencias para tomar decisiones en código. La palabra clave <code>if</code> le dice a JavaScript que ejecute el código entre llaves en ciertas condiciones, definidas entre paréntesis. Estas condiciones se conocen como condiciones <code>Boolean</code> y solo pueden ser <code>true</code> o <code>false</code> . 
-Cuando la condición se evalúa como <code>true</code> , el programa ejecuta la instrucción dentro de las llaves. Cuando la condición booleana se evalúa como <code>false</code> , la instrucción dentro de las llaves no se ejecutará. 
-<strong>pseudocódigo</strong> 
-<blockquote>if ( <i>condition is true</i> ) {<br>&nbsp;&nbsp; <i>statement is executed</i> <br>}</blockquote> 
-<strong>Ejemplo</strong> 
-<blockquote>function test (myCondition) {<br>&nbsp;&nbsp;if (myCondition) {<br>&nbsp;&nbsp;&nbsp;&nbsp; return "It was true";<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;return "It was false";<br>}<br>test(true);  // returns "It was true"<br>test(false); // returns "It was false"</blockquote> 
-Cuando se llama a la <code>test</code> con un valor <code>true</code> , la sentencia <code>if</code> evalúa <code>myCondition</code> para ver si es <code>true</code> o no. Dado que es <code>true</code> , la función devuelve <code>&quot;It was true&quot;</code> . Cuando llamamos a <code>test</code> con un valor de <code>false</code> , <code>myCondition</code> <em>no</em> es <code>true</code> y la instrucción entre llaves no se ejecuta y la función devuelve <code>&quot;It was false&quot;</code> . 
+<section id='description'>
+<code>If</code> se usan sentencias para tomar decisiones en código. La palabra clave <code>if</code> le dice a JavaScript que ejecute el código entre llaves en ciertas condiciones, definidas entre paréntesis. Estas condiciones se conocen como condiciones <code>Boolean</code> y solo pueden ser <code>true</code> o <code>false</code> .
+Cuando la condición se evalúa como <code>true</code> , el programa ejecuta la instrucción dentro de las llaves. Cuando la condición booleana se evalúa como <code>false</code> , la instrucción dentro de las llaves no se ejecutará.
+<strong>pseudocódigo</strong>
+<blockquote>if ( <i>condition is true</i> ) {<br>&nbsp;&nbsp; <i>statement is executed</i> <br>}</blockquote>
+<strong>Ejemplo</strong>
+<blockquote>function test (myCondition) {<br>&nbsp;&nbsp;if (myCondition) {<br>&nbsp;&nbsp;&nbsp;&nbsp; return "It was true";<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;return "It was false";<br>}<br>test(true);  // returns "It was true"<br>test(false); // returns "It was false"</blockquote>
+Cuando se llama a la <code>test</code> con un valor <code>true</code> , la sentencia <code>if</code> evalúa <code>myCondition</code> para ver si es <code>true</code> o no. Dado que es <code>true</code> , la función devuelve <code>&quot;It was true&quot;</code> . Cuando llamamos a <code>test</code> con un valor de <code>false</code> , <code>myCondition</code> <em>no</em> es <code>true</code> y la instrucción entre llaves no se ejecuta y la función devuelve <code>&quot;It was false&quot;</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cree una instrucción <code>if</code> dentro de la función para devolver <code>&quot;Yes, that was true&quot;</code> si el parámetro <code>wasThatTrue</code> es <code>true</code> y devuelva <code>&quot;No, that was false&quot;</code> contrario. 
+<section id='instructions'>
+Cree una instrucción <code>if</code> dentro de la función para devolver <code>&quot;Yes, that was true&quot;</code> si el parámetro <code>wasThatTrue</code> es <code>true</code> y devuelva <code>&quot;No, that was false&quot;</code> contrario.
 </section>
 
 ## Tests
@@ -32,9 +32,9 @@ tests:
     testString: 'assert(typeof trueOrFalse(true) === "string", "<code>trueOrFalse(true)</code> should return a string");'
   - text: <code>trueOrFalse(false)</code> debe devolver una cadena
     testString: 'assert(typeof trueOrFalse(false) === "string", "<code>trueOrFalse(false)</code> should return a string");'
-  - text: &#39; <code>trueOrFalse(true)</code> debe devolver &quot;Sí, eso fue cierto&quot;&#39;
+  - text: ' <code>trueOrFalse(true)</code> debe devolver &quot;Sí, eso fue cierto&quot;'
     testString: 'assert(trueOrFalse(true) === "Yes, that was true", "<code>trueOrFalse(true)</code> should return "Yes, that was true"");'
-  - text: &#39; <code>trueOrFalse(false)</code> debe devolver &quot;No, eso fue falso&quot;&#39;
+  - text: ' <code>trueOrFalse(false)</code> debe devolver &quot;No, eso fue falso&quot;'
     testString: 'assert(trueOrFalse(false) === "No, that was false", "<code>trueOrFalse(false)</code> should return "No, that was false"");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.spanish.md
index bdc91a1cb9..8da91bf515 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El <dfn>operador condicional</dfn> , también llamado <dfn>operador ternario</dfn> , se puede usar como una expresión de una línea si-else. 
-La sintaxis es: 
-<code>condition ? statement-if-true : statement-if-false;</code> 
-La siguiente función utiliza una instrucción if-else para verificar una condición: 
-<blockquote>function findGreater(a, b) {<br>&nbsp;&nbsp;if(a > b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return "a is greater";<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;else {<br>&nbsp;&nbsp;&nbsp;&nbsp;return "b is greater";<br>&nbsp;&nbsp;}<br>}</blockquote> 
-Esto se puede reescribir usando el <code>conditional operator</code> : 
-<blockquote>function findGreater(a, b) {<br>&nbsp;&nbsp;return a > b ? "a is greater" : "b is greater";<br>}</blockquote> 
+<section id='description'>
+El <dfn>operador condicional</dfn> , también llamado <dfn>operador ternario</dfn> , se puede usar como una expresión de una línea si-else.
+La sintaxis es:
+<code>condition ? statement-if-true : statement-if-false;</code>
+La siguiente función utiliza una instrucción if-else para verificar una condición:
+<blockquote>function findGreater(a, b) {<br>&nbsp;&nbsp;if(a > b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return "a is greater";<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;else {<br>&nbsp;&nbsp;&nbsp;&nbsp;return "b is greater";<br>&nbsp;&nbsp;}<br>}</blockquote>
+Esto se puede reescribir usando el <code>conditional operator</code> :
+<blockquote>function findGreater(a, b) {<br>&nbsp;&nbsp;return a > b ? "a is greater" : "b is greater";<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use el <code>conditional operator</code> en la función <code>checkEqual</code> para verificar si dos números son iguales o no. La función debe devolver verdadero o falso. 
+<section id='instructions'>
+Use el <code>conditional operator</code> en la función <code>checkEqual</code> para verificar si dos números son iguales o no. La función debe devolver verdadero o falso.
 </section>
 
 ## Tests
@@ -28,11 +28,11 @@ Use el <code>conditional operator</code> en la función <code>checkEqual</code>
 tests:
   - text: <code>checkEqual</code> debe usar el <code>conditional operator</code>
     testString: 'assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code), "<code>checkEqual</code> should use the <code>conditional operator</code>");'
-  - text: &#39; <code>checkEqual(1, 2)</code> debe devolver falso&#39;
+  - text: ' <code>checkEqual(1, 2)</code> debe devolver falso'
     testString: 'assert(checkEqual(1, 2) === false, "<code>checkEqual(1, 2)</code> should return false");'
-  - text: &#39; <code>checkEqual(1, 1)</code> debe devolver verdadero&#39;
+  - text: ' <code>checkEqual(1, 1)</code> debe devolver verdadero'
     testString: 'assert(checkEqual(1, 1) === true, "<code>checkEqual(1, 1)</code> should return true");'
-  - text: &#39; <code>checkEqual(1, -1)</code> debe devolver falso&#39;
+  - text: ' <code>checkEqual(1, -1)</code> debe devolver falso'
     testString: 'assert(checkEqual(1, -1) === false, "<code>checkEqual(1, -1)</code> should return false");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.spanish.md
index a7f4462824..d698beba04 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-objetos pueden considerarse como un almacenamiento de clave / valor, como un diccionario. Si tiene datos tabulares, puede usar un objeto para &quot;buscar&quot; valores en lugar de una instrucción <code>switch</code> o una cadena <code>if/else</code> . Esto es más útil cuando sabe que sus datos de entrada están limitados a un cierto rango. 
-Aquí hay un ejemplo de una búsqueda de alfabeto inversa simple: 
-<blockquote>var alpha = {<br>&nbsp;&nbsp;1:"Z",<br>&nbsp;&nbsp;2:"Y",<br>&nbsp;&nbsp;3:"X",<br>&nbsp;&nbsp;4:"W",<br>&nbsp;&nbsp;...<br>&nbsp;&nbsp;24:"C",<br>&nbsp;&nbsp;25:"B",<br>&nbsp;&nbsp;26:"A"<br>};<br>alpha[2]; // "Y"<br>alpha[24]; // "C"<br><br>var value = 2;<br>alpha[value]; // "Y"</blockquote> 
+<section id='description'>
+objetos pueden considerarse como un almacenamiento de clave / valor, como un diccionario. Si tiene datos tabulares, puede usar un objeto para &quot;buscar&quot; valores en lugar de una instrucción <code>switch</code> o una cadena <code>if/else</code> . Esto es más útil cuando sabe que sus datos de entrada están limitados a un cierto rango.
+Aquí hay un ejemplo de una búsqueda de alfabeto inversa simple:
+<blockquote>var alpha = {<br>&nbsp;&nbsp;1:"Z",<br>&nbsp;&nbsp;2:"Y",<br>&nbsp;&nbsp;3:"X",<br>&nbsp;&nbsp;4:"W",<br>&nbsp;&nbsp;...<br>&nbsp;&nbsp;24:"C",<br>&nbsp;&nbsp;25:"B",<br>&nbsp;&nbsp;26:"A"<br>};<br>alpha[2]; // "Y"<br>alpha[24]; // "C"<br><br>var value = 2;<br>alpha[value]; // "Y"</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Convertir la instrucción switch en un objeto llamado <code>lookup</code> . Úselo para buscar <code>val</code> y asignar la cadena asociada a la variable de <code>result</code> . 
+<section id='instructions'>
+Convertir la instrucción switch en un objeto llamado <code>lookup</code> . Úselo para buscar <code>val</code> y asignar la cadena asociada a la variable de <code>result</code> .
 </section>
 
 ## Tests
@@ -38,7 +38,7 @@ tests:
     testString: 'assert(typeof phoneticLookup("") === "undefined", "<code>phoneticLookup("")</code> should equal <code>undefined</code>");'
   - text: No debes modificar la declaración de <code>return</code> .
     testString: 'assert(code.match(/return\sresult;/), "You should not modify the <code>return</code> statement");'
-  - text: &#39;No debe usar <code>case</code> , <code>switch</code> , o <code>if</code> declaraciones&#39;
+  - text: 'No debe usar <code>case</code> , <code>switch</code> , o <code>if</code> declaraciones'
     testString: 'assert(!/case|switch|if/g.test(code.replace(/([/]{2}.*)|([/][*][^/*]*[*][/])/g,"")), "You should not use <code>case</code>, <code>switch</code>, or <code>if</code> statements"); '
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.spanish.md
index a8695fd955..d363da3faf 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora usaremos nuestro conocimiento de cuerdas para construir un juego de palabras al estilo de &quot; <a href='https://en.wikipedia.org/wiki/Mad_Libs' target='_blank'>Mad Libs</a> &quot; que llamamos &quot;Word Blanks&quot;. Creará una oración estilo &quot;Rellene los espacios en blanco&quot; (opcionalmente humorística). 
-En un juego de &quot;Mad Libs&quot;, se te proporcionan frases con algunas palabras faltantes, como sustantivos, verbos, adjetivos y adverbios. Luego, completa las piezas faltantes con las palabras que elijas de manera que la oración completa tenga sentido. 
-Considere esta oración: &quot;Fue realmente <strong>____</strong> , y nosotros <strong>____</strong> nosotros <strong>____</strong> &quot;. Esta oración tiene tres partes faltantes: un adjetivo, un verbo y un adverbio, y podemos agregar palabras de nuestra elección para completarla. Luego podemos asignar la oración completa a una variable de la siguiente manera: 
-<blockquote>var sentence = "It was really" + "hot" + ", and we" + "laughed" + "ourselves" + "silly.";</blockquote> 
+<section id='description'>
+Ahora usaremos nuestro conocimiento de cuerdas para construir un juego de palabras al estilo de &quot; <a href='https://en.wikipedia.org/wiki/Mad_Libs' target='_blank'>Mad Libs</a> &quot; que llamamos &quot;Word Blanks&quot;. Creará una oración estilo &quot;Rellene los espacios en blanco&quot; (opcionalmente humorística).
+En un juego de &quot;Mad Libs&quot;, se te proporcionan frases con algunas palabras faltantes, como sustantivos, verbos, adjetivos y adverbios. Luego, completa las piezas faltantes con las palabras que elijas de manera que la oración completa tenga sentido.
+Considere esta oración: &quot;Fue realmente <strong>____</strong> , y nosotros <strong>____</strong> nosotros <strong>____</strong> &quot;. Esta oración tiene tres partes faltantes: un adjetivo, un verbo y un adverbio, y podemos agregar palabras de nuestra elección para completarla. Luego podemos asignar la oración completa a una variable de la siguiente manera:
+<blockquote>var sentence = "It was really" + "hot" + ", and we" + "laughed" + "ourselves" + "silly.";</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-En este desafío, le proporcionamos un sustantivo, un verbo, un adjetivo y un adverbio. Debe formar una oración completa con las palabras de su elección, junto con las palabras que proporcionamos. 
-Necesitará utilizar el operador de concatenación de cadenas <code>+</code> para crear una nueva cadena, utilizando las variables proporcionadas: <code>myNoun</code> , <code>myAdjective</code> , <code>myVerb</code> y <code>myAdverb</code> . A continuación, asignará la cadena formada a la variable de <code>result</code> . 
-También deberá tener en cuenta los espacios en su cadena, de modo que la oración final tenga espacios entre todas las palabras. El resultado debe ser una oración completa. 
+<section id='instructions'>
+En este desafío, le proporcionamos un sustantivo, un verbo, un adjetivo y un adverbio. Debe formar una oración completa con las palabras de su elección, junto con las palabras que proporcionamos.
+Necesitará utilizar el operador de concatenación de cadenas <code>+</code> para crear una nueva cadena, utilizando las variables proporcionadas: <code>myNoun</code> , <code>myAdjective</code> , <code>myVerb</code> y <code>myAdverb</code> . A continuación, asignará la cadena formada a la variable de <code>result</code> .
+También deberá tener en cuenta los espacios en su cadena, de modo que la oración final tenga espacios entre todas las palabras. El resultado debe ser una oración completa.
 </section>
 
 ## Tests
@@ -25,11 +25,11 @@ También deberá tener en cuenta los espacios en su cadena, de modo que la oraci
 
 ```yml
 tests:
-  - text: &#39; <code>wordBlanks(&quot;&quot;,&quot;&quot;,&quot;&quot;,&quot;&quot;)</code> debe devolver una cadena.&#39;
+  - text: '<code>wordBlanks(&quot;&quot;,&quot;&quot;,&quot;&quot;,&quot;&quot;)</code> debe devolver una cadena.'
     testString: 'assert(typeof wordBlanks("","","","") === "string", "<code>wordBlanks("","","","")</code> should return a string.");'
-  - text: &#39; <code>wordBlanks(&quot;dog&quot;, &quot;big&quot;, &quot;ran&quot;, &quot;quickly&quot;)</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier palabra adicional en su libreta).
+  - text: '<code>wordBlanks(&quot;dog&quot;, &quot;big&quot;, &quot;ran&quot;, &quot;quickly&quot;)</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier palabra adicional en su libreta).'
     testString: 'assert(/\bdog\b/.test(test1) && /\bbig\b/.test(test1) && /\bran\b/.test(test1) && /\bquickly\b/.test(test1),"<code>wordBlanks("dog", "big", "ran", "quickly")</code> should contain all of the passed in words separated by non-word characters (and any additional words in your madlib).");'
-  - text: &#39; <code>wordBlanks(&quot;cat&quot;, &quot;little&quot;, &quot;hit&quot;, &quot;slowly&quot;)</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier otra palabra adicional en su madlib).
+  - text: ' <code>wordBlanks(&quot;cat&quot;, &quot;little&quot;, &quot;hit&quot;, &quot;slowly&quot;)</code> debe contener todas las palabras pasadas separadas por caracteres que no sean de palabras (y cualquier otra palabra adicional en su madlib).'
     testString: 'assert(/\bcat\b/.test(test2) && /\blittle\b/.test(test2) && /\bhit\b/.test(test2) && /\bslowly\b/.test(test2),"<code>wordBlanks("cat", "little", "hit", "slowly")</code> should contain all of the passed in words separated by non-word characters (and any additional words in your madlib).");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.spanish.md
index 61b4448ccf..ac0121cdd2 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.spanish.md
@@ -6,13 +6,13 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Continuando con la discusión sobre las funciones de llamada, el siguiente error a tener en cuenta es cuando los argumentos de una función se suministran en el orden incorrecto. Si los argumentos son de tipos diferentes, como una función que espera una matriz y un entero, es probable que se produzca un error de tiempo de ejecución. Si los argumentos son del mismo tipo (todos los enteros, por ejemplo), entonces la lógica del código no tendrá sentido. Asegúrese de proporcionar todos los argumentos necesarios, en el orden correcto para evitar estos problemas. 
+<section id='description'>
+Continuando con la discusión sobre las funciones de llamada, el siguiente error a tener en cuenta es cuando los argumentos de una función se suministran en el orden incorrecto. Si los argumentos son de tipos diferentes, como una función que espera una matriz y un entero, es probable que se produzca un error de tiempo de ejecución. Si los argumentos son del mismo tipo (todos los enteros, por ejemplo), entonces la lógica del código no tendrá sentido. Asegúrese de proporcionar todos los argumentos necesarios, en el orden correcto para evitar estos problemas.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-La función <code>raiseToPower</code> eleva una base a un exponente. Desafortunadamente, no se llama correctamente: repare el código para que el valor de la <code>power</code> sea ​​el esperado 8. 
+<section id='instructions'>
+La función <code>raiseToPower</code> eleva una base a un exponente. Desafortunadamente, no se llama correctamente: repare el código para que el valor de la <code>power</code> sea ​​el esperado 8.
 </section>
 
 ## Tests
@@ -20,7 +20,7 @@ La función <code>raiseToPower</code> eleva una base a un exponente. Desafortuna
 
 ```yml
 tests:
-  - text: &#39;Su código debería fijar la <code>power</code> variable de modo que sea igual a 2 elevado a la tercera potencia, no 3 elevado a la segunda potencia&#39;.
+  - text: 'Su código debería fijar la <code>power</code> variable de modo que sea igual a 2 elevado a la tercera potencia, no 3 elevado a la segunda potencia'
     testString: 'assert(power == 8, "Your code should fix the variable <code>power</code> so it equals 2 raised to the 3rd power, not 3 raised to the 2nd power.");'
   - text: Su código debe usar el orden correcto de los argumentos para la <code>raiseToPower</code> función <code>raiseToPower</code> .
     testString: 'assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g), "Your code should use the correct order of the arguments for the <code>raiseToPower</code> function call.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.spanish.md
index c684577d5d..315c16efb8 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<code>console.log()</code> y los métodos de <code>typeof</code> son las dos formas principales de verificar los valores intermedios y los tipos de salida del programa. Ahora es el momento de entrar en las formas comunes que toman los errores. Un problema de nivel de sintaxis con el que los usuarios rápidos pueden compadecerse es el humilde error de ortografía. 
-transpuestos, faltantes o mal colocados en una variable o nombre de función harán que el navegador busque un objeto que no existe, y se quejen en forma de un error de referencia. Las variables de JavaScript y los nombres de funciones distinguen entre mayúsculas y minúsculas. 
+<section id='description'>
+<code>console.log()</code> y los métodos de <code>typeof</code> son las dos formas principales de verificar los valores intermedios y los tipos de salida del programa. Ahora es el momento de entrar en las formas comunes que toman los errores. Un problema de nivel de sintaxis con el que los usuarios rápidos pueden compadecerse es el humilde error de ortografía.
+transpuestos, faltantes o mal colocados en una variable o nombre de función harán que el navegador busque un objeto que no existe, y se quejen en forma de un error de referencia. Las variables de JavaScript y los nombres de funciones distinguen entre mayúsculas y minúsculas.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Corrija los dos errores de ortografía en el código para que <code>netWorkingCapital</code> cálculo de <code>netWorkingCapital</code> . 
+<section id='instructions'>
+Corrija los dos errores de ortografía en el código para que <code>netWorkingCapital</code> cálculo de <code>netWorkingCapital</code> .
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Corrija los dos errores de ortografía en el código para que <code>netWorkingCa
 
 ```yml
 tests:
-  - text: 'Verifique la ortografía de las dos variables utilizadas en el cálculo de netWorkingCapital, la salida de la consola debe mostrar que "El capital de trabajo neto es: 2".
+  - text: 'Verifique la ortografía de las dos variables utilizadas en el cálculo de netWorkingCapital, la salida de la consola debe mostrar que "El capital de trabajo neto es: 2."
     testString: 'assert(netWorkingCapital === 2, "Check the spelling of the two variables used in the netWorkingCapital calculation, the console output should show that "Net working capital is: 2".");'
   - text: No debe haber instancias de variables mal escritas en el código.
     testString: 'assert(!code.match(/recievables/g), "There should be no instances of mis-spelled variables in the code.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.spanish.md
index 8325a91bce..5a3738985b 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-JavaScript permite el uso de comillas simples (&quot;) y dobles (&quot; &quot;) para declarar una cadena. Decidir cuál usar generalmente se reduce a preferencias personales, con algunas excepciones. 
-Tener dos opciones es excelente cuando una cadena tiene contracciones u otro fragmento de texto entre comillas. Solo tenga cuidado de no cerrar la cadena demasiado pronto, lo que provoca un error de sintaxis. 
-Aquí hay algunos ejemplos de comillas de mezcla: 
-<blockquote>// These are correct:<br>const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";<br>const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";<br>// This is incorrect:<br>const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';</blockquote> 
-Por supuesto, está bien usar solo un estilo de citas. Puede escapar de las comillas dentro de la cadena usando el carácter de escape de barra invertida (\): 
-<blockquote>// Correct use of same quotes:<br>const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';</blockquote> 
+<section id='description'>
+JavaScript permite el uso de comillas simples (&quot;) y dobles (&quot; &quot;) para declarar una cadena. Decidir cuál usar generalmente se reduce a preferencias personales, con algunas excepciones.
+Tener dos opciones es excelente cuando una cadena tiene contracciones u otro fragmento de texto entre comillas. Solo tenga cuidado de no cerrar la cadena demasiado pronto, lo que provoca un error de sintaxis.
+Aquí hay algunos ejemplos de comillas de mezcla:
+<blockquote>// These are correct:<br>const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";<br>const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";<br>// This is incorrect:<br>const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';</blockquote>
+Por supuesto, está bien usar solo un estilo de citas. Puede escapar de las comillas dentro de la cadena usando el carácter de escape de barra invertida (\):
+<blockquote>// Correct use of same quotes:<br>const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Arregle la cadena para que use comillas diferentes para el valor <code>href</code> , o escape de las existentes. Mantenga las comillas dobles alrededor de toda la cadena. 
+<section id='instructions'>
+Arregle la cadena para que use comillas diferentes para el valor <code>href</code> , o escape de las existentes. Mantenga las comillas dobles alrededor de toda la cadena.
 </section>
 
 ## Tests
@@ -25,7 +25,7 @@ Arregle la cadena para que use comillas diferentes para el valor <code>href</cod
 
 ```yml
 tests:
-  - text: &#39;Tu código debe corregir las comillas alrededor del valor <code>href</code> &quot;#Home&quot;, ya sea cambiándolos o escapándolos.&#39;
+  - text: 'Tu código debe corregir las comillas alrededor del valor <code>href</code> &quot;#Home&quot;, ya sea cambiándolos o escapándolos.'
     testString: 'assert(code.match(/<a href=\s*?("|\\")#Home\1\s*?>/g), "Your code should fix the quotes around the <code>href</code> value "#Home" by either changing or escaping them.");'
   - text: Su código debe mantener las comillas dobles alrededor de toda la cadena.
     testString: 'assert(code.match(/"<p>.*?<\/p>";/g), "Your code should keep the double quotes around the entire string.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.spanish.md
index d354515544..a196e62443 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Otro error de sintaxis a tener en cuenta es que todos los paréntesis de apertura, paréntesis, llaves y comillas tienen un par de cierre. El olvido de una pieza suele suceder cuando edita el código existente e inserta elementos con uno de los tipos de pares. Además, tenga cuidado al anidar bloques de código en otros, como agregar una función de devolución de llamada como un argumento a un método. 
-Una forma de evitar este error es tan pronto como se escribe el carácter de apertura, incluya inmediatamente la coincidencia de cierre, luego mueva el cursor entre ellos y continúe la codificación. Afortunadamente, la mayoría de los editores de código modernos generan la segunda mitad del par automáticamente. 
+<section id='description'>
+Otro error de sintaxis a tener en cuenta es que todos los paréntesis de apertura, paréntesis, llaves y comillas tienen un par de cierre. El olvido de una pieza suele suceder cuando edita el código existente e inserta elementos con uno de los tipos de pares. Además, tenga cuidado al anidar bloques de código en otros, como agregar una función de devolución de llamada como un argumento a un método.
+Una forma de evitar este error es tan pronto como se escribe el carácter de apertura, incluya inmediatamente la coincidencia de cierre, luego mueva el cursor entre ellos y continúe la codificación. Afortunadamente, la mayoría de los editores de código modernos generan la segunda mitad del par automáticamente.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Arreglar los errores de dos pares en el código. 
+<section id='instructions'>
+Arreglar los errores de dos pares en el código.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Arreglar los errores de dos pares en el código.
 tests:
   - text: Tu código debería arreglar la pieza faltante de la matriz.
     testString: 'assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g), "Your code should fix the missing piece of the array.");'
-  - text: 'Su código debe arreglar la pieza faltante del método <code clase = "notranslate">. Reduce () </code>. La salida de la consola debería mostrar que "la suma de los valores de la matriz es: 6".
+  - text: 'Su código debe arreglar la pieza faltante del método <code clase = "notranslate">. Reduce () </code>. La salida de la consola debería mostrar que "la suma de los valores de la matriz es: 6."
     testString: 'assert(arraySum === 6, "Your code should fix the missing piece of the <code>.reduce()</code> method. The console output should show that "Sum of array values is: 6".");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.spanish.md
index 03514d680c..3e8704db17 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Los programas de derivación, es decir, los que hacen cosas diferentes si se cumplen ciertas condiciones, dependen de las declaraciones <code>if</code> , <code>else if</code> , y <code>else</code> en JavaScript. La condición a veces toma la forma de probar si un resultado es igual a un valor. 
-Esta lógica se habla (en inglés, al menos) como &quot;si x es igual a y, entonces ...&quot; que puede traducirse literalmente en código usando el operador <code>=</code> , o asignación. Esto conduce a un flujo de control inesperado en su programa. 
-Como se cubrió en desafíos anteriores, el operador de asignación ( <code>=</code> ) en JavaScript asigna un valor a un nombre de variable. Y los operadores <code>==</code> y <code>===</code> verifican la igualdad (las pruebas triples <code>===</code> para la igualdad estricta, lo que significa que tanto el valor como el tipo son iguales). 
-El siguiente código asigna <code>x</code> para ser 2, que se evalúa como <code>true</code> . Casi todos los valores en JavaScript se evalúan como <code>true</code> , excepto lo que se conoce como valores &quot;falsos&quot;: <code>false</code> , <code>0</code> , <code>&quot;&quot;</code> (una cadena vacía), <code>NaN</code> , <code>undefined</code> y <code>null</code> . 
-<blockquote>let x = 1;<br>let y = 2;<br>if (x = y) {<br>&nbsp;&nbsp;// this code block will run for any value of y (unless y were originally set as a falsy)<br>} else {<br>&nbsp;&nbsp;// this code block is what should run (but won't) in this example<br>}</blockquote> 
+<section id='description'>
+Los programas de derivación, es decir, los que hacen cosas diferentes si se cumplen ciertas condiciones, dependen de las declaraciones <code>if</code> , <code>else if</code> , y <code>else</code> en JavaScript. La condición a veces toma la forma de probar si un resultado es igual a un valor.
+Esta lógica se habla (en inglés, al menos) como &quot;si x es igual a y, entonces ...&quot; que puede traducirse literalmente en código usando el operador <code>=</code> , o asignación. Esto conduce a un flujo de control inesperado en su programa.
+Como se cubrió en desafíos anteriores, el operador de asignación ( <code>=</code> ) en JavaScript asigna un valor a un nombre de variable. Y los operadores <code>==</code> y <code>===</code> verifican la igualdad (las pruebas triples <code>===</code> para la igualdad estricta, lo que significa que tanto el valor como el tipo son iguales).
+El siguiente código asigna <code>x</code> para ser 2, que se evalúa como <code>true</code> . Casi todos los valores en JavaScript se evalúan como <code>true</code> , excepto lo que se conoce como valores &quot;falsos&quot;: <code>false</code> , <code>0</code> , <code>&quot;&quot;</code> (una cadena vacía), <code>NaN</code> , <code>undefined</code> y <code>null</code> .
+<blockquote>let x = 1;<br>let y = 2;<br>if (x = y) {<br>&nbsp;&nbsp;// this code block will run for any value of y (unless y were originally set as a falsy)<br>} else {<br>&nbsp;&nbsp;// this code block is what should run (but won't) in this example<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Corrija la condición para que el programa ejecute la rama derecha y se asigne el valor apropiado al <code>result</code> . 
+<section id='instructions'>
+Corrija la condición para que el programa ejecute la rama derecha y se asigne el valor apropiado al <code>result</code> .
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Corrija la condición para que el programa ejecute la rama derecha y se asigne e
 
 ```yml
 tests:
-  - text: 'Tu código debería arreglar la condición para que verifique la igualdad, en lugar de usar la asignación'.
+  - text: 'Tu código debería arreglar la condición para que verifique la igualdad, en lugar de usar la asignación'
     testString: 'assert(result == "Not equal!", "Your code should fix the condition so it checks for equality, instead of using assignment.");'
   - text: La condición puede usar <code class = "notranslate"> == </code> o <code class = "notranslate"> === </code> para probar la igualdad.
     testString: 'assert(code.match(/x\s*?===?\s*?y/g), "The condition can use either <code>==</code> or <code>===</code> to test for equality.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.spanish.md
index 69ba7f181d..15a3b66c5e 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-La declaración <code>const</code> tiene muchos casos de uso en JavaScript moderno. 
-Algunos desarrolladores prefieren asignar todas sus variables usando <code>const</code> de forma predeterminada, a menos que sepan que deberán reasignar el valor. Solo en ese caso, usan <code>let</code> . 
-Sin embargo, es importante comprender que los objetos (incluidas las matrices y las funciones) asignados a una variable que usa <code>const</code> todavía son mutables. El uso de la declaración <code>const</code> solo evita la reasignación del identificador de variable. 
-<blockquote>"use strict";<br>const s = [5, 6, 7];<br>s = [1, 2, 3]; // throws error, trying to assign a const<br>s[2] = 45; // works just as it would with an array declared with var or let<br>console.log(s); // returns [5, 6, 45]</blockquote> 
-Como puede ver, puede mutar el objeto <code>[5, 6, 7]</code> sí mismo y la variable <code>s</code> seguirá apuntando a la matriz alterada <code>[5, 6, 45]</code> . Al igual que todas las matrices, los elementos de la matriz en <code>s</code> son mutables, pero debido a que se utilizó <code>const</code> , no puede usar el identificador de la variable <code>s</code> para apuntar a una matriz diferente mediante el operador de asignación. 
+<section id='description'>
+La declaración <code>const</code> tiene muchos casos de uso en JavaScript moderno.
+Algunos desarrolladores prefieren asignar todas sus variables usando <code>const</code> de forma predeterminada, a menos que sepan que deberán reasignar el valor. Solo en ese caso, usan <code>let</code> .
+Sin embargo, es importante comprender que los objetos (incluidas las matrices y las funciones) asignados a una variable que usa <code>const</code> todavía son mutables. El uso de la declaración <code>const</code> solo evita la reasignación del identificador de variable.
+<blockquote>"use strict";<br>const s = [5, 6, 7];<br>s = [1, 2, 3]; // throws error, trying to assign a const<br>s[2] = 45; // works just as it would with an array declared with var or let<br>console.log(s); // returns [5, 6, 45]</blockquote>
+Como puede ver, puede mutar el objeto <code>[5, 6, 7]</code> sí mismo y la variable <code>s</code> seguirá apuntando a la matriz alterada <code>[5, 6, 45]</code> . Al igual que todas las matrices, los elementos de la matriz en <code>s</code> son mutables, pero debido a que se utilizó <code>const</code> , no puede usar el identificador de la variable <code>s</code> para apuntar a una matriz diferente mediante el operador de asignación.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Una matriz se declara como <code>const s = [5, 7, 2]</code> . Cambie la matriz a <code>[2, 5, 7]</code> usando varias asignaciones de elementos. 
+<section id='instructions'>
+Una matriz se declara como <code>const s = [5, 7, 2]</code> . Cambie la matriz a <code>[2, 5, 7]</code> usando varias asignaciones de elementos.
 </section>
 
 ## Tests
@@ -30,7 +30,7 @@ tests:
     testString: 'getUserInput => assert(getUserInput("index").match(/const\s+s/g), "<code>s</code> should be a constant variable (by using <code>const</code>).");'
   - text: No cambie la declaración original de la matriz.
     testString: 'getUserInput => assert(getUserInput("index").match(/const\s+s\s*=\s*\[\s*5\s*,\s*7\s*,\s*2\s*\]\s*;?/g), "Do not change the original array declaration.");'
-  - text: &#39; <code>s</code> debe ser igual a <code>[2, 5, 7]</code> .&#39;
+  - text: ' <code>s</code> debe ser igual a <code>[2, 5, 7]</code> .'
     testString: 'assert.deepEqual(s, [2, 5, 7], "<code>s</code> should be equal to <code>[2, 5, 7]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.spanish.md
index 68999d558e..9fd826c857 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Para ayudarnos a crear funciones más flexibles, ES6 introduce <dfn>parámetros predeterminados</dfn> para las funciones. 
-Echa un vistazo a este código: 
-<blockquote>function greeting(name = "Anonymous") {<br>&nbsp;&nbsp;return "Hello " + name;<br>}<br>console.log(greeting("John")); // Hello John<br>console.log(greeting()); // Hello Anonymous</blockquote> 
-El parámetro predeterminado se activa cuando el argumento no está especificado (no está definido). Como puede ver en el ejemplo anterior, el <code>name</code> del parámetro recibirá su valor predeterminado <code>&quot;Anonymous&quot;</code> cuando no proporcione un valor para el parámetro. Puede agregar valores predeterminados para tantos parámetros como desee. 
+<section id='description'>
+Para ayudarnos a crear funciones más flexibles, ES6 introduce <dfn>parámetros predeterminados</dfn> para las funciones.
+Echa un vistazo a este código:
+<blockquote>function greeting(name = "Anonymous") {<br>&nbsp;&nbsp;return "Hello " + name;<br>}<br>console.log(greeting("John")); // Hello John<br>console.log(greeting()); // Hello Anonymous</blockquote>
+El parámetro predeterminado se activa cuando el argumento no está especificado (no está definido). Como puede ver en el ejemplo anterior, el <code>name</code> del parámetro recibirá su valor predeterminado <code>&quot;Anonymous&quot;</code> cuando no proporcione un valor para el parámetro. Puede agregar valores predeterminados para tantos parámetros como desee.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Modifique el <code>increment</code> la función agregando parámetros predeterminados para que agregue 1 al <code>number</code> si no se especifica el <code>value</code> . 
+<section id='instructions'>
+Modifique el <code>increment</code> la función agregando parámetros predeterminados para que agregue 1 al <code>number</code> si no se especifica el <code>value</code> .
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Modifique el <code>increment</code> la función agregando parámetros predetermi
 
 ```yml
 tests:
-  - text: &#39;El resultado del <code>increment(5, 2)</code> debe ser <code>7</code> &#39;.
+  - text: 'El resultado del <code>increment(5, 2)</code> debe ser <code>7</code> '
     testString: 'assert(increment(5, 2) === 7, "The result of <code>increment(5, 2)</code> should be <code>7</code>.");'
   - text: El resultado del <code>increment(5)</code> debe ser <code>6</code> .
     testString: 'assert(increment(5) === 6, "The result of <code>increment(5)</code> should be <code>6</code>.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.spanish.md
index 7aaa81c19c..3a6764cda4 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-ES6 hace que la desestructuración de matrices sea tan fácil como desestructurar objetos. 
-Una diferencia clave entre el operador de propagación y la desestructuración de matrices es que el operador de propagación desempaqueta todo el contenido de una matriz en una lista separada por comas. Por consiguiente, no puede seleccionar o elegir qué elementos desea asignar a las variables. 
-destrucción de una matriz nos permite hacer exactamente eso: 
-<blockquote>const [a, b] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b); // 1, 2</blockquote> 
-A la variable <code>a</code> se le asigna el primer valor de la matriz, <code>b</code> se le asigna el segundo valor de la matriz. 
-También podemos acceder al valor en cualquier índice en una matriz con desestructuración usando comas para alcanzar el índice deseado: 
-<blockquote>const [a, b,,, c] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b, c); // 1, 2, 5 </blockquote> 
+<section id='description'>
+ES6 hace que la desestructuración de matrices sea tan fácil como desestructurar objetos.
+Una diferencia clave entre el operador de propagación y la desestructuración de matrices es que el operador de propagación desempaqueta todo el contenido de una matriz en una lista separada por comas. Por consiguiente, no puede seleccionar o elegir qué elementos desea asignar a las variables.
+destrucción de una matriz nos permite hacer exactamente eso:
+<blockquote>const [a, b] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b); // 1, 2</blockquote>
+A la variable <code>a</code> se le asigna el primer valor de la matriz, <code>b</code> se le asigna el segundo valor de la matriz.
+También podemos acceder al valor en cualquier índice en una matriz con desestructuración usando comas para alcanzar el índice deseado:
+<blockquote>const [a, b,,, c] = [1, 2, 3, 4, 5, 6];<br>console.log(a, b, c); // 1, 2, 5 </blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la asignación de desestructuración para intercambiar los valores de <code>a</code> y <code>b</code> modo que <code>a</code> reciba el valor almacenado en <code>b</code> , y <code>b</code> reciba el valor almacenado en <code>a</code> . 
+<section id='instructions'>
+Use la asignación de desestructuración para intercambiar los valores de <code>a</code> y <code>b</code> modo que <code>a</code> reciba el valor almacenado en <code>b</code> , y <code>b</code> reciba el valor almacenado en <code>a</code> .
 </section>
 
 ## Tests
@@ -26,9 +26,9 @@ Use la asignación de desestructuración para intercambiar los valores de <code>
 
 ```yml
 tests:
-  - text: &#39;El valor de <code>a</code> debe ser 6, después del intercambio.&#39;
+  - text: 'El valor de <code>a</code> debe ser 6, después del intercambio.'
     testString: 'assert(a === 6, "Value of <code>a</code> should be 6, after swapping.");'
-  - text: &#39;El valor de <code>b</code> debería ser 8, después del intercambio.&#39;
+  - text: 'El valor de <code>b</code> debería ser 8, después del intercambio.'
     testString: 'assert(b === 8, "Value of <code>b</code> should be 8, after swapping.");'
   - text: Utilice la desestructuración de matrices para intercambiar a y b.
     testString: '// assert(/\[\s*(\w)\s*,\s*(\w)\s*\]\s*=\s*\[\s*\2\s*,\s*\1\s*\]/g.test(code), "Use array destructuring to swap a and b.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-operator-to-reassign-array-elements.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-operator-to-reassign-array-elements.spanish.md
index 59389b05c8..2e096af98f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-operator-to-reassign-array-elements.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-operator-to-reassign-array-elements.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En algunas situaciones que involucran la desestructuración de matrices, podríamos querer recopilar el resto de los elementos en una matriz separada. 
-El resultado es similar a <code>Array.prototype.slice()</code> , como se muestra a continuación: 
-<blockquote>const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];<br>console.log(a, b); // 1, 2<br>console.log(arr); // [3, 4, 5, 7]</blockquote> 
-Las variables <code>a</code> y <code>b</code> toman los valores primero y segundo de la matriz. Después de eso, debido a la presencia del operador en reposo, <code>arr</code> obtiene el resto de los valores en forma de una matriz. 
-El elemento resto solo funciona correctamente como la última variable en la lista. Como en, no puede usar el operador de descanso para capturar un subarreglo que omita el último elemento de la matriz original. 
+<section id='description'>
+En algunas situaciones que involucran la desestructuración de matrices, podríamos querer recopilar el resto de los elementos en una matriz separada.
+El resultado es similar a <code>Array.prototype.slice()</code> , como se muestra a continuación:
+<blockquote>const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];<br>console.log(a, b); // 1, 2<br>console.log(arr); // [3, 4, 5, 7]</blockquote>
+Las variables <code>a</code> y <code>b</code> toman los valores primero y segundo de la matriz. Después de eso, debido a la presencia del operador en reposo, <code>arr</code> obtiene el resto de los valores en forma de una matriz.
+El elemento resto solo funciona correctamente como la última variable en la lista. Como en, no puede usar el operador de descanso para capturar un subarreglo que omita el último elemento de la matriz original.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la asignación de desestructuración con el operador de descanso para realizar un <code>Array.prototype.slice()</code> efectivo de manera que <code>arr</code> sea ​​una sub-matriz de la <code>source</code> de la matriz original con los dos primeros elementos omitidos. 
+<section id='instructions'>
+Use la asignación de desestructuración con el operador de descanso para realizar un <code>Array.prototype.slice()</code> efectivo de manera que <code>arr</code> sea ​​una sub-matriz de la <code>source</code> de la matriz original con los dos primeros elementos omitidos.
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Use la asignación de desestructuración con el operador de descanso para realiz
 
 ```yml
 tests:
-  - text: &#39; <code>arr</code> debería ser <code>[3,4,5,6,7,8,9,10]</code> &#39;
+  - text: ' <code>arr</code> debería ser <code>[3,4,5,6,7,8,9,10]</code> '
     testString: 'assert(arr.every((v, i) => v === i + 3) && arr.length === 8,"<code>arr</code> should be <code>[3,4,5,6,7,8,9,10]</code>");'
   - text: Se debe utilizar la destrucción.
     testString: 'getUserInput => assert(getUserInput("index").match(/\[\s*\w*\s*,\s*\w*\s*,\s*...\w+\s*\]/g),"Destructuring should be used.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-the-rest-operator-with-function-parameters.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-the-rest-operator-with-function-parameters.spanish.md
index 316aa9d0c2..5b6b29d993 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-the-rest-operator-with-function-parameters.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/use-the-rest-operator-with-function-parameters.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Para ayudarnos a crear funciones más flexibles, ES6 presenta al <dfn>operador de resto</dfn> para los parámetros de función. Con el operador resto, puede crear funciones que toman un número variable de argumentos. Estos argumentos se almacenan en una matriz a la que se puede acceder posteriormente desde dentro de la función. 
-Echa un vistazo a este código: 
-<blockquote>function howMany(...args) {<br>&nbsp;&nbsp;return "You have passed " + args.length + " arguments.";<br>}<br>console.log(howMany(0, 1, 2)); // You have passed 3 arguments<br>console.log(howMany("string", null, [1, 2, 3], { })); // You have passed 4 arguments.</blockquote> 
-El operador restante elimina la necesidad de verificar la matriz de <code>args</code> y nos permite aplicar <code>map()</code> , <code>filter()</code> y <code>reduce()</code> en la matriz de parámetros. 
+<section id='description'>
+Para ayudarnos a crear funciones más flexibles, ES6 presenta al <dfn>operador de resto</dfn> para los parámetros de función. Con el operador resto, puede crear funciones que toman un número variable de argumentos. Estos argumentos se almacenan en una matriz a la que se puede acceder posteriormente desde dentro de la función.
+Echa un vistazo a este código:
+<blockquote>function howMany(...args) {<br>&nbsp;&nbsp;return "You have passed " + args.length + " arguments.";<br>}<br>console.log(howMany(0, 1, 2)); // You have passed 3 arguments<br>console.log(howMany("string", null, [1, 2, 3], { })); // You have passed 4 arguments.</blockquote>
+El operador restante elimina la necesidad de verificar la matriz de <code>args</code> y nos permite aplicar <code>map()</code> , <code>filter()</code> y <code>reduce()</code> en la matriz de parámetros.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Modifique la <code>sum</code> la función para que use el operador de descanso y funcione de la misma manera con cualquier número de parámetros. 
+<section id='instructions'>
+Modifique la <code>sum</code> la función para que use el operador de descanso y funcione de la misma manera con cualquier número de parámetros.
 </section>
 
 ## Tests
@@ -23,9 +23,9 @@ Modifique la <code>sum</code> la función para que use el operador de descanso y
 
 ```yml
 tests:
-  - text: &#39;El resultado de la <code>sum(0,1,2)</code> debe ser 3&#39;
+  - text: 'El resultado de la <code>sum(0,1,2)</code> debe ser 3'
     testString: 'assert(sum(0,1,2) === 3, "The result of <code>sum(0,1,2)</code> should be 3");'
-  - text: &#39;El resultado de la <code>sum(1,2,3,4)</code> debe ser 10&#39;
+  - text: 'El resultado de la <code>sum(1,2,3,4)</code> debe ser 10'
     testString: 'assert(sum(1,2,3,4) === 10, "The result of <code>sum(1,2,3,4)</code> should be 10");'
   - text: El resultado de la <code>sum(5)</code> debe ser 5.
     testString: 'assert(sum(5) === 5, "The result of <code>sum(5)</code> should be 5");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-simple-fields.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-simple-fields.spanish.md
index ede5dfa609..71a9cf666f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-simple-fields.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-simple-fields.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-ES6 agrega un buen soporte para definir fácilmente literales de objetos. 
-Considera el siguiente código: 
-<blockquote>const getMousePosition = (x, y) => ({<br>&nbsp;&nbsp;x: x,<br>&nbsp;&nbsp;y: y<br>});</blockquote> 
-<code>getMousePosition</code> es una función simple que devuelve un objeto que contiene dos campos. 
-ES6 proporciona el azúcar sintáctico para eliminar la redundancia de tener que escribir <code>x: x</code> . Simplemente puede escribir <code>x</code> una vez, y se convertirá a <code>x: x</code> (o algo equivalente) debajo del capó. 
-Aquí se reescribe la misma función de la anterior para usar esta nueva sintaxis: 
-<blockquote>const getMousePosition = (x, y) => ({ x, y });</blockquote> 
+<section id='description'>
+ES6 agrega un buen soporte para definir fácilmente literales de objetos.
+Considera el siguiente código:
+<blockquote>const getMousePosition = (x, y) => ({<br>&nbsp;&nbsp;x: x,<br>&nbsp;&nbsp;y: y<br>});</blockquote>
+<code>getMousePosition</code> es una función simple que devuelve un objeto que contiene dos campos.
+ES6 proporciona el azúcar sintáctico para eliminar la redundancia de tener que escribir <code>x: x</code> . Simplemente puede escribir <code>x</code> una vez, y se convertirá a <code>x: x</code> (o algo equivalente) debajo del capó.
+Aquí se reescribe la misma función de la anterior para usar esta nueva sintaxis:
+<blockquote>const getMousePosition = (x, y) => ({ x, y });</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice campos simples con objetos literales para crear y devolver un objeto <code>Person</code> . 
+<section id='instructions'>
+Utilice campos simples con objetos literales para crear y devolver un objeto <code>Person</code> .
 </section>
 
 ## Tests
@@ -26,9 +26,9 @@ Utilice campos simples con objetos literales para crear y devolver un objeto <co
 
 ```yml
 tests:
-  - text: &#39;la salida es <code>{name: &quot;Zodiac Hasbro&quot;, age: 56, gender: &quot;male&quot;}</code> .&#39;
+  - text: 'la salida es <code>{name: &quot;Zodiac Hasbro&quot;, age: 56, gender: &quot;male&quot;}</code> .'
     testString: 'assert(() => {const res={name:"Zodiac Hasbro",age:56,gender:"male"}; const person=createPerson("Zodiac Hasbro", 56, "male"); return Object.keys(person).every(k => person[k] === res[k]);}, "the output is <code>{name: "Zodiac Hasbro", age: 56, gender: "male"}</code>.");'
-  - text: &#39;No <code>:</code> fueron utilizados&#39;.
+  - text: 'No <code>:</code> fueron utilizados'
     testString: 'getUserInput => assert(!getUserInput("index").match(/:/g), "No <code>:</code> were used.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-higher-order-arrow-functions.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-higher-order-arrow-functions.spanish.md
index 8491d5c7e6..7d9a39b9e5 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-higher-order-arrow-functions.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/es6/write-higher-order-arrow-functions.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Es hora de que veamos cuán poderosas son las funciones de flecha al procesar datos. 
-funciones de flecha funcionan realmente bien con funciones de orden superior, como <code>map()</code> , <code>filter()</code> y <code>reduce()</code> , que toman otras funciones como argumentos para procesar colecciones de datos. 
-Lee el siguiente código: 
-<blockquote>FBPosts.filter(function(post) {<br>&nbsp;&nbsp;return post.thumbnail !== null && post.shares > 100 && post.likes > 500;<br>})</blockquote> 
-Hemos escrito esto con el <code>filter()</code> para al menos hacerlo un poco legible. Ahora compárelo con el siguiente código que usa la sintaxis de la función de flecha en su lugar: 
-<blockquote>FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)</blockquote> 
-Este código es más breve y realiza la misma tarea con menos líneas de código. 
+<section id='description'>
+Es hora de que veamos cuán poderosas son las funciones de flecha al procesar datos.
+funciones de flecha funcionan realmente bien con funciones de orden superior, como <code>map()</code> , <code>filter()</code> y <code>reduce()</code> , que toman otras funciones como argumentos para procesar colecciones de datos.
+Lee el siguiente código:
+<blockquote>FBPosts.filter(function(post) {<br>&nbsp;&nbsp;return post.thumbnail !== null && post.shares > 100 && post.likes > 500;<br>})</blockquote>
+Hemos escrito esto con el <code>filter()</code> para al menos hacerlo un poco legible. Ahora compárelo con el siguiente código que usa la sintaxis de la función de flecha en su lugar:
+<blockquote>FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)</blockquote>
+Este código es más breve y realiza la misma tarea con menos líneas de código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice la sintaxis de la función de flecha para calcular el cuadrado de solo los enteros positivos (los números decimales no son enteros) en la matriz <code>realNumberArray</code> y almacenar la nueva matriz en la variable <code>squaredIntegers</code> . 
+<section id='instructions'>
+Utilice la sintaxis de la función de flecha para calcular el cuadrado de solo los enteros positivos (los números decimales no son enteros) en la matriz <code>realNumberArray</code> y almacenar la nueva matriz en la variable <code>squaredIntegers</code> .
 </section>
 
 ## Tests
@@ -30,13 +30,13 @@ tests:
     testString: 'getUserInput => assert(getUserInput("index").match(/const\s+squaredIntegers/g), "<code>squaredIntegers</code> should be a constant variable (by using <code>const</code>).");'
   - text: <code>squaredIntegers</code> debe ser una <code>array</code>
     testString: 'assert(Array.isArray(squaredIntegers), "<code>squaredIntegers</code> should be an <code>array</code>");'
-  - text: &#39; <code>squaredIntegers</code> debe ser <code>[16, 1764, 36]</code> &#39;
+  - text: ' <code>squaredIntegers</code> debe ser <code>[16, 1764, 36]</code> '
     testString: 'assert.deepStrictEqual(squaredIntegers, [16, 1764, 36], "<code>squaredIntegers</code> should be <code>[16, 1764, 36]</code>");'
   - text: <code>function</code> palabra clave de la <code>function</code> no se utilizó.
     testString: 'getUserInput => assert(!getUserInput("index").match(/function/g), "<code>function</code> keyword was not used.");'
   - text: bucle no debe ser utilizado
     testString: 'getUserInput => assert(!getUserInput("index").match(/(for)|(while)/g), "loop should not be used");'
-  - text: &#39; <code>map</code> , <code>filter</code> o <code>reduce</code> debe ser utilizado&#39;
+  - text: ' <code>map</code> , <code>filter</code> o <code>reduce</code> debe ser utilizado'
     testString: 'getUserInput => assert(getUserInput("index").match(/map|filter|reduce/g), "<code>map</code>, <code>filter</code>, or <code>reduce</code> should be used");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.spanish.md
index e57fb21f22..b4133cb6d5 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-La programación funcional tiene que ver con la creación y el uso de funciones no mutantes. 
-El último desafío introdujo el método <code>concat</code> como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Comparar <code>concat</code> con el método de <code>push</code> . <code>Push</code> agrega un elemento al final de la misma matriz a la que se llama, lo que muta esa matriz. Aquí hay un ejemplo: 
-<blockquote>var arr = [1, 2, 3];<br>arr.push([4, 5, 6]);<br>// arr is changed to [1, 2, 3, [4, 5, 6]]<br>// Not the functional programming way</blockquote> 
-<code>Concat</code> ofrece una forma de agregar nuevos elementos al final de una matriz sin efectos secundarios de mutación. 
+<section id='description'>
+La programación funcional tiene que ver con la creación y el uso de funciones no mutantes.
+El último desafío introdujo el método <code>concat</code> como una forma de combinar arreglos en uno nuevo sin mutar los arreglos originales. Comparar <code>concat</code> con el método de <code>push</code> . <code>Push</code> agrega un elemento al final de la misma matriz a la que se llama, lo que muta esa matriz. Aquí hay un ejemplo:
+<blockquote>var arr = [1, 2, 3];<br>arr.push([4, 5, 6]);<br>// arr is changed to [1, 2, 3, [4, 5, 6]]<br>// Not the functional programming way</blockquote>
+<code>Concat</code> ofrece una forma de agregar nuevos elementos al final de una matriz sin efectos secundarios de mutación.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambie la función <code>nonMutatingPush</code> para que use <code>concat</code> para agregar <code>newItem</code> al final del <code>original</code> lugar de <code>push</code> . La función debe devolver una matriz. 
+<section id='instructions'>
+Cambie la función <code>nonMutatingPush</code> para que use <code>concat</code> para agregar <code>newItem</code> al final del <code>original</code> lugar de <code>push</code> . La función debe devolver una matriz.
 </section>
 
 ## Tests
@@ -31,7 +31,7 @@ tests:
     testString: 'assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]), "The <code>first</code> array should not change.");'
   - text: La <code>second</code> matriz no debe cambiar.
     testString: 'assert(JSON.stringify(second) === JSON.stringify([4, 5]), "The <code>second</code> array should not change.");'
-  - text: &#39; <code>nonMutatingPush([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .&#39;
+  - text: ' <code>nonMutatingPush([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
     testString: 'assert(JSON.stringify(nonMutatingPush([1, 2, 3], [4, 5])) === JSON.stringify([1, 2, 3, 4, 5]), "<code>nonMutatingPush([1, 2, 3], [4, 5])</code> should return <code>[1, 2, 3, 4, 5]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.spanish.md
index 7f3b843ea9..4d53e0fcf6 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El método de <code>join</code> se utiliza para unir los elementos de una matriz para crear una cadena. Toma un argumento para el delimitador que se usa para separar los elementos de la matriz en la cadena. 
-Aquí hay un ejemplo: 
-<blockquote>var arr = ["Hello", "World"];<br>var str = arr.join(" ");<br>// Sets str to "Hello World"</blockquote> 
+<section id='description'>
+El método de <code>join</code> se utiliza para unir los elementos de una matriz para crear una cadena. Toma un argumento para el delimitador que se usa para separar los elementos de la matriz en la cadena.
+Aquí hay un ejemplo:
+<blockquote>var arr = ["Hello", "World"];<br>var str = arr.join(" ");<br>// Sets str to "Hello World"</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use el método de <code>join</code> (entre otros) dentro de la función de <code>sentensify</code> para hacer una oración de las palabras en la cadena <code>str</code> . La función debe devolver una cadena. Por ejemplo, &quot;I-like-Star-Wars&quot; se convertiría a &quot;Me gusta Star Wars&quot;. Para este desafío, no utilice el método de <code>replace</code> . 
+<section id='instructions'>
+Use el método de <code>join</code> (entre otros) dentro de la función de <code>sentensify</code> para hacer una oración de las palabras en la cadena <code>str</code> . La función debe devolver una cadena. Por ejemplo, &quot;I-like-Star-Wars&quot; se convertiría a &quot;Me gusta Star Wars&quot;. Para este desafío, no utilice el método de <code>replace</code> .
 </section>
 
 ## Tests
@@ -32,7 +32,7 @@ tests:
     testString: 'assert(sentensify("May-the-force-be-with-you") === "May the force be with you", "<code>sentensify("May-the-force-be-with-you")</code> should return <code>"May the force be with you"</code>.");'
   - text: <code>sentensify(&quot;The.force.is.strong.with.this.one&quot;)</code> debe devolver <code>&quot;The force is strong with this one&quot;</code> .
     testString: 'assert(sentensify("The.force.is.strong.with.this.one") === "The force is strong with this one", "<code>sentensify("The.force.is.strong.with.this.one")</code> should return <code>"The force is strong with this one"</code>.");'
-  - text: &#39; <code>sentensify(&quot;There,has,been,an,awakening&quot;)</code> debería regresar <code>&quot;There has been an awakening&quot;</code> .
+  - text: ' <code>sentensify(&quot;There,has,been,an,awakening&quot;)</code> debería regresar <code>&quot;There has been an awakening&quot;</code> .
     testString: 'assert(sentensify("There,has,been,an,awakening") === "There has been an awakening", "<code>sentensify("There,has,been,an,awakening")</code> should return <code>"There has been an awakening"</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.spanish.md
index 30e09dbdab..017c3e6314 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<code>Concatenation</code> significa unir elementos de extremo a extremo. JavaScript ofrece el método <code>concat</code> para cadenas y matrices que funcionan de la misma manera. Para las matrices, el método se llama en una, luego se proporciona otra matriz como el argumento a <code>concat</code> , que se agrega al final de la primera matriz. Devuelve una nueva matriz y no muta ninguna de las matrices originales. Aquí hay un ejemplo: 
-<blockquote>[1, 2, 3].concat([4, 5, 6]);<br>// Returns a new array [1, 2, 3, 4, 5, 6]</blockquote> 
+<section id='description'>
+<code>Concatenation</code> significa unir elementos de extremo a extremo. JavaScript ofrece el método <code>concat</code> para cadenas y matrices que funcionan de la misma manera. Para las matrices, el método se llama en una, luego se proporciona otra matriz como el argumento a <code>concat</code> , que se agrega al final de la primera matriz. Devuelve una nueva matriz y no muta ninguna de las matrices originales. Aquí hay un ejemplo:
+<blockquote>[1, 2, 3].concat([4, 5, 6]);<br>// Returns a new array [1, 2, 3, 4, 5, 6]</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice el método <code>concat</code> en la función <code>nonMutatingConcat</code> para concatenar <code>attach</code> al final del <code>original</code> . La función debe devolver la matriz concatenada. 
+<section id='instructions'>
+Utilice el método <code>concat</code> en la función <code>nonMutatingConcat</code> para concatenar <code>attach</code> al final del <code>original</code> . La función debe devolver la matriz concatenada.
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ tests:
     testString: 'assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]), "The <code>first</code> array should not change.");'
   - text: La <code>second</code> matriz no debe cambiar.
     testString: 'assert(JSON.stringify(second) === JSON.stringify([4, 5]), "The <code>second</code> array should not change.");'
-  - text: &#39; <code>nonMutatingConcat([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .&#39;
+  - text: ' <code>nonMutatingConcat([1, 2, 3], [4, 5])</code> debe devolver <code>[1, 2, 3, 4, 5]</code> .'
     testString: 'assert(JSON.stringify(nonMutatingConcat([1, 2, 3], [4, 5])) === JSON.stringify([1, 2, 3, 4, 5]), "<code>nonMutatingConcat([1, 2, 3], [4, 5])</code> should return <code>[1, 2, 3, 4, 5]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.spanish.md
index 479c286094..36eefb60dc 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Como ha visto al aplicar <code>Array.prototype.map()</code> , o simplemente <code>map()</code> anteriormente, el método de <code>map</code> devuelve una matriz de la misma longitud que la que se solicitó. Tampoco altera la matriz original, siempre que su función de devolución de llamada no lo haga. 
-En otras palabras, el <code>map</code> es una función pura, y su salida depende únicamente de sus entradas. Además, toma otra función como argumento. 
-Nos enseñaría mucho sobre el <code>map</code> para intentar implementar una versión que se comporte exactamente como <code>Array.prototype.map()</code> con un bucle <code>for</code> o <code>Array.prototype.forEach()</code> . 
-Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también. 
+<section id='description'>
+Como ha visto al aplicar <code>Array.prototype.map()</code> , o simplemente <code>map()</code> anteriormente, el método de <code>map</code> devuelve una matriz de la misma longitud que la que se solicitó. Tampoco altera la matriz original, siempre que su función de devolución de llamada no lo haga.
+En otras palabras, el <code>map</code> es una función pura, y su salida depende únicamente de sus entradas. Además, toma otra función como argumento.
+Nos enseñaría mucho sobre el <code>map</code> para intentar implementar una versión que se comporte exactamente como <code>Array.prototype.map()</code> con un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
+Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportarse exactamente como <code>Array.prototype.map()</code> . Puedes usar un bucle <code>for</code> o el método <code>forEach</code> . 
+<section id='instructions'>
+Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportarse exactamente como <code>Array.prototype.map()</code> . Puedes usar un bucle <code>for</code> o el método <code>forEach</code> .
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Escriba su propio <code>Array.prototype.myMap()</code> , que debería comportars
 
 ```yml
 tests:
-  - text: &#39; <code>new_s</code> debe ser igual a <code>[46, 130, 196, 10]</code> .&#39;
+  - text: ' <code>new_s</code> debe ser igual a <code>[46, 130, 196, 10]</code> .'
     testString: 'assert(JSON.stringify(new_s) === JSON.stringify([46, 130, 196, 10]), "<code>new_s</code> should equal <code>[46, 130, 196, 10]</code>.");'
   - text: Su código no debe utilizar el método de <code>map</code> .
     testString: 'assert(!code.match(/\.map/g), "Your code should not use the <code>map</code> method.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.spanish.md
index cc07b6e618..9869886d82 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Nos enseñaría mucho sobre el método de <code>filter</code> si intentáramos implementar una versión que se comporte exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o <code>Array.prototype.forEach()</code> . 
-Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también. 
+<section id='description'>
+Nos enseñaría mucho sobre el método de <code>filter</code> si intentáramos implementar una versión que se comporte exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o <code>Array.prototype.forEach()</code> .
+Nota: Una función pura puede alterar las variables locales definidas dentro de su alcance, aunque es preferible evitar eso también.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o el método <code>Array.prototype.forEach()</code> . 
+<section id='instructions'>
+Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse exactamente como <code>Array.prototype.filter()</code> . Puede usar un bucle <code>for</code> o el método <code>Array.prototype.forEach()</code> .
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Escriba su propio <code>Array.prototype.myFilter()</code> , que debe comportarse
 
 ```yml
 tests:
-  - text: &#39; <code>new_s</code> debe ser igual a <code>[23, 65, 5]</code> .&#39;
+  - text: ' <code>new_s</code> debe ser igual a <code>[23, 65, 5]</code> .'
     testString: 'assert(JSON.stringify(new_s) === JSON.stringify([23, 65, 5]), "<code>new_s</code> should equal <code>[23, 65, 5]</code>.");'
   - text: Su código no debe utilizar el método de <code>filter</code> .
     testString: 'assert(!code.match(/\.filter/g), "Your code should not use the <code>filter</code> method.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.spanish.md
index e3b80682fe..a45df57b9d 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Hasta ahora, hemos visto dos principios distintos para la programación funcional: 
-1) No alterar una variable u objeto: cree nuevas variables y objetos y devuélvalos si es necesario desde una función. 
-2) Declare los argumentos de la función: cualquier cálculo dentro de una función depende solo de los argumentos, y no de cualquier objeto global o variable. 
-Agregar uno a un número no es muy emocionante, pero podemos aplicar estos principios al trabajar con matrices u objetos más complejos. 
+<section id='description'>
+Hasta ahora, hemos visto dos principios distintos para la programación funcional:
+1) No alterar una variable u objeto: cree nuevas variables y objetos y devuélvalos si es necesario desde una función.
+2) Declare los argumentos de la función: cualquier cálculo dentro de una función depende solo de los argumentos, y no de cualquier objeto global o variable.
+Agregar uno a un número no es muy emocionante, pero podemos aplicar estos principios al trabajar con matrices u objetos más complejos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Refactorice (reescriba) el código para que la matriz de <code>bookList</code> global no se <code>bookList</code> dentro de ninguna de las funciones. La función de <code>add</code> debería agregar el <code>bookName</code> de <code>bookName</code> dado al final de una matriz. La función de <code>remove</code> debe eliminar el <code>bookName</code> de <code>bookName</code> dado de una matriz. Ambas funciones deben devolver una matriz, y cualquier parámetro nuevo debe agregarse antes del <code>bookName</code> one. 
+<section id='instructions'>
+Refactorice (reescriba) el código para que la matriz de <code>bookList</code> global no se <code>bookList</code> dentro de ninguna de las funciones. La función de <code>add</code> debería agregar el <code>bookName</code> de <code>bookName</code> dado al final de una matriz. La función de <code>remove</code> debe eliminar el <code>bookName</code> de <code>bookName</code> dado de una matriz. Ambas funciones deben devolver una matriz, y cualquier parámetro nuevo debe agregarse antes del <code>bookName</code> one.
 </section>
 
 ## Tests
@@ -23,13 +23,13 @@ Refactorice (reescriba) el código para que la matriz de <code>bookList</code> g
 
 ```yml
 tests:
-  - text: &#39; <code>bookList</code> no debe cambiar y aún debe ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;On The Electrodynamics of Moving Bodies&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;]</code> .&#39;
+  - text: ' <code>bookList</code> no debe cambiar y aún debe ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;On The Electrodynamics of Moving Bodies&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;]</code> .'
     testString: 'assert(JSON.stringify(bookList) === JSON.stringify(["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]), "<code>bookList</code> should not change and still equal <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code>.");'
-  - text: &#39; <code>newBookList</code> debería ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;On The Electrodynamics of Moving Bodies&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;, &quot;A Brief History of Time&quot;]</code> .&#39;
+  - text: ' <code>newBookList</code> debería ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;On The Electrodynamics of Moving Bodies&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;, &quot;A Brief History of Time&quot;]</code> .'
     testString: 'assert(JSON.stringify(newBookList) === JSON.stringify(["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]), "<code>newBookList</code> should equal <code>["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code>.");'
-  - text: &#39; <code>newerBookList</code> debería ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;]</code> .&#39;
+  - text: ' <code>newerBookList</code> debería ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;]</code> .'
     testString: 'assert(JSON.stringify(newerBookList) === JSON.stringify(["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]), "<code>newerBookList</code> should equal <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]</code>.");'
-  - text: &#39; <code>newestBookList</code> debería ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;, &quot;A Brief History of Time&quot;]</code> .
+  - text: ' <code>newestBookList</code> debería ser igual a <code>[&quot;The Hound of the Baskervilles&quot;, &quot;Philosophiæ Naturalis Principia Mathematica&quot;, &quot;Disquisitiones Arithmeticae&quot;, &quot;A Brief History of Time&quot;]</code> .
     testString: 'assert(JSON.stringify(newestBookList) === JSON.stringify(["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]), "<code>newestBookList</code> should equal <code>["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.spanish.md
index 73dcbfbc6f..c281c3040b 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Un patrón común al trabajar con matrices es cuando desea eliminar elementos y conservar el resto de la matriz. JavaScript ofrece el método de <code>splice</code> para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos que se eliminarán. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método de <code>splice</code> muta la matriz original a la que se llama. Aquí hay un ejemplo: 
-<blockquote>var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];<br>cities.splice(3, 1); // Returns "London" and deletes it from the cities array<br>// cities is now ["Chicago", "Delhi", "Islamabad", "Berlin"]</blockquote> 
-Como hemos visto en el último desafío, la <code>slice</code> método no muta la matriz original, pero devuelve una nueva que se pueden guardar en una variable. Recuerde que el método de <code>slice</code> toma dos argumentos para que los índices comiencen y terminen la división (el final no es inclusivo) y devuelve esos elementos en una nueva matriz. Uso de la <code>slice</code> método en lugar de <code>splice</code> ayuda a evitar los efectos secundarios de matriz-mutación. 
+<section id='description'>
+Un patrón común al trabajar con matrices es cuando desea eliminar elementos y conservar el resto de la matriz. JavaScript ofrece el método de <code>splice</code> para esto, que toma argumentos para el índice de dónde comenzar a eliminar elementos, luego la cantidad de elementos que se eliminarán. Si no se proporciona el segundo argumento, el valor predeterminado es eliminar elementos hasta el final. Sin embargo, el método de <code>splice</code> muta la matriz original a la que se llama. Aquí hay un ejemplo:
+<blockquote>var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];<br>cities.splice(3, 1); // Returns "London" and deletes it from the cities array<br>// cities is now ["Chicago", "Delhi", "Islamabad", "Berlin"]</blockquote>
+Como hemos visto en el último desafío, la <code>slice</code> método no muta la matriz original, pero devuelve una nueva que se pueden guardar en una variable. Recuerde que el método de <code>slice</code> toma dos argumentos para que los índices comiencen y terminen la división (el final no es inclusivo) y devuelve esos elementos en una nueva matriz. Uso de la <code>slice</code> método en lugar de <code>splice</code> ayuda a evitar los efectos secundarios de matriz-mutación.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Reescriba la función <code>nonMutatingSplice</code> utilizando <code>slice</code> lugar de <code>splice</code> . Debe limitar la matriz de <code>cities</code> proporcionada a una longitud de 3 y devolver una nueva matriz con solo los tres primeros elementos. 
-No mutar la matriz original proporcionada a la función. 
+<section id='instructions'>
+Reescriba la función <code>nonMutatingSplice</code> utilizando <code>slice</code> lugar de <code>splice</code> . Debe limitar la matriz de <code>cities</code> proporcionada a una longitud de 3 y devolver una nueva matriz con solo los tres primeros elementos.
+No mutar la matriz original proporcionada a la función.
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ tests:
     testString: 'assert(!code.match(/\.splice/g), "Your code should not use the <code>splice</code> method.");'
   - text: La matriz <code>inputCities</code> no debería cambiar.
     testString: 'assert(JSON.stringify(inputCities) === JSON.stringify(["Chicago", "Delhi", "Islamabad", "London", "Berlin"]), "The <code>inputCities</code> array should not change.");'
-  - text: &#39; <code>nonMutatingSplice([&quot;Chicago&quot;, &quot;Delhi&quot;, &quot;Islamabad&quot;, &quot;London&quot;, &quot;Berlin&quot;])</code> debe devolver <code>[&quot;Chicago&quot;, &quot;Delhi&quot;, &quot;Islamabad&quot;]</code> .&#39;
+  - text: ' <code>nonMutatingSplice([&quot;Chicago&quot;, &quot;Delhi&quot;, &quot;Islamabad&quot;, &quot;London&quot;, &quot;Berlin&quot;])</code> debe devolver <code>[&quot;Chicago&quot;, &quot;Delhi&quot;, &quot;Islamabad&quot;]</code> .'
     testString: 'assert(JSON.stringify(nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])) === JSON.stringify(["Chicago", "Delhi", "Islamabad"]), "<code>nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])</code> should return <code>["Chicago", "Delhi", "Islamabad"]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.spanish.md
index 0b71bea524..7d0e58760e 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.spanish.md
@@ -6,13 +6,13 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Un efecto secundario del método de <code>sort</code> es que cambia el orden de los elementos en la matriz original. En otras palabras, muta la matriz en su lugar. Una forma de evitar esto es primero concatenar una matriz vacía con la ordenada (recuerde que <code>concat</code> devuelve una nueva matriz), luego ejecute el método de <code>sort</code> . 
+<section id='description'>
+Un efecto secundario del método de <code>sort</code> es que cambia el orden de los elementos en la matriz original. En otras palabras, muta la matriz en su lugar. Una forma de evitar esto es primero concatenar una matriz vacía con la ordenada (recuerde que <code>concat</code> devuelve una nueva matriz), luego ejecute el método de <code>sort</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice el método de <code>sort</code> en la función <code>nonMutatingSort</code> para ordenar los elementos de una matriz en orden ascendente. La función debe devolver una nueva matriz y no mutar la variable <code>globalArray</code> . 
+<section id='instructions'>
+Utilice el método de <code>sort</code> en la función <code>nonMutatingSort</code> para ordenar los elementos de una matriz en orden ascendente. La función debe devolver una nueva matriz y no mutar la variable <code>globalArray</code> .
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ tests:
     testString: 'assert(code.match(/\.concat/g), "Your code should use the <code>concat</code> method.");'
   - text: La variable <code>globalArray</code> no debe cambiar.
     testString: 'assert(JSON.stringify(globalArray) === JSON.stringify([5, 6, 3, 2, 9]), "The <code>globalArray</code> variable should not change.");'
-  - text: &#39; <code>nonMutatingSort(globalArray)</code> debe devolver <code>[2, 3, 5, 6, 9]</code> .&#39;
+  - text: ' <code>nonMutatingSort(globalArray)</code> debe devolver <code>[2, 3, 5, 6, 9]</code> .'
     testString: 'assert(JSON.stringify(nonMutatingSort(globalArray)) === JSON.stringify([2, 3, 5, 6, 9]), "<code>nonMutatingSort(globalArray)</code> should return <code>[2, 3, 5, 6, 9]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.spanish.md
index c0025fca50..4c9d33b875 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El método de <code>slice</code> devuelve una copia de ciertos elementos de una matriz. Puede tomar dos argumentos, el primero proporciona el índice de dónde comenzar la división, el segundo es el índice de dónde finalizar la división (y no está incluido). Si no se proporcionan los argumentos, el valor predeterminado es comenzar desde el principio de la matriz hasta el final, lo cual es una forma fácil de hacer una copia de toda la matriz. La <code>slice</code> método no muta la matriz original, pero devuelve una nueva. 
-Aquí hay un ejemplo: 
-<blockquote>var arr = ["Cat", "Dog", "Tiger", "Zebra"];<br>var newArray = arr.slice(1, 3);<br>// Sets newArray to ["Dog", "Tiger"]</blockquote> 
+<section id='description'>
+El método de <code>slice</code> devuelve una copia de ciertos elementos de una matriz. Puede tomar dos argumentos, el primero proporciona el índice de dónde comenzar la división, el segundo es el índice de dónde finalizar la división (y no está incluido). Si no se proporcionan los argumentos, el valor predeterminado es comenzar desde el principio de la matriz hasta el final, lo cual es una forma fácil de hacer una copia de toda la matriz. La <code>slice</code> método no muta la matriz original, pero devuelve una nueva.
+Aquí hay un ejemplo:
+<blockquote>var arr = ["Cat", "Dog", "Tiger", "Zebra"];<br>var newArray = arr.slice(1, 3);<br>// Sets newArray to ["Dog", "Tiger"]</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice la <code>slice</code> método en el <code>sliceArray</code> función para devolver parte de la <code>anim</code> matriz dada las proporcionadas <code>beginSlice</code> y <code>endSlice</code> índices. La función debe devolver una matriz. 
+<section id='instructions'>
+Utilice la <code>slice</code> método en el <code>sliceArray</code> función para devolver parte de la <code>anim</code> matriz dada las proporcionadas <code>beginSlice</code> y <code>endSlice</code> índices. La función debe devolver una matriz.
 </section>
 
 ## Tests
@@ -26,11 +26,11 @@ tests:
     testString: 'assert(code.match(/\.slice/g), "Your code should use the <code>slice</code> method.");'
   - text: La variable <code>inputAnim</code> no debe cambiar.
     testString: 'assert(JSON.stringify(inputAnim) === JSON.stringify(["Cat", "Dog", "Tiger", "Zebra", "Ant"]), "The <code>inputAnim</code> variable should not change.");'
-  - text: &#39; <code>sliceArray([&quot;Cat&quot;, &quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;, &quot;Ant&quot;], 1, 3)</code> debe devolver <code>[&quot;Dog&quot;, &quot;Tiger&quot;]</code> .&#39;
+  - text: ' <code>sliceArray([&quot;Cat&quot;, &quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;, &quot;Ant&quot;], 1, 3)</code> debe devolver <code>[&quot;Dog&quot;, &quot;Tiger&quot;]</code> .'
     testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)) === JSON.stringify(["Dog", "Tiger"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)</code> should return <code>["Dog", "Tiger"]</code>.");'
-  - text: &#39; <code>sliceArray([&quot;Cat&quot;, &quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;, &quot;Ant&quot;], 0, 1)</code> debe devolver <code>[&quot;Cat&quot;]</code> .&#39;
+  - text: ' <code>sliceArray([&quot;Cat&quot;, &quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;, &quot;Ant&quot;], 0, 1)</code> debe devolver <code>[&quot;Cat&quot;]</code> .'
     testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)) === JSON.stringify(["Cat"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)</code> should return <code>["Cat"]</code>.");'
-  - text: &#39; <code>sliceArray([&quot;Cat&quot;, &quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;, &quot;Ant&quot;], 1, 4)</code> debe devolver <code>[&quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;]</code> .&#39;
+  - text: ' <code>sliceArray([&quot;Cat&quot;, &quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;, &quot;Ant&quot;], 1, 4)</code> debe devolver <code>[&quot;Dog&quot;, &quot;Tiger&quot;, &quot;Zebra&quot;]</code> .'
     testString: 'assert(JSON.stringify(sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)) === JSON.stringify(["Dog", "Tiger", "Zebra"]), "<code>sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)</code> should return <code>["Dog", "Tiger", "Zebra"]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.spanish.md
index d672cdae9b..88019bcff9 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El método de <code>sort</code> ordena los elementos de una matriz de acuerdo con la función de devolución de llamada. 
-Por ejemplo: 
-<blockquote>function ascendingOrder(arr) {<br>&nbsp;&nbsp;return arr.sort(function(a, b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return a - b;<br>&nbsp;&nbsp;});<br>}<br>ascendingOrder([1, 5, 2, 3, 4]);<br>// Returns [1, 2, 3, 4, 5]<br><br>function reverseAlpha(arr) {<br>&nbsp;&nbsp;return arr.sort(function(a, b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return a < b;<br>&nbsp;&nbsp;});<br>}<br>reverseAlpha(['l', 'h', 'z', 'b', 's']);<br>// Returns ['z', 's', 'l', 'h', 'b']</blockquote> 
-Nota: Se recomienda proporcionar una función de devolución de llamada para especificar cómo ordenar los elementos de la matriz. El método de clasificación predeterminado de JavaScript es por valor de punto Unicode de cadena, que puede devolver resultados inesperados. 
+<section id='description'>
+El método de <code>sort</code> ordena los elementos de una matriz de acuerdo con la función de devolución de llamada.
+Por ejemplo:
+<blockquote>function ascendingOrder(arr) {<br>&nbsp;&nbsp;return arr.sort(function(a, b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return a - b;<br>&nbsp;&nbsp;});<br>}<br>ascendingOrder([1, 5, 2, 3, 4]);<br>// Returns [1, 2, 3, 4, 5]<br><br>function reverseAlpha(arr) {<br>&nbsp;&nbsp;return arr.sort(function(a, b) {<br>&nbsp;&nbsp;&nbsp;&nbsp;return a < b;<br>&nbsp;&nbsp;});<br>}<br>reverseAlpha(['l', 'h', 'z', 'b', 's']);<br>// Returns ['z', 's', 'l', 'h', 'b']</blockquote>
+Nota: Se recomienda proporcionar una función de devolución de llamada para especificar cómo ordenar los elementos de la matriz. El método de clasificación predeterminado de JavaScript es por valor de punto Unicode de cadena, que puede devolver resultados inesperados.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice el método de <code>sort</code> en la función de orden <code>alphabeticalOrder</code> para ordenar los elementos de <code>arr</code> en orden alfabético. 
+<section id='instructions'>
+Utilice el método de <code>sort</code> en la función de orden <code>alphabeticalOrder</code> para ordenar los elementos de <code>arr</code> en orden alfabético.
 </section>
 
 ## Tests
@@ -25,11 +25,11 @@ Utilice el método de <code>sort</code> en la función de orden <code>alphabetic
 tests:
   - text: Su código debe utilizar el método de <code>sort</code> .
     testString: 'assert(code.match(/\.sort/g), "Your code should use the <code>sort</code> method.");'
-  - text: &#39; <code>alphabeticalOrder([&quot;a&quot;, &quot;d&quot;, &quot;c&quot;, &quot;a&quot;, &quot;z&quot;, &quot;g&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;a&quot;, &quot;c&quot;, &quot;d&quot;, &quot;g&quot;, &quot;z&quot;]</code> . &#39;
+  - text: ' <code>alphabeticalOrder([&quot;a&quot;, &quot;d&quot;, &quot;c&quot;, &quot;a&quot;, &quot;z&quot;, &quot;g&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;a&quot;, &quot;c&quot;, &quot;d&quot;, &quot;g&quot;, &quot;z&quot;]</code> . '
     testString: 'assert(JSON.stringify(alphabeticalOrder(["a", "d", "c", "a", "z", "g"])) === JSON.stringify(["a", "a", "c", "d", "g", "z"]), "<code>alphabeticalOrder(["a", "d", "c", "a", "z", "g"])</code> should return <code>["a", "a", "c", "d", "g", "z"]</code>.");'
-  - text: &#39; <code>alphabeticalOrder([&quot;x&quot;, &quot;h&quot;, &quot;a&quot;, &quot;m&quot;, &quot;n&quot;, &quot;m&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;h&quot;, &quot;m&quot;, &quot;m&quot;, &quot;n&quot;, &quot;x&quot;]</code> . &#39;
+  - text: ' <code>alphabeticalOrder([&quot;x&quot;, &quot;h&quot;, &quot;a&quot;, &quot;m&quot;, &quot;n&quot;, &quot;m&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;h&quot;, &quot;m&quot;, &quot;m&quot;, &quot;n&quot;, &quot;x&quot;]</code> . '
     testString: 'assert(JSON.stringify(alphabeticalOrder(["x", "h", "a", "m", "n", "m"])) === JSON.stringify(["a", "h", "m", "m", "n", "x"]), "<code>alphabeticalOrder(["x", "h", "a", "m", "n", "m"])</code> should return <code>["a", "h", "m", "m", "n", "x"]</code>.");'
-  - text: &#39; <code>alphabeticalOrder([&quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;x&quot;, &quot;t&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;t&quot;, &quot;x&quot;]</code> . &#39;
+  - text: ' <code>alphabeticalOrder([&quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;x&quot;, &quot;t&quot;])</code> debe devolver <code>[&quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;a&quot;, &quot;t&quot;, &quot;x&quot;]</code> . '
     testString: 'assert(JSON.stringify(alphabeticalOrder(["a", "a", "a", "a", "x", "t"])) === JSON.stringify(["a", "a", "a", "a", "t", "x"]), "<code>alphabeticalOrder(["a", "a", "a", "a", "x", "t"])</code> should return <code>["a", "a", "a", "a", "t", "x"]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.spanish.md
index b67a3b87ed..63a148b3ea 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El método de <code>split</code> divide una cadena en una matriz de cadenas. Toma un argumento para el delimitador, que puede ser un carácter que se usa para separar la cadena o una expresión regular. Por ejemplo, si el delimitador es un espacio, obtiene una matriz de palabras, y si el delimitador es una cadena vacía, obtiene una matriz de cada carácter en la cadena. 
-Aquí hay dos ejemplos que dividen una cadena por espacios, luego otro por dígitos usando una expresión regular: 
-<blockquote>var str = "Hello World";<br>var bySpace = str.split(" ");<br>// Sets bySpace to ["Hello", "World"]<br><br>var otherString = "How9are7you2today";<br>var byDigits = otherString.split(/\d/);<br>// Sets byDigits to ["How", "are", "you", "today"]</blockquote> 
-Dado que las cadenas son inmutables, el método de <code>split</code> facilita el trabajo con ellas. 
+<section id='description'>
+El método de <code>split</code> divide una cadena en una matriz de cadenas. Toma un argumento para el delimitador, que puede ser un carácter que se usa para separar la cadena o una expresión regular. Por ejemplo, si el delimitador es un espacio, obtiene una matriz de palabras, y si el delimitador es una cadena vacía, obtiene una matriz de cada carácter en la cadena.
+Aquí hay dos ejemplos que dividen una cadena por espacios, luego otro por dígitos usando una expresión regular:
+<blockquote>var str = "Hello World";<br>var bySpace = str.split(" ");<br>// Sets bySpace to ["Hello", "World"]<br><br>var otherString = "How9are7you2today";<br>var byDigits = otherString.split(/\d/);<br>// Sets byDigits to ["How", "are", "you", "today"]</blockquote>
+Dado que las cadenas son inmutables, el método de <code>split</code> facilita el trabajo con ellas.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice la <code>split</code> método dentro de la <code>splitify</code> función de dividir <code>str</code> en una matriz de palabras. La función debe devolver la matriz. Tenga en cuenta que las palabras no siempre están separadas por espacios y que la matriz no debe contener puntuación. 
+<section id='instructions'>
+Utilice la <code>split</code> método dentro de la <code>splitify</code> función de dividir <code>str</code> en una matriz de palabras. La función debe devolver la matriz. Tenga en cuenta que las palabras no siempre están separadas por espacios y que la matriz no debe contener puntuación.
 </section>
 
 ## Tests
@@ -25,11 +25,11 @@ Utilice la <code>split</code> método dentro de la <code>splitify</code> funció
 tests:
   - text: Su código debe utilizar el método de <code>split</code> .
     testString: 'assert(code.match(/\.split/g), "Your code should use the <code>split</code> method.");'
-  - text: &#39; <code>splitify(&quot;Hello World,I-am code&quot;)</code> debe devolver <code>[&quot;Hello&quot;, &quot;World&quot;, &quot;I&quot;, &quot;am&quot;, &quot;code&quot;]</code> .&#39;
+  - text: ' <code>splitify(&quot;Hello World,I-am code&quot;)</code> debe devolver <code>[&quot;Hello&quot;, &quot;World&quot;, &quot;I&quot;, &quot;am&quot;, &quot;code&quot;]</code> .'
     testString: 'assert(JSON.stringify(splitify("Hello World,I-am code")) === JSON.stringify(["Hello", "World", "I", "am", "code"]), "<code>splitify("Hello World,I-am code")</code> should return <code>["Hello", "World", "I", "am", "code"]</code>.");'
-  - text: &#39; <code>splitify(&quot;Earth-is-our home&quot;)</code> debería devolver <code>[&quot;Earth&quot;, &quot;is&quot;, &quot;our&quot;, &quot;home&quot;]</code> .&#39;
+  - text: ' <code>splitify(&quot;Earth-is-our home&quot;)</code> debería devolver <code>[&quot;Earth&quot;, &quot;is&quot;, &quot;our&quot;, &quot;home&quot;]</code> .'
     testString: 'assert(JSON.stringify(splitify("Earth-is-our home")) === JSON.stringify(["Earth", "is", "our", "home"]), "<code>splitify("Earth-is-our home")</code> should return <code>["Earth", "is", "our", "home"]</code>.");'
-  - text: &#39; <code>splitify(&quot;This.is.a-sentence&quot;)</code> debe devolver <code>[&quot;This&quot;, &quot;is&quot;, &quot;a&quot;, &quot;sentence&quot;]</code> .&#39;
+  - text: ' <code>splitify(&quot;This.is.a-sentence&quot;)</code> debe devolver <code>[&quot;This&quot;, &quot;is&quot;, &quot;a&quot;, &quot;sentence&quot;]</code> .'
     testString: 'assert(JSON.stringify(splitify("This.is.a-sentence")) === JSON.stringify(["This", "is", "a", "sentence"]), "<code>splitify("This.is.a-sentence")</code> should return <code>["This", "is", "a", "sentence"]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.spanish.md
index 627d471ddf..55529f1287 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-<code>every</code> métodos funcionan con matrices para verificar si <em>cada</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si todos los valores cumplen los criterios, <code>false</code> si no. 
-Por ejemplo, el siguiente código verificará si cada elemento de la matriz de <code>numbers</code> es menor que 10: 
-<blockquote>var numbers = [1, 5, 8, 0, 10, 11];<br>numbers.every(function(currentValue) {<br>&nbsp;&nbsp;return currentValue < 10;<br>});<br>// Returns false</blockquote> 
+<section id='description'>
+<code>every</code> métodos funcionan con matrices para verificar si <em>cada</em> elemento pasa una prueba en particular. Devuelve un valor booleano: <code>true</code> si todos los valores cumplen los criterios, <code>false</code> si no.
+Por ejemplo, el siguiente código verificará si cada elemento de la matriz de <code>numbers</code> es menor que 10:
+<blockquote>var numbers = [1, 5, 8, 0, 10, 11];<br>numbers.every(function(currentValue) {<br>&nbsp;&nbsp;return currentValue < 10;<br>});<br>// Returns false</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use <code>every</code> método dentro de la función <code>checkPositive</code> para verificar si cada elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano. 
+<section id='instructions'>
+Use <code>every</code> método dentro de la función <code>checkPositive</code> para verificar si cada elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
 </section>
 
 ## Tests
@@ -24,11 +24,11 @@ Use <code>every</code> método dentro de la función <code>checkPositive</code>
 tests:
   - text: Su código debe utilizar <code>every</code> métodos.
     testString: 'assert(code.match(/\.every/g), "Your code should use the <code>every</code> method.");'
-  - text: &#39; <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>false</code> .&#39;
+  - text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>false</code> .'
     testString: 'assert(!checkPositive([1, 2, 3, -4, 5]), "<code>checkPositive([1, 2, 3, -4, 5])</code> should return <code>false</code>.");'
-  - text: &#39; <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .&#39;
+  - text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
     testString: 'assert(checkPositive([1, 2, 3, 4, 5]), "<code>checkPositive([1, 2, 3, 4, 5])</code> should return <code>true</code>.");'
-  - text: &#39; <code>checkPositive([1, -2, 3, -4, 5])</code> debe devolver <code>false</code> .&#39;
+  - text: ' <code>checkPositive([1, -2, 3, -4, 5])</code> debe devolver <code>false</code> .'
     testString: 'assert(!checkPositive([1, -2, 3, -4, 5]), "<code>checkPositive([1, -2, 3, -4, 5])</code> should return <code>false</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.spanish.md
index ff49d26898..e92b8ce803 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Otra función de matriz útil es <code>Array.prototype.filter()</code> , o simplemente <code>filter()</code> . El método de <code>filter</code> devuelve una nueva matriz que es a lo sumo tan larga como la matriz original, pero generalmente tiene menos elementos. 
-<code>Filter</code> no altera la matriz original, al igual que el <code>map</code> . Toma una función de devolución de llamada que aplica la lógica dentro de la devolución de llamada en cada elemento de la matriz. Si un elemento devuelve verdadero según los criterios en la función de devolución de llamada, entonces se incluye en la nueva matriz. 
+<section id='description'>
+Otra función de matriz útil es <code>Array.prototype.filter()</code> , o simplemente <code>filter()</code> . El método de <code>filter</code> devuelve una nueva matriz que es a lo sumo tan larga como la matriz original, pero generalmente tiene menos elementos.
+<code>Filter</code> no altera la matriz original, al igual que el <code>map</code> . Toma una función de devolución de llamada que aplica la lógica dentro de la devolución de llamada en cada elemento de la matriz. Si un elemento devuelve verdadero según los criterios en la función de devolución de llamada, entonces se incluye en la nueva matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-La variable <code>watchList</code> contiene una serie de objetos con información sobre varias películas. Use una combinación de <code>filter</code> y <code>map</code> para devolver una nueva matriz de objetos con solo <code>title</code> y claves de <code>rating</code> , pero donde <code>imdbRating</code> es mayor o igual a 8.0. Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y es posible que desee convertirlos en números para realizar operaciones matemáticas en ellos. 
+<section id='instructions'>
+La variable <code>watchList</code> contiene una serie de objetos con información sobre varias películas. Use una combinación de <code>filter</code> y <code>map</code> para devolver una nueva matriz de objetos con solo <code>title</code> y claves de <code>rating</code> , pero donde <code>imdbRating</code> es mayor o igual a 8.0. Tenga en cuenta que los valores de calificación se guardan como cadenas en el objeto y es posible que desee convertirlos en números para realizar operaciones matemáticas en ellos.
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ tests:
     testString: 'assert(code.match(/\.filter/g), "Your code should use the <code>filter</code> method.");'
   - text: Su código no debe utilizar un bucle <code>for</code> .
     testString: 'assert(!code.match(/for\s*?\(.+?\)/g), "Your code should not use a <code>for</code> loop.");'
-  - text: &#39; <code>filteredList</code> debe ser igual a <code>[{&quot;title&quot;: &quot;Inception&quot;,&quot;rating&quot;: &quot;8.8&quot;},{&quot;title&quot;: &quot;Interstellar&quot;,&quot;rating&quot;: &quot;8.6&quot;},{&quot;title&quot;: &quot;The Dark Knight&quot;,&quot;rating&quot;: &quot;9.0&quot;},{&quot;title&quot;: &quot;Batman Begins&quot;,&quot;rating&quot;: &quot;8.3&quot;}]</code> . &#39;
+  - text: ' <code>filteredList</code> debe ser igual a <code>[{&quot;title&quot;: &quot;Inception&quot;,&quot;rating&quot;: &quot;8.8&quot;},{&quot;title&quot;: &quot;Interstellar&quot;,&quot;rating&quot;: &quot;8.6&quot;},{&quot;title&quot;: &quot;The Dark Knight&quot;,&quot;rating&quot;: &quot;9.0&quot;},{&quot;title&quot;: &quot;Batman Begins&quot;,&quot;rating&quot;: &quot;8.3&quot;}]</code> . '
     testString: 'assert.deepEqual(filteredList, [{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}], "<code>filteredList</code> should equal <code>[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.spanish.md
index 547f30b772..8f4d0884e8 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.spanish.md
@@ -6,17 +6,17 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Hasta ahora hemos aprendido a usar funciones puras para evitar efectos secundarios en un programa. Además, hemos visto que el valor de tener una función solo depende de sus argumentos de entrada. 
-Esto es solo el comienzo. Como su nombre lo indica, la programación funcional se centra en una teoría de funciones. 
-Tendría sentido poder pasarlos como argumentos a otras funciones y devolver una función desde otra función. Las funciones se consideran <code>First Class Objects</code> en JavaScript, lo que significa que se pueden usar como cualquier otro objeto. Pueden guardarse en variables, almacenarse en un objeto o pasarse como argumentos de función. 
-Comencemos con algunas funciones de matriz simples, que son métodos en el prototipo de objeto de matriz. En este ejercicio estamos viendo <code>Array.prototype.map()</code> , o más simplemente un <code>map</code> . 
-Recuerde que el método de <code>map</code> es una forma de iterar sobre cada elemento en una matriz. Crea una nueva matriz (sin cambiar la original) después de aplicar una función de devolución de llamada a cada elemento. 
+<section id='description'>
+Hasta ahora hemos aprendido a usar funciones puras para evitar efectos secundarios en un programa. Además, hemos visto que el valor de tener una función solo depende de sus argumentos de entrada.
+Esto es solo el comienzo. Como su nombre lo indica, la programación funcional se centra en una teoría de funciones.
+Tendría sentido poder pasarlos como argumentos a otras funciones y devolver una función desde otra función. Las funciones se consideran <code>First Class Objects</code> en JavaScript, lo que significa que se pueden usar como cualquier otro objeto. Pueden guardarse en variables, almacenarse en un objeto o pasarse como argumentos de función.
+Comencemos con algunas funciones de matriz simples, que son métodos en el prototipo de objeto de matriz. En este ejercicio estamos viendo <code>Array.prototype.map()</code> , o más simplemente un <code>map</code> .
+Recuerde que el método de <code>map</code> es una forma de iterar sobre cada elemento en una matriz. Crea una nueva matriz (sin cambiar la original) después de aplicar una función de devolución de llamada a cada elemento.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-La matriz <code>watchList</code> contiene objetos con información sobre varias películas. Use el <code>map</code> para extraer el título y la clasificación de la <code>watchList</code> de <code>watchList</code> y guarde la nueva matriz en la variable de <code>rating</code> . El código en el editor actualmente usa un bucle <code>for</code> para hacer esto, reemplaza la funcionalidad de bucle con tu expresión de <code>map</code> . 
+<section id='instructions'>
+La matriz <code>watchList</code> contiene objetos con información sobre varias películas. Use el <code>map</code> para extraer el título y la clasificación de la <code>watchList</code> de <code>watchList</code> y guarde la nueva matriz en la variable de <code>rating</code> . El código en el editor actualmente usa un bucle <code>for</code> para hacer esto, reemplaza la funcionalidad de bucle con tu expresión de <code>map</code> .
 </section>
 
 ## Tests
@@ -30,7 +30,7 @@ tests:
     testString: 'assert(!code.match(/for\s*?\(.+?\)/g), "Your code should not use a <code>for</code> loop.");'
   - text: Su código debe utilizar el método de <code>map</code> .
     testString: 'assert(code.match(/\.map/g), "Your code should use the <code>map</code> method.");'
-  - text: La <code>rating</code> debería ser igual a <code>[{&quot;title&quot;:&quot;Inception&quot;,&quot;rating&quot;:&quot;8.8&quot;},{&quot;title&quot;:&quot;Interstellar&quot;,&quot;rating&quot;:&quot;8.6&quot;},{&quot;title&quot;:&quot;The Dark Knight&quot;,&quot;rating&quot;:&quot;9.0&quot;},{&quot;title&quot;:&quot;Batman Begins&quot;,&quot;rating&quot;:&quot;8.3&quot;},{&quot;title&quot;:&quot;Avatar&quot;,&quot;rating&quot;:&quot;7.9&quot;}]</code> . &#39;
+  - text: La <code>rating</code> debería ser igual a <code>[{&quot;title&quot;:&quot;Inception&quot;,&quot;rating&quot;:&quot;8.8&quot;},{&quot;title&quot;:&quot;Interstellar&quot;,&quot;rating&quot;:&quot;8.6&quot;},{&quot;title&quot;:&quot;The Dark Knight&quot;,&quot;rating&quot;:&quot;9.0&quot;},{&quot;title&quot;:&quot;Batman Begins&quot;,&quot;rating&quot;:&quot;8.3&quot;},{&quot;title&quot;:&quot;Avatar&quot;,&quot;rating&quot;:&quot;7.9&quot;}]</code> . '
     testString: 'assert(JSON.stringify(rating) === JSON.stringify([{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]), "<code>rating</code> should equal <code>[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.spanish.md
index daf6635801..38675a3c5c 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El <code>some</code> método funciona con matrices para comprobar si <em>cualquier</em> elemento pasa una prueba particular. Devuelve un valor booleano: <code>true</code> si alguno de los valores cumple los criterios, <code>false</code> si no. 
-Por ejemplo, el siguiente código verificará si algún elemento de la matriz de <code>numbers</code> es menor que 10: 
-<blockquote>var numbers = [10, 50, 8, 220, 110, 11];<br>numbers.some(function(currentValue) {<br>&nbsp;&nbsp;return currentValue < 10;<br>});<br>// Returns true</blockquote> 
+<section id='description'>
+El <code>some</code> método funciona con matrices para comprobar si <em>cualquier</em> elemento pasa una prueba particular. Devuelve un valor booleano: <code>true</code> si alguno de los valores cumple los criterios, <code>false</code> si no.
+Por ejemplo, el siguiente código verificará si algún elemento de la matriz de <code>numbers</code> es menor que 10:
+<blockquote>var numbers = [10, 50, 8, 220, 110, 11];<br>numbers.some(function(currentValue) {<br>&nbsp;&nbsp;return currentValue < 10;<br>});<br>// Returns true</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use <code>some</code> método dentro de la función <code>checkPositive</code> para verificar si algún elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano. 
+<section id='instructions'>
+Use <code>some</code> método dentro de la función <code>checkPositive</code> para verificar si algún elemento en <code>arr</code> es positivo. La función debe devolver un valor booleano.
 </section>
 
 ## Tests
@@ -24,11 +24,11 @@ Use <code>some</code> método dentro de la función <code>checkPositive</code> p
 tests:
   - text: Su código debe utilizar <code>some</code> método.
     testString: 'assert(code.match(/\.some/g), "Your code should use the <code>some</code> method.");'
-  - text: &#39; <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>true</code> .&#39;
+  - text: ' <code>checkPositive([1, 2, 3, -4, 5])</code> debe devolver <code>true</code> .'
     testString: 'assert(checkPositive([1, 2, 3, -4, 5]), "<code>checkPositive([1, 2, 3, -4, 5])</code> should return <code>true</code>.");'
-  - text: &#39; <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .&#39;
+  - text: ' <code>checkPositive([1, 2, 3, 4, 5])</code> debe devolver <code>true</code> .'
     testString: 'assert(checkPositive([1, 2, 3, 4, 5]), "<code>checkPositive([1, 2, 3, 4, 5])</code> should return <code>true</code>.");'
-  - text: &#39; <code>checkPositive([-1, -2, -3, -4, -5])</code> debe devolver <code>false</code> .&#39;
+  - text: ' <code>checkPositive([-1, -2, -3, -4, -5])</code> debe devolver <code>false</code> .'
     testString: 'assert(!checkPositive([-1, -2, -3, -4, -5]), "<code>checkPositive([-1, -2, -3, -4, -5])</code> should return <code>false</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.spanish.md
index fbdc640012..f6a74293c2 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.spanish.md
@@ -8,18 +8,18 @@ guideUrl: 'https://spanish.freecodecamp.org/guide/certificates/arguments-optiona
 ---
 
 ## Description
-<section id='description'> 
-Crea una función que suma dos argumentos juntos. Si solo se proporciona un argumento, entonces devuelva una función que espere un argumento y devuelva la suma. 
-Por ejemplo, <code>addTogether(2, 3)</code> debe devolver <code>5</code> y <code>addTogether(2)</code> debe devolver una función. 
-llamar a esta función devuelta con un solo argumento, se devolverá la suma: 
-<code>var sumTwoAnd = addTogether(2);</code> 
-<code>sumTwoAnd(3)</code> devuelve <code>5</code> . 
-Si cualquiera de los argumentos no es un número válido, devuelva indefinido. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Crea una función que suma dos argumentos juntos. Si solo se proporciona un argumento, entonces devuelva una función que espere un argumento y devuelva la suma.
+Por ejemplo, <code>addTogether(2, 3)</code> debe devolver <code>5</code> y <code>addTogether(2)</code> debe devolver una función.
+llamar a esta función devuelta con un solo argumento, se devolverá la suma:
+<code>var sumTwoAnd = addTogether(2);</code>
+<code>sumTwoAnd(3)</code> devuelve <code>5</code> .
+Si cualquiera de los argumentos no es un número válido, devuelva indefinido.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,15 +28,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>addTogether(2, 3)</code> debe devolver 5.&#39;
+  - text: ' <code>addTogether(2, 3)</code> debe devolver 5.'
     testString: 'assert.deepEqual(addTogether(2, 3), 5, "<code>addTogether(2, 3)</code> should return 5.");'
   - text: <code>addTogether(2)(3)</code> debe devolver 5.
     testString: 'assert.deepEqual(addTogether(2)(3), 5, "<code>addTogether(2)(3)</code> should return 5.");'
-  - text: &#39; <code>addTogether(&quot;http://bit.ly/IqT6zt&quot;)</code> debe devolver undefined.&#39;
+  - text: ' <code>addTogether(&quot;http://bit.ly/IqT6zt&quot;)</code> debe devolver undefined.'
     testString: 'assert.isUndefined(addTogether("http://bit.ly/IqT6zt"), "<code>addTogether("http://bit.ly/IqT6zt")</code> should return undefined.");'
-  - text: &#39; <code>addTogether(2, &quot;3&quot;)</code> debe devolver indefinido.&#39;
+  - text: ' <code>addTogether(2, &quot;3&quot;)</code> debe devolver indefinido.'
     testString: 'assert.isUndefined(addTogether(2, "3"), "<code>addTogether(2, "3")</code> should return undefined.");'
-  - text: &#39; <code>addTogether(2)([3])</code> debe devolver indefinido.&#39;
+  - text: ' <code>addTogether(2)([3])</code> debe devolver indefinido.'
     testString: 'assert.isUndefined(addTogether(2)([3]), "<code>addTogether(2)([3])</code> should return undefined.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.spanish.md
index ac576710cb..dc883f74b8 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devuelve una frase traducida al inglés de la cadena binaria pasada. 
-La cadena binaria estará separada por espacios. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Devuelve una frase traducida al inglés de la cadena binaria pasada.
+La cadena binaria estará separada por espacios.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,7 +23,7 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>binaryAgent(&quot;01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111&quot;)</code> &#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;.
+  - text: ' <code>binaryAgent(&quot;01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111&quot;)</code> &#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; &#39;&#39; '
     testString: 'assert.deepEqual(binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111"), "Aren"t bonfires fun!?", "<code>binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")</code> should return "Aren&#39;t bonfires fun!?"");'
   - text: <code>binaryAgent(&quot;01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001&quot;)</code> 0011.
     testString: 'assert.deepEqual(binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001"), "I love FreeCodeCamp!", "<code>binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")</code> should return "I love FreeCodeCamp!"");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.spanish.md
index 84ec677d66..97c9b5e20f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.spanish.md
@@ -7,13 +7,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Convierta los caracteres <code>&amp;</code> , <code>&lt;</code> , <code>&gt;</code> , <code>&quot;</code> (comillas dobles) y <code>&#39;</code> (apóstrofe), en una cadena a sus entidades HTML correspondientes. 
-Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Intente vincular el programa. Escribe tu propio código. 
+<section id='description'>
+Convierta los caracteres <code>&amp;</code> , <code>&lt;</code> , <code>&gt;</code> , <code>&quot;</code> (comillas dobles) y <code>&#39;</code> (apóstrofe), en una cadena a sus entidades HTML correspondientes.
+Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Intente vincular el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,17 +22,17 @@ Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>convertHTML(&quot;Dolce &amp; Gabbana&quot;)</code> debe devolver <code>Dolce &amp;​amp; Gabbana</code> .
+  - text: ' <code>convertHTML(&quot;Dolce &amp; Gabbana&quot;)</code> debe devolver <code>Dolce &amp;​amp; Gabbana</code> .
     testString: 'assert.match(convertHTML("Dolce & Gabbana"), /Dolce &amp; Gabbana/, "<code>convertHTML("Dolce & Gabbana")</code> should return <code>Dolce &&#8203;amp; Gabbana</code>.");'
-  - text: &#39; <code>convertHTML(&quot;Hamburgers &lt; Pizza &lt; Tacos&quot;)</code> debe devolver <code>Hamburgers &amp;​lt; Pizza &amp;​lt; Tacos</code> .
+  - text: ' <code>convertHTML(&quot;Hamburgers &lt; Pizza &lt; Tacos&quot;)</code> debe devolver <code>Hamburgers &amp;​lt; Pizza &amp;​lt; Tacos</code> .
     testString: 'assert.match(convertHTML("Hamburgers < Pizza < Tacos"), /Hamburgers &lt; Pizza &lt; Tacos/, "<code>convertHTML("Hamburgers < Pizza < Tacos")</code> should return <code>Hamburgers &&#8203;lt; Pizza &&#8203;lt; Tacos</code>.");'
-  - text: &#39; <code>convertHTML(&quot;Sixty &gt; twelve&quot;)</code> debe devolver <code>Sixty &amp;​gt; twelve</code> .
+  - text: ' <code>convertHTML(&quot;Sixty &gt; twelve&quot;)</code> debe devolver <code>Sixty &amp;​gt; twelve</code> .
     testString: 'assert.match(convertHTML("Sixty > twelve"), /Sixty &gt; twelve/, "<code>convertHTML("Sixty > twelve")</code> should return <code>Sixty &&#8203;gt; twelve</code>.");'
-  - text: &#39; <code>convertHTML(&#39;Stuff in &quot;quotation marks&quot;&#39;)</code> debería devolver <code>Stuff in &amp;​quot;quotation marks&amp;​quot;</code> .
+  - text: ' <code>convertHTML(&#39;Stuff in &quot;quotation marks&quot;&#39;)</code> debería devolver <code>Stuff in &amp;​quot;quotation marks&amp;​quot;</code> .
     testString: 'assert.match(convertHTML("Stuff in "quotation marks""), /Stuff in &quot;quotation marks&quot;/, "<code>convertHTML(&apos;Stuff in "quotation marks"&apos;)</code> should return <code>Stuff in &&#8203;quot;quotation marks&&#8203;quot;</code>.");'
-  - text: &#39; <code>convertHTML(&quot;Schindler&#39;s List&quot;)</code> debe devolver la <code>Schindler&amp;​apos;s List</code> .
+  - text: ' <code>convertHTML(&quot;Schindler&#39;s List&quot;)</code> debe devolver la <code>Schindler&amp;​apos;s List</code> .
     testString: 'assert.match(convertHTML("Schindler"s List"), /Schindler&apos;s List/, "<code>convertHTML("Schindler&apos;s List")</code> should return <code>Schindler&&#8203;apos;s List</code>.");'
-  - text: &#39; <code>convertHTML(&quot;&lt;&gt;&quot;)</code> debe devolver <code>&amp;​lt;&amp;​gt;</code> .
+  - text: ' <code>convertHTML(&quot;&lt;&gt;&quot;)</code> debe devolver <code>&amp;​lt;&amp;​gt;</code> .
     testString: 'assert.match(convertHTML("<>"), /&lt;&gt;/, "<code>convertHTML("<>")</code> should return <code>&&#8203;lt;&&#8203;gt;</code>.");'
   - text: <code>convertHTML(&quot;abc&quot;)</code> debe devolver <code>abc</code> .
     testString: 'assert.strictEqual(convertHTML("abc"), "abc", "<code>convertHTML("abc")</code> should return <code>abc</code>.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.spanish.md
index c7ee07d6a0..18085d8c76 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Compare dos arreglos y devuelva un nuevo arreglo con los elementos que solo se encuentran en uno de los dos arreglos dados, pero no en ambos. En otras palabras, devuelva la diferencia simétrica de las dos matrices. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
-<strong>Nota</strong> <br> Puede devolver la matriz con sus elementos en cualquier orden. 
+<section id='description'>
+Compare dos arreglos y devuelva un nuevo arreglo con los elementos que solo se encuentran en uno de los dos arreglos dados, pero no en ambos. En otras palabras, devuelva la diferencia simétrica de las dos matrices.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
+<strong>Nota</strong> <br> Puede devolver la matriz con sus elementos en cualquier orden.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,35 +23,35 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])</code> debe devolver una matriz.&#39;
+  - text: ' <code>diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])</code> debe devolver una matriz.'
     testString: 'assert(typeof diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]) === "object", "<code>diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])</code> should return an array.");'
-  - text: &#39; <code>[&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver <code>[&quot;pink wool&quot;]</code> . &#39;
+  - text: ' <code>[&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver <code>[&quot;pink wool&quot;]</code> . '
     testString: 'assert.sameMembers(diffArray(["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]), ["pink wool"], "<code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return <code>["pink wool"]</code>.");'
-  - text: &#39; <code>[&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debería devolver una matriz con un elemento &#39;.
+  - text: ' <code>[&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debería devolver una matriz con un elemento '
     testString: 'assert(diffArray(["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]).length === 1, "<code>["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return an array with one item.");'
-  - text: &#39; <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver <code>[&quot;diorite&quot;, &quot;pink wool&quot;]</code> .
+  - text: ' <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver <code>[&quot;diorite&quot;, &quot;pink wool&quot;]</code> .
     testString: 'assert.sameMembers(diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]), ["diorite", "pink wool"], "<code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return <code>["diorite", "pink wool"]</code>.");'
-  - text: &#39; <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver una matriz con dos elementos.
+  - text: ' <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;pink wool&quot;, &quot;dead shrub&quot;], [&quot;diorite&quot;, &quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver una matriz con dos elementos.
     testString: 'assert(diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]).length === 2, "<code>["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]</code> should return an array with two items.");'
-  - text: &#39; <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;], [&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver <code>[]</code> .&#39;
+  - text: ' <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;], [&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver <code>[]</code> .'
     testString: 'assert.sameMembers(diffArray(["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]), [], "<code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> should return <code>[]</code>.");'
-  - text: &#39; <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;], [&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver una matriz vacía.&#39;
+  - text: ' <code>[&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;], [&quot;andesite&quot;, &quot;grass&quot;, &quot;dirt&quot;, &quot;dead shrub&quot;]</code> debe devolver una matriz vacía.'
     testString: 'assert(diffArray(["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]).length === 0, "<code>["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]</code> should return an empty array.");'
-  - text: &#39; <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver <code>[4]</code> .&#39;
+  - text: ' <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver <code>[4]</code> .'
     testString: 'assert.sameMembers(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]), [4], "<code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> should return <code>[4]</code>.");'
-  - text: &#39; <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver una matriz con un elemento.&#39;
+  - text: ' <code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> debe devolver una matriz con un elemento.'
     testString: 'assert(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]).length  === 1, "<code>[1, 2, 3, 5], [1, 2, 3, 4, 5]</code> should return an array with one item.");'
-  - text: &#39; <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [1, &quot;calf&quot;, 3, 4]</code> debe devolver <code>[&quot;piglet&quot;, 4]</code> .&#39;
+  - text: ' <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [1, &quot;calf&quot;, 3, 4]</code> debe devolver <code>[&quot;piglet&quot;, 4]</code> .'
     testString: 'assert.sameMembers(diffArray([1, "calf", 3, "piglet"], [1, "calf", 3, 4]), ["piglet", 4], "<code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> should return <code>["piglet", 4]</code>.");'
-  - text: &#39; <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [1, &quot;calf&quot;, 3, 4]</code> debe devolver una matriz con dos elementos.&#39;
+  - text: ' <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [1, &quot;calf&quot;, 3, 4]</code> debe devolver una matriz con dos elementos.'
     testString: 'assert(diffArray([1, "calf", 3, "piglet"], [1, "calf", 3, 4]).length === 2, "<code>[1, "calf", 3, "piglet"], [1, "calf", 3, 4]</code> should return an array with two items.");'
-  - text: &#39; <code>[], [&quot;snuffleupagus&quot;, &quot;cookie monster&quot;, &quot;elmo&quot;]</code> debe devolver <code>[&quot;snuffleupagus&quot;, &quot;cookie monster&quot;, &quot;elmo&quot;]</code> .&#39;
+  - text: ' <code>[], [&quot;snuffleupagus&quot;, &quot;cookie monster&quot;, &quot;elmo&quot;]</code> debe devolver <code>[&quot;snuffleupagus&quot;, &quot;cookie monster&quot;, &quot;elmo&quot;]</code> .'
     testString: 'assert.sameMembers(diffArray([], ["snuffleupagus", "cookie monster", "elmo"]), ["snuffleupagus", "cookie monster", "elmo"], "<code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> should return <code>["snuffleupagus", "cookie monster", "elmo"]</code>.");'
-  - text: &#39; <code>[], [&quot;snuffleupagus&quot;, &quot;cookie monster&quot;, &quot;elmo&quot;]</code> debe devolver una matriz con tres elementos.&#39;
+  - text: ' <code>[], [&quot;snuffleupagus&quot;, &quot;cookie monster&quot;, &quot;elmo&quot;]</code> debe devolver una matriz con tres elementos.'
     testString: 'assert(diffArray([], ["snuffleupagus", "cookie monster", "elmo"]).length === 3, "<code>[], ["snuffleupagus", "cookie monster", "elmo"]</code> should return an array with three items.");'
-  - text: &#39; <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [7, &quot;filly&quot;]</code> debe devolver <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;, 7, &quot;filly&quot;]</code> .&#39;
+  - text: ' <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [7, &quot;filly&quot;]</code> debe devolver <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;, 7, &quot;filly&quot;]</code> .'
     testString: 'assert.sameMembers(diffArray([1, "calf", 3, "piglet"], [7, "filly"]), [1, "calf", 3, "piglet", 7, "filly"], "<code>[1, "calf", 3, "piglet"], [7, "filly"]</code> should return <code>[1, "calf", 3, "piglet", 7, "filly"]</code>.");'
-  - text: &#39; <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [7, &quot;filly&quot;]</code> debe devolver una matriz con seis elementos.&#39;
+  - text: ' <code>[1, &quot;calf&quot;, 3, &quot;piglet&quot;], [7, &quot;filly&quot;]</code> debe devolver una matriz con seis elementos.'
     testString: 'assert(diffArray([1, "calf", 3, "piglet"], [7, "filly"]).length === 6, "<code>[1, "calf", 3, "piglet"], [7, "filly"]</code> should return an array with six items.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.spanish.md
index 6266e808bd..d664f7d523 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.spanish.md
@@ -7,17 +7,17 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-A la cadena de ADN le falta el elemento de emparejamiento. Tome cada carácter, obtenga su par y devuelva los resultados como una matriz 2d. 
-<a href="http://en.wikipedia.org/wiki/Base_pair" target="_blank">pares de bases</a> son un par de AT y CG. Empareja el elemento que falta con el carácter proporcionado. 
-Devuelve el carácter proporcionado como el primer elemento en cada matriz. 
-Por ejemplo, para la entrada GCG, devuelva [[&quot;G&quot;, &quot;C&quot;], [&quot;C&quot;, &quot;G&quot;], [&quot;G&quot;, &quot;C&quot;]] 
-El carácter y su par están emparejados en una matriz, y todas las matrices se agrupan en una matriz de encapsulación. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+A la cadena de ADN le falta el elemento de emparejamiento. Tome cada carácter, obtenga su par y devuelva los resultados como una matriz 2d.
+<a href="http://en.wikipedia.org/wiki/Base_pair" target="_blank">pares de bases</a> son un par de AT y CG. Empareja el elemento que falta con el carácter proporcionado.
+Devuelve el carácter proporcionado como el primer elemento en cada matriz.
+Por ejemplo, para la entrada GCG, devuelva [[&quot;G&quot;, &quot;C&quot;], [&quot;C&quot;, &quot;G&quot;], [&quot;G&quot;, &quot;C&quot;]]
+El carácter y su par están emparejados en una matriz, y todas las matrices se agrupan en una matriz de encapsulación.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -26,11 +26,11 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>pairElement(&quot;ATCGA&quot;)</code> debe devolver <code>[[&quot;A&quot;,&quot;T&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;C&quot;,&quot;G&quot;],[&quot;G&quot;,&quot;C&quot;],[&quot;A&quot;,&quot;T&quot;]]</code> . &#39;
+  - text: ' <code>pairElement(&quot;ATCGA&quot;)</code> debe devolver <code>[[&quot;A&quot;,&quot;T&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;C&quot;,&quot;G&quot;],[&quot;G&quot;,&quot;C&quot;],[&quot;A&quot;,&quot;T&quot;]]</code> . '
     testString: 'assert.deepEqual(pairElement("ATCGA"),[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]], "<code>pairElement("ATCGA")</code> should return <code>[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]</code>.");'
-  - text: &#39; <code>pairElement(&quot;TTGAG&quot;)</code> debe devolver <code>[[&quot;T&quot;,&quot;A&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;G&quot;,&quot;C&quot;],[&quot;A&quot;,&quot;T&quot;],[&quot;G&quot;,&quot;C&quot;]]</code> . &#39;
+  - text: ' <code>pairElement(&quot;TTGAG&quot;)</code> debe devolver <code>[[&quot;T&quot;,&quot;A&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;G&quot;,&quot;C&quot;],[&quot;A&quot;,&quot;T&quot;],[&quot;G&quot;,&quot;C&quot;]]</code> . '
     testString: 'assert.deepEqual(pairElement("TTGAG"),[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]], "<code>pairElement("TTGAG")</code> should return <code>[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]</code>.");'
-  - text: &#39; <code>pairElement(&quot;CTCTA&quot;)</code> debe devolver <code>[[&quot;C&quot;,&quot;G&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;C&quot;,&quot;G&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;A&quot;,&quot;T&quot;]]</code> . &#39;
+  - text: ' <code>pairElement(&quot;CTCTA&quot;)</code> debe devolver <code>[[&quot;C&quot;,&quot;G&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;C&quot;,&quot;G&quot;],[&quot;T&quot;,&quot;A&quot;],[&quot;A&quot;,&quot;T&quot;]]</code> . '
     testString: 'assert.deepEqual(pairElement("CTCTA"),[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]], "<code>pairElement("CTCTA")</code> should return <code>[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.spanish.md
index cf2f9c1c09..80a85223ce 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Dado la matriz <code>arr</code> , iterar a través y eliminar cada elemento comenzando desde el primer elemento (el índice 0) hasta que la función <code>func</code> devuelva <code>true</code> cuando el elemento iterado se pasa a través de él. 
-Luego, devuelva el resto de la matriz una vez que se cumpla la condición; de lo contrario, <code>arr</code> debe devolverse como una matriz vacía. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Dado la matriz <code>arr</code> , iterar a través y eliminar cada elemento comenzando desde el primer elemento (el índice 0) hasta que la función <code>func</code> devuelva <code>true</code> cuando el elemento iterado se pasa a través de él.
+Luego, devuelva el resto de la matriz una vez que se cumpla la condición; de lo contrario, <code>arr</code> debe devolverse como una matriz vacía.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,17 +23,17 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>dropElements([1, 2, 3, 4], function(n) {return n &gt;= 3;})</code> debe devolver <code>[3, 4]</code> .&#39;
+  - text: ' <code>dropElements([1, 2, 3, 4], function(n) {return n &gt;= 3;})</code> debe devolver <code>[3, 4]</code> .'
     testString: 'assert.deepEqual(dropElements([1, 2, 3, 4], function(n) {return n >= 3;}), [3, 4], "<code>dropElements([1, 2, 3, 4], function(n) {return n >= 3;})</code> should return <code>[3, 4]</code>.");'
-  - text: &#39; <code>dropElements([0, 1, 0, 1], function(n) {return n === 1;})</code> debe devolver <code>[1, 0, 1]</code> .&#39;
+  - text: ' <code>dropElements([0, 1, 0, 1], function(n) {return n === 1;})</code> debe devolver <code>[1, 0, 1]</code> .'
     testString: 'assert.deepEqual(dropElements([0, 1, 0, 1], function(n) {return n === 1;}), [1, 0, 1], "<code>dropElements([0, 1, 0, 1], function(n) {return n === 1;})</code> should return <code>[1, 0, 1]</code>.");'
-  - text: &#39; <code>dropElements([1, 2, 3], function(n) {return n &gt; 0;})</code> debe devolver <code>[1, 2, 3]</code> .&#39;
+  - text: ' <code>dropElements([1, 2, 3], function(n) {return n &gt; 0;})</code> debe devolver <code>[1, 2, 3]</code> .'
     testString: 'assert.deepEqual(dropElements([1, 2, 3], function(n) {return n > 0;}), [1, 2, 3], "<code>dropElements([1, 2, 3], function(n) {return n > 0;})</code> should return <code>[1, 2, 3]</code>.");'
-  - text: &#39; <code>dropElements([1, 2, 3, 4], function(n) {return n &gt; 5;})</code> debe devolver <code>[]</code> .&#39;
+  - text: ' <code>dropElements([1, 2, 3, 4], function(n) {return n &gt; 5;})</code> debe devolver <code>[]</code> .'
     testString: 'assert.deepEqual(dropElements([1, 2, 3, 4], function(n) {return n > 5;}), [], "<code>dropElements([1, 2, 3, 4], function(n) {return n > 5;})</code> should return <code>[]</code>.");'
-  - text: &#39; <code>dropElements([1, 2, 3, 7, 4], function(n) {return n &gt; 3;})</code> debe devolver <code>[7, 4]</code> .&#39;
+  - text: ' <code>dropElements([1, 2, 3, 7, 4], function(n) {return n &gt; 3;})</code> debe devolver <code>[7, 4]</code> .'
     testString: 'assert.deepEqual(dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;}), [7, 4], "<code>dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})</code> should return <code>[7, 4]</code>.");'
-  - text: &#39; <code>dropElements([1, 2, 3, 9, 2], function(n) {return n &gt; 2;})</code> debe devolver <code>[3, 9, 2]</code> .&#39;
+  - text: ' <code>dropElements([1, 2, 3, 9, 2], function(n) {return n &gt; 2;})</code> debe devolver <code>[3, 9, 2]</code> .'
     testString: 'assert.deepEqual(dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;}), [3, 9, 2], "<code>dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})</code> should return <code>[3, 9, 2]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.spanish.md
index 1f6a739cc9..413c8882f4 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.spanish.md
@@ -7,48 +7,51 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Compruebe si el predicado (segundo argumento) es <dfn>verdadero</dfn> en todos los elementos de una colección (primer argumento). 
-En otras palabras, se le da una colección de objetos de matriz. El predicado <code>pre</code> será una propiedad de objeto y debe devolver <code>true</code> si su valor es <code>truthy</code> . De lo contrario, devuelve <code>false</code> . 
-En JavaScript, los valores de <code>truthy</code> son valores que se convierten en <code>true</code> cuando se evalúan en un contexto booleano. 
-Recuerde, puede acceder a las propiedades del objeto a través de la notación de puntos o la notación de <code>[]</code> . 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+
+<section id='description'>
+Compruebe si el predicado (segundo argumento) es <dfn>verdadero</dfn> en todos los elementos de una colección (primer argumento).
+En otras palabras, se le da una colección de objetos de matriz. El predicado <code>pre</code> será una propiedad de objeto y debe devolver <code>true</code> si su valor es <code>truthy</code> . De lo contrario, devuelve <code>false</code> .
+En JavaScript, los valores de <code>truthy</code> son valores que se convierten en <code>true</code> cuando se evalúan en un contexto booleano.
+Recuerde, puede acceder a las propiedades del objeto a través de la notación de puntos o la notación de <code>[]</code> .
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+
+<section id='instructions'>
 
 </section>
 
 ## Tests
+
 <section id='tests'>
 
 ```yml
 tests:
-  - text: &#39; <code>truthCheck([{&quot;user&quot;: &quot;Tinky-Winky&quot;, &quot;sex&quot;: &quot;male&quot;}, {&quot;user&quot;: &quot;Dipsy&quot;, &quot;sex&quot;: &quot;male&quot;}, {&quot;user&quot;: &quot;Laa-Laa&quot;, &quot;sex&quot;: &quot;female&quot;}, {&quot;user&quot;: &quot;Po&quot;, &quot;sex&quot;: &quot;female&quot;}], &quot;sex&quot;)</code> debe devolver el valor&quot;.
+  - text: ' <code>truthCheck([{&quot;user&quot;: &quot;Tinky-Winky&quot;, &quot;sex&quot;: &quot;male&quot;}, {&quot;user&quot;: &quot;Dipsy&quot;, &quot;sex&quot;: &quot;male&quot;}, {&quot;user&quot;: &quot;Laa-Laa&quot;, &quot;sex&quot;: &quot;female&quot;}, {&quot;user&quot;: &quot;Po&quot;, &quot;sex&quot;: &quot;female&quot;}], &quot;sex&quot;)</code> debe devolver el valor&quot;.'
     testString: 'assert.strictEqual(truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"), true, "<code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> should return true.");'
-  - text: &#39; <code>truthCheck([{&quot;user&quot;: &quot;Tinky-Winky&quot;, &quot;sex&quot;: &quot;male&quot;}, {&quot;user&quot;: &quot;Dipsy&quot;}, {&quot;user&quot;: &quot;Laa-Laa&quot;, &quot;sex&quot;: &quot;female&quot;}, {&quot;user&quot;: &quot;Po&quot;, &quot;sex&quot;: &quot;female&quot;}], &quot;sex&quot;)</code> debe devolver falso.
+  - text: ' <code>truthCheck([{&quot;user&quot;: &quot;Tinky-Winky&quot;, &quot;sex&quot;: &quot;male&quot;}, {&quot;user&quot;: &quot;Dipsy&quot;}, {&quot;user&quot;: &quot;Laa-Laa&quot;, &quot;sex&quot;: &quot;female&quot;}, {&quot;user&quot;: &quot;Po&quot;, &quot;sex&quot;: &quot;female&quot;}], &quot;sex&quot;)</code> debe devolver falso.'
     testString: 'assert.strictEqual(truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"), false, "<code>truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")</code> should return false.");'
-  - text: &#39; <code>truthCheck([{&quot;user&quot;: &quot;Tinky-Winky&quot;, &quot;sex&quot;: &quot;male&quot;, &quot;age&quot;: 0}, {&quot;user&quot;: &quot;Dipsy&quot;, &quot;sex&quot;: &quot;male&quot;, &quot;age&quot;: 3}, {&quot;user&quot;: &quot;Laa-Laa&quot;, &quot;sex&quot;: &quot;female&quot;, &quot;age&quot;: 5}, {&quot;user&quot;: &quot;Po&quot;, &quot;sex&quot;: &quot;female&quot;, &quot;age&quot;: 4}], &quot;age&quot;)</code> debe devolver falso.
+  - text: ' <code>truthCheck([{&quot;user&quot;: &quot;Tinky-Winky&quot;, &quot;sex&quot;: &quot;male&quot;, &quot;age&quot;: 0}, {&quot;user&quot;: &quot;Dipsy&quot;, &quot;sex&quot;: &quot;male&quot;, &quot;age&quot;: 3}, {&quot;user&quot;: &quot;Laa-Laa&quot;, &quot;sex&quot;: &quot;female&quot;, &quot;age&quot;: 5}, {&quot;user&quot;: &quot;Po&quot;, &quot;sex&quot;: &quot;female&quot;, &quot;age&quot;: 4}], &quot;age&quot;)</code> debe devolver falso.'
     testString: 'assert.strictEqual(truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 2}, {"user": "Dipsy", "sex": "male", "age": 0}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age"), false, "<code>truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")</code> should return false.");'
-  - text: &#39; <code>truthCheck([{&quot;name&quot;: &quot;Pete&quot;, &quot;onBoat&quot;: true}, {&quot;name&quot;: &quot;Repeat&quot;, &quot;onBoat&quot;: true}, {&quot;name&quot;: &quot;FastFoward&quot;, &quot;onBoat&quot;: null}], &quot;onBoat&quot;)</code> debe devolver falso &#39;
+  - text: ' <code>truthCheck([{&quot;name&quot;: &quot;Pete&quot;, &quot;onBoat&quot;: true}, {&quot;name&quot;: &quot;Repeat&quot;, &quot;onBoat&quot;: true}, {&quot;name&quot;: &quot;FastFoward&quot;, &quot;onBoat&quot;: null}], &quot;onBoat&quot;)</code> debe devolver falso '
     testString: 'assert.strictEqual(truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat"), false, "<code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat")</code> should return false");'
-  - text: &#39; <code>truthCheck([{&quot;name&quot;: &quot;Pete&quot;, &quot;onBoat&quot;: true}, {&quot;name&quot;: &quot;Repeat&quot;, &quot;onBoat&quot;: true, &quot;alias&quot;: &quot;Repete&quot;}, {&quot;name&quot;: &quot;FastFoward&quot;, &quot;onBoat&quot;: true}], &quot;onBoat&quot;)</code> debe devolver true &#39;
+  - text: ' <code>truthCheck([{&quot;name&quot;: &quot;Pete&quot;, &quot;onBoat&quot;: true}, {&quot;name&quot;: &quot;Repeat&quot;, &quot;onBoat&quot;: true, &quot;alias&quot;: &quot;Repete&quot;}, {&quot;name&quot;: &quot;FastFoward&quot;, &quot;onBoat&quot;: true}], &quot;onBoat&quot;)</code> debe devolver true '
     testString: 'assert.strictEqual(truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat"), true, "<code>truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat")</code> should return true");'
-  - text: &#39; <code>truthCheck([{&quot;single&quot;: &quot;yes&quot;}], &quot;single&quot;)</code> debe devolver verdadero&#39;
+  - text: ' <code>truthCheck([{&quot;single&quot;: &quot;yes&quot;}], &quot;single&quot;)</code> debe devolver verdadero'
     testString: 'assert.strictEqual(truthCheck([{"single": "yes"}], "single"), true, "<code>truthCheck([{"single": "yes"}], "single")</code> should return true");'
-  - text: &#39; <code>truthCheck([{&quot;single&quot;: &quot;&quot;}, {&quot;single&quot;: &quot;double&quot;}], &quot;single&quot;)</code> debe devolver falso&#39;
+  - text: ' <code>truthCheck([{&quot;single&quot;: &quot;&quot;}, {&quot;single&quot;: &quot;double&quot;}], &quot;single&quot;)</code> debe devolver falso'
     testString: 'assert.strictEqual(truthCheck([{"single": ""}, {"single": "double"}], "single"), false, "<code>truthCheck([{"single": ""}, {"single": "double"}], "single")</code> should return false");'
-  - text: &#39; <code>truthCheck([{&quot;single&quot;: &quot;double&quot;}, {&quot;single&quot;: undefined}], &quot;single&quot;)</code> debe devolver falso&#39;
+  - text: ' <code>truthCheck([{&quot;single&quot;: &quot;double&quot;}, {&quot;single&quot;: undefined}], &quot;single&quot;)</code> debe devolver falso'
     testString: 'assert.strictEqual(truthCheck([{"single": "double"}, {"single": undefined}], "single"), false, "<code>truthCheck([{"single": "double"}, {"single": undefined}], "single")</code> should return false");'
-  - text: &#39; <code>truthCheck([{&quot;single&quot;: &quot;double&quot;}, {&quot;single&quot;: NaN}], &quot;single&quot;)</code> debe devolver falso&#39;
+  - text: ' <code>truthCheck([{&quot;single&quot;: &quot;double&quot;}, {&quot;single&quot;: NaN}], &quot;single&quot;)</code> debe devolver falso'
     testString: 'assert.strictEqual(truthCheck([{"single": "double"}, {"single": NaN}], "single"), false, "<code>truthCheck([{"single": "double"}, {"single": NaN}], "single")</code> should return false");'
-
 ```
 
 </section>
 
 ## Challenge Seed
+
 <section id='challengeSeed'>
 
 <div id='js-seed'>
@@ -59,23 +62,31 @@ function truthCheck(collection, pre) {
   return pre;
 }
 
-truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
+truthCheck(
+  [
+    { user: 'Tinky-Winky', sex: 'male' },
+    { user: 'Dipsy', sex: 'male' },
+    { user: 'Laa-Laa', sex: 'female' },
+    { user: 'Po', sex: 'female' }
+  ],
+  'sex'
+);
 ```
 
 </div>
 
-
-
 </section>
 
 ## Solution
-<section id='solution'>
 
+<section id='solution'>
 
 ```js
 function truthCheck(collection, pre) {
   // Does everyone have one of these?
-  return collection.every(function(e) { return e[pre]; });
+  return collection.every(function(e) {
+    return e[pre];
+  });
 }
 ```
 
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.spanish.md
index e578393b83..c47ed93ccb 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.spanish.md
@@ -6,17 +6,17 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devuelve una nueva matriz que transforma la altitud promedio de los elementos en sus períodos orbitales (en segundos). 
-La matriz contendrá objetos en el formato <code>{name: &#39;name&#39;, avgAlt: avgAlt}</code> . 
-Puedes leer sobre periodos orbitales <a href="http://en.wikipedia.org/wiki/Orbital_period" target='_blank'>en Wikipedia</a> . 
-Los valores deben redondearse al número entero más cercano. El cuerpo que está siendo orbitado es la Tierra. 
-El radio de la Tierra es 6367.4447 kilómetros, y el valor GM de la Tierra es 398600.4418 km <sup>3</sup> s <sup>-2</sup> . 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Devuelve una nueva matriz que transforma la altitud promedio de los elementos en sus períodos orbitales (en segundos).
+La matriz contendrá objetos en el formato <code>{name: &#39;name&#39;, avgAlt: avgAlt}</code> .
+Puedes leer sobre periodos orbitales <a href="http://en.wikipedia.org/wiki/Orbital_period" target='_blank'>en Wikipedia</a> .
+Los valores deben redondearse al número entero más cercano. El cuerpo que está siendo orbitado es la Tierra.
+El radio de la Tierra es 6367.4447 kilómetros, y el valor GM de la Tierra es 398600.4418 km <sup>3</sup> s <sup>-2</sup> .
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,9 +25,9 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>orbitalPeriod([{name : &quot;sputnik&quot;, avgAlt : 35873.5553}])</code> debe devolver <code>[{name: &quot;sputnik&quot;, orbitalPeriod: 86400}]</code> .&#39;
+  - text: ' <code>orbitalPeriod([{name : &quot;sputnik&quot;, avgAlt : 35873.5553}])</code> debe devolver <code>[{name: &quot;sputnik&quot;, orbitalPeriod: 86400}]</code> .'
     testString: 'assert.deepEqual(orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]), [{name: "sputnik", orbitalPeriod: 86400}], "<code>orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])</code> should return <code>[{name: "sputnik", orbitalPeriod: 86400}]</code>.");'
-  - text: &#39; <code>orbitalPeriod([{name: &quot;iss&quot;, avgAlt: 413.6}, {name: &quot;hubble&quot;, avgAlt: 556.7}, {name: &quot;moon&quot;, avgAlt: 378632.553}])</code> debe devolver <code>[{name : &quot;iss&quot;, orbitalPeriod: 5557}, {name: &quot;hubble&quot;, orbitalPeriod: 5734}, {name: &quot;moon&quot;, orbitalPeriod: 2377399}]</code> . &#39;
+  - text: ' <code>orbitalPeriod([{name: &quot;iss&quot;, avgAlt: 413.6}, {name: &quot;hubble&quot;, avgAlt: 556.7}, {name: &quot;moon&quot;, avgAlt: 378632.553}])</code> debe devolver <code>[{name : &quot;iss&quot;, orbitalPeriod: 5557}, {name: &quot;hubble&quot;, orbitalPeriod: 5734}, {name: &quot;moon&quot;, orbitalPeriod: 2377399}]</code> . '
     testString: 'assert.deepEqual(orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}]), [{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}], "<code>orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])</code> should return <code>[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.spanish.md
index 9e2ac1e04d..e5bfb8cbb9 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.spanish.md
@@ -7,17 +7,17 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Realice una búsqueda y reemplace la oración usando los argumentos proporcionados y devuelva la nueva oración. 
-primer argumento es la oración para realizar la búsqueda y reemplazar. 
-Segundo argumento es la palabra que reemplazará (antes). 
-Tercer argumento es con lo que reemplazará el segundo argumento por (después). 
-<strong>Nota</strong> <br> Conserve el caso del primer carácter en la palabra original cuando lo reemplace. Por ejemplo, si quiere reemplazar la palabra &quot;Libro&quot; con la palabra &quot;perro&quot;, debe ser reemplazada como &quot;Perro&quot; 
-Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Realice una búsqueda y reemplace la oración usando los argumentos proporcionados y devuelva la nueva oración.
+primer argumento es la oración para realizar la búsqueda y reemplazar.
+Segundo argumento es la palabra que reemplazará (antes).
+Tercer argumento es con lo que reemplazará el segundo argumento por (después).
+<strong>Nota</strong> <br> Conserve el caso del primer carácter en la palabra original cuando lo reemplace. Por ejemplo, si quiere reemplazar la palabra &quot;Libro&quot; con la palabra &quot;perro&quot;, debe ser reemplazada como &quot;Perro&quot;
+Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si se atasca. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -26,15 +26,15 @@ Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>myReplace(&quot;Let us go to the store&quot;, &quot;store&quot;, &quot;mall&quot;)</code> debe devolver &quot;Vamos <code>myReplace(&quot;Let us go to the store&quot;, &quot;store&quot;, &quot;mall&quot;)</code> &quot;.&#39;
+  - text: ' <code>myReplace(&quot;Let us go to the store&quot;, &quot;store&quot;, &quot;mall&quot;)</code> debe devolver &quot;Vamos <code>myReplace(&quot;Let us go to the store&quot;, &quot;store&quot;, &quot;mall&quot;)</code> &quot;.'
     testString: 'assert.deepEqual(myReplace("Let us go to the store", "store", "mall"), "Let us go to the mall", "<code>myReplace("Let us go to the store", "store", "mall")</code> should return "Let us go to the mall".");'
-  - text: &#39; <code>myReplace(&quot;He is Sleeping on the couch&quot;, &quot;Sleeping&quot;, &quot;sitting&quot;)</code> debe devolver &quot;Está sentado en el sofá&quot;.
+  - text: ' <code>myReplace(&quot;He is Sleeping on the couch&quot;, &quot;Sleeping&quot;, &quot;sitting&quot;)</code> debe devolver &quot;Está sentado en el sofá&quot;.
     testString: 'assert.deepEqual(myReplace("He is Sleeping on the couch", "Sleeping", "sitting"), "He is Sitting on the couch", "<code>myReplace("He is Sleeping on the couch", "Sleeping", "sitting")</code> should return "He is Sitting on the couch".");'
-  - text: &#39; <code>myReplace(&quot;This has a spellngi error&quot;, &quot;spellngi&quot;, &quot;spelling&quot;)</code> debe devolver &quot;Esto tiene un error de ortografía&quot;.&#39;
+  - text: ' <code>myReplace(&quot;This has a spellngi error&quot;, &quot;spellngi&quot;, &quot;spelling&quot;)</code> debe devolver &quot;Esto tiene un error de ortografía&quot;.'
     testString: 'assert.deepEqual(myReplace("This has a spellngi error", "spellngi", "spelling"), "This has a spelling error", "<code>myReplace("This has a spellngi error", "spellngi", "spelling")</code> should return "This has a spelling error".");'
-  - text: &#39; <code>myReplace(&quot;His name is Tom&quot;, &quot;Tom&quot;, &quot;john&quot;)</code> debe devolver &quot;Su nombre es John&quot;.
+  - text: ' <code>myReplace(&quot;His name is Tom&quot;, &quot;Tom&quot;, &quot;john&quot;)</code> debe devolver &quot;Su nombre es John&quot;.
     testString: 'assert.deepEqual(myReplace("His name is Tom", "Tom", "john"), "His name is John", "<code>myReplace("His name is Tom", "Tom", "john")</code> should return "His name is John".");'
-  - text: &#39; <code>myReplace(&quot;Let us get back to more Coding&quot;, &quot;Coding&quot;, &quot;algorithms&quot;)</code> debería devolver &quot;Regresemos a más Algoritmos&quot;.
+  - text: ' <code>myReplace(&quot;Let us get back to more Coding&quot;, &quot;Coding&quot;, &quot;algorithms&quot;)</code> debería devolver &quot;Regresemos a más Algoritmos&quot;.
     testString: 'assert.deepEqual(myReplace("Let us get back to more Coding", "Coding", "algorithms"), "Let us get back to more Algorithms", "<code>myReplace("Let us get back to more Coding", "Coding", "algorithms")</code> should return "Let us get back to more Algorithms".");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.spanish.md
index 9e3553f221..deabf7c5b9 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Se le proporcionará una matriz inicial (el primer argumento en la función del destructor), seguido de uno o más argumentos. Elimine todos los elementos de la matriz inicial que tengan el mismo valor que estos argumentos. 
-<strong>Nota</strong> <br> Tienes que usar el objeto <code>arguments</code> . 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Se le proporcionará una matriz inicial (el primer argumento en la función del destructor), seguido de uno o más argumentos. Elimine todos los elementos de la matriz inicial que tengan el mismo valor que estos argumentos.
+<strong>Nota</strong> <br> Tienes que usar el objeto <code>arguments</code> .
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,17 +23,17 @@ Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>destroyer([1, 2, 3, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 1]</code> .&#39;
+  - text: ' <code>destroyer([1, 2, 3, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 1]</code> .'
     testString: 'assert.deepEqual(destroyer([1, 2, 3, 1, 2, 3], 2, 3), [1, 1], "<code>destroyer([1, 2, 3, 1, 2, 3], 2, 3)</code> should return <code>[1, 1]</code>.");'
-  - text: &#39; <code>destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 5, 1]</code> .&#39;
+  - text: ' <code>destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)</code> debe devolver <code>[1, 5, 1]</code> .'
     testString: 'assert.deepEqual(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3), [1, 5, 1], "<code>destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)</code> should return <code>[1, 5, 1]</code>.");'
-  - text: &#39; <code>destroyer([3, 5, 1, 2, 2], 2, 3, 5)</code> debe devolver <code>[1]</code> .&#39;
+  - text: ' <code>destroyer([3, 5, 1, 2, 2], 2, 3, 5)</code> debe devolver <code>[1]</code> .'
     testString: 'assert.deepEqual(destroyer([3, 5, 1, 2, 2], 2, 3, 5), [1], "<code>destroyer([3, 5, 1, 2, 2], 2, 3, 5)</code> should return <code>[1]</code>.");'
-  - text: &#39; <code>destroyer([2, 3, 2, 3], 2, 3)</code> debe devolver <code>[]</code> .&#39;
+  - text: ' <code>destroyer([2, 3, 2, 3], 2, 3)</code> debe devolver <code>[]</code> .'
     testString: 'assert.deepEqual(destroyer([2, 3, 2, 3], 2, 3), [], "<code>destroyer([2, 3, 2, 3], 2, 3)</code> should return <code>[]</code>.");'
-  - text: &#39; <code>destroyer([&quot;tree&quot;, &quot;hamburger&quot;, 53], &quot;tree&quot;, 53)</code> debe devolver <code>[&quot;hamburger&quot;]</code> .&#39;
+  - text: ' <code>destroyer([&quot;tree&quot;, &quot;hamburger&quot;, 53], &quot;tree&quot;, 53)</code> debe devolver <code>[&quot;hamburger&quot;]</code> .'
     testString: 'assert.deepEqual(destroyer(["tree", "hamburger", 53], "tree", 53), ["hamburger"], "<code>destroyer(["tree", "hamburger", 53], "tree", 53)</code> should return <code>["hamburger"]</code>.");'
-  - text: &#39; <code>destroyer([&quot;possum&quot;, &quot;trollo&quot;, 12, &quot;safari&quot;, &quot;hotdog&quot;, 92, 65, &quot;grandma&quot;, &quot;bugati&quot;, &quot;trojan&quot;, &quot;yacht&quot;], &quot;yacht&quot;, &quot;possum&quot;, &quot;trollo&quot;, &quot;safari&quot;, &quot;hotdog&quot;, &quot;grandma&quot;, &quot;bugati&quot;, &quot;trojan&quot;)</code> debe devolver <code>[12,92,65]</code> . &#39;
+  - text: ' <code>destroyer([&quot;possum&quot;, &quot;trollo&quot;, 12, &quot;safari&quot;, &quot;hotdog&quot;, 92, 65, &quot;grandma&quot;, &quot;bugati&quot;, &quot;trojan&quot;, &quot;yacht&quot;], &quot;yacht&quot;, &quot;possum&quot;, &quot;trollo&quot;, &quot;safari&quot;, &quot;hotdog&quot;, &quot;grandma&quot;, &quot;bugati&quot;, &quot;trojan&quot;)</code> debe devolver <code>[12,92,65]</code> . '
     testString: 'assert.deepEqual(destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan"), [12,92,65], "<code>destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")</code> should return <code>[12,92,65]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.spanish.md
index 1ab72a14ad..0e574b8a80 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.spanish.md
@@ -7,15 +7,15 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Encuentre el múltiplo común más pequeño de los parámetros provistos que pueden dividirse de manera uniforme por ambos, así como por todos los números secuenciales en el rango entre estos parámetros. 
-El rango será una matriz de dos números que no necesariamente estarán en orden numérico. 
-Por ejemplo, si se proporciona 1 y 3, encuentre el mínimo común múltiplo de 1 y 3 que también es divisible por todos los números <em>entre</em> 1 y 3. La respuesta aquí sería 6. 
-Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si te quedas atascado Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Encuentre el múltiplo común más pequeño de los parámetros provistos que pueden dividirse de manera uniforme por ambos, así como por todos los números secuenciales en el rango entre estos parámetros.
+El rango será una matriz de dos números que no necesariamente estarán en orden numérico.
+Por ejemplo, si se proporciona 1 y 3, encuentre el mínimo común múltiplo de 1 y 3 que también es divisible por todos los números <em>entre</em> 1 y 3. La respuesta aquí sería 6.
+Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Lectura-Búsqueda-Preguntar</a> si te quedas atascado Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,17 +24,17 @@ Recuerde usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>smallestCommons([1, 5])</code> debe devolver un número.&#39;
+  - text: ' <code>smallestCommons([1, 5])</code> debe devolver un número.'
     testString: 'assert.deepEqual(typeof smallestCommons([1, 5]), "number", "<code>smallestCommons([1, 5])</code> should return a number.");'
-  - text: &#39; <code>smallestCommons([1, 5])</code> debe devolver 60.&#39;
+  - text: ' <code>smallestCommons([1, 5])</code> debe devolver 60.'
     testString: 'assert.deepEqual(smallestCommons([1, 5]), 60, "<code>smallestCommons([1, 5])</code> should return 60.");'
-  - text: &#39; <code>smallestCommons([5, 1])</code> debe devolver 60.&#39;
+  - text: ' <code>smallestCommons([5, 1])</code> debe devolver 60.'
     testString: 'assert.deepEqual(smallestCommons([5, 1]), 60, "<code>smallestCommons([5, 1])</code> should return 60.");'
-  - text: &#39; <code>smallestCommons([2, 10])</code> debe devolver 2520.&#39;
+  - text: ' <code>smallestCommons([2, 10])</code> debe devolver 2520.'
     testString: 'assert.deepEqual(smallestCommons([2, 10]), 2520, "<code>smallestCommons([2, 10])</code> should return 2520.");'
-  - text: &#39; <code>smallestCommons([1, 13])</code> debe devolver 360360.&#39;
+  - text: ' <code>smallestCommons([1, 13])</code> debe devolver 360360.'
     testString: 'assert.deepEqual(smallestCommons([1, 13]), 360360, "<code>smallestCommons([1, 13])</code> should return 360360.");'
-  - text: &#39; <code>smallestCommons([23, 18])</code> debe devolver 6056820.&#39;
+  - text: ' <code>smallestCommons([23, 18])</code> debe devolver 6056820.'
     testString: 'assert.deepEqual(smallestCommons([23, 18]), 6056820, "<code>smallestCommons([23, 18])</code> should return 6056820.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.spanish.md
index d9026c9bfc..4d44516a01 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.spanish.md
@@ -7,16 +7,16 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Escriba una función que tome dos o más matrices y devuelva una nueva matriz de valores únicos en el orden de las matrices proporcionadas originales. 
-En otras palabras, todos los valores presentes de todas las matrices deben incluirse en su orden original, pero sin duplicados en la matriz final. 
-Los números únicos deben ordenarse según su orden original, pero la matriz final no debe ordenarse en orden numérico. 
-Verifique las pruebas de aserción para ver ejemplos. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Escriba una función que tome dos o más matrices y devuelva una nueva matriz de valores únicos en el orden de las matrices proporcionadas originales.
+En otras palabras, todos los valores presentes de todas las matrices deben incluirse en su orden original, pero sin duplicados en la matriz final.
+Los números únicos deben ordenarse según su orden original, pero la matriz final no debe ordenarse en orden numérico.
+Verifique las pruebas de aserción para ver ejemplos.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,13 +25,13 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])</code> debe devolver <code>[1, 3, 2, 5, 4]</code> .&#39;
+  - text: ' <code>uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])</code> debe devolver <code>[1, 3, 2, 5, 4]</code> .'
     testString: 'assert.deepEqual(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]), [1, 3, 2, 5, 4], "<code>uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])</code> should return <code>[1, 3, 2, 5, 4]</code>.");'
-  - text: &#39; <code>uniteUnique([1, 3, 2], [1, [5]], [2, [4]])</code> debe devolver <code>[1, 3, 2, [5], [4]]</code> .&#39;
+  - text: ' <code>uniteUnique([1, 3, 2], [1, [5]], [2, [4]])</code> debe devolver <code>[1, 3, 2, [5], [4]]</code> .'
     testString: 'assert.deepEqual(uniteUnique([1, 3, 2], [1, [5]], [2, [4]]), [1, 3, 2, [5], [4]], "<code>uniteUnique([1, 3, 2], [1, [5]], [2, [4]])</code> should return <code>[1, 3, 2, [5], [4]]</code>.");'
-  - text: &#39; <code>uniteUnique([1, 2, 3], [5, 2, 1])</code> debe devolver <code>[1, 2, 3, 5]</code> .&#39;
+  - text: ' <code>uniteUnique([1, 2, 3], [5, 2, 1])</code> debe devolver <code>[1, 2, 3, 5]</code> .'
     testString: 'assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1]), [1, 2, 3, 5], "<code>uniteUnique([1, 2, 3], [5, 2, 1])</code> should return <code>[1, 2, 3, 5]</code>.");'
-  - text: &#39; <code>uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])</code> debe devolver <code>[1, 2, 3, 5, 4, 6, 7, 8]</code> .
+  - text: ' <code>uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])</code> debe devolver <code>[1, 2, 3, 5, 4, 6, 7, 8]</code> .
     testString: 'assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]), [1, 2, 3, 5, 4, 6, 7, 8], "<code>uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])</code> should return <code>[1, 2, 3, 5, 4, 6, 7, 8]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.spanish.md
index fae59d64bc..a8edf0959f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.spanish.md
@@ -7,13 +7,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Aplanar una matriz anidada. Debe tener en cuenta los diferentes niveles de anidación. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Aplanar una matriz anidada. Debe tener en cuenta los diferentes niveles de anidación.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,13 +22,13 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>steamrollArray([[[&quot;a&quot;]], [[&quot;b&quot;]]])</code> debe devolver <code>[&quot;a&quot;, &quot;b&quot;]</code> .&#39;
+  - text: ' <code>steamrollArray([[[&quot;a&quot;]], [[&quot;b&quot;]]])</code> debe devolver <code>[&quot;a&quot;, &quot;b&quot;]</code> .'
     testString: 'assert.deepEqual(steamrollArray([[["a"]], [["b"]]]), ["a", "b"], "<code>steamrollArray([[["a"]], [["b"]]])</code> should return <code>["a", "b"]</code>.");'
-  - text: &#39; <code>steamrollArray([1, [2], [3, [[4]]]])</code> debe devolver <code>[1, 2, 3, 4]</code> .&#39;
+  - text: ' <code>steamrollArray([1, [2], [3, [[4]]]])</code> debe devolver <code>[1, 2, 3, 4]</code> .'
     testString: 'assert.deepEqual(steamrollArray([1, [2], [3, [[4]]]]), [1, 2, 3, 4], "<code>steamrollArray([1, [2], [3, [[4]]]])</code> should return <code>[1, 2, 3, 4]</code>.");'
-  - text: &#39; <code>steamrollArray([1, [], [3, [[4]]]])</code> debe devolver <code>[1, 3, 4]</code> .&#39;
+  - text: ' <code>steamrollArray([1, [], [3, [[4]]]])</code> debe devolver <code>[1, 3, 4]</code> .'
     testString: 'assert.deepEqual(steamrollArray([1, [], [3, [[4]]]]), [1, 3, 4], "<code>steamrollArray([1, [], [3, [[4]]]])</code> should return <code>[1, 3, 4]</code>.");'
-  - text: &#39; <code>steamrollArray([1, {}, [3, [[4]]]])</code> debe devolver <code>[1, {}, 3, 4]</code> .&#39;
+  - text: ' <code>steamrollArray([1, {}, [3, [[4]]]])</code> debe devolver <code>[1, {}, 3, 4]</code> .'
     testString: 'assert.deepEqual(steamrollArray([1, {}, [3, [[4]]]]), [1, {}, 3, 4], "<code>steamrollArray([1, {}, [3, [[4]]]])</code> should return <code>[1, {}, 3, 4]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.spanish.md
index 2de6124ff1..ce2f35079f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Te pasaremos una matriz de dos números. Devuelve la suma de esos dos números más la suma de todos los números entre ellos. 
-El número más bajo no siempre vendrá primero. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Te pasaremos una matriz de dos números. Devuelve la suma de esos dos números más la suma de todos los números entre ellos.
+El número más bajo no siempre vendrá primero.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,15 +23,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>sumAll([1, 4])</code> debe devolver un número.&#39;
+  - text: ' <code>sumAll([1, 4])</code> debe devolver un número.'
     testString: 'assert(typeof sumAll([1, 4]) === "number", "<code>sumAll([1, 4])</code> should return a number.");'
-  - text: &#39; <code>sumAll([1, 4])</code> debe devolver 10.&#39;
+  - text: ' <code>sumAll([1, 4])</code> debe devolver 10.'
     testString: 'assert.deepEqual(sumAll([1, 4]), 10, "<code>sumAll([1, 4])</code> should return 10.");'
-  - text: &#39; <code>sumAll([4, 1])</code> debe devolver 10.&#39;
+  - text: ' <code>sumAll([4, 1])</code> debe devolver 10.'
     testString: 'assert.deepEqual(sumAll([4, 1]), 10, "<code>sumAll([4, 1])</code> should return 10.");'
-  - text: &#39; <code>sumAll([5, 10])</code> debe devolver 45.&#39;
+  - text: ' <code>sumAll([5, 10])</code> debe devolver 45.'
     testString: 'assert.deepEqual(sumAll([5, 10]), 45, "<code>sumAll([5, 10])</code> should return 45.");'
-  - text: &#39; <code>sumAll([10, 5])</code> debe devolver 45.&#39;
+  - text: ' <code>sumAll([10, 5])</code> debe devolver 45.'
     testString: 'assert.deepEqual(sumAll([10, 5]), 45, "<code>sumAll([10, 5])</code> should return 45.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.spanish.md
index 54e7b2ac50..ae67508acc 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.spanish.md
@@ -7,14 +7,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Haga una función que examine una matriz de objetos (primer argumento) y devuelva una matriz de todos los objetos que tengan pares de nombre y valor coincidentes (segundo argumento). Cada par de nombre y valor del objeto de origen debe estar presente en el objeto de la colección si se va a incluir en la matriz devuelta. 
-Por ejemplo, si el primer argumento es <code>[{ first: &quot;Romeo&quot;, last: &quot;Montague&quot; }, { first: &quot;Mercutio&quot;, last: null }, { first: &quot;Tybalt&quot;, last: &quot;Capulet&quot; }]</code> , y el segundo argumento es <code>{ last: &quot;Capulet&quot; }</code> , luego debe devolver el tercer objeto de la matriz (el primer argumento), ya que contiene el nombre y su valor, que se pasó como el segundo argumento. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Haga una función que examine una matriz de objetos (primer argumento) y devuelva una matriz de todos los objetos que tengan pares de nombre y valor coincidentes (segundo argumento). Cada par de nombre y valor del objeto de origen debe estar presente en el objeto de la colección si se va a incluir en la matriz devuelta.
+Por ejemplo, si el primer argumento es <code>[{ first: &quot;Romeo&quot;, last: &quot;Montague&quot; }, { first: &quot;Mercutio&quot;, last: null }, { first: &quot;Tybalt&quot;, last: &quot;Capulet&quot; }]</code> , y el segundo argumento es <code>{ last: &quot;Capulet&quot; }</code> , luego debe devolver el tercer objeto de la matriz (el primer argumento), ya que contiene el nombre y su valor, que se pasó como el segundo argumento.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,17 +23,17 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>whatIsInAName([{ first: &quot;Romeo&quot;, last: &quot;Montague&quot; }, { first: &quot;Mercutio&quot;, last: null }, { first: &quot;Tybalt&quot;, last: &quot;Capulet&quot; }], { last: &quot;Capulet&quot; })</code> debe devolver <code>[{ first: &quot;Tybalt&quot;, last: &quot;Capulet&quot; }]</code> . &#39;
+  - text: ' <code>whatIsInAName([{ first: &quot;Romeo&quot;, last: &quot;Montague&quot; }, { first: &quot;Mercutio&quot;, last: null }, { first: &quot;Tybalt&quot;, last: &quot;Capulet&quot; }], { last: &quot;Capulet&quot; })</code> debe devolver <code>[{ first: &quot;Tybalt&quot;, last: &quot;Capulet&quot; }]</code> . '
     testString: 'assert.deepEqual(whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" }), [{ first: "Tybalt", last: "Capulet" }], "<code>whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })</code> should return <code>[{ first: "Tybalt", last: "Capulet" }]</code>.");'
-  - text: &#39; <code>whatIsInAName([{ &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2 }], { &quot;apple&quot;: 1 })</code> debe devolver <code>[{ &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2 }]</code> . &#39;
+  - text: ' <code>whatIsInAName([{ &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2 }], { &quot;apple&quot;: 1 })</code> debe devolver <code>[{ &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2 }]</code> . '
     testString: 'assert.deepEqual(whatIsInAName([{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], { "apple": 1 }), [{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], "<code>whatIsInAName([{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], { "apple": 1 })</code> should return <code>[{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }]</code>.");'
-  - text: &#39; <code>whatIsInAName([{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }], { &quot;apple&quot;: 1, &quot;bat&quot;: 2 })</code> debe devolver <code>[{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }]</code> . &#39;
+  - text: ' <code>whatIsInAName([{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }], { &quot;apple&quot;: 1, &quot;bat&quot;: 2 })</code> debe devolver <code>[{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }]</code> . '
     testString: 'assert.deepEqual(whatIsInAName([{ "apple": 1, "bat": 2 }, { "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "bat": 2 }), [{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], "<code>whatIsInAName([{ "apple": 1, "bat": 2 }, { "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "bat": 2 })</code> should return <code>[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }]</code>.");'
-  - text: &#39; <code>whatIsInAName([{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }], { &quot;apple&quot;: 1, &quot;cookie&quot;: 2 })</code> debe devolver <code>[{ &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }]</code> . &#39;
+  - text: ' <code>whatIsInAName([{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }], { &quot;apple&quot;: 1, &quot;cookie&quot;: 2 })</code> debe devolver <code>[{ &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }]</code> . '
     testString: 'assert.deepEqual(whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "cookie": 2 }), [{ "apple": 1, "bat": 2, "cookie": 2 }], "<code>whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "cookie": 2 })</code> should return <code>[{ "apple": 1, "bat": 2, "cookie": 2 }]</code>.");'
-  - text: &#39; <code>whatIsInAName([{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }, { &quot;bat&quot;:2 }], { &quot;apple&quot;: 1, &quot;bat&quot;: 2 })</code> debe devolver <code>[{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;:2 }]</code> . &#39;
+  - text: ' <code>whatIsInAName([{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;: 2 }, { &quot;bat&quot;:2 }], { &quot;apple&quot;: 1, &quot;bat&quot;: 2 })</code> debe devolver <code>[{ &quot;apple&quot;: 1, &quot;bat&quot;: 2 }, { &quot;apple&quot;: 1, &quot;bat&quot;: 2, &quot;cookie&quot;:2 }]</code> . '
     testString: 'assert.deepEqual(whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }, {"bat":2}], { "apple": 1, "bat": 2 }), [{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie":2 }], "<code>whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }, { "bat":2 }], { "apple": 1, "bat": 2 })</code> should return <code>[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie":2 }]</code>.");'
-  - text: &#39; <code>whatIsInAName([{&quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3}], {&quot;a&quot;: 1, &quot;b&quot;: 9999, &quot;c&quot;: 3})</code> debe devolver <code>[]</code> &#39;
+  - text: ' <code>whatIsInAName([{&quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3}], {&quot;a&quot;: 1, &quot;b&quot;: 9999, &quot;c&quot;: 3})</code> debe devolver <code>[]</code> '
     testString: 'assert.deepEqual(whatIsInAName([{ "a": 1, "b": 2, "c": 3 }], { "a": 1, "b": 9999, "c": 3 }), [], "<code>whatIsInAName([{"a": 1, "b": 2, "c": 3}], {"a": 1, "b": 9999, "c": 3})</code> should return <code>[]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.spanish.md
index 3b8df5beaf..214a354214 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.spanish.md
@@ -7,19 +7,19 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Diseñe una función de cajón de la caja registradora <code>checkCashRegister()</code> que acepte el precio de compra como primer argumento ( <code>price</code> ), el pago como segundo argumento ( <code>cash</code> ) y el cajón de efectivo ( <code>cid</code> ) como tercer argumento. 
-<code>cid</code> es una matriz 2D que muestra la moneda disponible. 
-La función <code>checkCashRegister()</code> siempre debe devolver un objeto con una clave de <code>status</code> y una clave de <code>change</code> . 
-Devuelva <code>{status: &quot;INSUFFICIENT_FUNDS&quot;, change: []}</code> si el efectivo en el cajón es inferior al cambio debido, o si no puede devolver el cambio exacto. 
-Devuelva <code>{status: &quot;CLOSED&quot;, change: [...]}</code> con cash-in-drawer como valor del <code>change</code> clave si es igual al cambio debido. 
-De lo contrario, devuelva <code>{status: &quot;OPEN&quot;, change: [...]}</code> , con el cambio en monedas y billetes, ordenados de mayor a menor, como el valor de la clave de <code>change</code> . 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
-<table class='table table-striped'><tr><th> Unidad monetaria </th><th> Cantidad </th></tr><tr><td> Centavo </td><td> $ 0.01 (PENNY) </td></tr><tr><td> Níquel </td><td> $ 0.05 (níquel) </td></tr><tr><td> Moneda de diez centavos </td><td> $ 0.1 (DIME) </td></tr><tr><td> Trimestre </td><td> $ 0.25 (TRIMESTRE) </td></tr><tr><td> Dólar </td><td> $ 1 (DÓLAR) </td></tr><tr><td> Cinco dólares </td><td> $ 5 (CINCO) </td></tr><tr><td> Diez dólares </td><td> $ 10 (DIEZ) </td></tr><tr><td> Veinte dólares </td><td> $ 20 (VEINTE) </td></tr><tr><td> Cien dolares </td><td> $ 100 (100) </td></tr></table> 
+<section id='description'>
+Diseñe una función de cajón de la caja registradora <code>checkCashRegister()</code> que acepte el precio de compra como primer argumento ( <code>price</code> ), el pago como segundo argumento ( <code>cash</code> ) y el cajón de efectivo ( <code>cid</code> ) como tercer argumento.
+<code>cid</code> es una matriz 2D que muestra la moneda disponible.
+La función <code>checkCashRegister()</code> siempre debe devolver un objeto con una clave de <code>status</code> y una clave de <code>change</code> .
+Devuelva <code>{status: &quot;INSUFFICIENT_FUNDS&quot;, change: []}</code> si el efectivo en el cajón es inferior al cambio debido, o si no puede devolver el cambio exacto.
+Devuelva <code>{status: &quot;CLOSED&quot;, change: [...]}</code> con cash-in-drawer como valor del <code>change</code> clave si es igual al cambio debido.
+De lo contrario, devuelva <code>{status: &quot;OPEN&quot;, change: [...]}</code> , con el cambio en monedas y billetes, ordenados de mayor a menor, como el valor de la clave de <code>change</code> .
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
+<table class='table table-striped'><tr><th> Unidad monetaria </th><th> Cantidad </th></tr><tr><td> Centavo </td><td> $ 0.01 (PENNY) </td></tr><tr><td> Níquel </td><td> $ 0.05 (níquel) </td></tr><tr><td> Moneda de diez centavos </td><td> $ 0.1 (DIME) </td></tr><tr><td> Trimestre </td><td> $ 0.25 (TRIMESTRE) </td></tr><tr><td> Dólar </td><td> $ 1 (DÓLAR) </td></tr><tr><td> Cinco dólares </td><td> $ 5 (CINCO) </td></tr><tr><td> Diez dólares </td><td> $ 10 (DIEZ) </td></tr><tr><td> Veinte dólares </td><td> $ 20 (VEINTE) </td></tr><tr><td> Cien dolares </td><td> $ 100 (100) </td></tr></table>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,17 +28,17 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 1.01], [&quot;NICKEL&quot;, 2.05], [&quot;DIME&quot;, 3.1], [&quot;QUARTER&quot;, 4.25], [&quot;ONE&quot;, 90], [&quot;FIVE&quot;, 55], [&quot;TEN&quot;, 20], [&quot;TWENTY&quot;, 60], [&quot;ONE HUNDRED&quot;, 100]])</code> debe devolver un objeto. &#39;
+  - text: ' <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 1.01], [&quot;NICKEL&quot;, 2.05], [&quot;DIME&quot;, 3.1], [&quot;QUARTER&quot;, 4.25], [&quot;ONE&quot;, 90], [&quot;FIVE&quot;, 55], [&quot;TEN&quot;, 20], [&quot;TWENTY&quot;, 60], [&quot;ONE HUNDRED&quot;, 100]])</code> debe devolver un objeto. '
     testString: 'assert.deepEqual(Object.prototype.toString.call(checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])), "[object Object]", "<code>checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])</code> should return an object.");'
-  - text: &#39; <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 1.01], [&quot;NICKEL&quot;, 2.05], [&quot;DIME&quot;, 3.1], [&quot;QUARTER&quot;, 4.25], [&quot;ONE&quot;, 90], [&quot;FIVE&quot;, 55], [&quot;TEN&quot;, 20], [&quot;TWENTY&quot;, 60], [&quot;ONE HUNDRED&quot;, 100]])</code> debe devolver <code>{status: &quot;OPEN&quot;, change: [[&quot;QUARTER&quot;, 0.5]]}</code> . &#39;
+  - text: ' <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 1.01], [&quot;NICKEL&quot;, 2.05], [&quot;DIME&quot;, 3.1], [&quot;QUARTER&quot;, 4.25], [&quot;ONE&quot;, 90], [&quot;FIVE&quot;, 55], [&quot;TEN&quot;, 20], [&quot;TWENTY&quot;, 60], [&quot;ONE HUNDRED&quot;, 100]])</code> debe devolver <code>{status: &quot;OPEN&quot;, change: [[&quot;QUARTER&quot;, 0.5]]}</code> . '
     testString: 'assert.deepEqual(checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]), {status: "OPEN", change: [["QUARTER", 0.5]]}, "<code>checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])</code> should return <code>{status: "OPEN", change: [["QUARTER", 0.5]]}</code>.");'
-  - text: &#39; <code>checkCashRegister(3.26, 100, [[&quot;PENNY&quot;, 1.01], [&quot;NICKEL&quot;, 2.05], [&quot;DIME&quot;, 3.1], [&quot;QUARTER&quot;, 4.25], [&quot;ONE&quot;, 90], [&quot;FIVE&quot;, 55], [&quot;TEN&quot;, 20], [&quot;TWENTY&quot;, 60], [&quot;ONE HUNDRED&quot;, 100]])</code> debe devolver <code>{status: &quot;OPEN&quot;, change: [[&quot;TWENTY&quot;, 60], [&quot;TEN&quot;, 20], [&quot;FIVE&quot;, 15], [&quot;ONE&quot;, 1], [&quot;QUARTER&quot;, 0.5], [&quot;DIME&quot;, 0.2], [&quot;PENNY&quot;, 0.04]]}</code> . &#39;
+  - text: ' <code>checkCashRegister(3.26, 100, [[&quot;PENNY&quot;, 1.01], [&quot;NICKEL&quot;, 2.05], [&quot;DIME&quot;, 3.1], [&quot;QUARTER&quot;, 4.25], [&quot;ONE&quot;, 90], [&quot;FIVE&quot;, 55], [&quot;TEN&quot;, 20], [&quot;TWENTY&quot;, 60], [&quot;ONE HUNDRED&quot;, 100]])</code> debe devolver <code>{status: &quot;OPEN&quot;, change: [[&quot;TWENTY&quot;, 60], [&quot;TEN&quot;, 20], [&quot;FIVE&quot;, 15], [&quot;ONE&quot;, 1], [&quot;QUARTER&quot;, 0.5], [&quot;DIME&quot;, 0.2], [&quot;PENNY&quot;, 0.04]]}</code> . '
     testString: 'assert.deepEqual(checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]), {status: "OPEN", change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]}, "<code>checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])</code> should return <code>{status: "OPEN", change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]}</code>.");'
-  - text: &#39; <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 0.01], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 0], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]])</code> debe devolver <code>{status: &quot;INSUFFICIENT_FUNDS&quot;, change: []}</code> . &#39;
+  - text: ' <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 0.01], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 0], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]])</code> debe devolver <code>{status: &quot;INSUFFICIENT_FUNDS&quot;, change: []}</code> . '
     testString: 'assert.deepEqual(checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]), {status: "INSUFFICIENT_FUNDS", change: []}, "<code>checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])</code> should return <code>{status: "INSUFFICIENT_FUNDS", change: []}</code>.");'
-  - text: &#39; <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 0.01], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 1], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]])</code> debe devolver <code>{status: &quot;INSUFFICIENT_FUNDS&quot;, change: []}</code> . &#39;
+  - text: ' <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 0.01], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 1], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]])</code> debe devolver <code>{status: &quot;INSUFFICIENT_FUNDS&quot;, change: []}</code> . '
     testString: 'assert.deepEqual(checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]), {status: "INSUFFICIENT_FUNDS", change: []}, "<code>checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])</code> should return <code>{status: "INSUFFICIENT_FUNDS", change: []}</code>.");'
-  - text: &#39; <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 0.5], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 0], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]])</code> debe devolver <code>{status: &quot;CLOSED&quot;, change: [[&quot;PENNY&quot;, 0.5], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 0], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]]}</code> . &#39;
+  - text: ' <code>checkCashRegister(19.5, 20, [[&quot;PENNY&quot;, 0.5], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 0], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]])</code> debe devolver <code>{status: &quot;CLOSED&quot;, change: [[&quot;PENNY&quot;, 0.5], [&quot;NICKEL&quot;, 0], [&quot;DIME&quot;, 0], [&quot;QUARTER&quot;, 0], [&quot;ONE&quot;, 0], [&quot;FIVE&quot;, 0], [&quot;TEN&quot;, 0], [&quot;TWENTY&quot;, 0], [&quot;ONE HUNDRED&quot;, 0]]}</code> . '
     testString: 'assert.deepEqual(checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]), {status: "CLOSED", change: [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]}, "<code>checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])</code> should return <code>{status: "CLOSED", change: [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]}</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.spanish.md
index a01a78d990..b726488462 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.spanish.md
@@ -7,17 +7,17 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Devuelve <code>true</code> si la cadena dada es un palíndromo. De lo contrario, devuelve <code>false</code> . 
-Un <dfn>palíndromo</dfn> es una palabra u oración que se escribe de la misma manera tanto hacia adelante como hacia atrás, ignorando la puntuación, el caso y el espaciado. 
-<strong>Nota</strong> <br> Deberá eliminar <strong>todos los caracteres no alfanuméricos</strong> (puntuación, espacios y símbolos) y convertir todo en el mismo caso (mayúsculas o minúsculas) para comprobar si hay palíndromos. 
-Pasaremos cadenas con distintos formatos, como <code>&quot;racecar&quot;</code> , <code>&quot;RaceCar&quot;</code> y <code>&quot;race CAR&quot;</code> entre otros. 
-También pasaremos cadenas con símbolos especiales, como <code>&quot;2A3*3a2&quot;</code> , <code>&quot;2A3 3a2&quot;</code> y <code>&quot;2_A3*3#A2&quot;</code> . 
-Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código. 
+<section id='description'>
+Devuelve <code>true</code> si la cadena dada es un palíndromo. De lo contrario, devuelve <code>false</code> .
+Un <dfn>palíndromo</dfn> es una palabra u oración que se escribe de la misma manera tanto hacia adelante como hacia atrás, ignorando la puntuación, el caso y el espaciado.
+<strong>Nota</strong> <br> Deberá eliminar <strong>todos los caracteres no alfanuméricos</strong> (puntuación, espacios y símbolos) y convertir todo en el mismo caso (mayúsculas o minúsculas) para comprobar si hay palíndromos.
+Pasaremos cadenas con distintos formatos, como <code>&quot;racecar&quot;</code> , <code>&quot;RaceCar&quot;</code> y <code>&quot;race CAR&quot;</code> entre otros.
+También pasaremos cadenas con símbolos especiales, como <code>&quot;2A3*3a2&quot;</code> , <code>&quot;2A3 3a2&quot;</code> y <code>&quot;2_A3*3#A2&quot;</code> .
+Recuerda usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> si te atascas. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -36,7 +36,7 @@ tests:
     testString: 'assert(palindrome("race car") === true, "<code>palindrome("race car")</code> should return true.");'
   - text: <code>palindrome(&quot;not a palindrome&quot;)</code> debe devolver falso.
     testString: 'assert(palindrome("not a palindrome") === false, "<code>palindrome("not a palindrome")</code> should return false.");'
-  - text: &#39; <code>palindrome(&quot;A man, a plan, a canal. Panama&quot;)</code> debería devolver la verdad &quot;.
+  - text: ' <code>palindrome(&quot;A man, a plan, a canal. Panama&quot;)</code> debería devolver la verdad &quot;.
     testString: 'assert(palindrome("A man, a plan, a canal. Panama") === true, "<code>palindrome("A man, a plan, a canal. Panama")</code> should return true.");'
   - text: <code>palindrome(&quot;never odd or even&quot;)</code> debe devolver verdadero.
     testString: 'assert(palindrome("never odd or even") === true, "<code>palindrome("never odd or even")</code> should return true.");'
@@ -44,11 +44,11 @@ tests:
     testString: 'assert(palindrome("nope") === false, "<code>palindrome("nope")</code> should return false.");'
   - text: <code>palindrome(&quot;almostomla&quot;)</code> debe devolver falso.
     testString: 'assert(palindrome("almostomla") === false, "<code>palindrome("almostomla")</code> should return false.");'
-  - text: &#39; <code>palindrome(&quot;My age is 0, 0 si ega ym.&quot;)</code> debería devolver verdadero.&#39;
+  - text: ' <code>palindrome(&quot;My age is 0, 0 si ega ym.&quot;)</code> debería devolver verdadero.'
     testString: 'assert(palindrome("My age is 0, 0 si ega ym.") === true, "<code>palindrome("My age is 0, 0 si ega ym.")</code> should return true.");'
   - text: <code>palindrome(&quot;1 eye for of 1 eye.&quot;)</code> debe devolver falso.
     testString: 'assert(palindrome("1 eye for of 1 eye.") === false, "<code>palindrome("1 eye for of 1 eye.")</code> should return false.");'
-  - text: &#39; <code>palindrome(&quot;0_0 (: /-\ :) 0-0&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>palindrome(&quot;0_0 (: /-\ :) 0-0&quot;)</code> debe devolver verdadero.'
     testString: 'assert(palindrome("0_0 (: /-\ :) 0-0") === true, "<code>palindrome("0_0 (: /-\ :) 0-0")</code> should return true.");'
   - text: <code>palindrome(&quot;five|\_/|four&quot;)</code> debe devolver falso.
     testString: 'assert(palindrome("five|\_/|four") === false, "<code>palindrome("five|\_/|four")</code> should return false.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.spanish.md
index d70ca9d60f..f0c7941a6d 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.spanish.md
@@ -7,16 +7,16 @@ isRequired: true
 ---
 
 ## Description
-<section id='description'> 
-Devuelva <code>true</code> si la cadena pasada parece un número de teléfono válido de EE. UU. 
-El usuario puede completar el campo del formulario de la forma que elija, siempre que tenga el formato de un número de EE. UU. Válido. Los siguientes son ejemplos de formatos válidos para números de EE. UU. (Consulte las siguientes pruebas para otras variantes): 
-<blockquote>555-555-5555<br>(555)555-5555<br>(555) 555-5555<br>555 555 5555<br>5555555555<br>1 555 555 5555</blockquote> 
-Para este desafío, se te presentará una cadena como <code>800-692-7753</code> o <code>8oo-six427676;laskdjf</code> . Su trabajo es validar o rechazar el número de teléfono de los EE. UU. En función de cualquier combinación de los formatos proporcionados anteriormente. El código de área es obligatorio. Si se proporciona el código de país, debe confirmar que el código de país es <code>1</code> . Devuelva <code>true</code> si la cadena es un número de teléfono de EE. UU. Válido; de lo contrario devuelve <code>false</code> . 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Devuelva <code>true</code> si la cadena pasada parece un número de teléfono válido de EE. UU.
+El usuario puede completar el campo del formulario de la forma que elija, siempre que tenga el formato de un número de EE. UU. Válido. Los siguientes son ejemplos de formatos válidos para números de EE. UU. (Consulte las siguientes pruebas para otras variantes):
+<blockquote>555-555-5555<br>(555)555-5555<br>(555) 555-5555<br>555 555 5555<br>5555555555<br>1 555 555 5555</blockquote>
+Para este desafío, se te presentará una cadena como <code>800-692-7753</code> o <code>8oo-six427676;laskdjf</code> . Su trabajo es validar o rechazar el número de teléfono de los EE. UU. En función de cualquier combinación de los formatos proporcionados anteriormente. El código de área es obligatorio. Si se proporciona el código de país, debe confirmar que el código de país es <code>1</code> . Devuelva <code>true</code> si la cadena es un número de teléfono de EE. UU. Válido; de lo contrario devuelve <code>false</code> .
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -49,7 +49,7 @@ tests:
     testString: 'assert(telephoneCheck("1 555 555 5555") === true, "<code>telephoneCheck("1 555 555 5555")</code> should return true.");'
   - text: <code>telephoneCheck(&quot;1 456 789 4444&quot;)</code> debe devolver verdadero.
     testString: 'assert(telephoneCheck("1 456 789 4444") === true, "<code>telephoneCheck("1 456 789 4444")</code> should return true.");'
-  - text: &#39; <code>telephoneCheck(&quot;123**&amp;!!asdf#&quot;)</code> debe devolver falso.&#39;
+  - text: ' <code>telephoneCheck(&quot;123**&amp;!!asdf#&quot;)</code> debe devolver falso.'
     testString: 'assert(telephoneCheck("123**&!!asdf#") === false, "<code>telephoneCheck("123**&!!asdf#")</code> should return false.");'
   - text: <code>telephoneCheck(&quot;55555555&quot;)</code> debe devolver falso.
     testString: 'assert(telephoneCheck("55555555") === false, "<code>telephoneCheck("55555555")</code> should return false.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.spanish.md
index df065d5295..5e585ece9f 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.spanish.md
@@ -6,24 +6,24 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En las lecciones anteriores, aprendió que un objeto puede heredar su comportamiento (métodos) de otro objeto clonando su objeto <code>prototype</code> : 
-<blockquote>ChildObject.prototype = Object.create(ParentObject.prototype);</blockquote> 
-Luego, <code>ChildObject</code> recibió sus propios métodos al encadenarlos a su <code>prototype</code> : 
-<blockquote>ChildObject.prototype.methodName = function() {...};</blockquote> 
-Es posible anular un método heredado. Se realiza de la misma manera: agregando un método a <code>ChildObject.prototype</code> utilizando el mismo nombre de método que el que se anula. 
-Este es un ejemplo de <code>Bird</code> anula el método <code>eat()</code> heredado de <code>Animal</code> : 
-<blockquote>function Animal() { }<br>Animal.prototype.eat = function() {<br>&nbsp;&nbsp;return "nom nom nom";<br>};<br>function Bird() { }<br><br>// Inherit all methods from Animal<br>Bird.prototype = Object.create(Animal.prototype);<br><br>// Bird.eat() overrides Animal.eat()<br>Bird.prototype.eat = function() {<br>&nbsp;&nbsp;return "peck peck peck";<br>};</blockquote> 
-Si tienes una instancia, <code>let duck = new Bird();</code> y llama a <code>duck.eat()</code> , así es como JavaScript busca el método en <code>duck&#39;s</code> cadena de <code>prototype</code> <code>duck&#39;s</code> : 
-1. duck =&gt; ¿Se define eat () aquí? No. 
-2. Pájaro =&gt; ¿Se define eat () aquí? =&gt; Sí. Ejecutarlo y dejar de buscar. 
-3. Animal =&gt; eat () también está definido, pero JavaScript dejó de buscar antes de alcanzar este nivel. 
-4. Objeto =&gt; JavaScript dejó de buscar antes de alcanzar este nivel. 
+<section id='description'>
+En las lecciones anteriores, aprendió que un objeto puede heredar su comportamiento (métodos) de otro objeto clonando su objeto <code>prototype</code> :
+<blockquote>ChildObject.prototype = Object.create(ParentObject.prototype);</blockquote>
+Luego, <code>ChildObject</code> recibió sus propios métodos al encadenarlos a su <code>prototype</code> :
+<blockquote>ChildObject.prototype.methodName = function() {...};</blockquote>
+Es posible anular un método heredado. Se realiza de la misma manera: agregando un método a <code>ChildObject.prototype</code> utilizando el mismo nombre de método que el que se anula.
+Este es un ejemplo de <code>Bird</code> anula el método <code>eat()</code> heredado de <code>Animal</code> :
+<blockquote>function Animal() { }<br>Animal.prototype.eat = function() {<br>&nbsp;&nbsp;return "nom nom nom";<br>};<br>function Bird() { }<br><br>// Inherit all methods from Animal<br>Bird.prototype = Object.create(Animal.prototype);<br><br>// Bird.eat() overrides Animal.eat()<br>Bird.prototype.eat = function() {<br>&nbsp;&nbsp;return "peck peck peck";<br>};</blockquote>
+Si tienes una instancia, <code>let duck = new Bird();</code> y llama a <code>duck.eat()</code> , así es como JavaScript busca el método en <code>duck&#39;s</code> cadena de <code>prototype</code> <code>duck&#39;s</code> :
+1. duck =&gt; ¿Se define eat () aquí? No.
+2. Pájaro =&gt; ¿Se define eat () aquí? =&gt; Sí. Ejecutarlo y dejar de buscar.
+3. Animal =&gt; eat () también está definido, pero JavaScript dejó de buscar antes de alcanzar este nivel.
+4. Objeto =&gt; JavaScript dejó de buscar antes de alcanzar este nivel.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Anula el método <code>fly()</code> de <code>Penguin</code> para que devuelva &quot;¡Ay !, este es un pájaro que no vuela&quot;. 
+<section id='instructions'>
+Anula el método <code>fly()</code> de <code>Penguin</code> para que devuelva &quot;¡Ay !, este es un pájaro que no vuela&quot;.
 </section>
 
 ## Tests
@@ -31,7 +31,7 @@ Anula el método <code>fly()</code> de <code>Penguin</code> para que devuelva &q
 
 ```yml
 tests:
-  - text: &#39; <code>penguin.fly()</code> debería devolver la cadena &quot;¡Ay !, este es un pájaro que no vuela».
+  - text: ' <code>penguin.fly()</code> debería devolver la cadena &quot;¡Ay !, este es un pájaro que no vuela».
     testString: 'assert(penguin.fly() === "Alas, this is a flightless bird.", "<code>penguin.fly()</code> should return the string "Alas, this is a flightless bird."");'
   - text: El método <code>bird.fly()</code> debería devolver &quot;Estoy volando!&quot;
     testString: 'assert((new Bird()).fly() === "I am flying!", "The <code>bird.fly()</code> method should return "I am flying!"");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.spanish.md
index 839c05855b..89cfb806ff 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.spanish.md
@@ -6,16 +6,16 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-A veces, los patrones que desea buscar pueden tener partes que pueden o no existir. Sin embargo, puede ser importante verificarlos de todas formas. 
-Puede especificar la posible existencia de un elemento con un signo de interrogación, <code>?</code> . Esto comprueba si hay cero o uno de los elementos anteriores. Puede pensar que este símbolo dice que el elemento anterior es opcional. 
-Por ejemplo, hay ligeras diferencias entre el inglés americano y el británico y puede usar el signo de interrogación para hacer coincidir ambas ortografías. 
-<blockquote>let american = "color";<br>let british = "colour";<br>let rainbowRegex= /colou?r/;<br>rainbowRegex.test(american); // Returns true<br>rainbowRegex.test(british); // Returns true</blockquote> 
+<section id='description'>
+A veces, los patrones que desea buscar pueden tener partes que pueden o no existir. Sin embargo, puede ser importante verificarlos de todas formas.
+Puede especificar la posible existencia de un elemento con un signo de interrogación, <code>?</code> . Esto comprueba si hay cero o uno de los elementos anteriores. Puede pensar que este símbolo dice que el elemento anterior es opcional.
+Por ejemplo, hay ligeras diferencias entre el inglés americano y el británico y puede usar el signo de interrogación para hacer coincidir ambas ortografías.
+<blockquote>let american = "color";<br>let british = "colour";<br>let rainbowRegex= /colou?r/;<br>rainbowRegex.test(american); // Returns true<br>rainbowRegex.test(british); // Returns true</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cambie el regex <code>favRegex</code> para que coincida con la versión del inglés americano (favorito) y del inglés británico (favorito) de la palabra. 
+<section id='instructions'>
+Cambie el regex <code>favRegex</code> para que coincida con la versión del inglés americano (favorito) y del inglés británico (favorito) de la palabra.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Cambie el regex <code>favRegex</code> para que coincida con la versión del ingl
 
 ```yml
 tests:
-  - text: &#39;Su expresión regular debe utilizar el símbolo opcional, <code>?</code> .
+  - text: 'Su expresión regular debe utilizar el símbolo opcional, <code>?</code> .
     testString: 'assert(favRegex.source.match(/\?/).length > 0, "Your regex should use the optional symbol, <code>?</code>.");'
   - text: Tu expresión regular debe coincidir con <code>&quot;favorite&quot;</code>
     testString: 'assert(favRegex.test("favorite"), "Your regex should match <code>"favorite"</code>");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.spanish.md
index 5cd2835b67..3242c6ec45 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El último desafío mostró cómo buscar dígitos usando el método abreviado <code>\d</code> con una minúscula <code>d</code> . También puede buscar no dígitos usando un atajo similar que use una <code>D</code> mayúscula en su lugar. 
-El atajo para buscar caracteres sin dígitos es <code>\D</code> Esto es igual a la clase de caracteres <code>[^0-9]</code> , que busca un solo carácter que no sea un número entre cero y nueve. 
+<section id='description'>
+El último desafío mostró cómo buscar dígitos usando el método abreviado <code>\d</code> con una minúscula <code>d</code> . También puede buscar no dígitos usando un atajo similar que use una <code>D</code> mayúscula en su lugar.
+El atajo para buscar caracteres sin dígitos es <code>\D</code> Esto es igual a la clase de caracteres <code>[^0-9]</code> , que busca un solo carácter que no sea un número entre cero y nueve.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la clase de caracteres abreviados para no dígitos <code>\D</code> para contar cuántos no dígitos hay en los títulos de las películas. 
+<section id='instructions'>
+Use la clase de caracteres abreviados para no dígitos <code>\D</code> para contar cuántos no dígitos hay en los títulos de las películas.
 </section>
 
 ## Tests
@@ -35,7 +35,7 @@ tests:
     testString: 'assert("One, Two, Three".match(noNumRegex).length == 15, "Your regex should find 15 non-digits in <code>"One, Two, Three"</code>.");'
   - text: Su expresión regular debe encontrar 12 no dígitos en <code class = "notranslate"> "21 Jump Street" </code>.
     testString: 'assert("21 Jump Street".match(noNumRegex).length == 12, "Your regex should find 12 non-digits in <code>"21 Jump Street"</code>.");'
-  - text: "Su expresión regular debe encontrar 17 dígitos que no sean dígitos en <code class =" notranslate ">" 2001: A Space Odyssey "</code>. '
+  - text: 'Su expresión regular debe encontrar 17 dígitos que no sean dígitos en <code class =" notranslate ">" 2001: A Space Odyssey "</code>. '
     testString: 'assert("2001: A Space Odyssey".match(noNumRegex).length == 17, "Your regex should find 17 non-digits in <code>"2001: A Space Odyssey"</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.spanish.md
index 943d2d9929..c401399573 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-El último desafío usó el signo más <code>+</code> para buscar caracteres que aparecen una o más veces. También hay una opción que coincide con los caracteres que aparecen cero o más veces. 
-El personaje para hacer esto es el <code>asterisk</code> o <code>star</code> : <code>*</code> . 
-<blockquote>let soccerWord = "gooooooooal!";<br>let gPhrase = "gut feeling";<br>let oPhrase = "over the moon";<br>let goRegex = /go*/;<br>soccerWord.match(goRegex); // Returns ["goooooooo"]<br>gPhrase.match(goRegex); // Returns ["g"]<br>oPhrase.match(goRegex); // Returns null</blockquote> 
+<section id='description'>
+El último desafío usó el signo más <code>+</code> para buscar caracteres que aparecen una o más veces. También hay una opción que coincide con los caracteres que aparecen cero o más veces.
+El personaje para hacer esto es el <code>asterisk</code> o <code>star</code> : <code>*</code> .
+<blockquote>let soccerWord = "gooooooooal!";<br>let gPhrase = "gut feeling";<br>let oPhrase = "over the moon";<br>let goRegex = /go*/;<br>soccerWord.match(goRegex); // Returns ["goooooooo"]<br>gPhrase.match(goRegex); // Returns ["g"]<br>oPhrase.match(goRegex); // Returns null</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cree un regex <code>chewieRegex</code> que use el carácter <code>*</code> para que coincida con todos los caracteres <code>&quot;a&quot;</code> superiores e inferiores en <code>chewieQuote</code> . Su expresión regular no necesita indicadores y no debe coincidir con ninguna de las otras comillas. 
+<section id='instructions'>
+Cree un regex <code>chewieRegex</code> que use el carácter <code>*</code> para que coincida con todos los caracteres <code>&quot;a&quot;</code> superiores e inferiores en <code>chewieQuote</code> . Su expresión regular no necesita indicadores y no debe coincidir con ninguna de las otras comillas.
 </section>
 
 ## Tests
@@ -28,9 +28,9 @@ tests:
     testString: 'assert(result[0].length === 16, "Your regex <code>chewieRegex</code> should match 16 characters.");'
   - text: Tu expresión regular debe coincidir con <code>&quot;Aaaaaaaaaaaaaaaa&quot;</code> .
     testString: 'assert(result[0] === "Aaaaaaaaaaaaaaaa", "Your regex should match <code>"Aaaaaaaaaaaaaaaa"</code>.");'
-  - text: &#39;Tu expresión regular no debe coincidir con ningún carácter en <code>&quot;He made a fair move. Screaming about it can&#39;t help you.&quot;</code> &#39;
+  - text: 'Tu expresión regular no debe coincidir con ningún carácter en <code>&quot;He made a fair move. Screaming about it can&#39;t help you.&quot;</code> '
     testString: 'assert(!"He made a fair move. Screaming about it can\"t help you.".match(chewieRegex), "Your regex should not match any characters in <code>"He made a fair move. Screaming about it can&#39t help you."</code>");'
-  - text: &quot;Tu expresión regular no debe coincidir con ningún carácter en <code>&quot;Let him have it. It&#39;s not wise to upset a Wookiee.&quot;</code> &#39;
+  - text: &quot;Tu expresión regular no debe coincidir con ningún carácter en <code>&quot;Let him have it. It&#39;s not wise to upset a Wookiee.&quot;</code> '
     testString: 'assert(!"Let him have it. It\"s not wise to upset a Wookiee.".match(chewieRegex), "Your regex should not match any characters in <code>"Let him have it. It&#39s not wise to upset a Wookiee."</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.spanish.md
index 21478f76b9..6f9ae4d7cd 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.spanish.md
@@ -6,15 +6,15 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ha aprendido que puede usar un atajo para hacer coincidir los caracteres alfanuméricos <code>[A-Za-z0-9_]</code> usando <code>\w</code> . Un patrón natural que quizás desee buscar es el opuesto a los alfanuméricos. 
-Puede buscar lo contrario de <code>\w</code> con <code>\W</code> Tenga en cuenta, el patrón opuesto utiliza una letra mayúscula. Este atajo es el mismo que <code>[^A-Za-z0-9_]</code> . 
-<blockquote>let shortHand = /\W/;<br>let numbers = "42%";<br>let sentence = "Coding!";<br>numbers.match(shortHand); // Returns ["%"]<br>sentence.match(shortHand); // Returns ["!"]<br></blockquote> 
+<section id='description'>
+Ha aprendido que puede usar un atajo para hacer coincidir los caracteres alfanuméricos <code>[A-Za-z0-9_]</code> usando <code>\w</code> . Un patrón natural que quizás desee buscar es el opuesto a los alfanuméricos.
+Puede buscar lo contrario de <code>\w</code> con <code>\W</code> Tenga en cuenta, el patrón opuesto utiliza una letra mayúscula. Este atajo es el mismo que <code>[^A-Za-z0-9_]</code> .
+<blockquote>let shortHand = /\W/;<br>let numbers = "42%";<br>let sentence = "Coding!";<br>numbers.match(shortHand); // Returns ["%"]<br>sentence.match(shortHand); // Returns ["!"]<br></blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la clase de caracteres abreviados <code>\W</code> para contar el número de caracteres no alfanuméricos en varias comillas y cadenas. 
+<section id='instructions'>
+Use la clase de caracteres abreviados <code>\W</code> para contar el número de caracteres no alfanuméricos en varias comillas y cadenas.
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Use la clase de caracteres abreviados <code>\W</code> para contar el número de
 tests:
   - text: Su expresión regular debe utilizar la bandera global.
     testString: 'assert(nonAlphabetRegex.global, "Your regex should use the global flag.");'
-  - text: Su expresión regular debe encontrar 6 caracteres no alfanuméricos en <code clase = "notranslate"> "Los cinco asistentes de boxeo saltan rápidamente".
+  - text: Su expresión regular debe encontrar 6 caracteres no alfanuméricos en <code clase = "notranslate"> "Los cinco asistentes de boxeo saltan rápidamente."
     testString: 'assert("The five boxing wizards jump quickly.".match(nonAlphabetRegex).length == 6, "Your regex should find 6 non-alphanumeric characters in <code>"The five boxing wizards jump quickly."</code>.");'
   - text: Tu expresión regular debe usar el carácter de taquigrafía.
     testString: 'assert(/\\W/.test(nonAlphabetRegex.source), "Your regex should use the shorthand character to match characters which are non-alphanumeric.");'
diff --git a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.spanish.md b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.spanish.md
index 8554225551..27b0d8259c 100644
--- a/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.spanish.md
+++ b/curriculum/challenges/spanish/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-A veces, los caracteres de espacios en blanco alrededor de las cadenas no son deseados pero están ahí. El procesamiento típico de las cadenas es eliminar el espacio en blanco al principio y al final. 
+<section id='description'>
+A veces, los caracteres de espacios en blanco alrededor de las cadenas no son deseados pero están ahí. El procesamiento típico de las cadenas es eliminar el espacio en blanco al principio y al final.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escriba una expresión regular y use los métodos de cadena apropiados para eliminar los espacios en blanco al principio y al final de las cadenas. 
-<strong>Nota</strong> <br> El método <code>.trim()</code> funcionaría aquí, pero necesitarás completar este desafío usando expresiones regulares. 
+<section id='instructions'>
+Escriba una expresión regular y use los métodos de cadena apropiados para eliminar los espacios en blanco al principio y al final de las cadenas.
+<strong>Nota</strong> <br> El método <code>.trim()</code> funcionaría aquí, pero necesitarás completar este desafío usando expresiones regulares.
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ Escriba una expresión regular y use los métodos de cadena apropiados para elim
 
 ```yml
 tests:
-  - text: El <code>result</code> debería ser igual a <code>&quot;Hello, World!&quot;</code> &#39;
+  - text: El <code>result</code> debería ser igual a <code>&quot;Hello, World!&quot;</code> '
     testString: 'assert(result == "Hello, World!", "<code>result</code> should equal to <code>"Hello, World!"</code>");'
   - text: No debes usar el método <code>.trim()</code> .
     testString: 'assert(!code.match(/\.trim\(.*?\)/), "You should not use the <code>.trim()</code> method.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/add-font-awesome-icons-to-all-of-our-buttons.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/add-font-awesome-icons-to-all-of-our-buttons.spanish.md
index 9e2084207a..6179e510df 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/add-font-awesome-icons-to-all-of-our-buttons.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/add-font-awesome-icons-to-all-of-our-buttons.spanish.md
@@ -9,14 +9,14 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-Font Awesome es una conveniente biblioteca de iconos. Estos iconos son gráficos vectoriales, almacenados en el formato de archivo <code>.svg</code> . Estos iconos son tratados como fuentes. Puede especificar su tamaño usando píxeles, y asumirán el tamaño de fuente de sus elementos HTML principales. 
-Use Font Awesome para agregar un ícono de <code>info-circle</code> de información a su botón de información y un ícono de <code>trash</code> a su botón de eliminar. 
-Nota: El elemento <code>span</code> es una alternativa aceptable al elemento <code>i</code> para las instrucciones a continuación. 
+<section id='description'>
+Font Awesome es una conveniente biblioteca de iconos. Estos iconos son gráficos vectoriales, almacenados en el formato de archivo <code>.svg</code> . Estos iconos son tratados como fuentes. Puede especificar su tamaño usando píxeles, y asumirán el tamaño de fuente de sus elementos HTML principales.
+Use Font Awesome para agregar un ícono de <code>info-circle</code> de información a su botón de información y un ícono de <code>trash</code> a su botón de eliminar.
+Nota: El elemento <code>span</code> es una alternativa aceptable al elemento <code>i</code> para las instrucciones a continuación.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,11 +25,11 @@ Nota: El elemento <code>span</code> es una alternativa aceptable al elemento <co
 
 ```yml
 tests:
-  - text: &#39;Debes agregar un <code>&lt;i class=&quot;fa fa-info-circle&quot;&gt;&lt;/i&gt;</code> dentro del elemento de tu botón de información.&#39;
+  - text: 'Debes agregar un <code>&lt;i class=&quot;fa fa-info-circle&quot;&gt;&lt;/i&gt;</code> dentro del elemento de tu botón de información.'
     testString: 'assert($(".btn-info > i").is(".fa.fa-info-circle") || $(".btn-info > span").is(".fa.fa-info-circle"), "You should add a <code>&#60;i class="fa fa-info-circle"&#62;&#60;/i&#62;</code> within your info button element.");'
-  - text: &#39;Debes agregar una <code>&lt;i class=&quot;fa fa-trash&quot;&gt;&lt;/i&gt;</code> dentro de tu elemento de botón de eliminar.&#39;
+  - text: 'Debes agregar una <code>&lt;i class=&quot;fa fa-trash&quot;&gt;&lt;/i&gt;</code> dentro de tu elemento de botón de eliminar.'
     testString: 'assert($(".btn-danger > i").is(".fa.fa-trash") || $(".btn-danger > span").is(".fa.fa-trash"), "You should add a <code>&#60;i class="fa fa-trash"&#62;&#60;/i&#62;</code> within your delete button element.");'
-  - text: &#39;Asegúrate de que cada uno de tus elementos <code>i</code> tenga una etiqueta de cierre y <code>&lt;i class=&quot;fa fa-thumbs-up&quot;&gt;&lt;/i&gt;</code> está en el elemento de tu botón me gusta.&#39;
+  - text: 'Asegúrate de que cada uno de tus elementos <code>i</code> tenga una etiqueta de cierre y <code>&lt;i class=&quot;fa fa-thumbs-up&quot;&gt;&lt;/i&gt;</code> está en el elemento de tu botón me gusta.'
     testString: 'assert(code.match(/<\/i>|<\/span/g) && code.match(/<\/i|<\/span>/g).length > 2 && ($(".btn-primary > i").is(".fa.fa-thumbs-up") || $(".btn-primary > span").is(".fa.fa-thumbs-up")), "Make sure each of your <code>i</code> elements has a closing tag and <code>&#60;i class="fa fa-thumbs-up"&#62;&#60;/i&#62;</code> is in your like button element.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/create-a-bootstrap-button.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/create-a-bootstrap-button.spanish.md
index 52f243bd9c..e088c72020 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/create-a-bootstrap-button.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/create-a-bootstrap-button.spanish.md
@@ -6,13 +6,13 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-Bootstrap tiene sus propios estilos para elementos de <code>button</code> , que se ven mucho mejor que los de HTML simple. 
-Crea un nuevo elemento de <code>button</code> debajo de tu foto grande de gatito. Asígnele las clases <code>btn</code> y <code>btn-default</code> , así como el texto de &quot;Me gusta&quot;. 
+<section id='description'>
+Bootstrap tiene sus propios estilos para elementos de <code>button</code> , que se ven mucho mejor que los de HTML simple.
+Crea un nuevo elemento de <code>button</code> debajo de tu foto grande de gatito. Asígnele las clases <code>btn</code> y <code>btn-default</code> , así como el texto de &quot;Me gusta&quot;.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,7 +23,7 @@ Crea un nuevo elemento de <code>button</code> debajo de tu foto grande de gatito
 tests:
   - text: Crea un nuevo elemento de <code>button</code> con el texto &quot;Me gusta&quot;.
     testString: 'assert(new RegExp("like","gi").test($("button").text()) && ($("img.img-responsive + button.btn").length > 0), "Create a new <code>button</code> element with the text "Like".");'
-  - text: &#39;Su nuevo botón debe tener dos clases: <code>btn</code> y <code>btn-default</code> .&#39;
+  - text: 'Su nuevo botón debe tener dos clases: <code>btn</code> y <code>btn-default</code> .'
     testString: 'assert($("button").hasClass("btn") && $("button").hasClass("btn-default"), "Your new button should have two classes: <code>btn</code> and <code>btn-default</code>.");'
   - text: Asegúrese de que todos los elementos de sus <code>button</code> tengan una etiqueta de cierre.
     testString: 'assert(code.match(/<\/button>/g) && code.match(/<button/g) && code.match(/<\/button>/g).length === code.match(/<button/g).length, "Make sure all your <code>button</code> elements have a closing tag.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-buttons.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-buttons.spanish.md
index 93a19a9793..5514f7bb64 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-buttons.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-buttons.spanish.md
@@ -6,13 +6,13 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-Al igual que etiquetamos nuestros pozos, queremos etiquetar nuestros botones. 
-Dé a cada uno de los elementos de su <code>button</code> texto que corresponda al selector de su <code>id</code> . 
+<section id='description'>
+Al igual que etiquetamos nuestros pozos, queremos etiquetar nuestros botones.
+Dé a cada uno de los elementos de su <code>button</code> texto que corresponda al selector de su <code>id</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -21,17 +21,17 @@ Dé a cada uno de los elementos de su <code>button</code> texto que corresponda
 
 ```yml
 tests:
-  - text: &#39;Déle a su elemento de <code>button</code> con el id <code>target1</code> el texto <code>#target1</code> &#39;.
+  - text: 'Déle a su elemento de <code>button</code> con el id <code>target1</code> el texto <code>#target1</code> '
     testString: 'assert(new RegExp("#target1","gi").test($("#target1").text()), "Give your <code>button</code> element with the id <code>target1</code> the text <code>#target1</code>.");'
-  - text: &#39;Déle a su elemento de <code>button</code> con el id <code>target2</code> el texto <code>#target2</code> &#39;.
+  - text: 'Déle a su elemento de <code>button</code> con el id <code>target2</code> el texto <code>#target2</code> '
     testString: 'assert(new RegExp("#target2","gi").test($("#target2").text()), "Give your <code>button</code> element with the id <code>target2</code> the text <code>#target2</code>.");'
-  - text: &#39;Déle a su elemento de <code>button</code> con el id <code>target3</code> el texto <code>#target3</code> &#39;.
+  - text: 'Déle a su elemento de <code>button</code> con el id <code>target3</code> el texto <code>#target3</code> '
     testString: 'assert(new RegExp("#target3","gi").test($("#target3").text()), "Give your <code>button</code> element with the id <code>target3</code> the text <code>#target3</code>.");'
-  - text: &#39;Dale a tu elemento de <code>button</code> con el id <code>target4</code> el texto <code>#target4</code> &#39;.
+  - text: 'Dale a tu elemento de <code>button</code> con el id <code>target4</code> el texto <code>#target4</code> '
     testString: 'assert(new RegExp("#target4","gi").test($("#target4").text()), "Give your <code>button</code> element with the id <code>target4</code> the text <code>#target4</code>.");'
-  - text: &#39;Dale a tu elemento del <code>button</code> con el id <code>target5</code> el texto <code>#target5</code> &#39;.
+  - text: 'Dale a tu elemento del <code>button</code> con el id <code>target5</code> el texto <code>#target5</code> '
     testString: 'assert(new RegExp("#target5","gi").test($("#target5").text()), "Give your <code>button</code> element with the id <code>target5</code> the text <code>#target5</code>.");'
-  - text: &#39;Dale a tu elemento del <code>button</code> con el id <code>target6</code> el texto <code>#target6</code> &#39;.
+  - text: 'Dale a tu elemento del <code>button</code> con el id <code>target6</code> el texto <code>#target6</code> '
     testString: 'assert(new RegExp("#target6","gi").test($("#target6").text()), "Give your <code>button</code> element with the id <code>target6</code> the text <code>#target6</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-wells.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-wells.spanish.md
index 493d26d0f0..7a3160903a 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-wells.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/label-bootstrap-wells.spanish.md
@@ -6,14 +6,14 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-Para mayor claridad, etiquetemos nuestros pozos con sus identificadores. 
-Por encima de su pozo izquierdo, dentro de su elemento <code>div</code> <code>col-xs-6</code> , agregue un elemento <code>h4</code> con el texto <code>#left-well</code> . 
-Por encima de su derecha-bien, dentro de su elemento <code>div</code> <code>col-xs-6</code> , agregue un elemento <code>h4</code> con el texto <code>#right-well</code> . 
+<section id='description'>
+Para mayor claridad, etiquetemos nuestros pozos con sus identificadores.
+Por encima de su pozo izquierdo, dentro de su elemento <code>div</code> <code>col-xs-6</code> , agregue un elemento <code>h4</code> con el texto <code>#left-well</code> .
+Por encima de su derecha-bien, dentro de su elemento <code>div</code> <code>col-xs-6</code> , agregue un elemento <code>h4</code> con el texto <code>#right-well</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,11 +22,11 @@ Por encima de su derecha-bien, dentro de su elemento <code>div</code> <code>col-
 
 ```yml
 tests:
-  - text: &#39;Agregue un elemento <code>h4</code> a cada uno de sus elementos <code>&lt;div class=&quot;col-xs-6&quot;&gt;</code> .&#39;
+  - text: 'Agregue un elemento <code>h4</code> a cada uno de sus elementos <code>&lt;div class=&quot;col-xs-6&quot;&gt;</code> .'
     testString: 'assert($(".col-xs-6").children("h4") && $(".col-xs-6").children("h4").length > 1, "Add an <code>h4</code> element to each of your <code>&#60;div class="col-xs-6"&#62;</code> elements.");'
-  - text: &#39;Un elemento <code>h4</code> debe tener el texto <code>#left-well</code> &#39;.
+  - text: 'Un elemento <code>h4</code> debe tener el texto <code>#left-well</code> '
     testString: 'assert(new RegExp("#left-well","gi").test($("h4").text()), "One <code>h4</code> element should have the text <code>#left-well</code>.");'
-  - text: &#39;Un elemento <code>h4</code> debería tener el texto <code>#right-well</code> &#39;.
+  - text: 'Un elemento <code>h4</code> debería tener el texto <code>#right-well</code> '
     testString: 'assert(new RegExp("#right-well","gi").test($("h4").text()), "One <code>h4</code> element should have the text <code>#right-well</code>.");'
   - text: Asegúrate de que todos tus elementos <code>h4</code> tengan etiquetas de cierre.
     testString: 'assert(code.match(/<\/h4>/g) && code.match(/<h4/g) && code.match(/<\/h4>/g).length === code.match(/<h4/g).length, "Make sure all your <code>h4</code> elements have closing tags.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/style-text-inputs-as-form-controls.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/style-text-inputs-as-form-controls.spanish.md
index f1c8651a3f..048175d695 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/style-text-inputs-as-form-controls.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/style-text-inputs-as-form-controls.spanish.md
@@ -9,14 +9,14 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-Puede agregar el ícono Font Awesome de <code>fa-paper-plane</code> agregando <code>&lt;i class=&quot;fa fa-paper-plane&quot;&gt;&lt;/i&gt;</code> dentro del elemento del <code>button</code> envío. 
-Asigne al campo de entrada de texto de su formulario una clase de <code>form-control</code> de <code>form-control</code> . Déle a su formulario el botón de enviar las clases <code>btn btn-primary</code> . También dé a este botón el icono de Font Awesome de <code>fa-paper-plane</code> . 
-Todos los elementos textuales <code>&lt;input&gt;</code> , <code>&lt;textarea&gt;</code> y <code>&lt;select&gt;</code> con la clase <code>.form-control</code> tienen un ancho del 100%. 
+<section id='description'>
+Puede agregar el ícono Font Awesome de <code>fa-paper-plane</code> agregando <code>&lt;i class=&quot;fa fa-paper-plane&quot;&gt;&lt;/i&gt;</code> dentro del elemento del <code>button</code> envío.
+Asigne al campo de entrada de texto de su formulario una clase de <code>form-control</code> de <code>form-control</code> . Déle a su formulario el botón de enviar las clases <code>btn btn-primary</code> . También dé a este botón el icono de Font Awesome de <code>fa-paper-plane</code> .
+Todos los elementos textuales <code>&lt;input&gt;</code> , <code>&lt;textarea&gt;</code> y <code>&lt;select&gt;</code> con la clase <code>.form-control</code> tienen un ancho del 100%.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,7 +27,7 @@ Todos los elementos textuales <code>&lt;input&gt;</code> , <code>&lt;textarea&gt
 tests:
   - text: Dale al botón de enviar en tu formulario las clases <code>btn btn-primary</code> .
     testString: 'assert($("button[type=\"submit\"]").hasClass("btn btn-primary"), "Give the submit button in your form the classes <code>btn btn-primary</code>.");'
-  - text: &#39;Agrega un <code>&lt;i class=&quot;fa fa-paper-plane&quot;&gt;&lt;/i&gt;</code> dentro de tu elemento de <code>button</code> envío.&#39;
+  - text: 'Agrega un <code>&lt;i class=&quot;fa fa-paper-plane&quot;&gt;&lt;/i&gt;</code> dentro de tu elemento de <code>button</code> envío.'
     testString: 'assert($("button[type=\"submit\"]:has(i.fa.fa-paper-plane)").length > 0, "Add a <code>&#60;i class="fa fa-paper-plane"&#62;&#60;/i&#62;</code> within your submit <code>button</code> element.");'
   - text: Dale al texto <code>input</code> en tu formulario la clase <code>form-control</code> .
     testString: 'assert($("input[type=\"text\"]").hasClass("form-control"), "Give the text <code>input</code> in your form the class <code>form-control</code>.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/use-comments-to-clarify-code.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/use-comments-to-clarify-code.spanish.md
index 75b1173b81..947bdc8905 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/use-comments-to-clarify-code.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/bootstrap/use-comments-to-clarify-code.spanish.md
@@ -6,15 +6,15 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-Cuando comencemos a usar jQuery, modificaremos los elementos HTML sin necesidad de cambiarlos realmente en HTML. 
-Asegurémonos de que todos sepan que no deberían modificar nada de este código directamente. 
-Recuerde que puede comenzar un comentario con <code>&lt;!--</code> y terminar un comentario con <code>--&gt;</code> 
-Agregue un comentario en la parte superior de su código HTML que diga <code>Only change code above this line.</code> 
+<section id='description'>
+Cuando comencemos a usar jQuery, modificaremos los elementos HTML sin necesidad de cambiarlos realmente en HTML.
+Asegurémonos de que todos sepan que no deberían modificar nada de este código directamente.
+Recuerde que puede comenzar un comentario con <code>&lt;!--</code> y terminar un comentario con <code>--&gt;</code>
+Agregue un comentario en la parte superior de su código HTML que diga <code>Only change code above this line.</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,11 +23,11 @@ Agregue un comentario en la parte superior de su código HTML que diga <code>Onl
 
 ```yml
 tests:
-  - text: &#39;Comience un comentario con <code>&lt;!--</code> en la parte superior de su HTML&#39;.
+  - text: 'Comience un comentario con <code>&lt;!--</code> en la parte superior de su HTML'
     testString: 'assert(code.match(/^\s*<!--/), "Start a comment with <code>&#60;!--</code> at the top of your HTML.");'
   - text: Su comentario debe tener el texto <code>Only change code above this line</code> .
     testString: 'assert(code.match(/<!--(?!(>|->|.*-->.*this line))\s*.*this line.*\s*-->/gi), "Your comment should have the text <code>Only change code above this line</code>.");'
-  - text: &#39;Asegúrese de cerrar su comentario con <code>--&gt;</code> .&#39;
+  - text: 'Asegúrese de cerrar su comentario con <code>--&gt;</code> .'
     testString: 'assert(code.match(/-->.*\n+.+/g), "Be sure to close your comment with <code>--&#62;</code>.");'
   - text: Debes tener el mismo número de abridores y cerradores de comentarios.
     testString: 'assert(code.match(/<!--/g).length === code.match(/-->/g).length, "You should have the same number of comment openers and closers.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/delete-your-jquery-functions.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/delete-your-jquery-functions.spanish.md
index a83a3b4d4b..44a33a50e9 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/delete-your-jquery-functions.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/delete-your-jquery-functions.spanish.md
@@ -8,13 +8,13 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Estas animaciones fueron geniales al principio, pero ahora se están distrayendo. 
-Borre las tres funciones de jQuery de su función de <code>document ready function</code> , pero deje la <code>document ready function</code> intacta. 
+<section id='description'>
+Estas animaciones fueron geniales al principio, pero ahora se están distrayendo.
+Borre las tres funciones de jQuery de su función de <code>document ready function</code> , pero deje la <code>document ready function</code> intacta.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,7 +27,7 @@ tests:
     testString: 'assert(code.match(/\{\s*\}\);/g), "Delete all three of your jQuery functions from your <code>document ready function</code>.");'
   - text: Deja tu elemento de <code>script</code> intacto.
     testString: 'assert(code.match(/<script>/g), "Leave your <code>script</code> element intact.");'
-  - text: &#39;Deje su <code>$(document).ready(function() {</code> al principio de su elemento de <code>script</code> .&#39;
+  - text: 'Deje su <code>$(document).ready(function() {</code> al principio de su elemento de <code>script</code> .'
     testString: 'assert(code.match(/\$\(document\)\.ready\(function\(\)\s?\{/g), "Leave your <code><section id='tests'>
 
 ```yml
@@ -46,7 +46,7 @@ tests:
 ```
 
 </section>#40document&#41.ready&#40function&#40&#41 {</code> to the beginning of your <code>script</code> element.");'
-  - text: &#39;Deje su &quot;función de documento listo&quot; cerrando <code>})</code> intacta.
+  - text: 'Deje su &quot;función de documento listo&quot; cerrando <code>})</code> intacta.
     testString: 'assert(code.match(/.*\s*\}\);/g), "Leave your "document ready function" closing <code>&#125;&#41;</code> intact.");'
   - text: Deje intacta la etiqueta de cierre del elemento de su <code>script</code> .
     testString: 'assert(code.match(/<\/script>/g) && code.match(/<script/g) && code.match(/<\/script>/g).length === code.match(/<script/g).length, "Leave your <code>script</code> element closing tag intact.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/learn-how-script-tags-and-document-ready-work.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/learn-how-script-tags-and-document-ready-work.spanish.md
index 86bb4e36b7..7ee1751b08 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/learn-how-script-tags-and-document-ready-work.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/learn-how-script-tags-and-document-ready-work.spanish.md
@@ -6,18 +6,18 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Ahora estamos listos para aprender jQuery, la herramienta de JavaScript más popular de todos los tiempos. 
-Antes de que podamos comenzar a usar jQuery, necesitamos agregar algunas cosas a nuestro HTML. 
-Primero, agregue un elemento de <code>script</code> en la parte superior de su página. Asegúrate de cerrarla en la siguiente línea. 
-Su navegador ejecutará cualquier JavaScript dentro de un elemento de <code>script</code> , incluyendo jQuery. 
-Dentro de su elemento de <code>script</code> , agregue este código: <code>$(document).ready(function() {</code> a su <code>script</code> . Luego ciérrelo en la siguiente línea (aún dentro de su elemento de <code>script</code> ) con: <code>});</code> 
-Aprenderemos más sobre las <code>functions</code> más adelante. Lo importante que debe saber es que el código que ingrese dentro de esta <code>function</code> se ejecutará tan pronto como su navegador haya cargado su página. 
-Esto es importante porque sin su <code>document ready function</code> , su código puede ejecutarse antes de que se genere su HTML, lo que causaría errores. 
+<section id='description'>
+Ahora estamos listos para aprender jQuery, la herramienta de JavaScript más popular de todos los tiempos.
+Antes de que podamos comenzar a usar jQuery, necesitamos agregar algunas cosas a nuestro HTML.
+Primero, agregue un elemento de <code>script</code> en la parte superior de su página. Asegúrate de cerrarla en la siguiente línea.
+Su navegador ejecutará cualquier JavaScript dentro de un elemento de <code>script</code> , incluyendo jQuery.
+Dentro de su elemento de <code>script</code> , agregue este código: <code>$(document).ready(function() {</code> a su <code>script</code> . Luego ciérrelo en la siguiente línea (aún dentro de su elemento de <code>script</code> ) con: <code>});</code>
+Aprenderemos más sobre las <code>functions</code> más adelante. Lo importante que debe saber es que el código que ingrese dentro de esta <code>function</code> se ejecutará tan pronto como su navegador haya cargado su página.
+Esto es importante porque sin su <code>document ready function</code> , su código puede ejecutarse antes de que se genere su HTML, lo que causaría errores.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,7 +28,7 @@ Esto es importante porque sin su <code>document ready function</code> , su códi
 tests:
   - text: Cree un elemento de <code>script</code> asegurándose de que sea válido y tenga una etiqueta de cierre.
     testString: 'assert(code.match(/<\/script\s*>/g) && code.match(/<script(\sasync|\sdefer)*(\s(charset|src|type)\s*=\s*["\"]+[^"\"]*["\"]+)*(\sasync|\sdefer)*\s*>/g) && code.match(/<\/script\s*>/g).length === code.match(/<script(\sasync|\sdefer)*(\s(charset|src|type)\s*=\s*["\"]+[^"\"]*["\"]+)*(\sasync|\sdefer)*\s*>/g).length, "Create a <code>script</code> element making sure it is valid and has a closing tag.");'
-  - text: &#39;Debes agregar <code>$(document).ready (function() {</code> al principio de tu elemento de <code>script</code> .&#39;
+  - text: 'Debes agregar <code>$(document).ready (function() {</code> al principio de tu elemento de <code>script</code> .'
     testString: 'assert(code.match(/\$\s*?\(\s*?document\s*?\)\.ready\s*?\(\s*?function\s*?\(\s*?\)\s*?\{/g), "You should add <code><section id='tests'>
 
 ```yml
@@ -43,7 +43,7 @@ tests:
 ```
 
 </section>#40;document&#41;.ready<wbr>&#40;function&#40;&#41; {</code> to the beginning of your <code>script</code> element.");'
-  - text: &#39;Cierre su <code>$(document).ready (function() {</code> function with <code>});</code> &#39;
+  - text: 'Cierre su <code>$(document).ready (function() {</code> function with <code>});</code> '
     testString: 'assert(code.match(/\n*?\s*?\}\s*?\);/g), "Close your <code><section id='tests'>
 
 ```yml
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-a-specific-child-of-an-element-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-a-specific-child-of-an-element-using-jquery.spanish.md
index 6e7a036424..0d1e85db06 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-a-specific-child-of-an-element-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-a-specific-child-of-an-element-using-jquery.spanish.md
@@ -8,17 +8,17 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Ha visto por qué los atributos de identificación son tan convenientes para la selección de objetivos con los selectores jQuery. Pero no siempre tendrás tan buenos identificadores con los que trabajar. 
-Afortunadamente, jQuery tiene algunos otros trucos para apuntar a los elementos correctos. 
-jQuery usa los selectores de CSS para apuntar a los elementos. El selector de CSS <code>target:nth-child(n)</code> permite seleccionar todos los elementos nth con la clase de destino o el tipo de elemento. 
-Así es como le darías al tercer elemento en cada pozo la clase de rebote: 
-<code>$(&quot;.target:nth-child(3)&quot;).addClass(&quot;animated bounce&quot;);</code> 
-Haz que el segundo niño en cada uno de tus elementos de pozo rebote. Debes seleccionar los elementos de los hijos con la clase <code>target</code> . 
+<section id='description'>
+Ha visto por qué los atributos de identificación son tan convenientes para la selección de objetivos con los selectores jQuery. Pero no siempre tendrás tan buenos identificadores con los que trabajar.
+Afortunadamente, jQuery tiene algunos otros trucos para apuntar a los elementos correctos.
+jQuery usa los selectores de CSS para apuntar a los elementos. El selector de CSS <code>target:nth-child(n)</code> permite seleccionar todos los elementos nth con la clase de destino o el tipo de elemento.
+Así es como le darías al tercer elemento en cada pozo la clase de rebote:
+<code>$(&quot;.target:nth-child(3)&quot;).addClass(&quot;animated bounce&quot;);</code>
+Haz que el segundo niño en cada uno de tus elementos de pozo rebote. Debes seleccionar los elementos de los hijos con la clase <code>target</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -31,7 +31,7 @@ tests:
     testString: 'assert($(".target:nth-child(2)").hasClass("animated") && $(".target:nth-child(2)").hasClass("bounce"), "The second element in your <code>target</code> elements should bounce.");'
   - text: Solo dos elementos deben rebotar.
     testString: 'assert($(".animated.bounce").length === 2, "Only two elements should bounce.");'
-  - text: &#39;Debería usar el selector <code>:nth-child()</code> para modificar estos elementos.&#39;
+  - text: 'Debería usar el selector <code>:nth-child()</code> para modificar estos elementos.'
     testString: 'assert(code.match(/\:nth-child\(/g), "You should use the <code>&#58;nth-child&#40&#41</code> selector to modify these elements.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(code.match(/\$\(".target:nth-child\(2\)"\)/g) || code.match(/\$\(".target:nth-child\(2\)"\)/g) || code.match(/\$\(".target"\).filter\(":nth-child\(2\)"\)/g) || code.match(/\$\(".target"\).filter\(":nth-child\(2\)"\)/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-class-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-class-using-jquery.spanish.md
index dda381c54e..82e08d7416 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-class-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-class-using-jquery.spanish.md
@@ -8,18 +8,18 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-¿Ves cómo hicimos rebotar todos los elementos de tus <code>button</code> ? Los seleccionamos con <code>$(&quot;button&quot;)</code> , luego les agregamos algunas clases de CSS con <code>.addClass(&quot;animated bounce&quot;);</code> . 
-Acaba de usar la función <code>.addClass()</code> jQuery, que le permite agregar clases a los elementos. 
-En primer lugar, vamos a orientar su <code>div</code> elementos con la clase <code>well</code> mediante el uso de la <code>$(&quot;.well&quot;)</code> selector. 
-Tenga en cuenta que, al igual que con las declaraciones de CSS, escribe a <code>.</code> antes del nombre de la clase. 
-Luego usa la función <code>.addClass()</code> jQuery para agregar las clases <code>animated</code> y <code>shake</code> . 
-Por ejemplo, puede hacer que todos los elementos con la clase <code>text-primary</code> shake agregando lo siguiente a su <code>document ready function</code> : 
-<code>$(&quot;.text-primary&quot;).addClass(&quot;animated shake&quot;);</code> 
+<section id='description'>
+¿Ves cómo hicimos rebotar todos los elementos de tus <code>button</code> ? Los seleccionamos con <code>$(&quot;button&quot;)</code> , luego les agregamos algunas clases de CSS con <code>.addClass(&quot;animated bounce&quot;);</code> .
+Acaba de usar la función <code>.addClass()</code> jQuery, que le permite agregar clases a los elementos.
+En primer lugar, vamos a orientar su <code>div</code> elementos con la clase <code>well</code> mediante el uso de la <code>$(&quot;.well&quot;)</code> selector.
+Tenga en cuenta que, al igual que con las declaraciones de CSS, escribe a <code>.</code> antes del nombre de la clase.
+Luego usa la función <code>.addClass()</code> jQuery para agregar las clases <code>animated</code> y <code>shake</code> .
+Por ejemplo, puede hacer que todos los elementos con la clase <code>text-primary</code> shake agregando lo siguiente a su <code>document ready function</code> :
+<code>$(&quot;.text-primary&quot;).addClass(&quot;animated shake&quot;);</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,7 +28,7 @@ Por ejemplo, puede hacer que todos los elementos con la clase <code>text-primary
 
 ```yml
 tests:
-  - text: &#39;Use el jQuery <code>addClass()</code> la función de dar las clases <code>animated</code> y <code>shake</code> a todos sus elementos con la clase <code>well</code> .&#39;
+  - text: 'Use el jQuery <code>addClass()</code> la función de dar las clases <code>animated</code> y <code>shake</code> a todos sus elementos con la clase <code>well</code> .'
     testString: 'assert($(".well").hasClass("animated") && $(".well").hasClass("shake"), "Use the jQuery <code>addClass&#40&#41</code> function to give the classes <code>animated</code> and <code>shake</code> to all your elements with the class <code>well</code>.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(!code.match(/class\.\*animated/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-id-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-id-using-jquery.spanish.md
index 69e92a4a67..be963bf7a1 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-id-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-elements-by-id-using-jquery.spanish.md
@@ -8,17 +8,17 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-También puede apuntar elementos por sus atributos de identificación. 
-Primero apunte el elemento de su <code>button</code> con el id <code>target3</code> usando el selector <code>$(&quot;#target3&quot;)</code> . 
-Tenga en cuenta que, al igual que con las declaraciones de CSS, escribe un <code>#</code> antes del nombre del ID. 
-Luego use la función <code>.addClass()</code> jQuery para agregar las clases <code>animated</code> y <code>fadeOut</code> . 
-Así es como harías que el elemento del <code>button</code> con el id <code>target6</code> desvanezca: 
-<code>$(&quot;#target6&quot;).addClass(&quot;animated fadeOut&quot;)</code> . 
+<section id='description'>
+También puede apuntar elementos por sus atributos de identificación.
+Primero apunte el elemento de su <code>button</code> con el id <code>target3</code> usando el selector <code>$(&quot;#target3&quot;)</code> .
+Tenga en cuenta que, al igual que con las declaraciones de CSS, escribe un <code>#</code> antes del nombre del ID.
+Luego use la función <code>.addClass()</code> jQuery para agregar las clases <code>animated</code> y <code>fadeOut</code> .
+Así es como harías que el elemento del <code>button</code> con el id <code>target6</code> desvanezca:
+<code>$(&quot;#target6&quot;).addClass(&quot;animated fadeOut&quot;)</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,9 +27,9 @@ Así es como harías que el elemento del <code>button</code> con el id <code>tar
 
 ```yml
 tests:
-  - text: &#39;Seleccione el elemento del <code>button</code> con el <code>id</code> de <code>target3</code> y use la función jQuery <code>addClass()</code> para darle la clase de <code>animated</code> .&#39;
+  - text: 'Seleccione el elemento del <code>button</code> con el <code>id</code> de <code>target3</code> y use la función jQuery <code>addClass()</code> para darle la clase de <code>animated</code> .'
     testString: 'assert($("#target3").hasClass("animated"), "Select the <code>button</code> element with the <code>id</code> of <code>target3</code> and use the jQuery <code>addClass&#40&#41</code> function to give it the class of <code>animated</code>.");'
-  - text: &#39; <code>target3</code> al elemento con el id <code>target3</code> y usa la función jQuery <code>addClass()</code> para darle a la clase <code>fadeOut</code> .&#39;
+  - text: ' <code>target3</code> al elemento con el id <code>target3</code> y usa la función jQuery <code>addClass()</code> para darle a la clase <code>fadeOut</code> .'
     testString: 'assert(($("#target3").hasClass("fadeOut") || $("#target3").hasClass("fadeout"))  && code.match(/\$\(\s*.#target3.\s*\)/g), "Target the element with the id <code>target3</code> and use the jQuery <code>addClass&#40&#41</code> function to give it the class <code>fadeOut</code>.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(!code.match(/class.*animated/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-even-elements-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-even-elements-using-jquery.spanish.md
index 402fdc8c49..707f5e6a40 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-even-elements-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-even-elements-using-jquery.spanish.md
@@ -8,16 +8,16 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-También puede apuntar elementos según sus posiciones usando <code>:odd</code> o <code>:even</code> selectores <code>:even</code> . 
-Tenga en cuenta que jQuery tiene un índice de cero, lo que significa que el primer elemento de una selección tiene una posición de 0. Esto puede ser un poco confuso, ya que, en contra de la intuición,: <code>:odd</code> selecciona el segundo elemento (posición 1), cuarto elemento (posición 3). ), y así. 
-Así es como se enfocaría en todos los elementos impares con la clase <code>target</code> y les daría clases: 
-<code>$(&quot;.target:odd&quot;).addClass(&quot;animated shake&quot;);</code> 
-Intenta seleccionar todos los elementos <code>target</code> uniformes y dales las clases de <code>animated</code> y <code>shake</code> . Recuerde que <strong>incluso se</strong> refiere a la posición de los elementos con un sistema basado en cero en mente. 
+<section id='description'>
+También puede apuntar elementos según sus posiciones usando <code>:odd</code> o <code>:even</code> selectores <code>:even</code> .
+Tenga en cuenta que jQuery tiene un índice de cero, lo que significa que el primer elemento de una selección tiene una posición de 0. Esto puede ser un poco confuso, ya que, en contra de la intuición,: <code>:odd</code> selecciona el segundo elemento (posición 1), cuarto elemento (posición 3). ), y así.
+Así es como se enfocaría en todos los elementos impares con la clase <code>target</code> y les daría clases:
+<code>$(&quot;.target:odd&quot;).addClass(&quot;animated shake&quot;);</code>
+Intenta seleccionar todos los elementos <code>target</code> uniformes y dales las clases de <code>animated</code> y <code>shake</code> . Recuerde que <strong>incluso se</strong> refiere a la posición de los elementos con un sistema basado en cero en mente.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,7 +28,7 @@ Intenta seleccionar todos los elementos <code>target</code> uniformes y dales la
 tests:
   - text: Todos los elementos de <code>target</code> que jQuery considera que están parejos deben sacudirse.
     testString: 'assert($(".target:even").hasClass("animated") && $(".target:even").hasClass("shake"), "All of the <code>target</code> elements that jQuery considers to be even should shake.");'
-  - text: &#39;Deberías usar el selector <code>:even</code> para modificar estos elementos&#39;.
+  - text: 'Deberías usar el selector <code>:even</code> para modificar estos elementos'
     testString: 'assert(code.match(/\:even/g), "You should use the <code>&#58;even</code> selector to modify these elements.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(code.match(/\$\(".target:even"\)/g) || code.match(/\$\(".target:even"\)/g) || code.match(/\$\(".target"\).filter\(":even"\)/g) || code.match(/\$\(".target"\).filter\(":even"\)/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-html-elements-with-selectors-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-html-elements-with-selectors-using-jquery.spanish.md
index acf2c6a2cb..18fffed208 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-html-elements-with-selectors-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-html-elements-with-selectors-using-jquery.spanish.md
@@ -8,17 +8,17 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Ahora tenemos una <code>document ready function</code> . 
-Ahora vamos a escribir nuestra primera declaración jQuery. Todas las funciones de jQuery comienzan con un <code>$</code> , generalmente conocido como <code>dollar sign operator</code> , o como <code>bling</code> . 
-jQuery a menudo selecciona un elemento HTML con un <code>selector</code> , luego le hace algo a ese elemento. 
-Por ejemplo, hagamos que todos los elementos de tus <code>button</code> reboten. Solo agregue este código dentro de su función de documento listo: 
-<code>$(&quot;button&quot;).addClass(&quot;animated bounce&quot;);</code> 
-Tenga en cuenta que ya hemos incluido la biblioteca jQuery y la biblioteca Animate.css en segundo plano para que pueda usarlas en el editor. Así que estás utilizando jQuery para aplicar la clase de <code>bounce</code> Animate.css a los elementos de tu <code>button</code> . 
+<section id='description'>
+Ahora tenemos una <code>document ready function</code> .
+Ahora vamos a escribir nuestra primera declaración jQuery. Todas las funciones de jQuery comienzan con un <code>$</code> , generalmente conocido como <code>dollar sign operator</code> , o como <code>bling</code> .
+jQuery a menudo selecciona un elemento HTML con un <code>selector</code> , luego le hace algo a ese elemento.
+Por ejemplo, hagamos que todos los elementos de tus <code>button</code> reboten. Solo agregue este código dentro de su función de documento listo:
+<code>$(&quot;button&quot;).addClass(&quot;animated bounce&quot;);</code>
+Tenga en cuenta que ya hemos incluido la biblioteca jQuery y la biblioteca Animate.css en segundo plano para que pueda usarlas en el editor. Así que estás utilizando jQuery para aplicar la clase de <code>bounce</code> Animate.css a los elementos de tu <code>button</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,7 +27,7 @@ Tenga en cuenta que ya hemos incluido la biblioteca jQuery y la biblioteca Anima
 
 ```yml
 tests:
-  - text: &#39;Use el jQuery <code>addClass()</code> la función de dar las clases <code>animated</code> y <code>bounce</code> a sus <code>button</code> elementos.&#39;
+  - text: 'Use el jQuery <code>addClass()</code> la función de dar las clases <code>animated</code> y <code>bounce</code> a sus <code>button</code> elementos.'
     testString: 'assert($("button").hasClass("animated") && $("button").hasClass("bounce"), "Use the jQuery <code>addClass&#40&#41</code> function to give the classes <code>animated</code> and <code>bounce</code> to your <code>button</code> elements.");'
   - text: Solo use jQuery para agregar estos colores al elemento.
     testString: 'assert(!code.match(/class.*animated/g), "Only use jQuery to add these colors to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-children-of-an-element-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-children-of-an-element-using-jquery.spanish.md
index e9d8ab6df9..6302b9d4be 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-children-of-an-element-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-children-of-an-element-using-jquery.spanish.md
@@ -6,16 +6,16 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Cuando los elementos HTML se colocan un nivel debajo de otro, se denominan <code>children</code> de ese elemento. Por ejemplo, los elementos de los botones en este desafío con el texto &quot;# destino1&quot;, &quot;# destino2&quot;, y &quot;# destino3&quot; son todos <code>children</code> de la <code>&lt;div class=&quot;well&quot; id=&quot;left-well&quot;&gt;</code> elemento. 
-jQuery tiene una función llamada <code>children()</code> que le permite acceder a los hijos de cualquier elemento que haya seleccionado. 
-Este es un ejemplo de cómo usaría la función <code>children()</code> para dar a los niños de su elemento de <code>left-well</code> el color <code>blue</code> : 
-<code>$(&quot;#left-well&quot;).children().css(&quot;color&quot;, &quot;blue&quot;)</code> 
+<section id='description'>
+Cuando los elementos HTML se colocan un nivel debajo de otro, se denominan <code>children</code> de ese elemento. Por ejemplo, los elementos de los botones en este desafío con el texto &quot;# destino1&quot;, &quot;# destino2&quot;, y &quot;# destino3&quot; son todos <code>children</code> de la <code>&lt;div class=&quot;well&quot; id=&quot;left-well&quot;&gt;</code> elemento.
+jQuery tiene una función llamada <code>children()</code> que le permite acceder a los hijos de cualquier elemento que haya seleccionado.
+Este es un ejemplo de cómo usaría la función <code>children()</code> para dar a los niños de su elemento de <code>left-well</code> el color <code>blue</code> :
+<code>$(&quot;#left-well&quot;).children().css(&quot;color&quot;, &quot;blue&quot;)</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Dale a todos los niños de tu elemento de <code>right-well</code> el color naranja. 
+<section id='instructions'>
+Dale a todos los niños de tu elemento de <code>right-well</code> el color naranja.
 </section>
 
 ## Tests
@@ -23,9 +23,9 @@ Dale a todos los niños de tu elemento de <code>right-well</code> el color naran
 
 ```yml
 tests:
-  - text: &#39;Todos los niños de <code>#right-well</code> deben tener texto naranja&#39;.
+  - text: 'Todos los niños de <code>#right-well</code> deben tener texto naranja'
     testString: 'assert($("#right-well").children().css("color") === "rgb(255, 165, 0)", "All children of <code>#right-well</code> should have orange text.");'
-  - text: &#39;Deberías usar la función <code>children()</code> para modificar estos elementos.&#39;
+  - text: 'Deberías usar la función <code>children()</code> para modificar estos elementos.'
     testString: 'assert(code.match(/\.children\(\)\.css/g), "You should use the <code>children&#40&#41</code> function to modify these elements.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(code.match(/<div class="well" id="right-well">/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-parent-of-an-element-using-jquery.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-parent-of-an-element-using-jquery.spanish.md
index 55b29b2a1c..1f91956452 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-parent-of-an-element-using-jquery.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-parent-of-an-element-using-jquery.spanish.md
@@ -6,17 +6,17 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Cada elemento HTML tiene un elemento <code>parent</code> del cual <code>inherits</code> propiedades. 
-Por ejemplo, su elemento <code>jQuery Playground</code> <code>h3</code> tiene el elemento primario de <code>&lt;div class=&quot;container-fluid&quot;&gt;</code> , que a su vez tiene el <code>body</code> principal. 
-jQuery tiene una función llamada <code>parent()</code> que le permite acceder al padre de cualquier elemento que haya seleccionado. 
-Este es un ejemplo de cómo usaría la función <code>parent()</code> si quisiera darle al elemento padre del elemento del <code>left-well</code> un color de fondo azul: 
-<code>$(&quot;#left-well&quot;).parent().css(&quot;background-color&quot;, &quot;blue&quot;)</code> 
-<code>#target1</code> al padre del elemento <code>#target1</code> un color de fondo rojo. 
+<section id='description'>
+Cada elemento HTML tiene un elemento <code>parent</code> del cual <code>inherits</code> propiedades.
+Por ejemplo, su elemento <code>jQuery Playground</code> <code>h3</code> tiene el elemento primario de <code>&lt;div class=&quot;container-fluid&quot;&gt;</code> , que a su vez tiene el <code>body</code> principal.
+jQuery tiene una función llamada <code>parent()</code> que le permite acceder al padre de cualquier elemento que haya seleccionado.
+Este es un ejemplo de cómo usaría la función <code>parent()</code> si quisiera darle al elemento padre del elemento del <code>left-well</code> un color de fondo azul:
+<code>$(&quot;#left-well&quot;).parent().css(&quot;background-color&quot;, &quot;blue&quot;)</code>
+<code>#target1</code> al padre del elemento <code>#target1</code> un color de fondo rojo.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,9 +27,9 @@ Este es un ejemplo de cómo usaría la función <code>parent()</code> si quisier
 tests:
   - text: Su elemento de <code>left-well</code> debe tener un fondo rojo.
     testString: 'assert($("#left-well").css("background-color") === "red" || $("#left-well").css("background-color") === "rgb(255, 0, 0)" || $("#left-well").css("background-color").toLowerCase() === "#ff0000" || $("#left-well").css("background-color").toLowerCase() === "#f00", "Your <code>left-well</code> element should have a red background.");'
-  - text: &#39;Deberías usar la función <code>.parent()</code> para modificar este elemento.&#39;
+  - text: 'Deberías usar la función <code>.parent()</code> para modificar este elemento.'
     testString: 'assert(code.match(/\.parent\s*\(\s*\)\s*\.css/g), "You should use the <code>&#46;parent&#40;&#41;</code> function to modify this element.");'
-  - text: &#39;El método <code>.parent()</code> debe llamarse en el elemento <code>#target1</code> .&#39;
+  - text: 'El método <code>.parent()</code> debe llamarse en el elemento <code>#target1</code> .'
     testString: 'assert(code.match(/\$\s*?\(\s*?(?:"|")\s*?#target1\s*?(?:"|")\s*?\)\s*?\.parent/gi), "The <code>&#46;parent&#40;&#41;</code> method should be called on the <code>&#35;target1</code> element.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(code.match(/<div class="well" id="left-well">/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-same-element-with-multiple-jquery-selectors.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-same-element-with-multiple-jquery-selectors.spanish.md
index 34d050747f..e4cb0b2a7a 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-same-element-with-multiple-jquery-selectors.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/jquery/target-the-same-element-with-multiple-jquery-selectors.spanish.md
@@ -8,18 +8,18 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Ahora conoce tres formas de apuntar elementos: por tipo: <code>$(&quot;button&quot;)</code> , por clase: <code>$(&quot;.btn&quot;)</code> , y por id <code>$(&quot;#target1&quot;)</code> . 
-Aunque es posible agregar varias clases en una sola llamada <code>.addClass()</code> , las agregaremos al mismo elemento de <em>tres maneras diferentes</em> . 
-Usando <code>.addClass()</code> , agregue solo una clase a la vez al mismo elemento, de tres maneras diferentes: 
-Agregue la clase <code>animated</code> a todos los elementos con el <code>button</code> tipo. 
-Agregue la clase <code>shake</code> a todos los botones con la clase <code>.btn</code> . 
-Agregue la clase <code>btn-primary</code> al botón con id <code>#target1</code> . 
-<strong>Nota</strong> <br> Solo debes apuntar a un elemento y agregar solo una clase a la vez. En total, sus tres selectores individuales terminarán agregando las tres clases <code>shake</code> , <code>animated</code> y <code>btn-primary</code> a <code>#target1</code> . 
+<section id='description'>
+Ahora conoce tres formas de apuntar elementos: por tipo: <code>$(&quot;button&quot;)</code> , por clase: <code>$(&quot;.btn&quot;)</code> , y por id <code>$(&quot;#target1&quot;)</code> .
+Aunque es posible agregar varias clases en una sola llamada <code>.addClass()</code> , las agregaremos al mismo elemento de <em>tres maneras diferentes</em> .
+Usando <code>.addClass()</code> , agregue solo una clase a la vez al mismo elemento, de tres maneras diferentes:
+Agregue la clase <code>animated</code> a todos los elementos con el <code>button</code> tipo.
+Agregue la clase <code>shake</code> a todos los botones con la clase <code>.btn</code> .
+Agregue la clase <code>btn-primary</code> al botón con id <code>#target1</code> .
+<strong>Nota</strong> <br> Solo debes apuntar a un elemento y agregar solo una clase a la vez. En total, sus tres selectores individuales terminarán agregando las tres clases <code>shake</code> , <code>animated</code> y <code>btn-primary</code> a <code>#target1</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,7 +28,7 @@ Agregue la clase <code>btn-primary</code> al botón con id <code>#target1</code>
 
 ```yml
 tests:
-  - text: &#39;Use el selector <code>$(&quot;button&quot;)</code> .&#39;
+  - text: 'Use el selector <code>$(&quot;button&quot;)</code> .'
     testString: 'assert(code.match(/\$\s*?\(\s*?(?:"|")\s*?button\s*?(?:"|")/gi), "Use the <code><section id='tests'>
 
 ```yml
@@ -49,7 +49,7 @@ tests:
 ```
 
 </section>#40"button"&#41</code> selector.");'
-  - text: &#39;Use el selector <code>$(&quot;.btn&quot;)</code> .&#39;
+  - text: 'Use el selector <code>$(&quot;.btn&quot;)</code> .'
     testString: 'assert(code.match(/\$\s*?\(\s*?(?:"|")\s*?\.btn\s*?(?:"|")/gi), "Use the <code><section id='tests'>
 
 ```yml
@@ -70,7 +70,7 @@ tests:
 ```
 
 </section>#40".btn"&#41</code> selector.");'
-  - text: &#39;Use el selector <code>$(&quot;#target1&quot;)</code> .&#39;
+  - text: 'Use el selector <code>$(&quot;#target1&quot;)</code> .'
     testString: 'assert(code.match(/\$\s*?\(\s*?(?:"|")\s*?#target1\s*?(?:"|")/gi), "Use the <code><section id='tests'>
 
 ```yml
@@ -93,7 +93,7 @@ tests:
 </section>#40"#target1"&#41</code> selector.");'
   - text: Solo agrega una clase con cada uno de tus tres selectores.
     testString: 'assert(code.match(/addClass/g) && code.match(/addClass\s*?\(\s*?("|")\s*?[\w-]+\s*?\1\s*?\)/g).length > 2, "Only add one class with each of your three selectors.");'
-  - text: &#39;Su elemento <code>#target1</code> debería tener las clases <code>animated</code> , <code>shake</code> y <code>btn-primary</code> &#39;.
+  - text: 'Su elemento <code>#target1</code> debería tener las clases <code>animated</code> , <code>shake</code> y <code>btn-primary</code> '
     testString: 'assert($("#target1").hasClass("animated") && $("#target1").hasClass("shake") && $("#target1").hasClass("btn-primary"), "Your <code>#target1</code> element should have the classes <code>animated</code>&#130; <code>shake</code> and <code>btn-primary</code>.");'
   - text: Solo use jQuery para agregar estas clases al elemento.
     testString: 'assert(!code.match(/class.*animated/g), "Only use jQuery to add these classes to the element.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/connect-redux-to-the-messages-app.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/connect-redux-to-the-messages-app.spanish.md
index e3a48305bb..2d7a1da38d 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/connect-redux-to-the-messages-app.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/connect-redux-to-the-messages-app.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Ahora que entiende cómo usar <code>connect</code> para conectarse React to Redux, puede aplicar lo que ha aprendido a su componente React que maneja los mensajes. 
-En la última lección, el componente que se conectó a Redux se llamó <code>Presentational</code> , y esto no fue arbitrario. Este término <i>generalmente se</i> refiere a los componentes React que no están directamente conectados a Redux. Simplemente son responsables de la presentación de la interfaz de usuario y hacen esto en función de los accesorios que reciben. Por el contrario, los componentes del contenedor están conectados a Redux. Estos son generalmente responsables de enviar acciones a la tienda y, a menudo, pasan el estado de la tienda a componentes secundarios como accesorios. 
+<section id='description'>
+Ahora que entiende cómo usar <code>connect</code> para conectarse React to Redux, puede aplicar lo que ha aprendido a su componente React que maneja los mensajes.
+En la última lección, el componente que se conectó a Redux se llamó <code>Presentational</code> , y esto no fue arbitrario. Este término <i>generalmente se</i> refiere a los componentes React que no están directamente conectados a Redux. Simplemente son responsables de la presentación de la interfaz de usuario y hacen esto en función de los accesorios que reciben. Por el contrario, los componentes del contenedor están conectados a Redux. Estos son generalmente responsables de enviar acciones a la tienda y, a menudo, pasan el estado de la tienda a componentes secundarios como accesorios.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene todo el código que has escrito en esta sección hasta ahora. El único cambio es que el componente React se renombra a <code>Presentational</code> . Cree un nuevo componente que se mantenga en una constante llamada <code>Container</code> que use <code>connect</code> para conectar el componente <code>Presentational</code> a Redux. Luego, en <code>AppWrapper</code> , renderice el componente React Redux <code>Provider</code> . Pase a <code>Provider</code> la <code>store</code> Redux como utilería y renderice <code>Container</code> como un niño. Una vez que todo esté configurado, verás nuevamente la aplicación de mensajes renderizada en la página. 
+<section id='instructions'>
+El editor de código tiene todo el código que has escrito en esta sección hasta ahora. El único cambio es que el componente React se renombra a <code>Presentational</code> . Cree un nuevo componente que se mantenga en una constante llamada <code>Container</code> que use <code>connect</code> para conectar el componente <code>Presentational</code> a Redux. Luego, en <code>AppWrapper</code> , renderice el componente React Redux <code>Provider</code> . Pase a <code>Provider</code> la <code>store</code> Redux como utilería y renderice <code>Container</code> como un niño. Una vez que todo esté configurado, verás nuevamente la aplicación de mensajes renderizada en la página.
 </section>
 
 ## Tests
@@ -24,9 +24,9 @@ El editor de código tiene todo el código que has escrito en esta sección hast
 tests:
   - text: El <code>AppWrapper</code> debe renderizar a la página.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("AppWrapper").length === 1; })(), "The <code>AppWrapper</code> should render to the page.");'
-  - text: &#39;El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.&#39;
+  - text: 'El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("Presentational").length === 1; })(), "The <code>Presentational</code> component should render an <code>h2</code>, <code>input</code>, <code>button</code>, and <code>ul</code> elements.");'
-  - text: &#39;El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.&#39;
+  - text: 'El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const PresentationalComponent = mockedComponent.find("Presentational"); return ( PresentationalComponent.find("div").length === 1 && PresentationalComponent.find("h2").length === 1 && PresentationalComponent.find("button").length === 1 && PresentationalComponent.find("ul").length === 1 ); })(), "The <code>Presentational</code> component should render an <code>h2</code>, <code>input</code>, <code>button</code>, and <code>ul</code> elements.");'
   - text: El componente de <code>Presentational</code> debe recibir <code>messages</code> de la tienda de Redux como prop.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const PresentationalComponent = mockedComponent.find("Presentational"); const props = PresentationalComponent.props(); return Array.isArray(props.messages); })(), "The <code>Presentational</code> component should receive <code>messages</code> from the Redux store as a prop.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/extract-local-state-into-redux.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/extract-local-state-into-redux.spanish.md
index 3cabe87650..d5cbf46a9e 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/extract-local-state-into-redux.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/extract-local-state-into-redux.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Ya casi terminas! Recuerde que escribió todo el código de Redux para que Redux pudiera controlar la administración del estado de su aplicación de mensajes React. Ahora que Redux está conectado, debe extraer la administración del estado del componente de <code>Presentational</code> y en Redux. Actualmente, tiene Redux conectado, pero está manejando el estado localmente dentro del componente de <code>Presentational</code> . 
+<section id='description'>
+Ya casi terminas! Recuerde que escribió todo el código de Redux para que Redux pudiera controlar la administración del estado de su aplicación de mensajes React. Ahora que Redux está conectado, debe extraer la administración del estado del componente de <code>Presentational</code> y en Redux. Actualmente, tiene Redux conectado, pero está manejando el estado localmente dentro del componente de <code>Presentational</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-En el componente <code>Presentational</code> , primero, elimine la propiedad de <code>messages</code> en el <code>state</code> local. Estos mensajes serán gestionados por Redux. A continuación, modifique el método <code>submitMessage()</code> para que <code>submitNewMessage()</code> desde <code>this.props</code> , y pase la entrada del mensaje actual del <code>state</code> local como un argumento. Como también eliminó los <code>messages</code> del estado local, elimine la propiedad de <code>messages</code> de la llamada a <code>this.setState()</code> aquí. Finalmente, modifique el método <code>render()</code> para que se asigne sobre los mensajes recibidos de los <code>props</code> lugar del <code>state</code> . 
-Una vez que se realicen estos cambios, la aplicación continuará funcionando de la misma manera, excepto que Redux administra el estado. Este ejemplo también ilustra cómo un componente puede tener un <code>state</code> local: su componente aún realiza un seguimiento local de las entradas del usuario en su propio <code>state</code> . Puede ver cómo Redux proporciona un marco de administración de estado útil sobre React. Obtuvo el mismo resultado utilizando solo el estado local de React al principio, y esto generalmente es posible con aplicaciones simples. Sin embargo, a medida que sus aplicaciones se vuelven más grandes y complejas, también lo hace la administración de su estado, y este es el problema que Redux resuelve. 
+<section id='instructions'>
+En el componente <code>Presentational</code> , primero, elimine la propiedad de <code>messages</code> en el <code>state</code> local. Estos mensajes serán gestionados por Redux. A continuación, modifique el método <code>submitMessage()</code> para que <code>submitNewMessage()</code> desde <code>this.props</code> , y pase la entrada del mensaje actual del <code>state</code> local como un argumento. Como también eliminó los <code>messages</code> del estado local, elimine la propiedad de <code>messages</code> de la llamada a <code>this.setState()</code> aquí. Finalmente, modifique el método <code>render()</code> para que se asigne sobre los mensajes recibidos de los <code>props</code> lugar del <code>state</code> .
+Una vez que se realicen estos cambios, la aplicación continuará funcionando de la misma manera, excepto que Redux administra el estado. Este ejemplo también ilustra cómo un componente puede tener un <code>state</code> local: su componente aún realiza un seguimiento local de las entradas del usuario en su propio <code>state</code> . Puede ver cómo Redux proporciona un marco de administración de estado útil sobre React. Obtuvo el mismo resultado utilizando solo el estado local de React al principio, y esto generalmente es posible con aplicaciones simples. Sin embargo, a medida que sus aplicaciones se vuelven más grandes y complejas, también lo hace la administración de su estado, y este es el problema que Redux resuelve.
 </section>
 
 ## Tests
@@ -24,15 +24,15 @@ Una vez que se realicen estos cambios, la aplicación continuará funcionando de
 tests:
   - text: El <code>AppWrapper</code> debe renderizar a la página.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("AppWrapper").length === 1; })(), "The <code>AppWrapper</code> should render to the page.");'
-  - text: &#39;El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.&#39;
+  - text: 'El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("Presentational").length === 1; })(), "The <code>Presentational</code> component should render an <code>h2</code>, <code>input</code>, <code>button</code>, and <code>ul</code> elements.");'
-  - text: &#39;El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.&#39;
+  - text: 'El componente de <code>Presentational</code> debe representar un <code>h2</code> , <code>input</code> , <code>button</code> y <code>ul</code> elementos.'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const PresentationalComponent = mockedComponent.find("Presentational"); return ( PresentationalComponent.find("div").length === 1 && PresentationalComponent.find("h2").length === 1 && PresentationalComponent.find("button").length === 1 && PresentationalComponent.find("ul").length === 1 ); })(), "The <code>Presentational</code> component should render an <code>h2</code>, <code>input</code>, <code>button</code>, and <code>ul</code> elements.");'
   - text: El componente de <code>Presentational</code> debe recibir <code>messages</code> de la tienda de Redux como prop.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const PresentationalComponent = mockedComponent.find("Presentational"); const props = PresentationalComponent.props(); return Array.isArray(props.messages); })(), "The <code>Presentational</code> component should receive <code>messages</code> from the Redux store as a prop.");'
   - text: El componente de <code>Presentational</code> debe recibir el creador de la acción <code>submitMessage</code> como prop.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const PresentationalComponent = mockedComponent.find("Presentational"); const props = PresentationalComponent.props(); return typeof props.submitNewMessage === "function"; })(), "The <code>Presentational</code> component should receive the <code>submitMessage</code> action creator as a prop.");'
-  - text: &#39;El estado del componente <code>Presentational</code> debe contener una propiedad, <code>input</code> , que se inicializa en una cadena vacía.&#39;
+  - text: 'El estado del componente <code>Presentational</code> debe contener una propiedad, <code>input</code> , que se inicializa en una cadena vacía.'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const PresentationalState = mockedComponent.find("Presentational").instance().state; return typeof PresentationalState.input === "string" && Object.keys(PresentationalState).length === 1; })(), "The state of the <code>Presentational</code> component should contain one property, <code>input</code>, which is initialized to an empty string.");'
   - text: Escribir en el elemento de <code>input</code> debe actualizar el estado del componente de <code>Presentational</code> .
     testString: 'async () => { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); const testValue = "__MOCK__INPUT__"; const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 100)); const causeChange = (c, v) => c.find("input").simulate("change", { target: { value: v }}); let initialInput = mockedComponent.find("Presentational").find("input"); const changed = () => { causeChange(mockedComponent, testValue); return waitForIt(() => mockedComponent )}; const updated = await changed(); const updatedInput = updated.find("Presentational").find("input"); assert(initialInput.props().value === "" && updatedInput.props().value === "__MOCK__INPUT__", "Typing in the <code>input</code> element should update the state of the <code>Presentational</code> component."); }; '
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/getting-started-with-react-redux.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/getting-started-with-react-redux.spanish.md
index d59b0fc192..beb37abcac 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/getting-started-with-react-redux.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/getting-started-with-react-redux.spanish.md
@@ -7,15 +7,15 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Esta serie de desafíos presenta cómo utilizar Redux con React. Primero, aquí hay una revisión de algunos de los principios clave de cada tecnología. React es una biblioteca de vistas que proporciona datos, luego la convierte de forma eficiente y predecible. Redux es un marco de administración de estado que puede utilizar para simplificar la administración del estado de su aplicación. Normalmente, en una aplicación React Redux, creas una sola tienda Redux que administra el estado de toda tu aplicación. Sus componentes de React se suscriben solo a los datos en la tienda que son relevantes para su función. Luego, envía acciones directamente desde los componentes de React, que luego activan las actualizaciones del almacén. 
-Aunque los componentes de React pueden administrar su propio estado localmente, cuando tiene una aplicación compleja, generalmente es mejor mantener el estado de la aplicación en una sola ubicación con Redux. Hay excepciones cuando los componentes individuales pueden tener un estado local específico solo para ellos. Finalmente, debido a que Redux no está diseñado para funcionar con React out of the box, debe usar el paquete <code>react-redux</code> . Le proporciona una forma de pasar el <code>state</code> Redux y <code>dispatch</code> a sus componentes React como <code>props</code> . 
-En los próximos desafíos, primero, creará un componente React simple que le permite ingresar nuevos mensajes de texto. Estos se agregan a una matriz que se muestra en la vista. Esto debería ser una buena revisión de lo que aprendiste en las lecciones de React. A continuación, creará un almacén de Redux y acciones que administran el estado de la matriz de mensajes. Finalmente, utilizará <code>react-redux</code> para conectar la tienda Redux con su componente, extrayendo así el estado local a la tienda Redux. 
+<section id='description'>
+Esta serie de desafíos presenta cómo utilizar Redux con React. Primero, aquí hay una revisión de algunos de los principios clave de cada tecnología. React es una biblioteca de vistas que proporciona datos, luego la convierte de forma eficiente y predecible. Redux es un marco de administración de estado que puede utilizar para simplificar la administración del estado de su aplicación. Normalmente, en una aplicación React Redux, creas una sola tienda Redux que administra el estado de toda tu aplicación. Sus componentes de React se suscriben solo a los datos en la tienda que son relevantes para su función. Luego, envía acciones directamente desde los componentes de React, que luego activan las actualizaciones del almacén.
+Aunque los componentes de React pueden administrar su propio estado localmente, cuando tiene una aplicación compleja, generalmente es mejor mantener el estado de la aplicación en una sola ubicación con Redux. Hay excepciones cuando los componentes individuales pueden tener un estado local específico solo para ellos. Finalmente, debido a que Redux no está diseñado para funcionar con React out of the box, debe usar el paquete <code>react-redux</code> . Le proporciona una forma de pasar el <code>state</code> Redux y <code>dispatch</code> a sus componentes React como <code>props</code> .
+En los próximos desafíos, primero, creará un componente React simple que le permite ingresar nuevos mensajes de texto. Estos se agregan a una matriz que se muestra en la vista. Esto debería ser una buena revisión de lo que aprendiste en las lecciones de React. A continuación, creará un almacén de Redux y acciones que administran el estado de la matriz de mensajes. Finalmente, utilizará <code>react-redux</code> para conectar la tienda Redux con su componente, extrayendo así el estado local a la tienda Redux.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Comience con un componente <code>DisplayMessages</code> . Agregue un constructor a este componente e inicialícelo con un estado que tenga dos propiedades: <code>input</code> , que se establece en una cadena vacía, y <code>messages</code> , que se establece en una matriz vacía. 
+<section id='instructions'>
+Comience con un componente <code>DisplayMessages</code> . Agregue un constructor a este componente e inicialícelo con un estado que tenga dos propiedades: <code>input</code> , que se establece en una cadena vacía, y <code>messages</code> , que se establece en una matriz vacía.
 </section>
 
 ## Tests
@@ -25,9 +25,9 @@ Comience con un componente <code>DisplayMessages</code> . Agregue un constructor
 tests:
   - text: El componente <code>DisplayMessages</code> debe representar un elemento <code>div</code> vacío.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(DisplayMessages)); return mockedComponent.find("div").text() === "" })(), "The <code>DisplayMessages</code> component should render an empty <code>div</code> element.");'
-  - text: &#39;El constructor de <code>DisplayMessages</code> debe llamarse correctamente con <code>super</code> , pasando en <code>props</code> &#39;.
+  - text: 'El constructor de <code>DisplayMessages</code> debe llamarse correctamente con <code>super</code> , pasando en <code>props</code> '
     testString: 'getUserInput => assert((function() { const noWhiteSpace = getUserInput("index").replace(/\s/g,""); return noWhiteSpace.includes("constructor(props)") && noWhiteSpace.includes("super(props"); })(), "The <code>DisplayMessages</code> constructor should be called properly with <code>super</code>, passing in <code>props</code>.");'
-  - text: &#39;El componente <code>DisplayMessages</code> debe tener un estado inicial igual a <code>{input: &quot;&quot;, messages: []}</code> .&#39;
+  - text: 'El componente <code>DisplayMessages</code> debe tener un estado inicial igual a <code>{input: &quot;&quot;, messages: []}</code> .'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(DisplayMessages)); const initialState = mockedComponent.state(); return typeof initialState === "object" && initialState.input === "" && Array.isArray(initialState.messages) && initialState.messages.length === 0; })(), "The <code>DisplayMessages</code> component should have an initial state equal to <code>{input: "", messages: []}</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/manage-state-locally-first.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/manage-state-locally-first.spanish.md
index a2d424f4f0..b679c5ed33 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/manage-state-locally-first.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/manage-state-locally-first.spanish.md
@@ -7,15 +7,15 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Aquí terminarás de crear el componente <code>DisplayMessages</code> . 
+<section id='description'>
+Aquí terminarás de crear el componente <code>DisplayMessages</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Primero, en el método <code>render()</code> , haga que el componente procese un elemento de <code>input</code> , un elemento de <code>button</code> y un elemento <code>ul</code> . Cuando el elemento de <code>input</code> cambia, debe activar un método <code>handleChange()</code> . Además, el elemento de <code>input</code> debe representar el valor de la <code>input</code> que se encuentra en el estado del componente. El elemento de <code>button</code> debe activar un método <code>submitMessage()</code> cuando se hace clic. 
-Segundo, escribe estos dos métodos. El método <code>handleChange()</code> debe actualizar la <code>input</code> con lo que el usuario está escribiendo. El método <code>submitMessage()</code> debe concatenar el mensaje actual (almacenado en la <code>input</code> ) a la matriz de <code>messages</code> en el estado local, y borrar el valor de la <code>input</code> . 
-Finalmente, use la <code>ul</code> para mapear sobre el conjunto de <code>messages</code> y procesarlos en la pantalla como una lista de elementos <code>li</code> . 
+<section id='instructions'>
+Primero, en el método <code>render()</code> , haga que el componente procese un elemento de <code>input</code> , un elemento de <code>button</code> y un elemento <code>ul</code> . Cuando el elemento de <code>input</code> cambia, debe activar un método <code>handleChange()</code> . Además, el elemento de <code>input</code> debe representar el valor de la <code>input</code> que se encuentra en el estado del componente. El elemento de <code>button</code> debe activar un método <code>submitMessage()</code> cuando se hace clic.
+Segundo, escribe estos dos métodos. El método <code>handleChange()</code> debe actualizar la <code>input</code> con lo que el usuario está escribiendo. El método <code>submitMessage()</code> debe concatenar el mensaje actual (almacenado en la <code>input</code> ) a la matriz de <code>messages</code> en el estado local, y borrar el valor de la <code>input</code> .
+Finalmente, use la <code>ul</code> para mapear sobre el conjunto de <code>messages</code> y procesarlos en la pantalla como una lista de elementos <code>li</code> .
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Finalmente, use la <code>ul</code> para mapear sobre el conjunto de <code>messag
 
 ```yml
 tests:
-  - text: &#39;El componente <code>DisplayMessages</code> debería inicializarse con un estado igual a <code>{ input: &quot;&quot;, messages: [] }</code> .&#39;
+  - text: 'El componente <code>DisplayMessages</code> debería inicializarse con un estado igual a <code>{ input: &quot;&quot;, messages: [] }</code> .'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(DisplayMessages)); const initialState = mockedComponent.state(); return ( typeof initialState === "object" && initialState.input === "" && initialState.messages.length === 0); })(), "The <code>DisplayMessages</code> component should initialize with a state equal to <code>{ input: "", messages: [] }</code>.");'
   - text: &quot;El componente <code>DisplayMessages</code> debería generar un <code>div</code> contenga un elemento <code>h2</code> , un elemento de <code>button</code> , un elemento <code>ul</code> y elementos <code>li</code> como elementos <code>li</code> &quot;.
     testString: 'async () => { const mockedComponent = Enzyme.mount(React.createElement(DisplayMessages)); const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 100)); const state = () => { mockedComponent.setState({messages: ["__TEST__MESSAGE"]}); return waitForIt(() => mockedComponent )}; const updated = await state(); assert(updated.find("div").length === 1 && updated.find("h2").length === 1 && updated.find("button").length === 1 && updated.find("ul").length === 1, "The <code>DisplayMessages</code> component should render a <code>div</code> containing an <code>h2</code> element, a <code>button</code> element, a <code>ul</code> element, and <code>li</code> elements as children."); }; '
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/use-provider-to-connect-redux-to-react.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/use-provider-to-connect-redux-to-react.spanish.md
index 4dda16b358..edfde14e25 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/use-provider-to-connect-redux-to-react.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react-and-redux/use-provider-to-connect-redux-to-react.spanish.md
@@ -7,16 +7,16 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-En el último desafío, creó un almacén Redux para manejar la matriz de mensajes y creó una acción para agregar nuevos mensajes. El siguiente paso es proporcionar acceso React a la tienda Redux y las acciones que necesita para enviar actualizaciones. React Redux proporciona su paquete <code>react-redux</code> para ayudar a realizar estas tareas. 
-React Redux proporciona una pequeña API con dos características clave: <code>Provider</code> y <code>connect</code> . Otro reto cubre <code>connect</code> . El <code>Provider</code> es un componente envolvente de React Redux que envuelve su aplicación React. Este contenedor le permite acceder a las funciones de <code>store</code> y <code>dispatch</code> Redux a través de su árbol de componentes. <code>Provider</code> toma dos accesorios, la tienda Redux y los componentes secundarios de su aplicación. La definición del <code>Provider</code> para un componente de la aplicación podría tener este aspecto: 
-<blockquote>&lt;Provider store={store}&gt;<br>&nbsp;&nbsp;&lt;App/&gt;<br>&lt;/Provider&gt;</blockquote> 
+<section id='description'>
+En el último desafío, creó un almacén Redux para manejar la matriz de mensajes y creó una acción para agregar nuevos mensajes. El siguiente paso es proporcionar acceso React a la tienda Redux y las acciones que necesita para enviar actualizaciones. React Redux proporciona su paquete <code>react-redux</code> para ayudar a realizar estas tareas.
+React Redux proporciona una pequeña API con dos características clave: <code>Provider</code> y <code>connect</code> . Otro reto cubre <code>connect</code> . El <code>Provider</code> es un componente envolvente de React Redux que envuelve su aplicación React. Este contenedor le permite acceder a las funciones de <code>store</code> y <code>dispatch</code> Redux a través de su árbol de componentes. <code>Provider</code> toma dos accesorios, la tienda Redux y los componentes secundarios de su aplicación. La definición del <code>Provider</code> para un componente de la aplicación podría tener este aspecto:
+<blockquote>&lt;Provider store={store}&gt;<br>&nbsp;&nbsp;&lt;App/&gt;<br>&lt;/Provider&gt;</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código ahora muestra todos sus códigos Redux y React de los últimos desafíos. Incluye la tienda Redux, las acciones y el componente <code>DisplayMessages</code> . La única pieza nueva es el componente <code>AppWrapper</code> en la parte inferior. Utilice este componente de nivel superior para representar al <code>Provider</code> desde <code>ReactRedux</code> , y pase la tienda Redux como prop. Luego renderice el componente <code>DisplayMessages</code> como un elemento secundario. Una vez que hayas terminado, deberías ver tu componente React renderizado en la página. 
-<strong>Nota:</strong> React Redux está disponible aquí como una variable global, por lo que puede acceder al Proveedor con notación de puntos. El código en el editor se aprovecha de esto y lo establece en un <code>Provider</code> constante para que lo use en el método de renderizado de <code>AppWrapper</code> . 
+<section id='instructions'>
+El editor de código ahora muestra todos sus códigos Redux y React de los últimos desafíos. Incluye la tienda Redux, las acciones y el componente <code>DisplayMessages</code> . La única pieza nueva es el componente <code>AppWrapper</code> en la parte inferior. Utilice este componente de nivel superior para representar al <code>Provider</code> desde <code>ReactRedux</code> , y pase la tienda Redux como prop. Luego renderice el componente <code>DisplayMessages</code> como un elemento secundario. Una vez que hayas terminado, deberías ver tu componente React renderizado en la página.
+<strong>Nota:</strong> React Redux está disponible aquí como una variable global, por lo que puede acceder al Proveedor con notación de puntos. El código en el editor se aprovecha de esto y lo establece en un <code>Provider</code> constante para que lo use en el método de renderizado de <code>AppWrapper</code> .
 </section>
 
 ## Tests
@@ -26,11 +26,11 @@ El editor de código ahora muestra todos sus códigos Redux y React de los últi
 tests:
   - text: El <code>AppWrapper</code> debe hacer.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("AppWrapper").length === 1; })(), "The <code>AppWrapper</code> should render.");'
-  - text: &#39;El componente contenedor del <code>Provider</code> debe tener una propiedad de la <code>store</code> pasado, igual a la tienda Redux&#39;.
+  - text: 'El componente contenedor del <code>Provider</code> debe tener una propiedad de la <code>store</code> pasado, igual a la tienda Redux'
     testString: 'getUserInput => assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return getUserInput("index").replace(/\s/g,"").includes("<Providerstore={store}>"); })(), "The <code>Provider</code> wrapper component should have a prop of <code>store</code> passed to it, equal to the Redux store.");'
   - text: <code>DisplayMessages</code> debería renderizarse como un elemento secundario de <code>AppWrapper</code> .
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("AppWrapper").find("DisplayMessages").length === 1; })(), "<code>DisplayMessages</code> should render as a child of <code>AppWrapper</code>.");'
-  - text: &#39;El componente <code>DisplayMessages</code> debe representar un elemento h2, input, button y <code>ul</code> .&#39;
+  - text: 'El componente <code>DisplayMessages</code> debe representar un elemento h2, input, button y <code>ul</code> .'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(AppWrapper)); return mockedComponent.find("div").length === 1 && mockedComponent.find("h2").length === 1 && mockedComponent.find("button").length === 1 && mockedComponent.find("ul").length === 1; })(), "The <code>DisplayMessages</code> component should render an h2, input, button, and <code>ul</code> element.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/bind-this-to-a-class-method.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/bind-this-to-a-class-method.spanish.md
index 251205f7db..fe124697a1 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/bind-this-to-a-class-method.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/bind-this-to-a-class-method.spanish.md
@@ -7,17 +7,17 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Además de establecer y actualizar el <code>state</code> , también puede definir métodos para su clase de componente. Un método de clase normalmente necesita usar <code>this</code> palabra clave para poder acceder a las propiedades de la clase (como el <code>state</code> y los <code>props</code> ) dentro del alcance del método. Hay algunas maneras de permitir que sus métodos de clase accedan a <code>this</code> . 
-Una forma común es vincular de forma explícita <code>this</code> en el constructor por lo que <code>this</code> se une a los métodos de la clase cuando el componente se inicializa. Es posible que haya notado que el último desafío utilizó <code>this.handleClick = this.handleClick.bind(this)</code> para su método <code>handleClick</code> en el constructor. Luego, cuando llama a una función como <code>this.setState()</code> dentro de su método de clase, <code>this</code> refiere a la clase y no quedará <code>undefined</code> . 
-<strong>Nota:</strong> <code>this</code> palabra clave es uno de los aspectos más confusos de JavaScript, pero desempeña un papel importante en React. A pesar de que su comportamiento aquí es totalmente normal, estas lecciones no son el lugar para una revisión en profundidad de <code>this</code> así que por favor consulte otras lecciones si lo anterior es confuso. 
+<section id='description'>
+Además de establecer y actualizar el <code>state</code> , también puede definir métodos para su clase de componente. Un método de clase normalmente necesita usar <code>this</code> palabra clave para poder acceder a las propiedades de la clase (como el <code>state</code> y los <code>props</code> ) dentro del alcance del método. Hay algunas maneras de permitir que sus métodos de clase accedan a <code>this</code> .
+Una forma común es vincular de forma explícita <code>this</code> en el constructor por lo que <code>this</code> se une a los métodos de la clase cuando el componente se inicializa. Es posible que haya notado que el último desafío utilizó <code>this.handleClick = this.handleClick.bind(this)</code> para su método <code>handleClick</code> en el constructor. Luego, cuando llama a una función como <code>this.setState()</code> dentro de su método de clase, <code>this</code> refiere a la clase y no quedará <code>undefined</code> .
+<strong>Nota:</strong> <code>this</code> palabra clave es uno de los aspectos más confusos de JavaScript, pero desempeña un papel importante en React. A pesar de que su comportamiento aquí es totalmente normal, estas lecciones no son el lugar para una revisión en profundidad de <code>this</code> así que por favor consulte otras lecciones si lo anterior es confuso.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene un componente con un <code>state</code> que realiza un seguimiento de un recuento de elementos. También tiene un método que le permite incrementar este recuento de elementos. Sin embargo, el método no funciona porque está usando <code>this</code> palabra clave que no está definida. Corregir el problema mediante la unión explícitamente <code>this</code> a la <code>addItem()</code> método en el constructor del componente. 
-A continuación, agregue un controlador de clic al elemento de <code>button</code> en el método de procesamiento. Debería activar el método <code>addItem()</code> cuando el botón recibe un evento de clic. Recuerde que el método que pase al controlador <code>onClick</code> necesita llaves porque debe interpretarse directamente como JavaScript. 
-Una vez que complete los pasos anteriores, debería poder hacer clic en el botón y ver el incremento en el recuento de elementos en el HTML. 
+<section id='instructions'>
+El editor de código tiene un componente con un <code>state</code> que realiza un seguimiento de un recuento de elementos. También tiene un método que le permite incrementar este recuento de elementos. Sin embargo, el método no funciona porque está usando <code>this</code> palabra clave que no está definida. Corregir el problema mediante la unión explícitamente <code>this</code> a la <code>addItem()</code> método en el constructor del componente.
+A continuación, agregue un controlador de clic al elemento de <code>button</code> en el método de procesamiento. Debería activar el método <code>addItem()</code> cuando el botón recibe un evento de clic. Recuerde que el método que pase al controlador <code>onClick</code> necesita llaves porque debe interpretarse directamente como JavaScript.
+Una vez que complete los pasos anteriores, debería poder hacer clic en el botón y ver el incremento en el recuento de elementos en el HTML.
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ Una vez que complete los pasos anteriores, debería poder hacer clic en el botó
 tests:
   - text: &quot; <code>MyComponent</code> debería devolver un elemento <code>div</code> que envuelva dos elementos, un botón y un elemento <code>h1</code> , en ese orden&quot;.
     testString: 'assert(Enzyme.mount(React.createElement(MyComponent)).find("div").length === 1 && Enzyme.mount(React.createElement(MyComponent)).find("div").childAt(0).type() === "button" && Enzyme.mount(React.createElement(MyComponent)).find("div").childAt(1).type() === "h1", "<code>MyComponent</code> should return a <code>div</code> element which wraps two elements, a button and an <code>h1</code> element, in that order.");'
-  - text: &#39;El estado de <code>MyComponent</code> debe inicializarse con el par de valores clave <code>{ itemCount: 0 }</code> .&#39;
+  - text: 'El estado de <code>MyComponent</code> debe inicializarse con el par de valores clave <code>{ itemCount: 0 }</code> .'
     testString: 'assert(Enzyme.mount(React.createElement(MyComponent)).state("itemCount") === 0, "The state of <code>MyComponent</code> should initialize with the key value pair <code>{ itemCount: 0 }</code>.");'
   - text: Al hacer clic en el elemento del <code>button</code> se debe ejecutar el método <code>addItem</code> e incrementar el estado <code>itemCount</code> en <code>1</code> .
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); const first = () => { mockedComponent.setState({ itemCount: 0 }); return waitForIt(() => mockedComponent.state("itemCount")); }; const second = () => { mockedComponent.find("button").simulate("click"); return waitForIt(() => mockedComponent.state("itemCount")); }; const firstValue = await first(); const secondValue = await second(); assert(firstValue === 0 && secondValue === 1, "Clicking the <code>button</code> element should run the <code>addItem</code> method and increment the state <code>itemCount</code> by <code>1</code>."); };'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/create-a-controlled-input.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/create-a-controlled-input.spanish.md
index ba06dd8488..3f190f4380 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/create-a-controlled-input.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/create-a-controlled-input.spanish.md
@@ -7,17 +7,17 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Su aplicación puede tener interacciones más complejas entre el <code>state</code> y la interfaz de usuario renderizada. Por ejemplo, los elementos de control de formulario para la entrada de texto, como <code>input</code> y <code>textarea</code> , mantienen su propio estado en el DOM según el tipo de usuario. Con Reaccionar, puede moverse en este estado mutable de un componente Reaccionar <code>state</code> . La entrada del usuario se convierte en parte del <code>state</code> de la aplicación, por lo que React controla el valor de ese campo de entrada. Normalmente, si tiene componentes React con campos de entrada en los que el usuario puede escribir, será un formulario de entrada controlado. 
+<section id='description'>
+Su aplicación puede tener interacciones más complejas entre el <code>state</code> y la interfaz de usuario renderizada. Por ejemplo, los elementos de control de formulario para la entrada de texto, como <code>input</code> y <code>textarea</code> , mantienen su propio estado en el DOM según el tipo de usuario. Con Reaccionar, puede moverse en este estado mutable de un componente Reaccionar <code>state</code> . La entrada del usuario se convierte en parte del <code>state</code> de la aplicación, por lo que React controla el valor de ese campo de entrada. Normalmente, si tiene componentes React con campos de entrada en los que el usuario puede escribir, será un formulario de entrada controlado.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene el esqueleto de un componente llamado <code>ControlledInput</code> para crear un elemento de <code>input</code> controlado. El <code>state</code> del componente ya está inicializado con una propiedad de <code>input</code> que contiene una cadena vacía. Este valor representa el texto que un usuario escribe en el campo de <code>input</code> . 
-Primero, cree un método llamado <code>handleChange()</code> que tenga un parámetro llamado <code>event</code> . Cuando se llama al método, recibe un objeto de <code>event</code> que contiene una cadena de texto del elemento de <code>input</code> . Puede acceder a esta cadena con <code>event.target.value</code> dentro del método. Actualice la propiedad de <code>input</code> del <code>state</code> del componente con esta nueva cadena. 
-En el método de procesamiento, cree el elemento de <code>input</code> sobre la etiqueta <code>h4</code> . Agregue un atributo de <code>value</code> que sea igual a la propiedad de <code>input</code> del <code>state</code> del componente. A continuación, añadir un <code>onChange()</code> controlador de eventos se establece en el <code>handleChange()</code> método. 
-Al escribir en el cuadro de entrada, el texto se procesa mediante el método <code>handleChange()</code> , se establece como la propiedad de <code>input</code> en el <code>state</code> local y se representa como el valor en el cuadro de <code>input</code> en la página. El <code>state</code> componente es la única fuente de verdad con respecto a los datos de entrada. 
-último, pero no menos importante, no olvide agregar los enlaces necesarios en el constructor. 
+<section id='instructions'>
+El editor de código tiene el esqueleto de un componente llamado <code>ControlledInput</code> para crear un elemento de <code>input</code> controlado. El <code>state</code> del componente ya está inicializado con una propiedad de <code>input</code> que contiene una cadena vacía. Este valor representa el texto que un usuario escribe en el campo de <code>input</code> .
+Primero, cree un método llamado <code>handleChange()</code> que tenga un parámetro llamado <code>event</code> . Cuando se llama al método, recibe un objeto de <code>event</code> que contiene una cadena de texto del elemento de <code>input</code> . Puede acceder a esta cadena con <code>event.target.value</code> dentro del método. Actualice la propiedad de <code>input</code> del <code>state</code> del componente con esta nueva cadena.
+En el método de procesamiento, cree el elemento de <code>input</code> sobre la etiqueta <code>h4</code> . Agregue un atributo de <code>value</code> que sea igual a la propiedad de <code>input</code> del <code>state</code> del componente. A continuación, añadir un <code>onChange()</code> controlador de eventos se establece en el <code>handleChange()</code> método.
+Al escribir en el cuadro de entrada, el texto se procesa mediante el método <code>handleChange()</code> , se establece como la propiedad de <code>input</code> en el <code>state</code> local y se representa como el valor en el cuadro de <code>input</code> en la página. El <code>state</code> componente es la única fuente de verdad con respecto a los datos de entrada.
+último, pero no menos importante, no olvide agregar los enlaces necesarios en el constructor.
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ tests:
     testString: 'assert(Enzyme.mount(React.createElement(ControlledInput)).find("div").children().find("input").length === 1 && Enzyme.mount(React.createElement(ControlledInput)).find("div").children().find("p").length === 1, "<code>ControlledInput</code> should return a <code>div</code> element which contains an <code>input</code> and a <code>p</code> tag.");'
   - text: El estado de <code>ControlledInput</code> debe inicializarse con una propiedad de <code>input</code> establecida en una cadena vacía.
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(ControlledInput)).state("input"), "", "The state of <code>ControlledInput</code> should initialize with an <code>input</code> property set to an empty string.");'
-  - text: &#39;Al escribir el elemento de entrada, se debe actualizar el estado y el valor de la entrada, y el elemento <code>p</code> debe representar este estado a medida que se escribe.&#39;
+  - text: 'Al escribir el elemento de entrada, se debe actualizar el estado y el valor de la entrada, y el elemento <code>p</code> debe representar este estado a medida que se escribe.'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(ControlledInput)); const _1 = () => { mockedComponent.setState({ input: "" }); return waitForIt(() => mockedComponent.state("input"))}; const _2 = () => { mockedComponent.find("input").simulate("change", { target: { value: "TestInput" }}); return waitForIt(() => ({ state: mockedComponent.state("input"), text: mockedComponent.find("p").text(), inputVal: mockedComponent.find("input").props().value }))}; const before = await _1(); const after = await _2(); assert(before === "" && after.state === "TestInput" && after.text === "TestInput" && after.inputVal === "TestInput", "Typing in the input element should update the state and the value of the input, and the <code>p</code> element should render this state as you type."); }; '
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/override-default-props.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/override-default-props.spanish.md
index 49fb436335..a7656461db 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/override-default-props.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/override-default-props.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-La capacidad de establecer accesorios predeterminados es una característica útil en React. La forma de anular los accesorios predeterminados es establecer explícitamente los valores de prop para un componente. 
+<section id='description'>
+La capacidad de establecer accesorios predeterminados es una característica útil en React. La forma de anular los accesorios predeterminados es establecer explícitamente los valores de prop para un componente.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El componente <code>ShoppingCart</code> ahora representa un componente secundario <code>Items</code> . Este componente de <code>Items</code> tiene una <code>quantity</code> prop predeterminada establecida en el entero <code>0</code> . Anule el prop predeterminado al pasar un valor de <code>10</code> por <code>quantity</code> . 
-<strong>Nota:</strong> recuerde que la sintaxis para agregar una propuesta a un componente es similar a la forma en que agrega atributos HTML. Sin embargo, dado que el valor para la <code>quantity</code> es un número entero, no irá entre comillas, pero debería estar entre corchetes. Por ejemplo, <code>{100}</code> . Esta sintaxis le dice a JSX que interprete el valor entre las llaves directamente como JavaScript. 
+<section id='instructions'>
+El componente <code>ShoppingCart</code> ahora representa un componente secundario <code>Items</code> . Este componente de <code>Items</code> tiene una <code>quantity</code> prop predeterminada establecida en el entero <code>0</code> . Anule el prop predeterminado al pasar un valor de <code>10</code> por <code>quantity</code> .
+<strong>Nota:</strong> recuerde que la sintaxis para agregar una propuesta a un componente es similar a la forma en que agrega atributos HTML. Sin embargo, dado que el valor para la <code>quantity</code> es un número entero, no irá entre comillas, pero debería estar entre corchetes. Por ejemplo, <code>{100}</code> . Esta sintaxis le dice a JSX que interprete el valor entre las llaves directamente como JavaScript.
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ tests:
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(ShoppingCart)); return mockedComponent.find("ShoppingCart").length === 1; })(), "The component <code>ShoppingCart</code> should render.");'
   - text: Los <code>Items</code> componente deben hacer.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(ShoppingCart)); return mockedComponent.find("Items").length === 1; })(), "The component <code>Items</code> should render.");'
-  - text: &#39;El componente <code>Items</code> debe tener una propiedad de <code>{ quantity: 10 }</code> aprobada desde el componente <code>ShoppingCart</code> .&#39;
+  - text: 'El componente <code>Items</code> debe tener una propiedad de <code>{ quantity: 10 }</code> aprobada desde el componente <code>ShoppingCart</code> .'
     testString: 'getUserInput => assert((function() { const mockedComponent = Enzyme.mount(React.createElement(ShoppingCart)); return mockedComponent.find("Items").props().quantity == 10 && getUserInput("index").replace(/ /g,"").includes("<Itemsquantity={10}/>"); })(), "The <code>Items</code> component should have a prop of <code>{ quantity: 10 }</code> passed from the <code>ShoppingCart</code> component.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/render-conditionally-from-props.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/render-conditionally-from-props.spanish.md
index 047573be15..a602a545ec 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/render-conditionally-from-props.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/render-conditionally-from-props.spanish.md
@@ -7,16 +7,16 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Hasta ahora, ha visto cómo usar <code>if/else</code> , <code>&amp;&amp;,</code> <code>null</code> y el operador ternario ( <code>condition ? expressionIfTrue : expressionIfFalse</code> ) para tomar decisiones condicionales sobre qué representar y cuándo. Sin embargo, hay un tema importante que queda por discutir que te permite combinar cualquiera o todos estos conceptos con otra poderosa característica React: accesorios. El uso de utilería para generar condicionalmente el código es muy común entre los desarrolladores de React, es decir, utilizan el valor de una prop determinada para tomar decisiones automáticamente sobre qué representar. 
-En este desafío, configurará un componente secundario para tomar decisiones de representación basadas en accesorios. También usará el operador ternario, pero puede ver cómo varios de los otros conceptos que se cubrieron en los últimos desafíos podrían ser igual de útiles en este contexto. 
+<section id='description'>
+Hasta ahora, ha visto cómo usar <code>if/else</code> , <code>&amp;&amp;,</code> <code>null</code> y el operador ternario ( <code>condition ? expressionIfTrue : expressionIfFalse</code> ) para tomar decisiones condicionales sobre qué representar y cuándo. Sin embargo, hay un tema importante que queda por discutir que te permite combinar cualquiera o todos estos conceptos con otra poderosa característica React: accesorios. El uso de utilería para generar condicionalmente el código es muy común entre los desarrolladores de React, es decir, utilizan el valor de una prop determinada para tomar decisiones automáticamente sobre qué representar.
+En este desafío, configurará un componente secundario para tomar decisiones de representación basadas en accesorios. También usará el operador ternario, pero puede ver cómo varios de los otros conceptos que se cubrieron en los últimos desafíos podrían ser igual de útiles en este contexto.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene dos componentes que están parcialmente definidos para usted: un padre llamado <code>GameOfChance</code> y un hijo llamado <code>Results</code> . Se utilizan para crear un juego simple en el que el usuario presiona un botón para ver si gana o pierde. 
-Primero, necesitará una expresión simple que retorne aleatoriamente un valor diferente cada vez que se ejecute. Puedes usar <code>Math.random()</code> . Este método devuelve un valor entre <code>0</code> (incluido) y <code>1</code> (exclusivo) cada vez que se llama. Entonces, para probabilidades 50/50, use <code>Math.random() &gt; .5</code> en su expresión. Estadísticamente hablando, esta expresión devolverá <code>true</code> 50% del tiempo, y <code>false</code> el otro 50%. En la línea 30, reemplace el comentario con esta expresión para completar la declaración de la variable. 
-Ahora tiene una expresión que puede usar para tomar una decisión aleatoria en el código. A continuación necesitas implementar esto. Procese el componente <code>Results</code> como un elemento secundario de <code>GameOfChance</code> y pase la <code>expression</code> como un prop llamado <code>fiftyFifty</code> . En el componente <code>Results</code> , escriba una expresión ternaria para representar el texto <code>&quot;You win!&quot;</code> o <code>&quot;You lose!&quot;</code> basado en la propuesta <code>fiftyFifty</code> que se transmite desde <code>GameOfChance</code> . Finalmente, asegúrese de que el método <code>handleClick()</code> esté contando correctamente cada turno para que el usuario sepa cuántas veces ha jugado. Esto también sirve para que el usuario sepa que el componente se ha actualizado en caso de que gane o pierda dos veces seguidas. 
+<section id='instructions'>
+El editor de código tiene dos componentes que están parcialmente definidos para usted: un padre llamado <code>GameOfChance</code> y un hijo llamado <code>Results</code> . Se utilizan para crear un juego simple en el que el usuario presiona un botón para ver si gana o pierde.
+Primero, necesitará una expresión simple que retorne aleatoriamente un valor diferente cada vez que se ejecute. Puedes usar <code>Math.random()</code> . Este método devuelve un valor entre <code>0</code> (incluido) y <code>1</code> (exclusivo) cada vez que se llama. Entonces, para probabilidades 50/50, use <code>Math.random() &gt; .5</code> en su expresión. Estadísticamente hablando, esta expresión devolverá <code>true</code> 50% del tiempo, y <code>false</code> el otro 50%. En la línea 30, reemplace el comentario con esta expresión para completar la declaración de la variable.
+Ahora tiene una expresión que puede usar para tomar una decisión aleatoria en el código. A continuación necesitas implementar esto. Procese el componente <code>Results</code> como un elemento secundario de <code>GameOfChance</code> y pase la <code>expression</code> como un prop llamado <code>fiftyFifty</code> . En el componente <code>Results</code> , escriba una expresión ternaria para representar el texto <code>&quot;You win!&quot;</code> o <code>&quot;You lose!&quot;</code> basado en la propuesta <code>fiftyFifty</code> que se transmite desde <code>GameOfChance</code> . Finalmente, asegúrese de que el método <code>handleClick()</code> esté contando correctamente cada turno para que el usuario sepa cuántas veces ha jugado. Esto también sirve para que el usuario sepa que el componente se ha actualizado en caso de que gane o pierda dos veces seguidas.
 </section>
 
 ## Tests
@@ -28,15 +28,15 @@ tests:
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(GameOfChance)).find("GameOfChance").length, 1, "The <code>GameOfChance</code> component should exist and render to the page.");'
   - text: <code>GameOfChance</code> debería devolver un único elemento de <code>button</code> .
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(GameOfChance)).find("button").length, 1, "<code>GameOfChance</code> should return a single <code>button</code> element.");'
-  - text: &#39; <code>GameOfChance</code> debe devolver una sola instancia del componente <code>Results</code> , que tiene un prop llamado <code>fiftyFifty</code> &#39;.
+  - text: ' <code>GameOfChance</code> debe devolver una sola instancia del componente <code>Results</code> , que tiene un prop llamado <code>fiftyFifty</code> '
     testString: 'assert(Enzyme.mount(React.createElement(GameOfChance)).find("Results").length === 1 && Enzyme.mount(React.createElement(GameOfChance)).find("Results").props().hasOwnProperty("fiftyFifty") === true, "<code>GameOfChance</code> should return a single instance of the <code>Results</code> component, which has a prop called <code>fiftyFifty</code>.");'
   - text: <code>GameOfChance</code> estado de <code>GameOfChance</code> debe inicializar con una propiedad de <code>counter</code> configurada en un valor de <code>1</code> .
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(GameOfChance)).state().counter, 1, "<code>GameOfChance</code> state should be initialized with a property of <code>counter</code> set to a value of <code>1</code>.");'
-  - text: &#39;Cuando el componente <code>GameOfChance</code> se procesa por primera vez en el DOM, se debe devolver un elemento <code>p</code> con el texto interno de <code>Turn: 1</code> &#39;.
+  - text: 'Cuando el componente <code>GameOfChance</code> se procesa por primera vez en el DOM, se debe devolver un elemento <code>p</code> con el texto interno de <code>Turn: 1</code> '
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(GameOfChance)).find("p").text(), "Turn: 1", "When the <code>GameOfChance</code> component is first rendered to the DOM, a <code>p</code> element should be returned with the inner text of <code>Turn: 1</code>.");'
-  - text: &#39;Cada vez que se hace clic en el botón, el estado del contador debe incrementarse en un valor de 1, y se debe representar un solo elemento <code>p</code> en el DOM que contiene el texto &quot;Turn: N&quot;, donde N es el valor del estado del contador .
+  - text: 'Cada vez que se hace clic en el botón, el estado del contador debe incrementarse en un valor de 1, y se debe representar un solo elemento <code>p</code> en el DOM que contiene el texto &quot;Turn: N&quot;, donde N es el valor del estado del contador .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const comp = Enzyme.mount(React.createElement(GameOfChance)); const simulate = () => { comp.find("button").simulate("click"); };const result = () => ({ count: comp.state("counter"), text: comp.find("p").text() });const _1 = () => { simulate(); return waitForIt(() => result())}; const _2 = () => { simulate(); return waitForIt(() => result())}; const _3 = () => { simulate(); return waitForIt(() => result())}; const _4 = () => { simulate(); return waitForIt(() => result())}; const _5 = () => { simulate(); return waitForIt(() => result())}; const _1_val = await _1(); const _2_val = await _2(); const _3_val = await _3(); const _4_val = await _4(); const _5_val = await _5(); assert(_1_val.count === 2 && _1_val.text === "Turn: 2" && _2_val.count === 3 && _2_val.text === "Turn: 3" && _3_val.count === 4 && _3_val.text === "Turn: 4" && _4_val.count === 5 && _4_val.text === "Turn: 5" && _5_val.count === 6 && _5_val.text === "Turn: 6", "Each time the button is clicked, the counter state should be incremented by a value of 1, and a single <code>p</code> element should be rendered to the DOM that contains the text "Turn: N", where N is the value of the counter state."); }; '
-  - text: &#39;Cuando el componente <code>GameOfChance</code> se monta por primera vez en el DOM y cada vez que se hace clic en el botón a continuación, se debe devolver un único elemento <code>h1</code> que muestre aleatoriamente ¡ <code>You Win!</code> o <code>You Lose!</code> .
+  - text: 'Cuando el componente <code>GameOfChance</code> se monta por primera vez en el DOM y cada vez que se hace clic en el botón a continuación, se debe devolver un único elemento <code>h1</code> que muestre aleatoriamente ¡ <code>You Win!</code> o <code>You Lose!</code> .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const comp = Enzyme.mount(React.createElement(GameOfChance)); const simulate = () => { comp.find("button").simulate("click"); };const result = () => ({ h1: comp.find("h1").length, text: comp.find("h1").text() });const _1 = result(); const _2 = () => { simulate(); return waitForIt(() => result())}; const _3 = () => { simulate(); return waitForIt(() => result())}; const _4 = () => { simulate(); return waitForIt(() => result())}; const _5 = () => { simulate(); return waitForIt(() => result())}; const _6 = () => { simulate(); return waitForIt(() => result())}; const _7 = () => { simulate(); return waitForIt(() => result())}; const _8 = () => { simulate(); return waitForIt(() => result())}; const _9 = () => { simulate(); return waitForIt(() => result())}; const _10 = () => { simulate(); return waitForIt(() => result())}; const _2_val = await _2(); const _3_val = await _3(); const _4_val = await _4(); const _5_val = await _5(); const _6_val = await _6(); const _7_val = await _7(); const _8_val = await _8(); const _9_val = await _9(); const _10_val = await _10(); const __text = new Set([_1.text, _2_val.text, _3_val.text, _4_val.text, _5_val.text, _6_val.text, _7_val.text, _8_val.text, _9_val.text, _10_val.text]); const __h1 = new Set([_1.h1, _2_val.h1, _3_val.h1, _4_val.h1, _5_val.h1, _6_val.h1, _7_val.h1, _8_val.h1, _9_val.h1, _10_val.h1]); assert(__text.size === 2 && __h1.size === 1, "When the <code>GameOfChance</code> component is first mounted to the DOM and each time the button is clicked thereafter, a single <code>h1</code> element should be returned that randomly renders either <code>You Win!</code> or <code>You Lose!</code>."); }; '
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/render-state-in-the-user-interface-another-way.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/render-state-in-the-user-interface-another-way.spanish.md
index 0c4e8b1a16..70facc214e 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/render-state-in-the-user-interface-another-way.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/render-state-in-the-user-interface-another-way.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Hay otra forma de acceder al <code>state</code> en un componente. En el método <code>render()</code> , antes de la declaración de <code>return</code> , puede escribir JavaScript directamente. Por ejemplo, podría declarar funciones, acceder a datos de <code>state</code> o <code>props</code> , realizar cálculos en estos datos, etc. Luego, puede asignar cualquier dato a las variables, a las que tiene acceso en la declaración de <code>return</code> . 
+<section id='description'>
+Hay otra forma de acceder al <code>state</code> en un componente. En el método <code>render()</code> , antes de la declaración de <code>return</code> , puede escribir JavaScript directamente. Por ejemplo, podría declarar funciones, acceder a datos de <code>state</code> o <code>props</code> , realizar cálculos en estos datos, etc. Luego, puede asignar cualquier dato a las variables, a las que tiene acceso en la declaración de <code>return</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-En el método de procesamiento de <code>MyComponent</code> , defina una <code>const</code> llamada <code>name</code> y establezca que sea igual al valor del nombre en el <code>state</code> del componente. Debido a que puede escribir JavaScript directamente en esta parte del código, no tiene que incluir esta referencia entre llaves. 
-A continuación, en la declaración de retorno, renderice este valor en una etiqueta <code>h1</code> usando el <code>name</code> la variable. Recuerde, debe usar la sintaxis JSX (llaves para JavaScript) en la declaración de devolución. 
+<section id='instructions'>
+En el método de procesamiento de <code>MyComponent</code> , defina una <code>const</code> llamada <code>name</code> y establezca que sea igual al valor del nombre en el <code>state</code> del componente. Debido a que puede escribir JavaScript directamente en esta parte del código, no tiene que incluir esta referencia entre llaves.
+A continuación, en la declaración de retorno, renderice este valor en una etiqueta <code>h1</code> usando el <code>name</code> la variable. Recuerde, debe usar la sintaxis JSX (llaves para JavaScript) en la declaración de devolución.
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ tests:
     testString: 'assert(Enzyme.mount(React.createElement(MyComponent)).state("name") === "freeCodeCamp", "<code>MyComponent</code> should have a key <code>name</code> with value <code>freeCodeCamp</code> stored in its state.");'
   - text: <code>MyComponent</code> debe representar un encabezado <code>h1</code> incluido en un solo <code>div</code> .
     testString: 'assert(/<div><h1>.*<\/h1><\/div>/.test(Enzyme.mount(React.createElement(MyComponent)).html()), "<code>MyComponent</code> should render an <code>h1</code> header enclosed in a single <code>div</code>.");'
-  - text: &#39;La etiqueta <code>h1</code> representada debe incluir una referencia a <code>{name}</code> .&#39;
+  - text: 'La etiqueta <code>h1</code> representada debe incluir una referencia a <code>{name}</code> .'
     testString: 'getUserInput => assert(/<h1>\n*\s*\{\s*name\s*\}\s*\n*<\/h1>/.test(getUserInput("index")), "The rendered <code>h1</code> tag should include a reference to <code>{name}</code>.");'
   - text: El encabezado <code>h1</code> representado debe contener texto representado desde el estado del componente.
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); const first = () => { mockedComponent.setState({ name: "TestName" });   return waitForIt(() => mockedComponent.html()) }; const firstValue = await first(); assert(firstValue === "<div><h1>TestName</h1></div>", "The rendered <code>h1</code> header should contain text rendered from the component&apos;s state."); };'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/render-with-an-if-else-condition.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/render-with-an-if-else-condition.spanish.md
index e2e4833a27..ff0d75c9f2 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/render-with-an-if-else-condition.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/render-with-an-if-else-condition.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Otra aplicación del uso de JavaScript para controlar su vista renderizada es vincular los elementos que se representan a una condición. Cuando la condición es verdadera, una vista se renderiza. Cuando es falso, es una vista diferente. Puede hacer esto con una instrucción <code>if/else</code> estándar en el método <code>render()</code> de un componente React. 
+<section id='description'>
+Otra aplicación del uso de JavaScript para controlar su vista renderizada es vincular los elementos que se representan a una condición. Cuando la condición es verdadera, una vista se renderiza. Cuando es falso, es una vista diferente. Puede hacer esto con una instrucción <code>if/else</code> estándar en el método <code>render()</code> de un componente React.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-MyComponent contiene un <code>boolean</code> en su estado que rastrea si desea mostrar algún elemento en la interfaz de usuario o no. El <code>button</code> cambia el estado de este valor. Actualmente, rinde la misma interfaz de usuario cada vez. Reescriba el método <code>render()</code> con una instrucción <code>if/else</code> para que si la <code>display</code> es <code>true</code> , devuelva el marcado actual. De lo contrario, devuelva el marcado sin el elemento <code>h1</code> . 
-<strong>Nota:</strong> Debe escribir un <code>if/else</code> para pasar las pruebas. El uso del operador ternario no pasará aquí. 
+<section id='instructions'>
+MyComponent contiene un <code>boolean</code> en su estado que rastrea si desea mostrar algún elemento en la interfaz de usuario o no. El <code>button</code> cambia el estado de este valor. Actualmente, rinde la misma interfaz de usuario cada vez. Reescriba el método <code>render()</code> con una instrucción <code>if/else</code> para que si la <code>display</code> es <code>true</code> , devuelva el marcado actual. De lo contrario, devuelva el marcado sin el elemento <code>h1</code> .
+<strong>Nota:</strong> Debe escribir un <code>if/else</code> para pasar las pruebas. El uso del operador ternario no pasará aquí.
 </section>
 
 ## Tests
@@ -24,9 +24,9 @@ MyComponent contiene un <code>boolean</code> en su estado que rastrea si desea m
 tests:
   - text: <code>MyComponent</code> debería existir y renderizarse.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); return mockedComponent.find("MyComponent").length === 1; })(), "<code>MyComponent</code> should exist and render.");'
-  - text: &#39;Cuando la <code>display</code> está configurada como <code>true</code> , deberían <code>display</code> un <code>div</code> , un <code>button</code> y <code>h1</code> .&#39;
+  - text: 'Cuando la <code>display</code> está configurada como <code>true</code> , deberían <code>display</code> un <code>div</code> , un <code>button</code> y <code>h1</code> .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); const state_1 = () => { mockedComponent.setState({display: true}); return waitForIt(() => mockedComponent )}; const updated = await state_1(); assert(mockedComponent.find("div").length === 1 && mockedComponent.find("div").children().length === 2 && mockedComponent.find("button").length === 1 && mockedComponent.find("h1").length === 1, "When <code>display</code> is set to <code>true</code>, a <code>div</code>, <code>button</code>, and <code>h1</code> should render."); }; '
-  - text: &#39;Cuando la <code>display</code> está configurada en <code>false</code> , solo deberían <code>display</code> un <code>button</code> <code>div</code> y&#39;.
+  - text: 'Cuando la <code>display</code> está configurada en <code>false</code> , solo deberían <code>display</code> un <code>button</code> <code>div</code> y'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); const state_1 = () => { mockedComponent.setState({display: false}); return waitForIt(() => mockedComponent )}; const updated = await state_1(); assert(mockedComponent.find("div").length === 1 && mockedComponent.find("div").children().length === 1 && mockedComponent.find("button").length === 1 && mockedComponent.find("h1").length === 0, "When <code>display</code> is set to <code>false</code>, only a <code>div</code> and <code>button</code> should render."); }; '
   - text: El método de render debería usar una instrucción <code>if/else</code> para verificar la condición de <code>this.state.display</code> .
     testString: 'getUserInput => assert(getUserInput("index").includes("if") && getUserInput("index").includes("else"), "The render method should use an <code>if/else</code> statement to check the condition of <code>this.state.display</code>.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/set-state-with-this.setstate.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/set-state-with-this.setstate.spanish.md
index af08ec5f30..b4d6be65c3 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/set-state-with-this.setstate.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/set-state-with-this.setstate.spanish.md
@@ -7,16 +7,16 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Los desafíos anteriores cubrieron el <code>state</code> componente y cómo inicializar el estado en el <code>constructor</code> . También hay una manera de cambiar el <code>state</code> del componente. React proporciona un método para actualizar el <code>state</code> componente llamado <code>setState</code> . Llama al método <code>setState</code> dentro de su clase de componente así: <code>this.setState()</code> , pasando un objeto con pares clave-valor. Las claves son las propiedades de su estado y los valores son los datos de estado actualizados. Por ejemplo, si almacenáramos un <code>username</code> de <code>username</code> en estado y quisiéramos actualizarlo, se vería así: 
-<blockquote>this.setState({<br>&nbsp;&nbsp;username: 'Lewis'<br>});</blockquote> 
-React espera que nunca modifique el <code>state</code> directamente, en su lugar, siempre use <code>this.setState()</code> cuando ocurran cambios de estado. Además, debe tener en cuenta que React puede generar varias actualizaciones de estado por lotes para mejorar el rendimiento. Lo que esto significa es que las actualizaciones de estado a través del método <code>setState</code> pueden ser asíncronas. Hay una sintaxis alternativa para el método <code>setState</code> que proporciona una forma de solucionar este problema. Esto rara vez es necesario, pero es bueno tenerlo en cuenta. Por favor, consulte la <a target="_blank" href="https://facebook.github.io/react/docs/state-and-lifecycle.html">documentación de React</a> para más detalles. 
+<section id='description'>
+Los desafíos anteriores cubrieron el <code>state</code> componente y cómo inicializar el estado en el <code>constructor</code> . También hay una manera de cambiar el <code>state</code> del componente. React proporciona un método para actualizar el <code>state</code> componente llamado <code>setState</code> . Llama al método <code>setState</code> dentro de su clase de componente así: <code>this.setState()</code> , pasando un objeto con pares clave-valor. Las claves son las propiedades de su estado y los valores son los datos de estado actualizados. Por ejemplo, si almacenáramos un <code>username</code> de <code>username</code> en estado y quisiéramos actualizarlo, se vería así:
+<blockquote>this.setState({<br>&nbsp;&nbsp;username: 'Lewis'<br>});</blockquote>
+React espera que nunca modifique el <code>state</code> directamente, en su lugar, siempre use <code>this.setState()</code> cuando ocurran cambios de estado. Además, debe tener en cuenta que React puede generar varias actualizaciones de estado por lotes para mejorar el rendimiento. Lo que esto significa es que las actualizaciones de estado a través del método <code>setState</code> pueden ser asíncronas. Hay una sintaxis alternativa para el método <code>setState</code> que proporciona una forma de solucionar este problema. Esto rara vez es necesario, pero es bueno tenerlo en cuenta. Por favor, consulte la <a target="_blank" href="https://facebook.github.io/react/docs/state-and-lifecycle.html">documentación de React</a> para más detalles.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hay un elemento de <code>button</code> en el editor de código que tiene un controlador <code>onClick()</code> . Este controlador se activa cuando el <code>button</code> recibe un evento de clic en el navegador y ejecuta el método <code>handleClick</code> definido en <code>MyComponent</code> . Dentro del método <code>handleClick</code> , actualice el <code>state</code> del componente usando <code>this.setState()</code> . Establezca la propiedad de <code>name</code> en <code>state</code> para que sea igual a la cadena <code>React Rocks!</code> . 
-Haga clic en el botón y observe la actualización del estado renderizado. No se preocupe si no entiende completamente cómo funciona el código del controlador de clics en este momento. Está cubierto en los próximos desafíos. 
+<section id='instructions'>
+Hay un elemento de <code>button</code> en el editor de código que tiene un controlador <code>onClick()</code> . Este controlador se activa cuando el <code>button</code> recibe un evento de clic en el navegador y ejecuta el método <code>handleClick</code> definido en <code>MyComponent</code> . Dentro del método <code>handleClick</code> , actualice el <code>state</code> del componente usando <code>this.setState()</code> . Establezca la propiedad de <code>name</code> en <code>state</code> para que sea igual a la cadena <code>React Rocks!</code> .
+Haga clic en el botón y observe la actualización del estado renderizado. No se preocupe si no entiende completamente cómo funciona el código del controlador de clics en este momento. Está cubierto en los próximos desafíos.
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Haga clic en el botón y observe la actualización del estado renderizado. No se
 
 ```yml
 tests:
-  - text: &#39;El estado de <code>MyComponent</code> debe <code>MyComponent</code> con el par de valores clave <code>{ name: Initial State }</code> .&#39;
+  - text: 'El estado de <code>MyComponent</code> debe <code>MyComponent</code> con el par de valores clave <code>{ name: Initial State }</code> .'
     testString: 'assert(Enzyme.mount(React.createElement(MyComponent)).state("name") === "Initial State", "The state of <code>MyComponent</code> should initialize with the key value pair <code>{ name: Initial State }</code>.");'
   - text: <code>MyComponent</code> debe hacer un encabezado <code>h1</code> .
     testString: 'assert(Enzyme.mount(React.createElement(MyComponent)).find("h1").length === 1, "<code>MyComponent</code> should render an <code>h1</code> header.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/use--for-a-more-concise-conditional.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/use--for-a-more-concise-conditional.spanish.md
index 1ef0d0e7b9..9497f204a0 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/use--for-a-more-concise-conditional.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/use--for-a-more-concise-conditional.spanish.md
@@ -7,15 +7,15 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Las declaraciones if / else funcionaron en el último desafío, pero hay una forma más concisa de lograr el mismo resultado. Imagine que está rastreando varias condiciones en un componente y desea que se representen diferentes elementos en función de cada una de estas condiciones. Si escribe muchas <code>else if</code> instrucciones, <code>else if</code> declaraciones devuelven interfaces de usuario ligeramente diferentes, puede repetir el código que deja espacio para el error. En su lugar, puede utilizar el operador lógico <code>&amp;&amp;</code> para realizar la lógica condicional de una manera más concisa. Esto es posible porque desea verificar si una condición es <code>true</code> y, si lo es, devolver algún margen de beneficio. Aquí hay un ejemplo: 
-<code>{condition &amp;&amp; &lt;p&gt;markup&lt;/p&gt;}</code> 
-Si la <code>condition</code> es <code>true</code> , se devolverá la marca. Si la condición es <code>false</code> , la operación devolverá inmediatamente <code>false</code> después de evaluar la <code>condition</code> y no devolverá nada. Puede incluir estas declaraciones directamente en su JSX y encadenar varias condiciones juntas escribiendo <code>&amp;&amp;</code> después de cada una. Esto le permite manejar una lógica condicional más compleja en su método <code>render()</code> sin repetir mucho código. 
+<section id='description'>
+Las declaraciones if / else funcionaron en el último desafío, pero hay una forma más concisa de lograr el mismo resultado. Imagine que está rastreando varias condiciones en un componente y desea que se representen diferentes elementos en función de cada una de estas condiciones. Si escribe muchas <code>else if</code> instrucciones, <code>else if</code> declaraciones devuelven interfaces de usuario ligeramente diferentes, puede repetir el código que deja espacio para el error. En su lugar, puede utilizar el operador lógico <code>&amp;&amp;</code> para realizar la lógica condicional de una manera más concisa. Esto es posible porque desea verificar si una condición es <code>true</code> y, si lo es, devolver algún margen de beneficio. Aquí hay un ejemplo:
+<code>{condition &amp;&amp; &lt;p&gt;markup&lt;/p&gt;}</code>
+Si la <code>condition</code> es <code>true</code> , se devolverá la marca. Si la condición es <code>false</code> , la operación devolverá inmediatamente <code>false</code> después de evaluar la <code>condition</code> y no devolverá nada. Puede incluir estas declaraciones directamente en su JSX y encadenar varias condiciones juntas escribiendo <code>&amp;&amp;</code> después de cada una. Esto le permite manejar una lógica condicional más compleja en su método <code>render()</code> sin repetir mucho código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Resuelva el ejemplo anterior nuevamente, de modo que <code>h1</code> solo <code>display</code> si la <code>display</code> es <code>true</code> , pero use el operador lógico <code>&amp;&amp;</code> lugar de una instrucción <code>if/else</code> . 
+<section id='instructions'>
+Resuelva el ejemplo anterior nuevamente, de modo que <code>h1</code> solo <code>display</code> si la <code>display</code> es <code>true</code> , pero use el operador lógico <code>&amp;&amp;</code> lugar de una instrucción <code>if/else</code> .
 </section>
 
 ## Tests
@@ -25,9 +25,9 @@ Resuelva el ejemplo anterior nuevamente, de modo que <code>h1</code> solo <code>
 tests:
   - text: <code>MyComponent</code> debería existir y renderizarse.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); return mockedComponent.find("MyComponent").length; })(), "<code>MyComponent</code> should exist and render.");'
-  - text: &#39;Cuando la <code>display</code> está configurada como <code>true</code> , deberían <code>display</code> un <code>div</code> , un <code>button</code> y <code>h1</code> .&#39;
+  - text: 'Cuando la <code>display</code> está configurada como <code>true</code> , deberían <code>display</code> un <code>div</code> , un <code>button</code> y <code>h1</code> .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); const state_1 = () => { mockedComponent.setState({display: true}); return waitForIt(() => mockedComponent )}; const updated = await state_1(); assert(updated.find("div").length === 1 && updated.find("div").children().length === 2 && updated.find("button").length === 1 && updated.find("h1").length === 1, "When <code>display</code> is set to <code>true</code>, a <code>div</code>, <code>button</code>, and <code>h1</code> should render."); }; '
-  - text: &#39;Cuando la <code>display</code> está configurada en <code>false</code> , solo deberían <code>display</code> un <code>button</code> <code>div</code> y&#39;.
+  - text: 'Cuando la <code>display</code> está configurada en <code>false</code> , solo deberían <code>display</code> un <code>button</code> <code>div</code> y'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(MyComponent)); const state_1 = () => { mockedComponent.setState({display: false}); return waitForIt(() => mockedComponent )}; const updated = await state_1(); assert(updated.find("div").length === 1 && updated.find("div").children().length === 1 && updated.find("button").length === 1 && updated.find("h1").length === 0, "When <code>display</code> is set to <code>false</code>, only a <code>div</code> and <code>button</code> should render."); }; '
   - text: El método de representación debe utilizar el operador lógico &amp;&amp; para verificar la condición de this.state.display.
     testString: 'getUserInput => assert(getUserInput("index").includes("&&"), "The render method should use the && logical operator to check the condition of this.state.display.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/use-a-ternary-expression-for-conditional-rendering.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/use-a-ternary-expression-for-conditional-rendering.spanish.md
index 7a7e834fd7..760f8afd19 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/use-a-ternary-expression-for-conditional-rendering.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/use-a-ternary-expression-for-conditional-rendering.spanish.md
@@ -7,15 +7,15 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Antes de pasar a las técnicas de representación dinámica, hay una última forma de usar condicionales de JavaScript incorporados para representar lo que desea: el <em><strong>operador ternario</strong></em> . El operador ternario se utiliza a menudo como acceso directo para las declaraciones <code>if/else</code> en JavaScript. No son tan robustos como las declaraciones tradicionales <code>if/else</code> , pero son muy populares entre los desarrolladores de React. Una razón para esto se debe a cómo se compila JSX, <code>if/else</code> sentencias no se pueden insertar directamente en el código JSX. Es posible que haya notado esto hace un par de desafíos: cuando se requería una declaración <code>if/else</code> , siempre estaba <em>fuera de</em> la declaración de <code>return</code> . Las expresiones ternarias pueden ser una excelente alternativa si desea implementar lógica condicional dentro de su JSX. Recuerde que un operador ternario tiene tres partes, pero puede combinar varias expresiones ternarias juntas. Aquí está la sintaxis básica: 
-<blockquote>condition ? expressionIfTrue : expressionIfFalse</blockquote> 
+<section id='description'>
+Antes de pasar a las técnicas de representación dinámica, hay una última forma de usar condicionales de JavaScript incorporados para representar lo que desea: el <em><strong>operador ternario</strong></em> . El operador ternario se utiliza a menudo como acceso directo para las declaraciones <code>if/else</code> en JavaScript. No son tan robustos como las declaraciones tradicionales <code>if/else</code> , pero son muy populares entre los desarrolladores de React. Una razón para esto se debe a cómo se compila JSX, <code>if/else</code> sentencias no se pueden insertar directamente en el código JSX. Es posible que haya notado esto hace un par de desafíos: cuando se requería una declaración <code>if/else</code> , siempre estaba <em>fuera de</em> la declaración de <code>return</code> . Las expresiones ternarias pueden ser una excelente alternativa si desea implementar lógica condicional dentro de su JSX. Recuerde que un operador ternario tiene tres partes, pero puede combinar varias expresiones ternarias juntas. Aquí está la sintaxis básica:
+<blockquote>condition ? expressionIfTrue : expressionIfFalse</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene tres constantes definidas dentro del <code>CheckUserAge</code> <code>render()</code> del componente <code>CheckUserAge</code> . Se denominan <code>buttonOne</code> , <code>buttonTwo</code> y <code>buttonThree</code> . A cada uno de estos se les asigna una expresión JSX simple que representa un elemento de botón. Primero, inicialice el estado de <code>CheckUserAge</code> con <code>input</code> y <code>userAge</code> ambos configurados en valores de una cadena vacía. 
-Una vez que el componente está brindando información a la página, los usuarios deben tener una forma de interactuar con él. Dentro de la declaración de <code>return</code> del componente, configure una expresión ternaria que implemente la siguiente lógica: cuando la página se carga por primera vez, renderice el botón de envío, <code>buttonOne</code> , a la página. Luego, cuando un usuario ingresa su edad y hace clic en el botón, renderiza un botón diferente según la edad. Si un usuario ingresa un número menor que <code>18</code> , render <code>buttonThree</code> . Si un usuario ingresa un número mayor o igual a <code>18</code> , renderice el <code>buttonTwo</code> . 
+<section id='instructions'>
+El editor de código tiene tres constantes definidas dentro del <code>CheckUserAge</code> <code>render()</code> del componente <code>CheckUserAge</code> . Se denominan <code>buttonOne</code> , <code>buttonTwo</code> y <code>buttonThree</code> . A cada uno de estos se les asigna una expresión JSX simple que representa un elemento de botón. Primero, inicialice el estado de <code>CheckUserAge</code> con <code>input</code> y <code>userAge</code> ambos configurados en valores de una cadena vacía.
+Una vez que el componente está brindando información a la página, los usuarios deben tener una forma de interactuar con él. Dentro de la declaración de <code>return</code> del componente, configure una expresión ternaria que implemente la siguiente lógica: cuando la página se carga por primera vez, renderice el botón de envío, <code>buttonOne</code> , a la página. Luego, cuando un usuario ingresa su edad y hace clic en el botón, renderiza un botón diferente según la edad. Si un usuario ingresa un número menor que <code>18</code> , render <code>buttonThree</code> . Si un usuario ingresa un número mayor o igual a <code>18</code> , renderice el <code>buttonTwo</code> .
 </section>
 
 ## Tests
@@ -25,13 +25,13 @@ Una vez que el componente está brindando información a la página, los usuario
 tests:
   - text: El componente <code>CheckUserAge</code> debe procesarse con un solo elemento de <code>input</code> y un solo elemento de <code>button</code> .
     testString: 'assert(Enzyme.mount(React.createElement(CheckUserAge)).find("div").find("input").length === 1 && Enzyme.mount(React.createElement(CheckUserAge)).find("div").find("button").length === 1, "The <code>CheckUserAge</code> component should render with a single <code>input</code> element and a single <code>button</code> element.");'
-  - text: &#39;El <code>CheckUserAge</code> componente <code>CheckUserAge</code> debe inicializarse con una propiedad de <code>userAge</code> y una propiedad de <code>input</code> , ambas configuradas con el valor de una cadena vacía&#39;.
+  - text: 'El <code>CheckUserAge</code> componente <code>CheckUserAge</code> debe inicializarse con una propiedad de <code>userAge</code> y una propiedad de <code>input</code> , ambas configuradas con el valor de una cadena vacía'
     testString: 'assert(Enzyme.mount(React.createElement(CheckUserAge)).state().input === "" && Enzyme.mount(React.createElement(CheckUserAge)).state().userAge === "", "The <code>CheckUserAge</code> component&apos;s state should be initialized with a property of <code>userAge</code> and a property of <code>input</code>, both set to a value of an empty string.");'
-  - text: &#39;Cuando el componente <code>CheckUserAge</code> se procesa por primera vez en el DOM, el texto interno del <code>button</code> debe ser Enviar.&#39;
+  - text: 'Cuando el componente <code>CheckUserAge</code> se procesa por primera vez en el DOM, el texto interno del <code>button</code> debe ser Enviar.'
     testString: 'assert(Enzyme.mount(React.createElement(CheckUserAge)).find("button").text() === "Submit", "When the <code>CheckUserAge</code> component is first rendered to the DOM, the <code>button</code>&apos;s inner text should be Submit.");'
-  - text: &#39;Cuando se introduce un número inferior a 18 a la <code>input</code> elemento y el <code>button</code> se hace clic en el <code>button</code> &#39;s texto interno debe leer <code>You Shall Not Pass</code> .&#39;
+  - text: 'Cuando se introduce un número inferior a 18 a la <code>input</code> elemento y el <code>button</code> se hace clic en el <code>button</code> &#39;s texto interno debe leer <code>You Shall Not Pass</code> .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(CheckUserAge)); const initialButton = mockedComponent.find("button").text(); const enter3AndClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "3" }}); mockedComponent.find("button").simulate("click"); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const enter17AndClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "17" }}); mockedComponent.find("button").simulate("click"); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const userAge3 = await enter3AndClickButton(); const userAge17 = await enter17AndClickButton(); assert(initialButton === "Submit" && userAge3 === "You Shall Not Pass" && userAge17 === "You Shall Not Pass", "When a number of less than 18 is entered into the <code>input</code> element and the <code>button</code> is clicked, the <code>button</code>&apos;s inner text should read <code>You Shall Not Pass</code>."); }; '
-  - text: &#39;Cuando se introduce un número mayor o igual a 18 a la <code>input</code> elemento y el <code>button</code> se hace clic en el <code>button</code> &#39;s texto interno debe leer <code>You May Enter</code> .&#39;
+  - text: 'Cuando se introduce un número mayor o igual a 18 a la <code>input</code> elemento y el <code>button</code> se hace clic en el <code>button</code> &#39;s texto interno debe leer <code>You May Enter</code> .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(CheckUserAge)); const initialButton = mockedComponent.find("button").text(); const enter18AndClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "18" }}); mockedComponent.find("button").simulate("click"); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const enter35AndClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "35" }}); mockedComponent.find("button").simulate("click"); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const userAge18 = await enter18AndClickButton(); const userAge35 = await enter35AndClickButton(); assert(initialButton === "Submit" && userAge18 === "You May Enter" && userAge35 === "You May Enter", "When a number greater than or equal to 18 is entered into the <code>input</code> element and the <code>button</code> is clicked, the <code>button</code>&apos;s inner text should read <code>You May Enter</code>."); }; '
   - text: &quot;Una vez que se ha enviado un número y el valor de la <code>input</code> se cambia de nuevo, el <code>button</code> debería volver a leer <code>Submit</code> &quot;.
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const mockedComponent = Enzyme.mount(React.createElement(CheckUserAge)); const enter18AndClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "18" }}); mockedComponent.find("button").simulate("click"); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const changeInputDontClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "5" }}); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const enter10AndClickButton = () => { mockedComponent.find("input").simulate("change", {target: { value: "10" }}); mockedComponent.find("button").simulate("click"); return waitForIt(() => { mockedComponent.update(); return mockedComponent.find("button").text(); }); }; const userAge18 = await enter18AndClickButton(); const changeInput1 = await changeInputDontClickButton(); const userAge10 = await enter10AndClickButton(); const changeInput2 = await changeInputDontClickButton(); assert(userAge18 === "You May Enter" && changeInput1 === "Submit" && userAge10 === "You Shall Not Pass" && changeInput2 === "Submit", "Once a number has been submitted, and the value of the <code>input</code> is once again changed, the <code>button</code> should return to reading <code>Submit</code>."); }; '
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/use-array.filter-to-dynamically-filter-an-array.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/use-array.filter-to-dynamically-filter-an-array.spanish.md
index 6d2112de9b..e86ec7d0c4 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/use-array.filter-to-dynamically-filter-an-array.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/use-array.filter-to-dynamically-filter-an-array.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-El método de matriz de <code>map</code> es una herramienta poderosa que usará a menudo cuando trabaje con React. Otro método relacionado con el <code>map</code> es el <code>filter</code> , que filtra el contenido de una matriz según una condición y luego devuelve una nueva matriz. Por ejemplo, si tiene una serie de usuarios que tienen una propiedad en <code>online</code> que puede configurarse como <code>true</code> o <code>false</code> , puede filtrar solo aquellos usuarios que están en línea escribiendo: 
-<code>let onlineUsers = users.filter(user =&gt; user.online);</code> que los usuarios en línea <code>let onlineUsers = users.filter(user =&gt; user.online);</code> 
+<section id='description'>
+El método de matriz de <code>map</code> es una herramienta poderosa que usará a menudo cuando trabaje con React. Otro método relacionado con el <code>map</code> es el <code>filter</code> , que filtra el contenido de una matriz según una condición y luego devuelve una nueva matriz. Por ejemplo, si tiene una serie de usuarios que tienen una propiedad en <code>online</code> que puede configurarse como <code>true</code> o <code>false</code> , puede filtrar solo aquellos usuarios que están en línea escribiendo:
+<code>let onlineUsers = users.filter(user =&gt; user.online);</code> que los usuarios en línea <code>let onlineUsers = users.filter(user =&gt; user.online);</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-En el editor de código, el <code>state</code> <code>MyComponent</code> se inicializa con una matriz de usuarios. Algunos usuarios están en línea y otros no. Filtre la matriz para ver solo los usuarios que están en línea. Para hacer esto, primero use el <code>filter</code> para devolver una nueva matriz que contenga solo los usuarios cuya propiedad en <code>online</code> es <code>true</code> . Luego, en la variable <code>renderOnline</code> , <code>renderOnline</code> sobre la matriz filtrada y devuelva un elemento <code>li</code> para cada usuario que contenga el texto de su <code>username</code> de <code>username</code> . Asegúrese de incluir también una <code>key</code> única, como en los últimos desafíos. 
+<section id='instructions'>
+En el editor de código, el <code>state</code> <code>MyComponent</code> se inicializa con una matriz de usuarios. Algunos usuarios están en línea y otros no. Filtre la matriz para ver solo los usuarios que están en línea. Para hacer esto, primero use el <code>filter</code> para devolver una nueva matriz que contenga solo los usuarios cuya propiedad en <code>online</code> es <code>true</code> . Luego, en la variable <code>renderOnline</code> , <code>renderOnline</code> sobre la matriz filtrada y devuelva un elemento <code>li</code> para cada usuario que contenga el texto de su <code>username</code> de <code>username</code> . Asegúrese de incluir también una <code>key</code> única, como en los últimos desafíos.
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ tests:
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(MyComponent)).find("MyComponent").length, 1, "<code>MyComponent</code> should exist and render to the page.");'
   - text: El estado de <code>MyComponent</code> debería inicializarse a una matriz de seis usuarios &quot;.
     testString: 'assert(Array.isArray(Enzyme.mount(React.createElement(MyComponent)).state("users")) === true && Enzyme.mount(React.createElement(MyComponent)).state("users").length === 6, "<code>MyComponent</code>&apos;s state should be initialized to an array of six users.");'
-  - text: &#39; <code>MyComponent</code> debe devolver un <code>div</code> , un <code>h1</code> , y luego una lista desordenada que contiene elementos <code>li</code> para cada usuario cuyo estado en línea se establece en <code>true</code> .&#39;
+  - text: ' <code>MyComponent</code> debe devolver un <code>div</code> , un <code>h1</code> , y luego una lista desordenada que contiene elementos <code>li</code> para cada usuario cuyo estado en línea se establece en <code>true</code> .'
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const comp = Enzyme.mount(React.createElement(MyComponent)); const users = (bool) => ({users:[ { username: "Jeff", online: bool }, { username: "Alan", online: bool }, { username: "Mary", online: bool }, { username: "Jim", online: bool   }, { username: "Laura", online: bool } ]}); const result = () => comp.find("li").length; const _1 = result(); const _2 = () => { comp.setState(users(true)); return waitForIt(() => result()) }; const _3 = () => { comp.setState(users(false)); return waitForIt(() => result()) }; const _4 = () => { comp.setState({ users: [] }); return waitForIt(() => result()) }; const _2_val = await _2(); const _3_val = await _3(); const _4_val = await _4(); assert(comp.find("div").length === 1 && comp.find("h1").length === 1 && comp.find("ul").length === 1 && _1 === 4 && _2_val === 5 && _3_val === 0 && _4_val === 0, "<code>MyComponent</code> should return a <code>div</code>, an <code>h1</code>, and then an unordered list containing <code>li</code> elements for every user whose online status is set to <code>true</code>."); }; '
   - text: <code>MyComponent</code> debe representar elementos <code>li</code> que contengan el nombre de usuario de cada usuario en línea.
     testString: 'async () => { const waitForIt = (fn) => new Promise((resolve, reject) => setTimeout(() => resolve(fn()), 250)); const comp = Enzyme.mount(React.createElement(MyComponent)); const users = (bool) => ({users:[ { username: "Jeff", online: bool }, { username: "Alan", online: bool }, { username: "Mary", online: bool }, { username: "Jim", online: bool   }, { username: "Laura", online: bool } ]}); const ul = () => { comp.setState(users(true)); return waitForIt(() => comp.find("ul").html()) }; const html = await ul(); assert(html === "<ul><li>Jeff</li><li>Alan</li><li>Mary</li><li>Jim</li><li>Laura</li></ul>", "<code>MyComponent</code> should render <code>li</code> elements that contain the username of each online user."); }; '
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/use-default-props.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/use-default-props.spanish.md
index d7d2da1139..b1c4159532 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/use-default-props.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/use-default-props.spanish.md
@@ -7,13 +7,13 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-React también tiene una opción para establecer accesorios predeterminados. Puede asignar accesorios predeterminados a un componente como una propiedad en el propio componente y React asigna el apoyo predeterminado si es necesario. Esto le permite especificar lo que debe ser un valor de propiedad si no se proporciona ningún valor explícitamente. Por ejemplo, si declara <code>MyComponent.defaultProps = { location: &#39;San Francisco&#39; }</code> , ha definido un prop de ubicación que se establece en la cadena <code>San Francisco</code> , a menos que especifique lo contrario. React asigna props por defecto si los prop no están definidos, pero si pasa <code>null</code> como valor para un prop, seguirá siendo <code>null</code> . 
+<section id='description'>
+React también tiene una opción para establecer accesorios predeterminados. Puede asignar accesorios predeterminados a un componente como una propiedad en el propio componente y React asigna el apoyo predeterminado si es necesario. Esto le permite especificar lo que debe ser un valor de propiedad si no se proporciona ningún valor explícitamente. Por ejemplo, si declara <code>MyComponent.defaultProps = { location: &#39;San Francisco&#39; }</code> , ha definido un prop de ubicación que se establece en la cadena <code>San Francisco</code> , a menos que especifique lo contrario. React asigna props por defecto si los prop no están definidos, pero si pasa <code>null</code> como valor para un prop, seguirá siendo <code>null</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código muestra un componente <code>ShoppingCart</code> . Defina accesorios predeterminados en este componente que especifican <code>items</code> prop con un valor de <code>0</code> . 
+<section id='instructions'>
+El editor de código muestra un componente <code>ShoppingCart</code> . Defina accesorios predeterminados en este componente que especifican <code>items</code> prop con un valor de <code>0</code> .
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ El editor de código muestra un componente <code>ShoppingCart</code> . Defina ac
 tests:
   - text: El componente <code>ShoppingCart</code> debe renderizar.
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(ShoppingCart)); return mockedComponent.find("ShoppingCart").length === 1; })(), "The <code>ShoppingCart</code> component should render.");'
-  - text: &#39;El componente <code>ShoppingCart</code> debe tener un prop predeterminado de <code>{ items: 0 }</code> .&#39;
+  - text: 'El componente <code>ShoppingCart</code> debe tener un prop predeterminado de <code>{ items: 0 }</code> .'
     testString: 'assert((function() { const mockedComponent = Enzyme.mount(React.createElement(ShoppingCart)); mockedComponent.setProps({items: undefined}); return mockedComponent.find("ShoppingCart").props().items === 0; })(), "The <code>ShoppingCart</code> component should have a default prop of <code>{ items: 0 }</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/react/write-a-simple-counter.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/react/write-a-simple-counter.spanish.md
index 3f53024b72..070ef3a212 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/react/write-a-simple-counter.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/react/write-a-simple-counter.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Puede diseñar un componente con estado más complejo combinando los conceptos cubiertos hasta ahora. Estos incluyen el <code>state</code> inicialización, los métodos de escritura que establecen el <code>state</code> y la asignación de controladores de clics para activar estos métodos. 
+<section id='description'>
+Puede diseñar un componente con estado más complejo combinando los conceptos cubiertos hasta ahora. Estos incluyen el <code>state</code> inicialización, los métodos de escritura que establecen el <code>state</code> y la asignación de controladores de clics para activar estos métodos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El componente <code>Counter</code> realiza un seguimiento de un valor de <code>count</code> en el <code>state</code> . Hay dos botones que llaman a los métodos <code>increment()</code> y <code>decrement()</code> . Escriba estos métodos para que el valor del contador se incremente o disminuya en 1 cuando se hace clic en el botón apropiado. Además, cree un método de <code>reset()</code> para que cuando se haga clic en el botón de reinicio, el conteo se establezca en 0. 
-<strong>Nota:</strong> Asegúrese de no modificar los <code>classNames</code> de <code>classNames</code> de los botones. Además, recuerde agregar los enlaces necesarios para los métodos recién creados en el constructor. 
+<section id='instructions'>
+El componente <code>Counter</code> realiza un seguimiento de un valor de <code>count</code> en el <code>state</code> . Hay dos botones que llaman a los métodos <code>increment()</code> y <code>decrement()</code> . Escriba estos métodos para que el valor del contador se incremente o disminuya en 1 cuando se hace clic en el botón apropiado. Además, cree un método de <code>reset()</code> para que cuando se haga clic en el botón de reinicio, el conteo se establezca en 0.
+<strong>Nota:</strong> Asegúrese de no modificar los <code>classNames</code> de <code>classNames</code> de los botones. Además, recuerde agregar los enlaces necesarios para los métodos recién creados en el constructor.
 </section>
 
 ## Tests
@@ -22,7 +22,7 @@ El componente <code>Counter</code> realiza un seguimiento de un valor de <code>c
 
 ```yml
 tests:
-  - text: &#39;El <code>Counter</code> debe devolver un elemento <code>div</code> que contiene tres botones con contenido de texto en este orden <code>Increment!</code> , <code>Decrement!</code> , <code>Reset</code> .
+  - text: 'El <code>Counter</code> debe devolver un elemento <code>div</code> que contiene tres botones con contenido de texto en este orden <code>Increment!</code> , <code>Decrement!</code> , <code>Reset</code> .
     testString: 'assert((() => { const mockedComponent = Enzyme.mount(React.createElement(Counter)); return (mockedComponent.find(".inc").text() === "Increment!" && mockedComponent.find(".dec").text() === "Decrement!" && mockedComponent.find(".reset").text() === "Reset"); })(), "<code>Counter</code> should return a <code>div</code> element which contains three buttons with text content in this order <code>Increment!</code>, <code>Decrement!</code>, <code>Reset</code>.");'
   - text: El estado del <code>Counter</code> debe inicializarse con una propiedad de <code>count</code> establecida en <code>0</code> .
     testString: 'assert.strictEqual(Enzyme.mount(React.createElement(Counter)).state("count"), 0, "The state of <code>Counter</code> should initialize with a <code>count</code> property set to <code>0</code>.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/redux/combine-multiple-reducers.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/redux/combine-multiple-reducers.spanish.md
index 934b07500f..2ce7ea1450 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/redux/combine-multiple-reducers.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/redux/combine-multiple-reducers.spanish.md
@@ -7,17 +7,17 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Cuando el estado de su aplicación comienza a hacerse más complejo, puede ser tentador dividir el estado en varias partes. En su lugar, recuerde el primer principio de Redux: todo el estado de la aplicación se mantiene en un objeto de un solo estado en la tienda. Por lo tanto, Redux proporciona la composición del reductor como una solución para un modelo de estado complejo. Usted define múltiples reductores para manejar diferentes partes del estado de su aplicación, luego componga estos reductores juntos en un reductor de raíz. El reductor de raíz se pasa luego al método <code>createStore()</code> Redux. 
-Para permitirnos combinar varios reductores juntos, Redux proporciona el método <code>combineReducers()</code> . Este método acepta un objeto como un argumento en el que define propiedades que asocian claves a funciones reductoras específicas. Redux usará el nombre que le dé a las teclas como el nombre para el estado asociado. 
-Por lo general, es una buena práctica crear un reductor para cada parte del estado de la aplicación cuando son distintos o únicos de alguna manera. Por ejemplo, en una aplicación para tomar notas con autenticación de usuario, un reductor podría manejar la autenticación, mientras que otro maneja el texto y observa que el usuario está enviando. Para una aplicación de este tipo, podríamos escribir el método <code>combineReducers()</code> siguiente manera: 
-<blockquote>const rootReducer = Redux.combineReducers({<br>&nbsp;&nbsp;auth: authenticationReducer,<br>&nbsp;&nbsp;notes: notesReducer<br>});</blockquote> 
-Ahora, las <code>notes</code> clave contendrán todo el estado asociado con nuestras notas y manejado por nuestro <code>notesReducer</code> . Así es como se pueden componer varios reductores para administrar un estado de aplicación más complejo. En este ejemplo, el estado mantenido en el almacén de Redux sería entonces un único objeto que contiene las propiedades <code>auth</code> y <code>notes</code> . 
+<section id='description'>
+Cuando el estado de su aplicación comienza a hacerse más complejo, puede ser tentador dividir el estado en varias partes. En su lugar, recuerde el primer principio de Redux: todo el estado de la aplicación se mantiene en un objeto de un solo estado en la tienda. Por lo tanto, Redux proporciona la composición del reductor como una solución para un modelo de estado complejo. Usted define múltiples reductores para manejar diferentes partes del estado de su aplicación, luego componga estos reductores juntos en un reductor de raíz. El reductor de raíz se pasa luego al método <code>createStore()</code> Redux.
+Para permitirnos combinar varios reductores juntos, Redux proporciona el método <code>combineReducers()</code> . Este método acepta un objeto como un argumento en el que define propiedades que asocian claves a funciones reductoras específicas. Redux usará el nombre que le dé a las teclas como el nombre para el estado asociado.
+Por lo general, es una buena práctica crear un reductor para cada parte del estado de la aplicación cuando son distintos o únicos de alguna manera. Por ejemplo, en una aplicación para tomar notas con autenticación de usuario, un reductor podría manejar la autenticación, mientras que otro maneja el texto y observa que el usuario está enviando. Para una aplicación de este tipo, podríamos escribir el método <code>combineReducers()</code> siguiente manera:
+<blockquote>const rootReducer = Redux.combineReducers({<br>&nbsp;&nbsp;auth: authenticationReducer,<br>&nbsp;&nbsp;notes: notesReducer<br>});</blockquote>
+Ahora, las <code>notes</code> clave contendrán todo el estado asociado con nuestras notas y manejado por nuestro <code>notesReducer</code> . Así es como se pueden componer varios reductores para administrar un estado de aplicación más complejo. En este ejemplo, el estado mantenido en el almacén de Redux sería entonces un único objeto que contiene las propiedades <code>auth</code> y <code>notes</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Hay <code>counterReducer()</code> y <code>authReducer()</code> provistas en el editor de código, junto con una tienda Redux. Termine de escribir la función <code>rootReducer()</code> utilizando el método <code>Redux.combineReducers()</code> . Asigne <code>counterReducer</code> a una clave llamada <code>count</code> y <code>authReducer</code> a una clave llamada <code>auth</code> . 
+<section id='instructions'>
+Hay <code>counterReducer()</code> y <code>authReducer()</code> provistas en el editor de código, junto con una tienda Redux. Termine de escribir la función <code>rootReducer()</code> utilizando el método <code>Redux.combineReducers()</code> . Asigne <code>counterReducer</code> a una clave llamada <code>count</code> y <code>authReducer</code> a una clave llamada <code>auth</code> .
 </section>
 
 ## Tests
@@ -29,7 +29,7 @@ tests:
     testString: 'assert((function() { const initalState = store.getState().count; store.dispatch({type: INCREMENT}); store.dispatch({type: INCREMENT}); const firstState = store.getState().count; store.dispatch({type: DECREMENT}); const secondState = store.getState().count; return firstState === initalState + 2 && secondState === firstState - 1  })(), "The <code>counterReducer</code> should increment and decrement the <code>state</code>.");'
   - text: El <code>authReducer</code> debe cambiar el <code>state</code> de <code>authenticated</code> entre <code>true</code> y <code>false</code> .
     testString: 'assert((function() {  store.dispatch({type: LOGIN}); const loggedIn = store.getState().auth.authenticated; store.dispatch({type: LOGOUT}); const loggedOut = store.getState().auth.authenticated; return loggedIn === true && loggedOut === false  })(), "The <code>authReducer</code> should toggle the <code>state</code> of <code>authenticated</code> between <code>true</code> and <code>false</code>.");'
-  - text: &#39;El <code>state</code> tienda debe tener dos claves: <code>count</code> , que contiene un número, y <code>auth</code> , que contiene un objeto. El objeto <code>auth</code> debe tener una propiedad de <code>authenticated</code> , que contiene un valor booleano. &#39;
+  - text: 'El <code>state</code> tienda debe tener dos claves: <code>count</code> , que contiene un número, y <code>auth</code> , que contiene un objeto. El objeto <code>auth</code> debe tener una propiedad de <code>authenticated</code> , que contiene un valor booleano. '
     testString: 'assert((function() { const state = store.getState(); return typeof state.auth === "object" && typeof state.auth.authenticated === "boolean" && typeof state.count === "number" })(), "The store <code>state</code> should have two keys: <code>count</code>, which holds a number, and <code>auth</code>, which holds an object. The <code>auth</code> object should have a property of <code>authenticated</code>, which holds a boolean.");'
   - text: El <code>rootReducer</code> debe ser una función que combine el <code>counterReducer</code> y el <code>authReducer</code> .
     testString: 'getUserInput => assert((function() {  const noWhiteSpace = getUserInput("index").replace(/\s/g,""); return typeof rootReducer === "function" && noWhiteSpace.includes("Redux.combineReducers")  })(), "The <code>rootReducer</code> should be a function that combines the <code>counterReducer</code> and the <code>authReducer</code>.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/redux/handle-an-action-in-the-store.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/redux/handle-an-action-in-the-store.spanish.md
index e76f554fbf..2066e242a9 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/redux/handle-an-action-in-the-store.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/redux/handle-an-action-in-the-store.spanish.md
@@ -7,14 +7,14 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Después de crear y enviar una acción, la tienda Redux debe saber cómo responder a esa acción. Este es el trabajo de una función <code>reducer</code> . Los reductores en Redux son responsables de las modificaciones de estado que tienen lugar en respuesta a las acciones. Un <code>reducer</code> toma el <code>state</code> y la <code>action</code> como argumentos, y siempre devuelve un nuevo <code>state</code> . Es importante ver que este es el <strong>único</strong> papel del reductor. No tiene efectos secundarios: nunca llama a un punto final de la API y nunca tiene sorpresas ocultas. El reductor es simplemente una función pura que toma estado y acción, luego devuelve un nuevo estado. 
-Otro principio clave en Redux es que el <code>state</code> es de solo lectura. En otras palabras, la función <code>reducer</code> <strong>siempre</strong> debe devolver una nueva copia del <code>state</code> y nunca modificar el estado directamente. Redux no impone la inmutabilidad del estado, sin embargo, usted es responsable de hacerlo cumplir en el código de sus funciones de reductor. Practicarás esto en desafíos posteriores. 
+<section id='description'>
+Después de crear y enviar una acción, la tienda Redux debe saber cómo responder a esa acción. Este es el trabajo de una función <code>reducer</code> . Los reductores en Redux son responsables de las modificaciones de estado que tienen lugar en respuesta a las acciones. Un <code>reducer</code> toma el <code>state</code> y la <code>action</code> como argumentos, y siempre devuelve un nuevo <code>state</code> . Es importante ver que este es el <strong>único</strong> papel del reductor. No tiene efectos secundarios: nunca llama a un punto final de la API y nunca tiene sorpresas ocultas. El reductor es simplemente una función pura que toma estado y acción, luego devuelve un nuevo estado.
+Otro principio clave en Redux es que el <code>state</code> es de solo lectura. En otras palabras, la función <code>reducer</code> <strong>siempre</strong> debe devolver una nueva copia del <code>state</code> y nunca modificar el estado directamente. Redux no impone la inmutabilidad del estado, sin embargo, usted es responsable de hacerlo cumplir en el código de sus funciones de reductor. Practicarás esto en desafíos posteriores.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El editor de código tiene el ejemplo anterior así como el inicio de una función de <code>reducer</code> para usted. Complete el cuerpo de la función del <code>reducer</code> modo que si recibe una acción del tipo <code>&#39;LOGIN&#39;</code> , devuelva un objeto de estado con el <code>login</code> establecido en <code>true</code> . De lo contrario, devuelve el <code>state</code> actual. Tenga en cuenta que el <code>state</code> actual y la <code>action</code> distribuida se pasan al reductor, por lo que puede acceder al tipo de acción directamente con <code>action.type</code> . 
+<section id='instructions'>
+El editor de código tiene el ejemplo anterior así como el inicio de una función de <code>reducer</code> para usted. Complete el cuerpo de la función del <code>reducer</code> modo que si recibe una acción del tipo <code>&#39;LOGIN&#39;</code> , devuelva un objeto de estado con el <code>login</code> establecido en <code>true</code> . De lo contrario, devuelve el <code>state</code> actual. Tenga en cuenta que el <code>state</code> actual y la <code>action</code> distribuida se pasan al reductor, por lo que puede acceder al tipo de acción directamente con <code>action.type</code> .
 </section>
 
 ## Tests
@@ -28,7 +28,7 @@ tests:
     testString: 'assert(store.getState().login === false, "The store should be initialized with an object with property <code>login</code> set to <code>false</code>.");'
   - text: Despachando <code>loginAction</code> debe actualizar la propiedad de <code>login</code> en el estado de la tienda a <code>true</code> .
     testString: 'assert((function() {  const initialState = store.getState(); store.dispatch(loginAction()); const afterState = store.getState(); return initialState.login === false && afterState.login === true })(), "Dispatching <code>loginAction</code> should update the <code>login</code> property in the store state to <code>true</code>.");'
-  - text: &#39;Si la acción no es de tipo <code>LOGIN</code> , la tienda debería devolver el estado actual.&#39;
+  - text: 'Si la acción no es de tipo <code>LOGIN</code> , la tienda debería devolver el estado actual.'
     testString: 'assert((function() { store.dispatch({type: "__TEST__ACTION__"}); let afterTest = store.getState(); return typeof afterTest === "object" && afterTest.hasOwnProperty("login") })(), "If the action is not of type <code>LOGIN</code>, the store should return the current state.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/redux/remove-an-item-from-an-array.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/redux/remove-an-item-from-an-array.spanish.md
index de7339b177..30e9a3a55e 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/redux/remove-an-item-from-an-array.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/redux/remove-an-item-from-an-array.spanish.md
@@ -7,13 +7,13 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Tiempo para practicar la eliminación de elementos de una matriz. El operador de propagación se puede utilizar aquí también. Otros métodos útiles de JavaScript incluyen <code>slice()</code> y <code>concat()</code> . 
+<section id='description'>
+Tiempo para practicar la eliminación de elementos de una matriz. El operador de propagación se puede utilizar aquí también. Otros métodos útiles de JavaScript incluyen <code>slice()</code> y <code>concat()</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El reductor y el creador de acciones se modificaron para eliminar un elemento de una matriz según el índice del elemento. Termine de escribir el reductor para que se devuelva una nueva matriz de estado con el elemento en el índice específico eliminado. 
+<section id='instructions'>
+El reductor y el creador de acciones se modificaron para eliminar un elemento de una matriz según el índice del elemento. Termine de escribir el reductor para que se devuelva una nueva matriz de estado con el elemento en el índice específico eliminado.
 </section>
 
 ## Tests
@@ -21,7 +21,7 @@ El reductor y el creador de acciones se modificaron para eliminar un elemento de
 
 ```yml
 tests:
-  - text: &#39;La tienda Redux debería existir e inicializarse con un estado igual a <code>[0,1,2,3,4,5]</code> &#39;
+  - text: 'La tienda Redux debería existir e inicializarse con un estado igual a <code>[0,1,2,3,4,5]</code> '
     testString: 'assert((function() { const initialState = store.getState(); return (Array.isArray(initialState) === true && DeepEqual(initialState, [0, 1, 2, 3, 4, 5])); })(), "The Redux store should exist and initialize with a state equal to <code>[0,1,2,3,4,5]</code>");'
   - text: <code>removeItem</code> y <code>immutableReducer</code> deben ser funciones.
     testString: 'assert(typeof removeItem === "function" && typeof immutableReducer === "function", "<code>removeItem</code> and <code>immutableReducer</code> both should be functions.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/redux/use-the-spread-operator-on-arrays.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/redux/use-the-spread-operator-on-arrays.spanish.md
index b99e801cee..17c23e4353 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/redux/use-the-spread-operator-on-arrays.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/redux/use-the-spread-operator-on-arrays.spanish.md
@@ -7,15 +7,15 @@ isRequired: false
 ---
 
 ## Description
-<section id='description'> 
-Una solución de ES6 para ayudar a imponer la inmutabilidad del estado en Redux es el operador de propagación: <code>...</code> El operador de difusión tiene una variedad de aplicaciones, una de las cuales está bien adaptada al desafío anterior de producir una nueva matriz a partir de una matriz existente. Esta es una sintaxis relativamente nueva, pero comúnmente utilizada. Por ejemplo, si tiene una matriz <code>myArray</code> y escribe: 
-<code>let newArray = [...myArray];</code> 
-<code>newArray</code> ahora es un clon de <code>myArray</code> . Ambas matrices todavía existen por separado en la memoria. Si realiza una mutación como <code>newArray.push(5)</code> , <code>myArray</code> no cambia. El <code>...</code> <i>propaga</i> eficazmente los valores en <code>myArray</code> en una nueva matriz. Para clonar una matriz pero agregar valores adicionales en la nueva matriz, puede escribir <code>[...myArray, &#39;new value&#39;]</code> . Esto devolvería una nueva matriz compuesta por los valores en <code>myArray</code> y la cadena <code>&#39;new value&#39;</code> como el último valor. La sintaxis de propagación se puede utilizar varias veces en una composición de matriz como esta, pero es importante tener en cuenta que solo hace una copia superficial de la matriz. Es decir, solo proporciona operaciones de matriz inmutables para matrices unidimensionales. 
+<section id='description'>
+Una solución de ES6 para ayudar a imponer la inmutabilidad del estado en Redux es el operador de propagación: <code>...</code> El operador de difusión tiene una variedad de aplicaciones, una de las cuales está bien adaptada al desafío anterior de producir una nueva matriz a partir de una matriz existente. Esta es una sintaxis relativamente nueva, pero comúnmente utilizada. Por ejemplo, si tiene una matriz <code>myArray</code> y escribe:
+<code>let newArray = [...myArray];</code>
+<code>newArray</code> ahora es un clon de <code>myArray</code> . Ambas matrices todavía existen por separado en la memoria. Si realiza una mutación como <code>newArray.push(5)</code> , <code>myArray</code> no cambia. El <code>...</code> <i>propaga</i> eficazmente los valores en <code>myArray</code> en una nueva matriz. Para clonar una matriz pero agregar valores adicionales en la nueva matriz, puede escribir <code>[...myArray, &#39;new value&#39;]</code> . Esto devolvería una nueva matriz compuesta por los valores en <code>myArray</code> y la cadena <code>&#39;new value&#39;</code> como el último valor. La sintaxis de propagación se puede utilizar varias veces en una composición de matriz como esta, pero es importante tener en cuenta que solo hace una copia superficial de la matriz. Es decir, solo proporciona operaciones de matriz inmutables para matrices unidimensionales.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Utilice el operador de propagación para devolver una nueva copia del estado cuando se agrega una tarea pendiente. 
+<section id='instructions'>
+Utilice el operador de propagación para devolver una nueva copia del estado cuando se agrega una tarea pendiente.
 </section>
 
 ## Tests
@@ -23,7 +23,7 @@ Utilice el operador de propagación para devolver una nueva copia del estado cua
 
 ```yml
 tests:
-  - text: &#39;El almacén Redux debería existir e inicializarse con un estado igual a <code>[Do not mutate state!]</code> .&#39;
+  - text: 'El almacén Redux debería existir e inicializarse con un estado igual a <code>[Do not mutate state!]</code> .'
     testString: 'assert((function() { const initialState = store.getState(); return ( Array.isArray(initialState) === true && initialState[0] === "Do not mutate state!"); })(), "The Redux store should exist and initialize with a state equal to <code>[Do not mutate state!]</code>.");'
   - text: <code>addToDo</code> y <code>immutableReducer</code> deben ser funciones.
     testString: 'assert(typeof addToDo === "function" && typeof immutableReducer === "function", "<code>addToDo</code> and <code>immutableReducer</code> both should be functions.");'
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/sass/create-reusable-css-with-mixins.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/sass/create-reusable-css-with-mixins.spanish.md
index 209aef306c..50c02a4f06 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/sass/create-reusable-css-with-mixins.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/sass/create-reusable-css-with-mixins.spanish.md
@@ -9,21 +9,21 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-En Sass, un <code>mixin</code> es un grupo de declaraciones CSS que se pueden reutilizar en toda la hoja de estilos. 
-Las nuevas funciones de CSS toman tiempo antes de que se adopten por completo y estén listas para usar en todos los navegadores. A medida que las funciones se agregan a los navegadores, las reglas CSS que los usan pueden necesitar prefijos de proveedores. Considere &quot;caja-sombra&quot;: 
-<blockquote>div {<br>&nbsp;&nbsp;-webkit-box-shadow: 0px 0px 4px #fff;<br>&nbsp;&nbsp;-moz-box-shadow: 0px 0px 4px #fff;<br>&nbsp;&nbsp;-ms-box-shadow: 0px 0px 4px #fff;<br>&nbsp;&nbsp;box-shadow: 0px 0px 4px #fff;<br>}</blockquote> 
-Es mucho escribir para volver a escribir esta regla para todos los elementos que tienen una <code>box-shadow</code> , o para cambiar cada valor para probar diferentes efectos. 
-<code>Mixins</code> son como funciones para CSS. Aquí está cómo escribir uno: 
-<blockquote>@mixin box-shadow($x, $y, $blur, $c){ <br>&nbsp;&nbsp;-webkit-box-shadow: $x, $y, $blur, $c;<br>&nbsp;&nbsp;-moz-box-shadow: $x, $y, $blur, $c;<br>&nbsp;&nbsp;-ms-box-shadow: $x, $y, $blur, $c;<br>&nbsp;&nbsp;box-shadow: $x, $y, $blur, $c;<br>}</blockquote> 
-La definición comienza con <code>@mixin</code> seguido de un nombre personalizado. Los parámetros ( <code>$x</code> , <code>$y</code> , <code>$blur</code> y <code>$c</code> en el ejemplo anterior) son opcionales. 
-Ahora, cada vez que se necesita una regla de <code>box-shadow</code> , solo una línea que llama a la <code>mixin</code> reemplaza tener que escribir todos los prefijos de proveedores. Se llama un <code>mixin</code> con la directiva <code>@include</code> : 
-<blockquote>div {<br>&nbsp;&nbsp;@include box-shadow(0px, 0px, 4px, #fff);<br>}</blockquote> 
+<section id='description'>
+En Sass, un <code>mixin</code> es un grupo de declaraciones CSS que se pueden reutilizar en toda la hoja de estilos.
+Las nuevas funciones de CSS toman tiempo antes de que se adopten por completo y estén listas para usar en todos los navegadores. A medida que las funciones se agregan a los navegadores, las reglas CSS que los usan pueden necesitar prefijos de proveedores. Considere &quot;caja-sombra&quot;:
+<blockquote>div {<br>&nbsp;&nbsp;-webkit-box-shadow: 0px 0px 4px #fff;<br>&nbsp;&nbsp;-moz-box-shadow: 0px 0px 4px #fff;<br>&nbsp;&nbsp;-ms-box-shadow: 0px 0px 4px #fff;<br>&nbsp;&nbsp;box-shadow: 0px 0px 4px #fff;<br>}</blockquote>
+Es mucho escribir para volver a escribir esta regla para todos los elementos que tienen una <code>box-shadow</code> , o para cambiar cada valor para probar diferentes efectos.
+<code>Mixins</code> son como funciones para CSS. Aquí está cómo escribir uno:
+<blockquote>@mixin box-shadow($x, $y, $blur, $c){ <br>&nbsp;&nbsp;-webkit-box-shadow: $x, $y, $blur, $c;<br>&nbsp;&nbsp;-moz-box-shadow: $x, $y, $blur, $c;<br>&nbsp;&nbsp;-ms-box-shadow: $x, $y, $blur, $c;<br>&nbsp;&nbsp;box-shadow: $x, $y, $blur, $c;<br>}</blockquote>
+La definición comienza con <code>@mixin</code> seguido de un nombre personalizado. Los parámetros ( <code>$x</code> , <code>$y</code> , <code>$blur</code> y <code>$c</code> en el ejemplo anterior) son opcionales.
+Ahora, cada vez que se necesita una regla de <code>box-shadow</code> , solo una línea que llama a la <code>mixin</code> reemplaza tener que escribir todos los prefijos de proveedores. Se llama un <code>mixin</code> con la directiva <code>@include</code> :
+<blockquote>div {<br>&nbsp;&nbsp;@include box-shadow(0px, 0px, 4px, #fff);<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escribe una <code>mixin</code> para <code>border-radius</code> de <code>border-radius</code> y dale un parámetro de <code>$radius</code> . Debe usar todos los prefijos de proveedores del ejemplo. A continuación, utilice la <code>border-radius</code> <code>mixin</code> para dar el <code>#awesome</code> elemento de un radio de borde de 15 píxeles. 
+<section id='instructions'>
+Escribe una <code>mixin</code> para <code>border-radius</code> de <code>border-radius</code> y dale un parámetro de <code>$radius</code> . Debe usar todos los prefijos de proveedores del ejemplo. A continuación, utilice la <code>border-radius</code> <code>mixin</code> para dar el <code>#awesome</code> elemento de un radio de borde de 15 píxeles.
 </section>
 
 ## Tests
@@ -41,7 +41,7 @@ tests:
     testString: 'assert(code.match(/-ms-border-radius:\s*?\$radius;/gi), "Your code should include the <code>-ms-border-radius</code> vender prefix that uses the <code>$radius</code> parameter.");'
   - text: Su código debe incluir la regla general <code>border-radius</code> que usa el parámetro <code>$radius</code> .
     testString: 'assert(code.match(/border-radius:\s*?\$radius;/gi).length == 4, "Your code should include the general <code>border-radius</code> rule that uses the <code>$radius</code> parameter.");'
-  - text: &#39;Su código debe llamar a la <code>border-radius mixin</code> usando la palabra clave <code>@include</code> , configurándolo en 15px&#39;.
+  - text: 'Su código debe llamar a la <code>border-radius mixin</code> usando la palabra clave <code>@include</code> , configurándolo en 15px'
     testString: 'assert(code.match(/@include\s+?border-radius\(\s*?15px\s*?\);/gi), "Your code should call the <code>border-radius mixin</code> using the <code>@include</code> keyword, setting it to 15px.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/sass/split-your-styles-into-smaller-chunks-with-partials.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/sass/split-your-styles-into-smaller-chunks-with-partials.spanish.md
index b641e99082..151e5ba6f2 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/sass/split-your-styles-into-smaller-chunks-with-partials.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/sass/split-your-styles-into-smaller-chunks-with-partials.spanish.md
@@ -9,17 +9,17 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-<code>Partials</code> en Sass son archivos separados que contienen segmentos de código CSS. Estos son importados y utilizados en otros archivos Sass. Esta es una excelente manera de agrupar código similar en un módulo para mantenerlo organizado. 
-nombres de los <code>partials</code> comienzan con el carácter de subrayado ( <code>_</code> ), que le dice a Sass que es un pequeño segmento de CSS y que no debe convertirlo en un archivo CSS. Además, los archivos Sass terminan con la extensión de archivo <code>.scss</code> . Para llevar el código en el <code>partial</code> a otro archivo Sass, use la directiva <code>@import</code> . 
-Por ejemplo, si todos sus <code>mixins</code> se guardan en un <code>partial</code> llamado &quot;_mixins.scss&quot;, y se necesitan en el archivo &quot;main.scss&quot;, esta es la forma de usarlos en el archivo principal: 
-<blockquote>// In the main.scss file<br><br>@import 'mixins'</blockquote> 
-Tenga en cuenta que el guión bajo no es necesario en la declaración de <code>import</code> : Sass entiende que es <code>partial</code> . Una vez que se importa un <code>partial</code> en un archivo, todas las variables, <code>mixins</code> y otros códigos están disponibles para su uso. 
+<section id='description'>
+<code>Partials</code> en Sass son archivos separados que contienen segmentos de código CSS. Estos son importados y utilizados en otros archivos Sass. Esta es una excelente manera de agrupar código similar en un módulo para mantenerlo organizado.
+nombres de los <code>partials</code> comienzan con el carácter de subrayado ( <code>_</code> ), que le dice a Sass que es un pequeño segmento de CSS y que no debe convertirlo en un archivo CSS. Además, los archivos Sass terminan con la extensión de archivo <code>.scss</code> . Para llevar el código en el <code>partial</code> a otro archivo Sass, use la directiva <code>@import</code> .
+Por ejemplo, si todos sus <code>mixins</code> se guardan en un <code>partial</code> llamado &quot;_mixins.scss&quot;, y se necesitan en el archivo &quot;main.scss&quot;, esta es la forma de usarlos en el archivo principal:
+<blockquote>// In the main.scss file<br><br>@import 'mixins'</blockquote>
+Tenga en cuenta que el guión bajo no es necesario en la declaración de <code>import</code> : Sass entiende que es <code>partial</code> . Una vez que se importa un <code>partial</code> en un archivo, todas las variables, <code>mixins</code> y otros códigos están disponibles para su uso.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escriba una instrucción <code>@import</code> para importar un <code>partial</code> llamado <code>_variables.scss</code> en el archivo main.scss. 
+<section id='instructions'>
+Escriba una instrucción <code>@import</code> para importar un <code>partial</code> llamado <code>_variables.scss</code> en el archivo main.scss.
 </section>
 
 ## Tests
@@ -27,7 +27,7 @@ Escriba una instrucción <code>@import</code> para importar un <code>partial</co
 
 ```yml
 tests:
-  - text: &#39;Su código debe usar la directiva <code>@import</code> , y no debe incluir el subrayado en el nombre del archivo&#39;.
+  - text: 'Su código debe usar la directiva <code>@import</code> , y no debe incluir el subrayado en el nombre del archivo'
     testString: 'assert(code.match(/@import\s+?("|")variables\1/gi), "Your code should use the <code>@import</code> directive, and should not include the underscore in the file name.");'
 
 ```
diff --git a/curriculum/challenges/spanish/03-front-end-libraries/sass/use-if-and-else-to-add-logic-to-your-styles.spanish.md b/curriculum/challenges/spanish/03-front-end-libraries/sass/use-if-and-else-to-add-logic-to-your-styles.spanish.md
index b528230175..f3abd0414f 100644
--- a/curriculum/challenges/spanish/03-front-end-libraries/sass/use-if-and-else-to-add-logic-to-your-styles.spanish.md
+++ b/curriculum/challenges/spanish/03-front-end-libraries/sass/use-if-and-else-to-add-logic-to-your-styles.spanish.md
@@ -9,17 +9,17 @@ challengeType: 0
 ---
 
 ## Description
-<section id='description'> 
-La directiva <code>@if</code> en Sass es útil para probar un caso específico: funciona igual que la sentencia <code>if</code> en JavaScript. 
-<blockquote>@mixin make-bold($bool) {<br>&nbsp;&nbsp;@if $bool == true {<br>&nbsp;&nbsp;&nbsp;&nbsp;font-weight: bold;<br>&nbsp;&nbsp;}<br>}</blockquote> 
-Y al igual que en JavaScript, <code>@else if</code> y <code>@else</code> prueban para más condiciones: 
-<blockquote>@mixin text-effect($val) {<br>&nbsp;&nbsp;@if $val == danger {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: red;<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;@else if $val == alert {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: yellow;<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;@else if $val == success {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: green;<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;@else {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: black;<br>&nbsp;&nbsp;}<br>}</blockquote> 
+<section id='description'>
+La directiva <code>@if</code> en Sass es útil para probar un caso específico: funciona igual que la sentencia <code>if</code> en JavaScript.
+<blockquote>@mixin make-bold($bool) {<br>&nbsp;&nbsp;@if $bool == true {<br>&nbsp;&nbsp;&nbsp;&nbsp;font-weight: bold;<br>&nbsp;&nbsp;}<br>}</blockquote>
+Y al igual que en JavaScript, <code>@else if</code> y <code>@else</code> prueban para más condiciones:
+<blockquote>@mixin text-effect($val) {<br>&nbsp;&nbsp;@if $val == danger {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: red;<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;@else if $val == alert {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: yellow;<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;@else if $val == success {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: green;<br>&nbsp;&nbsp;}<br>&nbsp;&nbsp;@else {<br>&nbsp;&nbsp;&nbsp;&nbsp;color: black;<br>&nbsp;&nbsp;}<br>}</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Crea un <code>mixin</code> llamado <code>border-stroke</code> que toma un parámetro <code>$val</code> . La <code>mixin</code> debe verificar las siguientes condiciones usando <code>@if</code> , <code>@else if</code> , y <code>@else</code> : 
-<blockquote>light - 1px solid black<br>medium - 3px solid black<br>heavy - 6px solid black<br>none - no border</blockquote> 
+<section id='instructions'>
+Crea un <code>mixin</code> llamado <code>border-stroke</code> que toma un parámetro <code>$val</code> . La <code>mixin</code> debe verificar las siguientes condiciones usando <code>@if</code> , <code>@else if</code> , y <code>@else</code> :
+<blockquote>light - 1px solid black<br>medium - 3px solid black<br>heavy - 6px solid black<br>none - no border</blockquote>
 </section>
 
 ## Tests
@@ -29,11 +29,11 @@ Crea un <code>mixin</code> llamado <code>border-stroke</code> que toma un parám
 tests:
   - text: Su código debe declarar un <code>mixin</code> denominado <code>border-stroke</code> que tiene un parámetro llamado <code>$val</code> .
     testString: 'assert(code.match(/@mixin\s+?border-stroke\s*?\(\s*?\$val\s*?\)\s*?{/gi), "Your code should declare a <code>mixin</code> named <code>border-stroke</code> which has a parameter named <code>$val</code>.");'
-  - text: &#39;Su <code>mixin</code> debe tener una instrucción <code>@if</code> para verificar si <code>$val</code> está iluminado, y para establecer el <code>border</code> en 1px negro sólido&#39;.
+  - text: 'Su <code>mixin</code> debe tener una instrucción <code>@if</code> para verificar si <code>$val</code> está iluminado, y para establecer el <code>border</code> en 1px negro sólido'
     testString: 'assert(code.match(/@if\s+?\$val\s*?===?\s*?light\s*?{\s*?border\s*?:\s*?1px\s+?solid\s+?black\s*?;\s*?}/gi), "Your <code>mixin</code> should have an <code>@if</code> statement to check if <code>$val</code> is light, and to set the <code>border</code> to 1px solid black.");'
-  - text: &#39;Su <code>mixin</code> debe tener una <code>@else if</code> para verificar si <code>$val</code> es medio y para establecer el <code>border</code> en 3px negro sólido&#39;.
+  - text: 'Su <code>mixin</code> debe tener una <code>@else if</code> para verificar si <code>$val</code> es medio y para establecer el <code>border</code> en 3px negro sólido'
     testString: 'assert(code.match(/@else\s+?if\s+?\$val\s*?===?\s*?medium\s*?{\s*?border\s*?:\s*?3px\s+?solid\s+?black\s*?;\s*?}/gi), "Your <code>mixin</code> should have an <code>@else if</code> statement to check if <code>$val</code> is medium, and to set the <code>border</code> to 3px solid black.");'
-  - text: &#39;Su <code>mixin</code> debe tener una <code>@else if</code> para verificar si <code>$val</code> es pesado, y para establecer el <code>border</code> en 6px negro sólido&#39;.
+  - text: 'Su <code>mixin</code> debe tener una <code>@else if</code> para verificar si <code>$val</code> es pesado, y para establecer el <code>border</code> en 6px negro sólido'
     testString: 'assert(code.match(/@else\s+?if\s+?\$val\s*?===?\s*?heavy\s*?{\s*?border\s*?:\s*?6px\s+?solid\s+?black\s*?;\s*?}/gi), "Your <code>mixin</code> should have an <code>@else if</code> statement to check if <code>$val</code> is heavy, and to set the <code>border</code> to 6px solid black.");'
   - text: Su <code>mixin</code> debe tener una instrucción <code>@else</code> para establecer el <code>border</code> en ninguno.
     testString: 'assert(code.match(/@else\s*?{\s*?border\s*?:\s*?none\s*?;\s*?}/gi), "Your <code>mixin</code> should have an <code>@else</code> statement to set the <code>border</code> to none.");'
diff --git a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-attributes-to-the-circle-elements.spanish.md b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-attributes-to-the-circle-elements.spanish.md
index 4bf284c7f3..61f6087c6b 100644
--- a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-attributes-to-the-circle-elements.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-attributes-to-the-circle-elements.spanish.md
@@ -8,16 +8,16 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-El último desafío creó los elementos del <code>circle</code> para cada punto en el <code>dataset</code> y los anexó al lienzo de SVG. Pero D3 necesita más información sobre la posición y el tamaño de cada <code>circle</code> para mostrarlos correctamente. 
-Un <code>circle</code> en SVG tiene tres atributos principales. Los atributos <code>cx</code> y <code>cy</code> son las coordenadas. Le dicen a D3 dónde colocar el <em>centro</em> de la forma en el lienzo de SVG. El radio (atributo <code>r</code> ) da el tamaño del <code>circle</code> . 
-Al igual que la coordenada <code>rect</code> <code>y</code> , el atributo <code>cy</code> para un <code>circle</code> se mide desde la parte superior del lienzo SVG, no desde la parte inferior. 
-Los tres atributos pueden usar una función de devolución de llamada para establecer sus valores dinámicamente. Recuerde que todos los métodos encadenados después de los <code>data(dataset)</code> ejecutan una vez por elemento en el <code>dataset</code> de <code>dataset</code> . El parámetro <code>d</code> en la función de devolución de llamada se refiere al elemento actual en el <code>dataset</code> de <code>dataset</code> , que es una matriz para cada punto. Utiliza la notación de corchete, como <code>d[0]</code> , para acceder a los valores de esa matriz. 
+<section id='description'>
+El último desafío creó los elementos del <code>circle</code> para cada punto en el <code>dataset</code> y los anexó al lienzo de SVG. Pero D3 necesita más información sobre la posición y el tamaño de cada <code>circle</code> para mostrarlos correctamente.
+Un <code>circle</code> en SVG tiene tres atributos principales. Los atributos <code>cx</code> y <code>cy</code> son las coordenadas. Le dicen a D3 dónde colocar el <em>centro</em> de la forma en el lienzo de SVG. El radio (atributo <code>r</code> ) da el tamaño del <code>circle</code> .
+Al igual que la coordenada <code>rect</code> <code>y</code> , el atributo <code>cy</code> para un <code>circle</code> se mide desde la parte superior del lienzo SVG, no desde la parte inferior.
+Los tres atributos pueden usar una función de devolución de llamada para establecer sus valores dinámicamente. Recuerde que todos los métodos encadenados después de los <code>data(dataset)</code> ejecutan una vez por elemento en el <code>dataset</code> de <code>dataset</code> . El parámetro <code>d</code> en la función de devolución de llamada se refiere al elemento actual en el <code>dataset</code> de <code>dataset</code> , que es una matriz para cada punto. Utiliza la notación de corchete, como <code>d[0]</code> , para acceder a los valores de esa matriz.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue los atributos <code>cx</code> , <code>cy</code> y <code>r</code> a los elementos del <code>circle</code> . El valor <code>cx</code> debe ser el primer número en la matriz para cada elemento en el <code>dataset</code> de <code>dataset</code> . El valor <code>cy</code> debe basarse en el segundo número de la matriz, pero asegúrese de mostrar el gráfico hacia arriba y no invertido. El valor <code>r</code> debe ser 5 para todos los círculos. 
+<section id='instructions'>
+Agregue los atributos <code>cx</code> , <code>cy</code> y <code>r</code> a los elementos del <code>circle</code> . El valor <code>cx</code> debe ser el primer número en la matriz para cada elemento en el <code>dataset</code> de <code>dataset</code> . El valor <code>cy</code> debe basarse en el segundo número de la matriz, pero asegúrese de mostrar el gráfico hacia arriba y no invertido. El valor <code>r</code> debe ser 5 para todos los círculos.
 </section>
 
 ## Tests
@@ -27,25 +27,25 @@ Agregue los atributos <code>cx</code> , <code>cy</code> y <code>r</code> a los e
 tests:
   - text: Tu código debe tener 10 elementos <code>circle</code> .
     testString: 'assert($("circle").length == 10, "Your code should have 10 <code>circle</code> elements.");'
-  - text: &#39;El primer elemento del <code>circle</code> debe tener un valor <code>cx</code> de 34, un valor <code>cy</code> de 422 y un valor <code>r</code> de 5.&#39;
+  - text: 'El primer elemento del <code>circle</code> debe tener un valor <code>cx</code> de 34, un valor <code>cy</code> de 422 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(0).attr("cx") == "34" && $("circle").eq(0).attr("cy") == "422" && $("circle").eq(0).attr("r") == "5", "The first <code>circle</code> element should have a <code>cx</code> value of 34, a <code>cy</code> value of 422, and an <code>r</code> value of 5.");'
-  - text: &#39;El segundo elemento del <code>circle</code> debe tener un valor <code>cx</code> de 109, un valor <code>cy</code> de 220 y un valor <code>r</code> de 5.&#39;
+  - text: 'El segundo elemento del <code>circle</code> debe tener un valor <code>cx</code> de 109, un valor <code>cy</code> de 220 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(1).attr("cx") == "109" && $("circle").eq(1).attr("cy") == "220" && $("circle").eq(1).attr("r") == "5", "The second <code>circle</code> element should have a <code>cx</code> value of 109, a <code>cy</code> value of 220, and an <code>r</code> value of 5.");'
-  - text: &#39;El tercer elemento del <code>circle</code> debe tener un valor <code>cx</code> de 310, un valor <code>cy</code> de 380 y un valor <code>r</code> de 5.&#39;
+  - text: 'El tercer elemento del <code>circle</code> debe tener un valor <code>cx</code> de 310, un valor <code>cy</code> de 380 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(2).attr("cx") == "310" && $("circle").eq(2).attr("cy") == "380" && $("circle").eq(2).attr("r") == "5", "The third <code>circle</code> element should have a <code>cx</code> value of 310, a <code>cy</code> value of 380, and an <code>r</code> value of 5.");'
-  - text: &#39;El cuarto elemento del <code>circle</code> debe tener un valor <code>cx</code> de 79, un valor <code>cy</code> de 89 y un valor <code>r</code> de 5.&#39;
+  - text: 'El cuarto elemento del <code>circle</code> debe tener un valor <code>cx</code> de 79, un valor <code>cy</code> de 89 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(3).attr("cx") == "79" && $("circle").eq(3).attr("cy") == "89" && $("circle").eq(3).attr("r") == "5", "The fourth <code>circle</code> element should have a <code>cx</code> value of 79, a <code>cy</code> value of 89, and an <code>r</code> value of 5.");'
-  - text: &#39;El quinto elemento del <code>circle</code> debe tener un valor <code>cx</code> de 420, un valor <code>cy</code> de 280 y un valor <code>r</code> de 5.&#39;
+  - text: 'El quinto elemento del <code>circle</code> debe tener un valor <code>cx</code> de 420, un valor <code>cy</code> de 280 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(4).attr("cx") == "420" && $("circle").eq(4).attr("cy") == "280" && $("circle").eq(4).attr("r") == "5", "The fifth <code>circle</code> element should have a <code>cx</code> value of 420, a <code>cy</code> value of 280, and an <code>r</code> value of 5.");'
-  - text: &#39;El elemento del sexto <code>circle</code> debe tener un valor <code>cx</code> de 233, un valor <code>cy</code> de 355 y un valor <code>r</code> de 5.&#39;
+  - text: 'El elemento del sexto <code>circle</code> debe tener un valor <code>cx</code> de 233, un valor <code>cy</code> de 355 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(5).attr("cx") == "233" && $("circle").eq(5).attr("cy") == "355" && $("circle").eq(5).attr("r") == "5", "The sixth <code>circle</code> element should have a <code>cx</code> value of 233, a <code>cy</code> value of 355, and an <code>r</code> value of 5.");'
-  - text: &#39;El elemento del séptimo <code>circle</code> debe tener un valor <code>cx</code> de 333, un valor <code>cy</code> de 404 y un valor <code>r</code> de 5.&#39;
+  - text: 'El elemento del séptimo <code>circle</code> debe tener un valor <code>cx</code> de 333, un valor <code>cy</code> de 404 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(6).attr("cx") == "333" && $("circle").eq(6).attr("cy") == "404" && $("circle").eq(6).attr("r") == "5", "The seventh <code>circle</code> element should have a <code>cx</code> value of 333, a <code>cy</code> value of 404, and an <code>r</code> value of 5.");'
-  - text: &#39;El elemento del octavo <code>circle</code> debe tener un valor <code>cx</code> de 222, un valor <code>cy</code> de 167 y un valor <code>r</code> de 5.&#39;
+  - text: 'El elemento del octavo <code>circle</code> debe tener un valor <code>cx</code> de 222, un valor <code>cy</code> de 167 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(7).attr("cx") == "222" && $("circle").eq(7).attr("cy") == "167" && $("circle").eq(7).attr("r") == "5", "The eighth <code>circle</code> element should have a <code>cx</code> value of 222, a <code>cy</code> value of 167, and an <code>r</code> value of 5.");'
-  - text: &#39;El elemento del noveno <code>circle</code> debe tener un valor <code>cx</code> de 78, un valor <code>cy</code> de 180 y un valor <code>r</code> de 5.&#39;
+  - text: 'El elemento del noveno <code>circle</code> debe tener un valor <code>cx</code> de 78, un valor <code>cy</code> de 180 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(8).attr("cx") == "78" && $("circle").eq(8).attr("cy") == "180" && $("circle").eq(8).attr("r") == "5", "The ninth <code>circle</code> element should have a <code>cx</code> value of 78, a <code>cy</code> value of 180, and an <code>r</code> value of 5.");'
-  - text: &#39;El elemento del décimo <code>circle</code> debe tener un valor <code>cx</code> de 21, un valor <code>cy</code> de 377 y un valor <code>r</code> de 5.&#39;
+  - text: 'El elemento del décimo <code>circle</code> debe tener un valor <code>cx</code> de 21, un valor <code>cy</code> de 377 y un valor <code>r</code> de 5.'
     testString: 'assert($("circle").eq(9).attr("cx") == "21" && $("circle").eq(9).attr("cy") == "377" && $("circle").eq(9).attr("r") == "5", "The tenth <code>circle</code> element should have a <code>cx</code> value of 21, a <code>cy</code> value of 377, and an <code>r</code> value of 5.");'
 
 ```
diff --git a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-axes-to-a-visualization.spanish.md b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-axes-to-a-visualization.spanish.md
index fa751470e0..d70dd1c15a 100644
--- a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-axes-to-a-visualization.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-axes-to-a-visualization.spanish.md
@@ -8,22 +8,22 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Otra forma de mejorar el diagrama de dispersión es agregar un eje xy un eje y. 
-D3 tiene dos métodos <code>axisLeft()</code> y <code>axisBottom()</code> para representar los ejes y y x, respectivamente. (Ejes es la forma plural de eje). Aquí hay un ejemplo para crear el eje x basado en <code>xScale</code> en los desafíos anteriores: 
-<code>const xAxis = d3.axisBottom(xScale);</code> 
-El siguiente paso es representar el eje en el lienzo de SVG. Para hacerlo, puedes usar un componente general SVG, el elemento <code>g</code> . La <code>g</code> significa grupo. 
-A diferencia de <code>rect</code> , <code>circle</code> y <code>text</code> , un eje es solo una línea recta cuando se procesa. Porque es una forma simple, usando <code>g</code> funciona. 
-El último paso es aplicar un atributo de <code>transform</code> para colocar el eje en el lienzo SVG en el lugar correcto. De lo contrario, la línea se representaría a lo largo del borde del lienzo SVG y no sería visible. 
-SVG admite diferentes tipos de <code>transforms</code> , pero es necesario <code>translate</code> posicionamiento de un eje. Cuando se aplica al elemento <code>g</code> , mueve todo el grupo hacia arriba y hacia abajo según las cantidades dadas. Aquí hay un ejemplo: 
-<blockquote>const xAxis = d3.axisBottom(xScale);<br><br>svg.append("g")<br>&nbsp;&nbsp; .attr("transform", "translate(0, " + (h - padding) + ")")<br>&nbsp;&nbsp; .call(xAxis);</blockquote> 
-El código anterior coloca el eje x en la parte inferior del lienzo de SVG. Luego se pasa como un argumento al método <code>call()</code> . 
-El eje y funciona de la misma manera, excepto que el argumento de <code>translate</code> está en la forma (x, 0). Debido a que <code>translate</code> es una cadena en el método <code>attr()</code> anterior, puede usar la concatenación para incluir valores variables para sus argumentos. 
+<section id='description'>
+Otra forma de mejorar el diagrama de dispersión es agregar un eje xy un eje y.
+D3 tiene dos métodos <code>axisLeft()</code> y <code>axisBottom()</code> para representar los ejes y y x, respectivamente. (Ejes es la forma plural de eje). Aquí hay un ejemplo para crear el eje x basado en <code>xScale</code> en los desafíos anteriores:
+<code>const xAxis = d3.axisBottom(xScale);</code>
+El siguiente paso es representar el eje en el lienzo de SVG. Para hacerlo, puedes usar un componente general SVG, el elemento <code>g</code> . La <code>g</code> significa grupo.
+A diferencia de <code>rect</code> , <code>circle</code> y <code>text</code> , un eje es solo una línea recta cuando se procesa. Porque es una forma simple, usando <code>g</code> funciona.
+El último paso es aplicar un atributo de <code>transform</code> para colocar el eje en el lienzo SVG en el lugar correcto. De lo contrario, la línea se representaría a lo largo del borde del lienzo SVG y no sería visible.
+SVG admite diferentes tipos de <code>transforms</code> , pero es necesario <code>translate</code> posicionamiento de un eje. Cuando se aplica al elemento <code>g</code> , mueve todo el grupo hacia arriba y hacia abajo según las cantidades dadas. Aquí hay un ejemplo:
+<blockquote>const xAxis = d3.axisBottom(xScale);<br><br>svg.append("g")<br>&nbsp;&nbsp; .attr("transform", "translate(0, " + (h - padding) + ")")<br>&nbsp;&nbsp; .call(xAxis);</blockquote>
+El código anterior coloca el eje x en la parte inferior del lienzo de SVG. Luego se pasa como un argumento al método <code>call()</code> .
+El eje y funciona de la misma manera, excepto que el argumento de <code>translate</code> está en la forma (x, 0). Debido a que <code>translate</code> es una cadena en el método <code>attr()</code> anterior, puede usar la concatenación para incluir valores variables para sus argumentos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-El diagrama de dispersión ahora tiene un eje x. Cree un eje y en una variable llamada <code>yAxis</code> usando el método <code>axisLeft()</code> . Luego renderiza el eje usando un elemento <code>g</code> . Asegúrese de usar un atributo de <code>transform</code> para traducir el eje por la cantidad de unidades de relleno a la derecha y 0 unidades hacia abajo. Recuerda <code>call()</code> al eje. 
+<section id='instructions'>
+El diagrama de dispersión ahora tiene un eje x. Cree un eje y en una variable llamada <code>yAxis</code> usando el método <code>axisLeft()</code> . Luego renderiza el eje usando un elemento <code>g</code> . Asegúrese de usar un atributo de <code>transform</code> para traducir el eje por la cantidad de unidades de relleno a la derecha y 0 unidades hacia abajo. Recuerda <code>call()</code> al eje.
 </section>
 
 ## Tests
@@ -33,7 +33,7 @@ El diagrama de dispersión ahora tiene un eje x. Cree un eje y en una variable l
 tests:
   - text: Su código debe usar el método <code>axisLeft()</code> con <code>yScale</code> pasado como argumento.
     testString: 'assert(code.match(/\.axisLeft\(yScale\)/g), "Your code should use the <code>axisLeft()</code> method with <code>yScale</code> passed as the argument.");'
-  - text: &#39;El elemento <code>g</code> eje y debe tener un atributo de <code>transform</code> para traducir el eje en (60, 0).&#39;
+  - text: 'El elemento <code>g</code> eje y debe tener un atributo de <code>transform</code> para traducir el eje en (60, 0).'
     testString: 'assert($("g").eq(1).attr("transform").match(/translate\(60\s*?,\s*?0\)/g), "The y-axis <code>g</code> element should have a <code>transform</code> attribute to translate the axis by (60, 0).");'
   - text: Su código debe llamar al <code>yAxis</code> .
     testString: 'assert(code.match(/\.call\(yAxis\)/g), "Your code should call the <code>yAxis</code>.");'
diff --git a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-labels-to-scatter-plot-circles.spanish.md b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-labels-to-scatter-plot-circles.spanish.md
index 7fc2af1dc5..698af8067d 100644
--- a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-labels-to-scatter-plot-circles.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/add-labels-to-scatter-plot-circles.spanish.md
@@ -8,15 +8,15 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Puede agregar texto para crear etiquetas para los puntos en un diagrama de dispersión. 
-El objetivo es mostrar los valores separados por comas para los campos primero ( <code>x</code> ) y segundo ( <code>y</code> ) de cada elemento en el <code>dataset</code> de <code>dataset</code> . 
-Los nodos de <code>text</code> necesitan los atributos <code>x</code> e <code>y</code> para colocarlos en el lienzo SVG. En este desafío, el valor <code>y</code> (que determina la altura) puede usar el mismo valor que el <code>circle</code> usa para su atributo <code>cy</code> . El valor <code>x</code> puede ser ligeramente mayor que el valor <code>cx</code> del <code>circle</code> , por lo que la etiqueta es visible. Esto empujará la etiqueta a la derecha del punto trazado. 
+<section id='description'>
+Puede agregar texto para crear etiquetas para los puntos en un diagrama de dispersión.
+El objetivo es mostrar los valores separados por comas para los campos primero ( <code>x</code> ) y segundo ( <code>y</code> ) de cada elemento en el <code>dataset</code> de <code>dataset</code> .
+Los nodos de <code>text</code> necesitan los atributos <code>x</code> e <code>y</code> para colocarlos en el lienzo SVG. En este desafío, el valor <code>y</code> (que determina la altura) puede usar el mismo valor que el <code>circle</code> usa para su atributo <code>cy</code> . El valor <code>x</code> puede ser ligeramente mayor que el valor <code>cx</code> del <code>circle</code> , por lo que la etiqueta es visible. Esto empujará la etiqueta a la derecha del punto trazado.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Etiquete cada punto en el diagrama de dispersión utilizando los elementos de <code>text</code> . El texto de la etiqueta debe ser los dos valores separados por una coma y un espacio. Por ejemplo, la etiqueta para el primer punto es &quot;34, 78&quot;. Establezca el atributo <code>x</code> para que sea 5 unidades más que el valor que usó para el atributo <code>cx</code> en el <code>circle</code> . Establezca el atributo <code>y</code> la misma manera que se usa para el valor <code>cy</code> en el <code>circle</code> . 
+<section id='instructions'>
+Etiquete cada punto en el diagrama de dispersión utilizando los elementos de <code>text</code> . El texto de la etiqueta debe ser los dos valores separados por una coma y un espacio. Por ejemplo, la etiqueta para el primer punto es &quot;34, 78&quot;. Establezca el atributo <code>x</code> para que sea 5 unidades más que el valor que usó para el atributo <code>cx</code> en el <code>circle</code> . Establezca el atributo <code>y</code> la misma manera que se usa para el valor <code>cy</code> en el <code>circle</code> .
 </section>
 
 ## Tests
@@ -26,25 +26,25 @@ Etiquete cada punto en el diagrama de dispersión utilizando los elementos de <c
 tests:
   - text: Su código debe tener 10 elementos de <code>text</code> .
     testString: 'assert($("text").length == 10, "Your code should have 10 <code>text</code> elements.");'
-  - text: &#39;La primera etiqueta debe tener texto de &quot;34, 78&quot;, un valor de <code>x</code> de 39 y un valor de <code>y</code> de 422.&#39;
+  - text: 'La primera etiqueta debe tener texto de &quot;34, 78&quot;, un valor de <code>x</code> de 39 y un valor de <code>y</code> de 422.'
     testString: 'assert($("text").eq(0).text() == "34, 78" && $("text").eq(0).attr("x") == "39" && $("text").eq(0).attr("y") == "422", "The first label should have text of "34, 78", an <code>x</code> value of 39, and a <code>y</code> value of 422.");'
-  - text: &#39;La segunda etiqueta debe tener texto de &quot;109, 280&quot;, un valor de <code>x</code> de 114 y un valor de <code>y</code> de 220.&#39;
+  - text: 'La segunda etiqueta debe tener texto de &quot;109, 280&quot;, un valor de <code>x</code> de 114 y un valor de <code>y</code> de 220.'
     testString: 'assert($("text").eq(1).text() == "109, 280" && $("text").eq(1).attr("x") == "114" && $("text").eq(1).attr("y") == "220", "The second label should have text of "109, 280", an <code>x</code> value of 114, and a <code>y</code> value of 220.");'
-  - text: &#39;La tercera etiqueta debe tener texto de &quot;310, 120&quot;, un valor de <code>x</code> de 315 y un valor de <code>y</code> de 380.&#39;
+  - text: 'La tercera etiqueta debe tener texto de &quot;310, 120&quot;, un valor de <code>x</code> de 315 y un valor de <code>y</code> de 380.'
     testString: 'assert($("text").eq(2).text() == "310, 120" && $("text").eq(2).attr("x") == "315" && $("text").eq(2).attr("y") == "380", "The third label should have text of "310, 120", an <code>x</code> value of 315, and a <code>y</code> value of 380.");'
-  - text: &#39;La cuarta etiqueta debe tener el texto de &quot;79, 411&quot;, un valor de <code>x</code> de 84 y un valor de <code>y</code> de 89.&#39;
+  - text: 'La cuarta etiqueta debe tener el texto de &quot;79, 411&quot;, un valor de <code>x</code> de 84 y un valor de <code>y</code> de 89.'
     testString: 'assert($("text").eq(3).text() == "79, 411" && $("text").eq(3).attr("x") == "84" && $("text").eq(3).attr("y") == "89", "The fourth label should have text of "79, 411", an <code>x</code> value of 84, and a <code>y</code> value of 89.");'
-  - text: &#39;La quinta etiqueta debe tener texto de &quot;420, 220&quot;, un valor de <code>x</code> de 425 y un valor de <code>y</code> de 280.&#39;
+  - text: 'La quinta etiqueta debe tener texto de &quot;420, 220&quot;, un valor de <code>x</code> de 425 y un valor de <code>y</code> de 280.'
     testString: 'assert($("text").eq(4).text() == "420, 220" && $("text").eq(4).attr("x") == "425" && $("text").eq(4).attr("y") == "280", "The fifth label should have text of "420, 220", an <code>x</code> value of 425, and a <code>y</code> value of 280.");'
-  - text: &#39;La sexta etiqueta debe tener texto de &quot;233, 145&quot;, un valor de <code>x</code> de 238 y un valor de <code>y</code> de 355.&#39;
+  - text: 'La sexta etiqueta debe tener texto de &quot;233, 145&quot;, un valor de <code>x</code> de 238 y un valor de <code>y</code> de 355.'
     testString: 'assert($("text").eq(5).text() == "233, 145" && $("text").eq(5).attr("x") == "238" && $("text").eq(5).attr("y") == "355", "The sixth label should have text of "233, 145", an <code>x</code> value of 238, and a <code>y</code> value of 355.");'
-  - text: &#39;La séptima etiqueta debe tener texto de &quot;333, 96&quot;, un valor de <code>x</code> de 338 y un valor de <code>y</code> de 404.&#39;
+  - text: 'La séptima etiqueta debe tener texto de &quot;333, 96&quot;, un valor de <code>x</code> de 338 y un valor de <code>y</code> de 404.'
     testString: 'assert($("text").eq(6).text() == "333, 96" && $("text").eq(6).attr("x") == "338" && $("text").eq(6).attr("y") == "404", "The seventh label should have text of "333, 96", an <code>x</code> value of 338, and a <code>y</code> value of 404.");'
-  - text: &#39;La octava etiqueta debe tener texto de &quot;222, 333&quot;, un valor de <code>x</code> de 227 y un valor de <code>y</code> de 167.&#39;
+  - text: 'La octava etiqueta debe tener texto de &quot;222, 333&quot;, un valor de <code>x</code> de 227 y un valor de <code>y</code> de 167.'
     testString: 'assert($("text").eq(7).text() == "222, 333" && $("text").eq(7).attr("x") == "227" && $("text").eq(7).attr("y") == "167", "The eighth label should have text of "222, 333", an <code>x</code> value of 227, and a <code>y</code> value of 167.");'
-  - text: &#39;La novena etiqueta debe tener un texto de &quot;78, 320&quot;, un valor de <code>x</code> de 83 y un valor de <code>y</code> de 180.&#39;
+  - text: 'La novena etiqueta debe tener un texto de &quot;78, 320&quot;, un valor de <code>x</code> de 83 y un valor de <code>y</code> de 180.'
     testString: 'assert($("text").eq(8).text() == "78, 320" && $("text").eq(8).attr("x") == "83" && $("text").eq(8).attr("y") == "180", "The ninth label should have text of "78, 320", an <code>x</code> value of 83, and a <code>y</code> value of 180.");'
-  - text: &#39;La décima etiqueta debe tener texto de &quot;21, 123&quot;, un valor de <code>x</code> de 26 y un valor de <code>y</code> de 377.&#39;
+  - text: 'La décima etiqueta debe tener texto de &quot;21, 123&quot;, un valor de <code>x</code> de 26 y un valor de <code>y</code> de 377.'
     testString: 'assert($("text").eq(9).text() == "21, 123" && $("text").eq(9).attr("x") == "26" && $("text").eq(9).attr("y") == "377", "The tenth label should have text of "21, 123", an <code>x</code> value of 26, and a <code>y</code> value of 377.");'
 
 ```
diff --git a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/select-a-group-of-elements-with-d3.spanish.md b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/select-a-group-of-elements-with-d3.spanish.md
index 42bf01dc2a..b87533d4bc 100644
--- a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/select-a-group-of-elements-with-d3.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/select-a-group-of-elements-with-d3.spanish.md
@@ -8,15 +8,15 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-D3 también tiene el método <code>selectAll()</code> para seleccionar un grupo de elementos. Devuelve una matriz de nodos HTML para todos los elementos del documento que coinciden con la cadena de entrada. Aquí hay un ejemplo para seleccionar todas las etiquetas de anclaje en un documento: 
-<code>const anchors = d3.selectAll(&quot;a&quot;);</code> 
-Al igual que el método <code>select()</code> , <code>selectAll()</code> admite el encadenamiento de métodos, y puede usarlo con otros métodos. 
+<section id='description'>
+D3 también tiene el método <code>selectAll()</code> para seleccionar un grupo de elementos. Devuelve una matriz de nodos HTML para todos los elementos del documento que coinciden con la cadena de entrada. Aquí hay un ejemplo para seleccionar todas las etiquetas de anclaje en un documento:
+<code>const anchors = d3.selectAll(&quot;a&quot;);</code>
+Al igual que el método <code>select()</code> , <code>selectAll()</code> admite el encadenamiento de métodos, y puede usarlo con otros métodos.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Seleccione todas las etiquetas <code>li</code> en el documento y cambie su texto a &quot;elemento de lista&quot; encadenando el método <code>.text()</code> . 
+<section id='instructions'>
+Seleccione todas las etiquetas <code>li</code> en el documento y cambie su texto a &quot;elemento de lista&quot; encadenando el método <code>.text()</code> .
 </section>
 
 ## Tests
@@ -24,7 +24,7 @@ Seleccione todas las etiquetas <code>li</code> en el documento y cambie su texto
 
 ```yml
 tests:
-  - text: &#39;Debería haber 3 elementos <code>li</code> en la página, y el texto de cada uno debería decir &quot;elemento de la lista&quot;. La capitalización y el espaciado deben coincidir exactamente.
+  - text: 'Debería haber 3 elementos <code>li</code> en la página, y el texto de cada uno debería decir &quot;elemento de la lista&quot;. La capitalización y el espaciado deben coincidir exactamente.
     testString: 'assert($("li").text().match(/list item/g).length == 3, "There should be 3 <code>li</code> elements on the page, and the text in each one should say "list item". Capitalization and spacing should match exactly.");'
   - text: Su código debe acceder al objeto <code>d3</code> .
     testString: 'assert(code.match(/d3/g), "Your code should access the <code>d3</code> object.");'
diff --git a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/set-a-domain-and-a-range-on-a-scale.spanish.md b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/set-a-domain-and-a-range-on-a-scale.spanish.md
index c05b72fdfc..c640ec846b 100644
--- a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/set-a-domain-and-a-range-on-a-scale.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/set-a-domain-and-a-range-on-a-scale.spanish.md
@@ -8,19 +8,19 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-De forma predeterminada, las escalas utilizan la relación de identidad: el valor de entrada se asigna al valor de salida. Pero las escalas pueden ser mucho más flexibles e interesantes. 
-Supongamos que un conjunto de datos tiene valores que oscilan entre 50 y 480. Esta es la información de entrada para una escala y también se conoce como dominio. 
-Desea asignar esos puntos a lo largo del eje <code>x</code> en el lienzo de SVG, entre 10 unidades y 500 unidades. Esta es la información de salida, que también se conoce como el rango. 
-Los métodos de <code>domain()</code> y <code>range()</code> establecen estos valores para la escala. Ambos métodos toman una matriz de al menos dos elementos como un argumento. Aquí hay un ejemplo: 
-<blockquote>// Set a domain<br>// The domain covers the set of input values<br>scale.domain([50, 480]);<br>// Set a range<br>// The range covers the set of output values<br>scale.range([10, 500]);<br>scale(50) // Returns 10<br>scale(480) // Returns 500<br>scale(325) // Returns 323.37<br>scale(750) // Returns 807.67<br>d3.scaleLinear()</blockquote> 
-Observe que la escala usa la relación lineal entre el dominio y los valores de rango para determinar cuál debe ser la salida para un número dado. El valor mínimo en el dominio (50) se asigna al valor mínimo (10) en el rango. 
+<section id='description'>
+De forma predeterminada, las escalas utilizan la relación de identidad: el valor de entrada se asigna al valor de salida. Pero las escalas pueden ser mucho más flexibles e interesantes.
+Supongamos que un conjunto de datos tiene valores que oscilan entre 50 y 480. Esta es la información de entrada para una escala y también se conoce como dominio.
+Desea asignar esos puntos a lo largo del eje <code>x</code> en el lienzo de SVG, entre 10 unidades y 500 unidades. Esta es la información de salida, que también se conoce como el rango.
+Los métodos de <code>domain()</code> y <code>range()</code> establecen estos valores para la escala. Ambos métodos toman una matriz de al menos dos elementos como un argumento. Aquí hay un ejemplo:
+<blockquote>// Set a domain<br>// The domain covers the set of input values<br>scale.domain([50, 480]);<br>// Set a range<br>// The range covers the set of output values<br>scale.range([10, 500]);<br>scale(50) // Returns 10<br>scale(480) // Returns 500<br>scale(325) // Returns 323.37<br>scale(750) // Returns 807.67<br>d3.scaleLinear()</blockquote>
+Observe que la escala usa la relación lineal entre el dominio y los valores de rango para determinar cuál debe ser la salida para un número dado. El valor mínimo en el dominio (50) se asigna al valor mínimo (10) en el rango.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Cree una escala y establezca su dominio en <code>[250, 500]</code> y alcance en <code>[10, 150]</code> . 
-<strong>Nota</strong> <br> Puede encadenar los métodos de <code>domain()</code> y <code>range()</code> a la variable de <code>scale</code> . 
+<section id='instructions'>
+Cree una escala y establezca su dominio en <code>[250, 500]</code> y alcance en <code>[10, 150]</code> .
+<strong>Nota</strong> <br> Puede encadenar los métodos de <code>domain()</code> y <code>range()</code> a la variable de <code>scale</code> .
 </section>
 
 ## Tests
@@ -30,11 +30,11 @@ Cree una escala y establezca su dominio en <code>[250, 500]</code> y alcance en
 tests:
   - text: Su código debe utilizar el método <code>domain()</code> .
     testString: 'assert(code.match(/\.domain/g), "Your code should use the <code>domain()</code> method.");'
-  - text: &#39;El <code>domain()</code> de la escala se debe establecer en <code>[250, 500]</code> .&#39;
+  - text: 'El <code>domain()</code> de la escala se debe establecer en <code>[250, 500]</code> .'
     testString: 'assert(JSON.stringify(scale.domain()) == JSON.stringify([250, 500]), "The <code>domain()</code> of the scale should be set to <code>[250, 500]</code>.");'
   - text: Su código debe utilizar el método <code>range()</code> .
     testString: 'assert(code.match(/\.range/g), "Your code should use the <code>range()</code> method.");'
-  - text: &#39;El <code>range()</code> de la escala se debe establecer en <code>[10, 150]</code> .&#39;
+  - text: 'El <code>range()</code> de la escala se debe establecer en <code>[10, 150]</code> .'
     testString: 'assert(JSON.stringify(scale.range()) == JSON.stringify([10, 150]), "The <code>range()</code> of the scale should be set to <code>[10, 150]</code>.");'
   - text: El texto en el <code>h2</code> debe ser -102.
     testString: 'assert($("h2").text() == "-102", "The text in the <code>h2</code> should be -102.");'
diff --git a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/use-dynamic-scales.spanish.md b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/use-dynamic-scales.spanish.md
index 57338c7f12..1793ed517e 100644
--- a/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/use-dynamic-scales.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/data-visualization-with-d3/use-dynamic-scales.spanish.md
@@ -8,19 +8,19 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Los métodos D3 <code>min()</code> y <code>max()</code> son útiles para ayudar a establecer la escala. 
-Dado un conjunto de datos complejo, una prioridad es establecer la escala para que la visualización se ajuste al ancho y al alto del contenedor SVG. Desea que todos los datos se representen en el lienzo de SVG para que estén visibles en la página web. 
-El siguiente ejemplo establece la escala del eje x para los datos del diagrama de dispersión. El método <code>domain()</code> pasa información a la escala sobre los valores de datos sin procesar para el gráfico. El método <code>range()</code> le proporciona información sobre el espacio real en la página web para la visualización. 
-En el ejemplo, el dominio va de 0 al máximo en el conjunto. Utiliza el método <code>max()</code> con una función de devolución de llamada basada en los valores de x en las matrices. El rango utiliza el ancho del lienzo de SVG ( <code>w</code> ), pero también incluye algunos rellenos. Esto pone espacio entre los puntos del diagrama de dispersión y el borde del lienzo SVG. 
-<blockquote>const dataset = [<br>&nbsp;&nbsp;[ 34,    78 ],<br>&nbsp;&nbsp;[ 109,   280 ],<br>&nbsp;&nbsp;[ 310,   120 ],<br>&nbsp;&nbsp;[ 79,    411 ],<br>&nbsp;&nbsp;[ 420,   220 ],<br>&nbsp;&nbsp;[ 233,   145 ],<br>&nbsp;&nbsp;[ 333,   96 ],<br>&nbsp;&nbsp;[ 222,   333 ],<br>&nbsp;&nbsp;[ 78,    320 ],<br>&nbsp;&nbsp;[ 21,    123 ]<br>];<br>const w = 500;<br>const h = 500;<br><br>// Padding between the SVG canvas boundary and the plot<br>const padding = 30;<br>const xScale = d3.scaleLinear()<br>&nbsp;&nbsp;.domain([0, d3.max(dataset, (d) => d[0])])<br>&nbsp;&nbsp;.range([padding, w - padding]);</blockquote> 
-El relleno puede ser confuso al principio. Represente el eje x como una línea horizontal de 0 a 500 (el valor de ancho para el lienzo SVG). La inclusión del relleno en el método <code>range()</code> obliga a la trama a comenzar en 30 a lo largo de esa línea (en lugar de 0), y termina en 470 (en lugar de 500). 
+<section id='description'>
+Los métodos D3 <code>min()</code> y <code>max()</code> son útiles para ayudar a establecer la escala.
+Dado un conjunto de datos complejo, una prioridad es establecer la escala para que la visualización se ajuste al ancho y al alto del contenedor SVG. Desea que todos los datos se representen en el lienzo de SVG para que estén visibles en la página web.
+El siguiente ejemplo establece la escala del eje x para los datos del diagrama de dispersión. El método <code>domain()</code> pasa información a la escala sobre los valores de datos sin procesar para el gráfico. El método <code>range()</code> le proporciona información sobre el espacio real en la página web para la visualización.
+En el ejemplo, el dominio va de 0 al máximo en el conjunto. Utiliza el método <code>max()</code> con una función de devolución de llamada basada en los valores de x en las matrices. El rango utiliza el ancho del lienzo de SVG ( <code>w</code> ), pero también incluye algunos rellenos. Esto pone espacio entre los puntos del diagrama de dispersión y el borde del lienzo SVG.
+<blockquote>const dataset = [<br>&nbsp;&nbsp;[ 34,    78 ],<br>&nbsp;&nbsp;[ 109,   280 ],<br>&nbsp;&nbsp;[ 310,   120 ],<br>&nbsp;&nbsp;[ 79,    411 ],<br>&nbsp;&nbsp;[ 420,   220 ],<br>&nbsp;&nbsp;[ 233,   145 ],<br>&nbsp;&nbsp;[ 333,   96 ],<br>&nbsp;&nbsp;[ 222,   333 ],<br>&nbsp;&nbsp;[ 78,    320 ],<br>&nbsp;&nbsp;[ 21,    123 ]<br>];<br>const w = 500;<br>const h = 500;<br><br>// Padding between the SVG canvas boundary and the plot<br>const padding = 30;<br>const xScale = d3.scaleLinear()<br>&nbsp;&nbsp;.domain([0, d3.max(dataset, (d) => d[0])])<br>&nbsp;&nbsp;.range([padding, w - padding]);</blockquote>
+El relleno puede ser confuso al principio. Represente el eje x como una línea horizontal de 0 a 500 (el valor de ancho para el lienzo SVG). La inclusión del relleno en el método <code>range()</code> obliga a la trama a comenzar en 30 a lo largo de esa línea (en lugar de 0), y termina en 470 (en lugar de 500).
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Use la variable <code>yScale</code> para crear una escala lineal del eje y. El dominio debe comenzar en cero e ir al valor máximo de y en el conjunto. El rango debe usar la altura SVG ( <code>h</code> ) e incluir el relleno. 
-<strong>Nota</strong> <br> Recuerda mantener la trama al revés. Cuando establece el rango para las coordenadas y, el valor más alto (altura menos relleno) es el primer argumento, y el valor más bajo es el segundo argumento. 
+<section id='instructions'>
+Use la variable <code>yScale</code> para crear una escala lineal del eje y. El dominio debe comenzar en cero e ir al valor máximo de y en el conjunto. El rango debe usar la altura SVG ( <code>h</code> ) e incluir el relleno.
+<strong>Nota</strong> <br> Recuerda mantener la trama al revés. Cuando establece el rango para las coordenadas y, el valor más alto (altura menos relleno) es el primer argumento, y el valor más bajo es el segundo argumento.
 </section>
 
 ## Tests
@@ -30,9 +30,9 @@ Use la variable <code>yScale</code> para crear una escala lineal del eje y. El d
 tests:
   - text: El texto en el <code>h2</code> debe ser 30.
     testString: 'assert(output == 30 && $("h2").text() == "30", "The text in the <code>h2</code> should be 30.");'
-  - text: &#39;El <code>domain()</code> de yScale debe ser equivalente a <code>[0, 411]</code> .&#39;
+  - text: 'El <code>domain()</code> de yScale debe ser equivalente a <code>[0, 411]</code> .'
     testString: 'assert(JSON.stringify(yScale.domain()) == JSON.stringify([0, 411]), "The <code>domain()</code> of yScale should be equivalent to <code>[0, 411]</code>.");'
-  - text: &#39;El <code>range()</code> de yScale debe ser equivalente a <code>[470, 30]</code> .&#39;
+  - text: 'El <code>range()</code> de yScale debe ser equivalente a <code>[470, 30]</code> .'
     testString: 'assert(JSON.stringify(yScale.range()) == JSON.stringify([470, 30]), "The <code>range()</code> of yScale should be equivalent to <code>[470, 30]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/04-data-visualization/json-apis-and-ajax/get-geolocation-data-to-find-a-users-gps-coordinates.spanish.md b/curriculum/challenges/spanish/04-data-visualization/json-apis-and-ajax/get-geolocation-data-to-find-a-users-gps-coordinates.spanish.md
index 73d4dabd91..7bd1b81a39 100644
--- a/curriculum/challenges/spanish/04-data-visualization/json-apis-and-ajax/get-geolocation-data-to-find-a-users-gps-coordinates.spanish.md
+++ b/curriculum/challenges/spanish/04-data-visualization/json-apis-and-ajax/get-geolocation-data-to-find-a-users-gps-coordinates.spanish.md
@@ -6,19 +6,19 @@ challengeType: 6
 ---
 
 ## Description
-<section id='description'> 
-Otra cosa interesante que puedes hacer es acceder a la ubicación actual de tu usuario. Cada navegador tiene un navegador incorporado que puede proporcionarle esta información. 
-El navegador obtendrá la longitud y latitud actual del usuario. 
-Verá un aviso para permitir o bloquear este sitio para que no sepa su ubicación actual. El desafío se puede completar de cualquier manera, siempre que el código sea correcto. 
-Al seleccionar permitir, verá que el texto del teléfono de salida cambia a su latitud y longitud. 
-Aquí está el código que hace esto: 
-<blockquote>if (navigator.geolocation){<br>&nbsp;&nbsp;navigator.geolocation.getCurrentPosition(function(position) {<br>&nbsp;&nbsp;&nbsp;&nbsp;document.getElementById('data').innerHTML="latitude: "+ position.coords.latitude +  "&lt;br&gt;longitude: " +  position.coords.longitude;<br>&nbsp;&nbsp;});<br>}</blockquote> 
-Primero, comprueba si el objeto <code>navigator.geolocation</code> existe. Si lo hace, se <code>getCurrentPosition</code> método <code>getCurrentPosition</code> en ese objeto, que inicia una solicitud asíncrona para la posición del usuario. Si la solicitud es exitosa, la función de devolución de llamada en el método se ejecuta. Esta función accede a los valores del objeto de <code>position</code> para latitud y longitud usando notación de puntos y actualiza el HTML. 
+<section id='description'>
+Otra cosa interesante que puedes hacer es acceder a la ubicación actual de tu usuario. Cada navegador tiene un navegador incorporado que puede proporcionarle esta información.
+El navegador obtendrá la longitud y latitud actual del usuario.
+Verá un aviso para permitir o bloquear este sitio para que no sepa su ubicación actual. El desafío se puede completar de cualquier manera, siempre que el código sea correcto.
+Al seleccionar permitir, verá que el texto del teléfono de salida cambia a su latitud y longitud.
+Aquí está el código que hace esto:
+<blockquote>if (navigator.geolocation){<br>&nbsp;&nbsp;navigator.geolocation.getCurrentPosition(function(position) {<br>&nbsp;&nbsp;&nbsp;&nbsp;document.getElementById('data').innerHTML="latitude: "+ position.coords.latitude +  "&lt;br&gt;longitude: " +  position.coords.longitude;<br>&nbsp;&nbsp;});<br>}</blockquote>
+Primero, comprueba si el objeto <code>navigator.geolocation</code> existe. Si lo hace, se <code>getCurrentPosition</code> método <code>getCurrentPosition</code> en ese objeto, que inicia una solicitud asíncrona para la posición del usuario. Si la solicitud es exitosa, la función de devolución de llamada en el método se ejecuta. Esta función accede a los valores del objeto de <code>position</code> para latitud y longitud usando notación de puntos y actualiza el HTML.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Agregue el código de ejemplo dentro de las etiquetas de <code>script</code> para verificar la ubicación actual de un usuario e insértelo en el HTML. 
+<section id='instructions'>
+Agregue el código de ejemplo dentro de las etiquetas de <code>script</code> para verificar la ubicación actual de un usuario e insértelo en el HTML.
 </section>
 
 ## Tests
@@ -26,13 +26,13 @@ Agregue el código de ejemplo dentro de las etiquetas de <code>script</code> par
 
 ```yml
 tests:
-  - text: &#39;Su código debe usar <code>navigator.geolocation</code> para acceder a la ubicación actual del usuario&#39;.
+  - text: 'Su código debe usar <code>navigator.geolocation</code> para acceder a la ubicación actual del usuario'
     testString: 'assert(code.match(/navigator\.geolocation\.getCurrentPosition/g), "Your code should use <code>navigator.geolocation</code> to access the user&#39;s current location.");'
-  - text: &#39;Su código debe usar <code>position.coords.latitude</code> para mostrar la ubicación latitudinal del usuario&#39;.
+  - text: 'Su código debe usar <code>position.coords.latitude</code> para mostrar la ubicación latitudinal del usuario'
     testString: 'assert(code.match(/position\.coords\.latitude/g), "Your code should use <code>position.coords.latitude</code> to display the user&#39;s latitudinal location.");'
-  - text: &#39;Su código debe usar <code>position.coords.longitude</code> para mostrar la ubicación longitudinal del usuario&#39;.
+  - text: 'Su código debe usar <code>position.coords.longitude</code> para mostrar la ubicación longitudinal del usuario'
     testString: 'assert(code.match(/position\.coords\.longitude/g), "Your code should use <code>position.coords.longitude</code> to display the user&#39;s longitudinal location.");'
-  - text: &#39;Debería mostrar la posición del usuario dentro del elemento de <code>data</code> div.&#39;
+  - text: 'Debería mostrar la posición del usuario dentro del elemento de <code>data</code> div.'
     testString: 'assert(code.match(/document\.getElementById\(\s*?("|")data\1\s*?\)\.innerHTML/g), "You should display the user&#39;s position within the <code>data</code> div element.");'
 
 ```
diff --git a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/anonymous-message-board.spanish.md b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/anonymous-message-board.spanish.md
index 07b513adc9..9fff61acd5 100644
--- a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/anonymous-message-board.spanish.md
+++ b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/anonymous-message-board.spanish.md
@@ -7,14 +7,14 @@ isRequired: true
 ---
 
 ## Description
-<section id='description'> 
-Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://horn-celery.glitch.me/' target='_blank'>https://horn-celery.glitch.me/</a> . 
-Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas. 
-Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-messageboard/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-messageboard/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro. 
+<section id='description'>
+Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://horn-celery.glitch.me/' target='_blank'>https://horn-celery.glitch.me/</a> .
+Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
+Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-messageboard/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-messageboard/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -29,7 +29,7 @@ tests:
     testString: ''
   - text: Solo permita que su sitio envíe la referencia para sus propias páginas.
     testString: ''
-  - text: 'Puedo enviar un hilo a un tablero de mensajes específico pasando el texto del formulario de datos y deletepassword_ a /api/threads/{board}.(Recomendar res.redirect a la página del tablero / b / {board}) El archivo guardado será al menos _id, 'text, createdon_ (date & time), bumpedon_ (date & time, comienza igual que created_on), reportado (boolean), deletepassword_, & replies (array).'
+  - text: 'Puedo enviar un hilo a un tablero de mensajes específico pasando el texto del formulario de datos y deletepassword_ a /api/threads/{board}.(Recomendar res.redirect a la página del tablero / b / {board}) El archivo guardado será al menos _id, text, createdon_ (date & time), bumpedon_ (date & time, comienza igual que created_on), reportado (boolean), deletepassword_, & replies (array).'
     testString: ''
   - text: 'Puedo POSTAR una respuesta a un hilo en una placa específica pasando el texto del formulario de datos, deletepassword_, & threadid_ a / api / replies / {board} y también actualizará la fecha de bumped_on a la fecha de los comentarios. (Recomiende res.redirect para enlazar la página / b / {board} / {thread_id}) En la matriz de respuestas del hilo, se guardará _id, text, createdon_, deletepassword_, y se informará. '
     testString: ''
diff --git a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/issue-tracker.spanish.md b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/issue-tracker.spanish.md
index 44008464c1..c7a0185081 100644
--- a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/issue-tracker.spanish.md
+++ b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/issue-tracker.spanish.md
@@ -7,14 +7,14 @@ isRequired: true
 ---
 
 ## Description
-<section id='description'> 
-Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://protective-garage.glitch.me/' target='_blank'>https://protective-garage.glitch.me/</a> . 
-Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas. 
-Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-issuetracker/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-issuetracker/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro. 
+<section id='description'>
+Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://protective-garage.glitch.me/' target='_blank'>https://protective-garage.glitch.me/</a> .
+Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
+Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-issuetracker/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-issuetracker/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,15 +27,15 @@ tests:
     testString: ''
   - text: 'Puedo POST / api / issues / {projectname} con los datos del formulario que contengan issue_title, issue_text, created_by, y Optional_trabajo y status_text.'
     testString: ''
-  - text: 'El objeto guardado (y devuelto) incluirá todos esos campos (en blanco para no entrada opcional) y también incluye created_on (fecha / hora), updated_on (fecha / hora), abierto (booleano, verdadero para abierto, falso para cerrado) , y _id '.
+  - text: 'El objeto guardado (y devuelto) incluirá todos esos campos (en blanco para no entrada opcional) y también incluye created_on (fecha / hora), updated_on (fecha / hora), abierto (booleano, verdadero para abierto, falso para cerrado) , y _id '
     testString: ''
-  - text: 'Puedo PUT / api / issues / {projectname} con un ID y cualquier campo en el objeto con un valor para objetar dicho objeto. Devuelto será "actualizado con éxito" o "no se pudo actualizar" + id. Esto siempre debe actualizar updated_on. Si no se envían campos, devuelva "no se envió ningún campo actualizado".
+  - text: 'Puedo PUT / api / issues / {projectname} con un ID y cualquier campo en el objeto con un valor para objetar dicho objeto. Devuelto será "actualizado con éxito" o "no se pudo actualizar" + id. Esto siempre debe actualizar updated_on. Si no se envían campos, devuelva "no se envió ningún campo actualizado."
     testString: ''
   - text: 'Puedo BORRAR / api / issues / {projectname} con un ID para eliminar completamente un problema. Si no se envía ningún _id, devuelva "id error", éxito: "eliminado" + id, falló: "no se pudo eliminar" + id. '
     testString: ''
   - text: 'Puedo obtener / api / issues / {projectname} para una serie de todos los problemas en ese proyecto específico con toda la información para cada problema, tal como se devolvió cuando se publicó.'
     testString: ''
-  - text: 'Puedo filtrar mi solicitud de obtención pasando también cualquier campo y valor en la consulta (es decir. / Api / issues / {project}? Open = false). Puedo pasar tantos campos / valores como quiera '.
+  - text: 'Puedo filtrar mi solicitud de obtención pasando también cualquier campo y valor en la consulta (es decir. / Api / issues / {project}? Open = false). Puedo pasar tantos campos / valores como quiera .'
     testString: ''
   - text: Todas las 11 pruebas funcionales están completas y aprobadas.
     testString: ''
diff --git a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/personal-library.spanish.md b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/personal-library.spanish.md
index b51b6c93a0..0d2c62733c 100644
--- a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/personal-library.spanish.md
+++ b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/personal-library.spanish.md
@@ -7,14 +7,14 @@ isRequired: true
 ---
 
 ## Description
-<section id='description'> 
-Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://spark-cathedral.glitch.me/' target='_blank'>https://spark-cathedral.glitch.me/</a> . 
-Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas. 
-Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-library/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-library/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro. 
+<section id='description'>
+Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://spark-cathedral.glitch.me/' target='_blank'>https://spark-cathedral.glitch.me/</a> .
+Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
+Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-library/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-library/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -35,11 +35,11 @@ tests:
     testString: ''
   - text: 'Puedo publicar un comentario en / api / books / {id} para agregar un comentario a un libro y devolverlo será el objeto de libros similar a get / api / books / {id}, incluido el nuevo comentario.'
     testString: ''
-  - text: 'Puedo eliminar / api / books / {_ id} para eliminar un libro de la colección. Devuelto será "eliminar con éxito" si tiene éxito.
+  - text: 'Puedo eliminar / api / books / {_ id} para eliminar un libro de la colección. Devuelto será "eliminar con éxito" si tiene éxito.'
     testString: ''
-  - text: Si trato de solicitar un libro que no existe, me devolverán "no existe ningún libro".
+  - text: Si trato de solicitar un libro que no existe, me devolverán "no existe ningún libro."
     testString: ''
-  - text: Puedo enviar una solicitud de eliminación a / api / books para eliminar todos los libros en la base de datos. Devuelto será 'completar eliminar con éxito' si tiene éxito.
+  - text: Puedo enviar una solicitud de eliminación a / api / books para eliminar todos los libros en la base de datos. Devuelto será "completar eliminar con éxito" si tiene éxito.
     testString: ''
   - text: Todas las 6 pruebas funcionales requeridas están completas y aprobadas.
     testString: ''
diff --git a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/stock-price-checker.spanish.md b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/stock-price-checker.spanish.md
index b3038362b1..53bee5c6ba 100644
--- a/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/stock-price-checker.spanish.md
+++ b/curriculum/challenges/spanish/06-information-security-and-quality-assurance/information-security-and-quality-assurance-projects/stock-price-checker.spanish.md
@@ -7,14 +7,14 @@ isRequired: true
 ---
 
 ## Description
-<section id='description'> 
-Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://giant-chronometer.glitch.me/' target='_blank'>https://giant-chronometer.glitch.me/</a> . 
-Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas. 
-Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-stockchecker/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-stockchecker/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro. 
+<section id='description'>
+Cree una aplicación de JavaScript de pila completa que sea funcionalmente similar a esto: <a href='https://giant-chronometer.glitch.me/' target='_blank'>https://giant-chronometer.glitch.me/</a> .
+Trabajar en este proyecto implicará que escriba su código en Glitch en nuestro proyecto de inicio. Después de completar este proyecto, puede copiar su URL de error público (en la página de inicio de su aplicación) en esta pantalla para probarlo. Opcionalmente, puede optar por escribir su proyecto en otra plataforma, pero debe ser visible públicamente para nuestras pruebas.
+Inicie este proyecto en Glitch usando <a href='https://glitch.com/#!/import/github/freeCodeCamp/boilerplate-project-stockchecker/'>este enlace</a> o clone <a href='https://github.com/freeCodeCamp/boilerplate-project-stockchecker/'>este repositorio</a> en GitHub! Si utiliza Glitch, recuerde guardar el enlace a su proyecto en un lugar seguro.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -31,7 +31,7 @@ tests:
     testString: ''
   - text: También puedo pasar un campo como true (booleano) para agregar mi me gusta a la (s) acción (es). Sólo 1 me gusta por ip debe ser aceptado.
     testString: ''
-  - text: "Si paso 2 acciones, el objeto devuelto será una matriz con la información de ambas acciones. En lugar de me gusta, mostrará rel_likes (la diferencia entre las me gusta en ambas acciones) en ambas".
+  - text: "Si paso 2 acciones, el objeto devuelto será una matriz con la información de ambas acciones. En lugar de me gusta, mostrará rel_likes (la diferencia entre las me gusta en ambas acciones) en ambas"
     testString: ''
   - text: 'Una buena forma de recibir el precio actual es la siguiente API externa (que reemplaza "GOOG" con su stock): https://finance.google.com/finance/info?q=NASDAQ%3aGOOG'
     testString: ''
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/find-the-symmetric-difference.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/find-the-symmetric-difference.spanish.md
index c936f30dfa..13e9560166 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/find-the-symmetric-difference.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/find-the-symmetric-difference.spanish.md
@@ -6,14 +6,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Cree una función que tome dos o más matrices y devuelva una matriz de la <dfn>diferencia simétrica</dfn> ( <code>△</code> o <code>⊕</code> ) de las matrices proporcionadas. 
-Dado dos conjuntos (por ejemplo, conjunto <code>A = {1, 2, 3}</code> y conjunto <code>B = {2, 3, 4}</code> ), el término matemático &quot;diferencia simétrica&quot; ​​es el conjunto de elementos que se encuentran en cualquiera de los dos conjuntos, pero no en ambos ( <code>A △ B = C = {1, 4}</code> ). Por cada diferencia simétrica adicional que tome (por ejemplo, en un conjunto <code>D = {2, 3}</code> ), debe obtener el conjunto con elementos que están en cualquiera de los dos conjuntos pero no en ambos ( <code>C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}</code> ). La matriz resultante debe contener solo valores únicos ( <em>no duplicados</em> ). 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Cree una función que tome dos o más matrices y devuelva una matriz de la <dfn>diferencia simétrica</dfn> ( <code>△</code> o <code>⊕</code> ) de las matrices proporcionadas.
+Dado dos conjuntos (por ejemplo, conjunto <code>A = {1, 2, 3}</code> y conjunto <code>B = {2, 3, 4}</code> ), el término matemático &quot;diferencia simétrica&quot; ​​es el conjunto de elementos que se encuentran en cualquiera de los dos conjuntos, pero no en ambos ( <code>A △ B = C = {1, 4}</code> ). Por cada diferencia simétrica adicional que tome (por ejemplo, en un conjunto <code>D = {2, 3}</code> ), debe obtener el conjunto con elementos que están en cualquiera de los dos conjuntos pero no en ambos ( <code>C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}</code> ). La matriz resultante debe contener solo valores únicos ( <em>no duplicados</em> ).
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,33 +22,33 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .&#39;
+  - text: ' <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .'
     testString: 'assert.sameMembers(sym([1, 2, 3], [5, 2, 1, 4]), [3, 4, 5], "<code>sym([1, 2, 3], [5, 2, 1, 4])</code> should return <code>[3, 4, 5]</code>.");'
-  - text: &#39; <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.&#39;
+  - text: ' <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.'
     testString: 'assert.equal(sym([1, 2, 3], [5, 2, 1, 4]).length, 3, "<code>sym([1, 2, 3], [5, 2, 1, 4])</code> should contain only three elements.");'
-  - text: &#39; <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .&#39;
+  - text: ' <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .'
     testString: 'assert.sameMembers(sym([1, 2, 3, 3], [5, 2, 1, 4]), [3, 4, 5], "<code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> should return <code>[3, 4, 5]</code>.");'
-  - text: &#39; <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.&#39;
+  - text: ' <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.'
     testString: 'assert.equal(sym([1, 2, 3, 3], [5, 2, 1, 4]).length, 3, "<code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> should contain only three elements.");'
-  - text: &#39; <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe devolver <code>[3, 4, 5]</code> .&#39;
+  - text: ' <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe devolver <code>[3, 4, 5]</code> .'
     testString: 'assert.sameMembers(sym([1, 2, 3], [5, 2, 1, 4, 5]), [3, 4, 5], "<code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> should return <code>[3, 4, 5]</code>.");'
-  - text: &#39; <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe contener solo tres elementos.&#39;
+  - text: ' <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe contener solo tres elementos.'
     testString: 'assert.equal(sym([1, 2, 3], [5, 2, 1, 4, 5]).length, 3, "<code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> should contain only three elements.");'
-  - text: &#39; <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe devolver <code>[1, 4, 5]</code> &#39;
+  - text: ' <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe devolver <code>[1, 4, 5]</code> '
     testString: 'assert.sameMembers(sym([1, 2, 5], [2, 3, 5], [3, 4, 5]), [1, 4, 5], "<code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> should return <code>[1, 4, 5]</code>");'
-  - text: &#39; <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe contener solo tres elementos.&#39;
+  - text: ' <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe contener solo tres elementos.'
     testString: 'assert.equal(sym([1, 2, 5], [2, 3, 5], [3, 4, 5]).length, 3, "<code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> should contain only three elements.");'
-  - text: &#39; <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe devolver <code>[1, 4, 5]</code> .&#39;
+  - text: ' <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe devolver <code>[1, 4, 5]</code> .'
     testString: 'assert.sameMembers(sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]), [1, 4, 5], "<code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> should return <code>[1, 4, 5]</code>.");'
-  - text: &#39; <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe contener solo tres elementos.&#39;
+  - text: ' <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe contener solo tres elementos.'
     testString: 'assert.equal(sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]).length, 3, "<code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> should contain only three elements.");'
-  - text: &#39; <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe devolver <code>[2, 3, 4, 6, 7]</code> .
+  - text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe devolver <code>[2, 3, 4, 6, 7]</code> .
     testString: 'assert.sameMembers(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3]), [2, 3, 4, 6, 7], "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> should return <code>[2, 3, 4, 6, 7]</code>.");'
-  - text: &#39; <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe contener solo cinco elementos.&#39;
+  - text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe contener solo cinco elementos.'
     testString: 'assert.equal(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3]).length, 5, "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> should contain only five elements.");'
-  - text: &#39; <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe devolver <code>[1, 2, 4, 5, 6, 7, 8, 9]</code> . &#39;
+  - text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe devolver <code>[1, 2, 4, 5, 6, 7, 8, 9]</code> . '
     testString: 'assert.sameMembers(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1]), [1, 2, 4, 5, 6, 7, 8, 9], "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> should return <code>[1, 2, 4, 5, 6, 7, 8, 9]</code>.");'
-  - text: &#39; <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe contener solo ocho elementos &#39;.
+  - text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe contener solo ocho elementos '
     testString: 'assert.equal(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1]).length, 8, "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> should contain only eight elements.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/inventory-update.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/inventory-update.spanish.md
index f66cd68bfd..8f03d3da53 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/inventory-update.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/inventory-update.spanish.md
@@ -6,13 +6,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Compare y actualice el inventario almacenado en una matriz 2D con una segunda matriz 2D de una entrega nueva. Actualice las cantidades de artículos de inventario existentes actuales (en <code>arr1</code> ). Si no se puede encontrar un artículo, agregue el nuevo artículo y la cantidad en la matriz de inventario. La matriz de inventario devuelta debe estar ordenada alfabéticamente por artículo. 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Compare y actualice el inventario almacenado en una matriz 2D con una segunda matriz 2D de una entrega nueva. Actualice las cantidades de artículos de inventario existentes actuales (en <code>arr1</code> ). Si no se puede encontrar un artículo, agregue el nuevo artículo y la cantidad en la matriz de inventario. La matriz de inventario devuelta debe estar ordenada alfabéticamente por artículo.
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,15 +23,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 tests:
   - text: La función <code>updateInventory</code> debería devolver una matriz.
     testString: 'assert.isArray(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]), "The function <code>updateInventory</code> should return an array.");'
-  - text: &#39; <code>updateInventory([[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]], [[2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [67, &quot;Bowling Ball&quot;], [7, &quot;Toothpaste&quot;]])</code> debe devolver una matriz con una longitud de 6. &#39;
+  - text: ' <code>updateInventory([[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]], [[2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [67, &quot;Bowling Ball&quot;], [7, &quot;Toothpaste&quot;]])</code> debe devolver una matriz con una longitud de 6. '
     testString: 'assert.equal(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]).length, 6, "<code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> should return an array with a length of 6.");'
-  - text: &#39; <code>updateInventory([[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]], [[2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [67, &quot;Bowling Ball&quot;], [7, &quot;Toothpaste&quot;]])</code> debe devolver <code>[[88, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [3, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [5, &quot;Microphone&quot;], [7, &quot;Toothpaste&quot;]]</code> . &#39;
+  - text: ' <code>updateInventory([[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]], [[2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [67, &quot;Bowling Ball&quot;], [7, &quot;Toothpaste&quot;]])</code> debe devolver <code>[[88, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [3, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [5, &quot;Microphone&quot;], [7, &quot;Toothpaste&quot;]]</code> . '
     testString: 'assert.deepEqual(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]), [[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]], "<code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> should return <code>[[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]]</code>.");'
-  - text: &#39; <code>updateInventory([[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]], [])</code> debe devolver <code>[[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]]</code> . &#39;
+  - text: ' <code>updateInventory([[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]], [])</code> debe devolver <code>[[21, &quot;Bowling Ball&quot;], [2, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [5, &quot;Microphone&quot;]]</code> . '
     testString: 'assert.deepEqual(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], []), [[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], "<code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [])</code> should return <code>[[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]]</code>.");'
-  - text: &#39; <code>updateInventory([], [[2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [67, &quot;Bowling Ball&quot;], [7, &quot;Toothpaste&quot;]])</code> debe devolver <code>[[67, &quot;Bowling Ball&quot;], [2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [7, &quot;Toothpaste&quot;]]</code> . &#39;
+  - text: ' <code>updateInventory([], [[2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [67, &quot;Bowling Ball&quot;], [7, &quot;Toothpaste&quot;]])</code> debe devolver <code>[[67, &quot;Bowling Ball&quot;], [2, &quot;Hair Pin&quot;], [3, &quot;Half-Eaten Apple&quot;], [7, &quot;Toothpaste&quot;]]</code> . '
     testString: 'assert.deepEqual(updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]), [[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]], "<code>updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> should return <code>[[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]]</code>.");'
-  - text: &#39; <code>updateInventory([[0, &quot;Bowling Ball&quot;], [0, &quot;Dirty Sock&quot;], [0, &quot;Hair Pin&quot;], [0, &quot;Microphone&quot;]], [[1, &quot;Hair Pin&quot;], [1, &quot;Half-Eaten Apple&quot;], [1, &quot;Bowling Ball&quot;], [1, &quot;Toothpaste&quot;]])</code> debe devolver <code>[[1, &quot;Bowling Ball&quot;], [0, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [1, &quot;Half-Eaten Apple&quot;], [0, &quot;Microphone&quot;], [1, &quot;Toothpaste&quot;]]</code> . &#39;
+  - text: ' <code>updateInventory([[0, &quot;Bowling Ball&quot;], [0, &quot;Dirty Sock&quot;], [0, &quot;Hair Pin&quot;], [0, &quot;Microphone&quot;]], [[1, &quot;Hair Pin&quot;], [1, &quot;Half-Eaten Apple&quot;], [1, &quot;Bowling Ball&quot;], [1, &quot;Toothpaste&quot;]])</code> debe devolver <code>[[1, &quot;Bowling Ball&quot;], [0, &quot;Dirty Sock&quot;], [1, &quot;Hair Pin&quot;], [1, &quot;Half-Eaten Apple&quot;], [0, &quot;Microphone&quot;], [1, &quot;Toothpaste&quot;]]</code> . '
     testString: 'assert.deepEqual(updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]]), [[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]], "<code>updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]])</code> should return <code>[[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/pairwise.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/pairwise.spanish.md
index eb434f97f3..20f502dede 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/pairwise.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/algorithms/pairwise.spanish.md
@@ -6,18 +6,18 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Dado una matriz <code>arr</code> , encuentre pares de elementos cuya suma sea igual al segundo argumento <code>arg</code> y devuelva la suma de sus índices. 
-Puede usar varios pares que tengan los mismos elementos numéricos pero diferentes índices. Cada par debe usar los índices disponibles más bajos posibles. Una vez que se ha utilizado un elemento, no puede reutilizarse para emparejarse con otro elemento. Por ejemplo, por <code>pairwise([1, 1, 2], 3)</code> crea un par <code>[2, 1]</code> usando el 1 en el índice 0 en lugar del 1 en el índice 1, porque 0 + 2 &lt;1 + 2. 
-Por ejemplo, por <code>pairwise([7, 9, 11, 13, 15], 20)</code> devuelve <code>6</code> . Los pares que suman 20 son <code>[7, 13]</code> y <code>[9, 11]</code> . Luego podemos escribir la matriz con sus índices y valores. 
-<table class="table"><tr><th> <strong>Índice</strong> </th><th> 0 </th><th> 1 </th><th> 2 </th><th> 3 </th><th> 4 </th></tr><tr><td> Valor </td><td> 7 </td><td> 9 </td><td> 11 </td><td> 13 </td><td> 15 </td></tr></table> 
-A continuación tomaremos sus índices correspondientes y los añadiremos. 
-7 + 13 = 20 → Índices 0 + 3 = 3 <br> 9 + 11 = 20 → Índices 1 + 2 = 3 <br> 3 + 3 = 6 → Volver <code>6</code> 
-Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código. 
+<section id='description'>
+Dado una matriz <code>arr</code> , encuentre pares de elementos cuya suma sea igual al segundo argumento <code>arg</code> y devuelva la suma de sus índices.
+Puede usar varios pares que tengan los mismos elementos numéricos pero diferentes índices. Cada par debe usar los índices disponibles más bajos posibles. Una vez que se ha utilizado un elemento, no puede reutilizarse para emparejarse con otro elemento. Por ejemplo, por <code>pairwise([1, 1, 2], 3)</code> crea un par <code>[2, 1]</code> usando el 1 en el índice 0 en lugar del 1 en el índice 1, porque 0 + 2 &lt;1 + 2.
+Por ejemplo, por <code>pairwise([7, 9, 11, 13, 15], 20)</code> devuelve <code>6</code> . Los pares que suman 20 son <code>[7, 13]</code> y <code>[9, 11]</code> . Luego podemos escribir la matriz con sus índices y valores.
+<table class="table"><tr><th> <strong>Índice</strong> </th><th> 0 </th><th> 1 </th><th> 2 </th><th> 3 </th><th> 4 </th></tr><tr><td> Valor </td><td> 7 </td><td> 9 </td><td> 11 </td><td> 13 </td><td> 15 </td></tr></table>
+A continuación tomaremos sus índices correspondientes y los añadiremos.
+7 + 13 = 20 → Índices 0 + 3 = 3 <br> 9 + 11 = 20 → Índices 1 + 2 = 3 <br> 3 + 3 = 6 → Volver <code>6</code>
+Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -26,15 +26,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
 
 ```yml
 tests:
-  - text: &#39; <code>pairwise([1, 4, 2, 3, 0, 5], 7)</code> debe devolver 11.&#39;
+  - text: ' <code>pairwise([1, 4, 2, 3, 0, 5], 7)</code> debe devolver 11.'
     testString: 'assert.deepEqual(pairwise([1, 4, 2, 3, 0, 5], 7), 11, "<code>pairwise([1, 4, 2, 3, 0, 5], 7)</code> should return 11.");'
-  - text: &#39; <code>pairwise([1, 3, 2, 4], 4)</code> debe devolver 1.&#39;
+  - text: ' <code>pairwise([1, 3, 2, 4], 4)</code> debe devolver 1.'
     testString: 'assert.deepEqual(pairwise([1, 3, 2, 4], 4), 1, "<code>pairwise([1, 3, 2, 4], 4)</code> should return 1.");'
-  - text: &#39; <code>pairwise([1, 1, 1], 2)</code> debe devolver 1.&#39;
+  - text: ' <code>pairwise([1, 1, 1], 2)</code> debe devolver 1.'
     testString: 'assert.deepEqual(pairwise([1, 1, 1], 2), 1, "<code>pairwise([1, 1, 1], 2)</code> should return 1.");'
-  - text: &#39; <code>pairwise([0, 0, 0, 0, 1, 1], 1)</code> debe devolver 10.&#39;
+  - text: ' <code>pairwise([0, 0, 0, 0, 1, 1], 1)</code> debe devolver 10.'
     testString: 'assert.deepEqual(pairwise([0, 0, 0, 0, 1, 1], 1), 10, "<code>pairwise([0, 0, 0, 0, 1, 1], 1)</code> should return 10.");'
-  - text: &#39; <code>pairwise([], 100)</code> debe devolver 0.&#39;
+  - text: ' <code>pairwise([], 100)</code> debe devolver 0.'
     testString: 'assert.deepEqual(pairwise([], 100), 0, "<code>pairwise([], 100)</code> should return 0.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/breadth-first-search.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/breadth-first-search.spanish.md
index 3e8455d5e7..a398748436 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/breadth-first-search.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/breadth-first-search.spanish.md
@@ -6,22 +6,22 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Hasta ahora, hemos aprendido diferentes formas de crear representaciones de gráficos. ¿Ahora que? Una pregunta natural que se debe tener es ¿cuáles son las distancias entre dos nodos en el gráfico? Introduzca los <dfn>algoritmos de recorrido del gráfico</dfn> . 
-<dfn>algoritmos de recorrido</dfn> son algoritmos para atravesar o visitar los nodos en un gráfico. Un tipo de algoritmo de recorrido es el primer algoritmo de búsqueda. 
-Este algoritmo comienza en un nodo, primero visita a todos sus vecinos que están a un borde de distancia, luego continúa visitando a cada uno de sus vecinos. 
-Visualmente, esto es lo que hace el algoritmo. 
-<img class='img-responsive' src='https://camo.githubusercontent.com/2f57e6239884a1a03402912f13c49555dec76d06/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f342f34362f416e696d617465645f4246532e676966'> 
-Para implementar este algoritmo, deberá ingresar una estructura de gráfico y un nodo en el que desee comenzar. 
-Primero, querrá estar al tanto de las distancias desde el nodo de inicio. Esto querrá comenzar todas sus distancias, inicialmente un número grande, como <code>Infinity</code> . Esto proporciona una referencia para el caso en el que no se puede acceder a un nodo desde su nodo de inicio. 
-A continuación, querrá ir desde el nodo de inicio a sus vecinos. Estos vecinos están a un borde de distancia y en este punto debes agregar una unidad de distancia a las distancias que estás siguiendo. 
-último, la cola es una estructura de datos importante que ayudará a implementar el primer algoritmo de búsqueda. Esta es una matriz donde puede agregar elementos a un extremo y eliminar elementos del otro extremo. Esto también se conoce como estructura de datos <dfn>FIFO</dfn> o <dfn>primero en entrar, primero en salir</dfn> . 
+<section id='description'>
+Hasta ahora, hemos aprendido diferentes formas de crear representaciones de gráficos. ¿Ahora que? Una pregunta natural que se debe tener es ¿cuáles son las distancias entre dos nodos en el gráfico? Introduzca los <dfn>algoritmos de recorrido del gráfico</dfn> .
+<dfn>algoritmos de recorrido</dfn> son algoritmos para atravesar o visitar los nodos en un gráfico. Un tipo de algoritmo de recorrido es el primer algoritmo de búsqueda.
+Este algoritmo comienza en un nodo, primero visita a todos sus vecinos que están a un borde de distancia, luego continúa visitando a cada uno de sus vecinos.
+Visualmente, esto es lo que hace el algoritmo.
+<img class='img-responsive' src='https://camo.githubusercontent.com/2f57e6239884a1a03402912f13c49555dec76d06/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f342f34362f416e696d617465645f4246532e676966'>
+Para implementar este algoritmo, deberá ingresar una estructura de gráfico y un nodo en el que desee comenzar.
+Primero, querrá estar al tanto de las distancias desde el nodo de inicio. Esto querrá comenzar todas sus distancias, inicialmente un número grande, como <code>Infinity</code> . Esto proporciona una referencia para el caso en el que no se puede acceder a un nodo desde su nodo de inicio.
+A continuación, querrá ir desde el nodo de inicio a sus vecinos. Estos vecinos están a un borde de distancia y en este punto debes agregar una unidad de distancia a las distancias que estás siguiendo.
+último, la cola es una estructura de datos importante que ayudará a implementar el primer algoritmo de búsqueda. Esta es una matriz donde puede agregar elementos a un extremo y eliminar elementos del otro extremo. Esto también se conoce como estructura de datos <dfn>FIFO</dfn> o <dfn>primero en entrar, primero en salir</dfn> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escriba una función <code>bfs()</code> que tome un gráfico de matriz de adyacencia (una matriz bidimensional) y una raíz de etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor entero del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico. 
-Su función dará salida a un objeto JavaScript pares de clave-valor con el nodo y su distancia desde la raíz. Si no se pudo alcanzar el nodo, debería tener una distancia de <code>Infinity</code> . 
+<section id='instructions'>
+Escriba una función <code>bfs()</code> que tome un gráfico de matriz de adyacencia (una matriz bidimensional) y una raíz de etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor entero del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico.
+Su función dará salida a un objeto JavaScript pares de clave-valor con el nodo y su distancia desde la raíz. Si no se pudo alcanzar el nodo, debería tener una distancia de <code>Infinity</code> .
 </section>
 
 ## Tests
@@ -29,13 +29,13 @@ Su función dará salida a un objeto JavaScript pares de clave-valor con el nodo
 
 ```yml
 tests:
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debe devolver <code>{0: 1, 1: 0, 2: 1, 3: 2}</code> &#39;
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debe devolver <code>{0: 1, 1: 0, 2: 1, 3: 2}</code> '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; var results = bfs(graph, 1); return isEquivalent(results, {0: 1, 1: 0, 2: 1, 3: 2})})(), "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return <code>{0: 1, 1: 0, 2: 1, 3: 2}</code>");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code> &#39;
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code> '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; var results = bfs(graph, 1); return isEquivalent(results, {0: 1, 1: 0, 2: 1, 3: Infinity})})(), "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>1</code> should return <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code>");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1, 2: 2, 3: 3}</code> &#39;
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1, 2: 2, 3: 3}</code> '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; var results = bfs(graph, 0); return isEquivalent(results, {0: 0, 1: 1, 2: 2, 3: 3})})(), "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return <code>{0: 0, 1: 1, 2: 2, 3: 3}</code>");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1], [1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1}</code> &#39;
+  - text: 'El gráfico de entrada <code>[[0, 1], [1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1}</code> '
     testString: 'assert((function() { var graph = [[0, 1], [1, 0]]; var results = bfs(graph, 0); return isEquivalent(results, {0: 0, 1: 1})})(), "The input graph <code>[[0, 1], [1, 0]]</code> with a start node of <code>0</code> should return <code>{0: 0, 1: 1}</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-a-map-data-structure.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-a-map-data-structure.spanish.md
index 88499343df..05455a6844 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-a-map-data-structure.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-a-map-data-structure.spanish.md
@@ -6,23 +6,23 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Los próximos desafíos cubrirán mapas y tablas hash. Los mapas son estructuras de datos que almacenan pares clave-valor. En JavaScript, estos están disponibles para nosotros como objetos. Los mapas proporcionan una búsqueda rápida de elementos almacenados en función de valores clave y son estructuras de datos muy comunes y útiles. 
-Instrucciones: Hagamos algo de práctica creando nuestro propio mapa. Debido a que los objetos de JavaScript proporcionan una estructura de mapa mucho más eficiente que cualquier otra que podamos escribir aquí, esto está pensado principalmente como un ejercicio de aprendizaje. Sin embargo, los objetos de JavaScript solo nos proporcionan ciertas operaciones. ¿Y si quisiéramos definir operaciones personalizadas? 
-Utilice el objeto <code>Map</code> que se proporciona aquí como una envoltura alrededor de un <code>object</code> JavaScript. Cree los siguientes métodos y operaciones en el objeto Mapa: 
-<ul> 
-<li> <code>add</code> acepta una <code>key, value</code> par de <code>key, value</code> para agregar al mapa. </li> 
-<li> <code>remove</code> acepta una clave y elimina la <code>key, value</code> asociada <code>key, value</code> par de <code>key, value</code> </li> 
-<li> <code>get</code> acepta una <code>key</code> y devuelve el <code>value</code> almacenado </li> 
-<li> <code>has</code> acepta una <code>key</code> y devuelve <dfn>verdadero</dfn> si existe la clave o <dfn>falso</dfn> si no lo hace. </li> 
-<li> <code>values</code> devuelve una matriz de todos los valores en el mapa </li> 
-<li> <code>size</code> devuelve el número de elementos en el mapa </li> 
-<li> <code>clear</code> vacía el mapa </li> 
-</ul> 
+<section id='description'>
+Los próximos desafíos cubrirán mapas y tablas hash. Los mapas son estructuras de datos que almacenan pares clave-valor. En JavaScript, estos están disponibles para nosotros como objetos. Los mapas proporcionan una búsqueda rápida de elementos almacenados en función de valores clave y son estructuras de datos muy comunes y útiles.
+Instrucciones: Hagamos algo de práctica creando nuestro propio mapa. Debido a que los objetos de JavaScript proporcionan una estructura de mapa mucho más eficiente que cualquier otra que podamos escribir aquí, esto está pensado principalmente como un ejercicio de aprendizaje. Sin embargo, los objetos de JavaScript solo nos proporcionan ciertas operaciones. ¿Y si quisiéramos definir operaciones personalizadas?
+Utilice el objeto <code>Map</code> que se proporciona aquí como una envoltura alrededor de un <code>object</code> JavaScript. Cree los siguientes métodos y operaciones en el objeto Mapa:
+<ul>
+<li> <code>add</code> acepta una <code>key, value</code> par de <code>key, value</code> para agregar al mapa. </li>
+<li> <code>remove</code> acepta una clave y elimina la <code>key, value</code> asociada <code>key, value</code> par de <code>key, value</code> </li>
+<li> <code>get</code> acepta una <code>key</code> y devuelve el <code>value</code> almacenado </li>
+<li> <code>has</code> acepta una <code>key</code> y devuelve <dfn>verdadero</dfn> si existe la clave o <dfn>falso</dfn> si no lo hace. </li>
+<li> <code>values</code> devuelve una matriz de todos los valores en el mapa </li>
+<li> <code>size</code> devuelve el número de elementos en el mapa </li>
+<li> <code>clear</code> vacía el mapa </li>
+</ul>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -33,7 +33,7 @@ Utilice el objeto <code>Map</code> que se proporciona aquí como una envoltura a
 tests:
   - text: La estructura de datos del mapa existe.
     testString: 'assert((function() { var test = false; if (typeof Map !== "undefined") { test = new Map() }; return (typeof test == "object")})(), "The Map data structure exists.");'
-  - text: 'El objeto Mapa tiene los siguientes métodos: agregar, eliminar, obtener, tiene, valores, borrar y tamaño'.
+  - text: 'El objeto Mapa tiene los siguientes métodos: agregar, eliminar, obtener, tiene, valores, borrar y tamaño.'
     testString: 'assert((function() { var test = false; if (typeof Map !== "undefined") { test = new Map() }; return (typeof test.add == "function" && typeof test.remove == "function" && typeof test.get == "function" && typeof test.has == "function" && typeof test.values == "function" && typeof test.clear == "function" && typeof test.size == "function")})(), "The Map object has the following methods: add, remove, get, has, values, clear, and size.");'
   - text: El método add agrega elementos al mapa.
     testString: 'assert((function() { var test = false; if (typeof Map !== "undefined") { test = new Map() }; test.add(5,6); test.add(2,3); test.add(2,5); return (test.size() == 2)})(), "The add method adds items to the map.");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-and-add-to-sets-in-es6.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-and-add-to-sets-in-es6.spanish.md
index 09f97b89cb..a7824e0c83 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-and-add-to-sets-in-es6.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/create-and-add-to-sets-in-es6.spanish.md
@@ -6,23 +6,23 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora que ha trabajado con ES5, va a realizar algo similar en ES6. Esto será considerablemente más fácil. ES6 contiene una estructura de datos incorporada <code>Set</code> muchas de las operaciones que ha escrito a mano se incluyen ahora para usted. Echemos un vistazo: 
-Para crear un nuevo conjunto vacío: 
-<code>var set = new Set();</code> 
-Puede crear un conjunto con un valor: 
-<code>var set = new Set(1);</code> 
-Puede crear un conjunto con una matriz: 
-<code>var set = new Set([1, 2, 3]);</code> 
-Una vez que haya creado un conjunto, puede agregar los valores que desee utilizando el método de <code>add</code> : 
-<blockquote>var set = new Set([1, 2, 3]);<br>set.add([4, 5, 6]);</blockquote> 
-Como recordatorio, un conjunto es una estructura de datos que no puede contener valores duplicados: 
-<blockquote>var set = new Set([1, 2, 3, 1, 2, 3]);<br>// set contains [1, 2, 3] only</blockquote> 
+<section id='description'>
+Ahora que ha trabajado con ES5, va a realizar algo similar en ES6. Esto será considerablemente más fácil. ES6 contiene una estructura de datos incorporada <code>Set</code> muchas de las operaciones que ha escrito a mano se incluyen ahora para usted. Echemos un vistazo:
+Para crear un nuevo conjunto vacío:
+<code>var set = new Set();</code>
+Puede crear un conjunto con un valor:
+<code>var set = new Set(1);</code>
+Puede crear un conjunto con una matriz:
+<code>var set = new Set([1, 2, 3]);</code>
+Una vez que haya creado un conjunto, puede agregar los valores que desee utilizando el método de <code>add</code> :
+<blockquote>var set = new Set([1, 2, 3]);<br>set.add([4, 5, 6]);</blockquote>
+Como recordatorio, un conjunto es una estructura de datos que no puede contener valores duplicados:
+<blockquote>var set = new Set([1, 2, 3, 1, 2, 3]);<br>// set contains [1, 2, 3] only</blockquote>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Para este ejercicio, devuelva un conjunto con los siguientes valores: <code>1, 2, 3, &#39;Taco&#39;, &#39;Cat&#39;, &#39;Awesome&#39;</code> 
+<section id='instructions'>
+Para este ejercicio, devuelva un conjunto con los siguientes valores: <code>1, 2, 3, &#39;Taco&#39;, &#39;Cat&#39;, &#39;Awesome&#39;</code>
 </section>
 
 ## Tests
@@ -30,7 +30,7 @@ Para este ejercicio, devuelva un conjunto con los siguientes valores: <code>1, 2
 
 ```yml
 tests:
-  - text: &#39;Tu <code>Set</code> solo debe contener los valores <code>1, 2, 3, Taco, Cat, Awesome</code> &#39;.
+  - text: 'Tu <code>Set</code> solo debe contener los valores <code>1, 2, 3, Taco, Cat, Awesome</code> '
     testString: 'assert(function(){var test = checkSet(); return (test.size == 6) && test.has(1) && test.has(2) && test.has(3) && test.has("Taco") && test.has("Cat") && test.has("Awesome");}, "Your <code>Set</code> should only contain the values <code>1, 2, 3, Taco, Cat, Awesome</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.spanish.md
index 28b32ebecb..72c64bb7d2 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-leaf-node-in-a-binary-search-tree.spanish.md
@@ -6,18 +6,18 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Este es el primero de los tres desafíos en los que implementaremos una operación más difícil en los árboles de búsqueda binarios: eliminación. La eliminación es difícil porque la eliminación de nodos rompe los enlaces en el árbol. Estos enlaces deben restablecerse cuidadosamente para garantizar que se mantenga la estructura del árbol binario. Para algunas eliminaciones, esto significa que el árbol debe ser reorganizado. En general, encontrará uno de los tres casos cuando intente eliminar un nodo: 
-Nodo hoja: el objetivo que se eliminará tiene cero hijos. 
-Un hijo: el objetivo que se eliminará solo tiene un hijo. 
-Dos hijos: El objetivo a eliminar tiene dos nodos hijos. 
-Eliminar un nodo hoja es fácil, simplemente lo eliminamos. Eliminar un nodo con un hijo también es relativamente fácil, simplemente lo eliminamos y vinculamos su padre al hijo del nodo que eliminamos. Sin embargo, la eliminación de un nodo con dos hijos es más difícil, ya que esto crea dos nodos hijos que deben volver a conectarse al árbol padre. Veremos cómo lidiar con este caso en el tercer desafío. Además, debe tener en cuenta algunos casos de ventaja al manejar la eliminación. ¿Qué pasa si el árbol está vacío? ¿Qué pasa si el nodo a eliminar es el nodo raíz? ¿Y si solo hay dos elementos en el árbol? Por ahora, vamos a manejar el primer caso donde eliminamos un nodo de hoja. 
-Instrucciones: Crea un método en nuestro árbol binario llamado <code>remove</code> . Construiremos la lógica para nuestra operación de eliminación aquí. Primero, querrá crear una función dentro de eliminar que encuentre el nodo que intentamos eliminar en el árbol actual. Si el nodo no está presente en el árbol, <code>remove</code> debe devolver <code>null</code> . Ahora, si el nodo de destino es un nodo de hoja sin hijos, entonces la referencia principal debe establecerse en <code>null</code> . Esto elimina efectivamente el nodo del árbol. Para hacer esto, también deberá hacer un seguimiento del padre del nodo que estamos intentando eliminar. También será útil para crear una forma de realizar un seguimiento del número de hijos que tiene el nodo de destino, ya que esto determinará en qué caso se encuentra nuestra eliminación. 
-Manejaremos el segundo y tercer caso en los próximos desafíos. ¡Buena suerte! 
+<section id='description'>
+Este es el primero de los tres desafíos en los que implementaremos una operación más difícil en los árboles de búsqueda binarios: eliminación. La eliminación es difícil porque la eliminación de nodos rompe los enlaces en el árbol. Estos enlaces deben restablecerse cuidadosamente para garantizar que se mantenga la estructura del árbol binario. Para algunas eliminaciones, esto significa que el árbol debe ser reorganizado. En general, encontrará uno de los tres casos cuando intente eliminar un nodo:
+Nodo hoja: el objetivo que se eliminará tiene cero hijos.
+Un hijo: el objetivo que se eliminará solo tiene un hijo.
+Dos hijos: El objetivo a eliminar tiene dos nodos hijos.
+Eliminar un nodo hoja es fácil, simplemente lo eliminamos. Eliminar un nodo con un hijo también es relativamente fácil, simplemente lo eliminamos y vinculamos su padre al hijo del nodo que eliminamos. Sin embargo, la eliminación de un nodo con dos hijos es más difícil, ya que esto crea dos nodos hijos que deben volver a conectarse al árbol padre. Veremos cómo lidiar con este caso en el tercer desafío. Además, debe tener en cuenta algunos casos de ventaja al manejar la eliminación. ¿Qué pasa si el árbol está vacío? ¿Qué pasa si el nodo a eliminar es el nodo raíz? ¿Y si solo hay dos elementos en el árbol? Por ahora, vamos a manejar el primer caso donde eliminamos un nodo de hoja.
+Instrucciones: Crea un método en nuestro árbol binario llamado <code>remove</code> . Construiremos la lógica para nuestra operación de eliminación aquí. Primero, querrá crear una función dentro de eliminar que encuentre el nodo que intentamos eliminar en el árbol actual. Si el nodo no está presente en el árbol, <code>remove</code> debe devolver <code>null</code> . Ahora, si el nodo de destino es un nodo de hoja sin hijos, entonces la referencia principal debe establecerse en <code>null</code> . Esto elimina efectivamente el nodo del árbol. Para hacer esto, también deberá hacer un seguimiento del padre del nodo que estamos intentando eliminar. También será útil para crear una forma de realizar un seguimiento del número de hijos que tiene el nodo de destino, ya que esto determinará en qué caso se encuentra nuestra eliminación.
+Manejaremos el segundo y tercer caso en los próximos desafíos. ¡Buena suerte!
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -32,7 +32,7 @@ tests:
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function")})(), "The binary search tree has a method called <code>remove</code>.");'
   - text: Intentar eliminar un elemento que no existe devuelve <code>null</code> .
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; return (test.remove(100) == null); })(), "Trying to remove an element that does not exist returns <code>null</code>.");'
-  - text: &#39;Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> &#39;.
+  - text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(500); test.remove(500); return (test.inorder() == null); })(), "If the root node has no children, deleting it sets the root to <code>null</code>.");'
   - text: El método de <code>remove</code> elimina los nodos de hoja del árbol.
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(5); test.add(3); test.add(7); test.add(6); test.add(10); test.add(12); test.remove(3); test.remove(12); test.remove(10); return (test.inorder().join("") == "567"); })(), "The <code>remove</code> method removes leaf nodes from the tree");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-one-child-in-a-binary-search-tree.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-one-child-in-a-binary-search-tree.spanish.md
index bbe2f24b87..ab5e2db597 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-one-child-in-a-binary-search-tree.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-one-child-in-a-binary-search-tree.spanish.md
@@ -6,13 +6,13 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Ahora que podemos eliminar los nodos de hoja, pasemos al segundo caso: eliminar un nodo con un hijo. Para este caso, digamos que tenemos un árbol con los siguientes nodos 1 - 2 - 3 donde 1 es la raíz. Para eliminar 2, simplemente necesitamos hacer la referencia correcta en 1 punto a 3. De manera más general, para eliminar un nodo con un solo hijo, hacemos que la referencia principal de ese nodo sea el siguiente nodo del árbol. 
-Instrucciones: Hemos proporcionado algún código en nuestro método de <code>remove</code> que cumple las tareas del último desafío. Encontramos el objetivo a eliminar y su padre y definimos la cantidad de hijos que tiene el nodo objetivo. Agreguemos el siguiente caso aquí para los nodos de destino con un solo hijo. Aquí, tendremos que determinar si el único hijo es una rama izquierda o derecha en el árbol y luego establecer la referencia correcta en el padre para apuntar a este nodo. Además, consideremos el caso en el que el destino es el nodo raíz (esto significa que el nodo principal será <code>null</code> ). Siéntase libre de reemplazar todo el código de inicio con el suyo, siempre y cuando pase las pruebas. 
+<section id='description'>
+Ahora que podemos eliminar los nodos de hoja, pasemos al segundo caso: eliminar un nodo con un hijo. Para este caso, digamos que tenemos un árbol con los siguientes nodos 1 - 2 - 3 donde 1 es la raíz. Para eliminar 2, simplemente necesitamos hacer la referencia correcta en 1 punto a 3. De manera más general, para eliminar un nodo con un solo hijo, hacemos que la referencia principal de ese nodo sea el siguiente nodo del árbol.
+Instrucciones: Hemos proporcionado algún código en nuestro método de <code>remove</code> que cumple las tareas del último desafío. Encontramos el objetivo a eliminar y su padre y definimos la cantidad de hijos que tiene el nodo objetivo. Agreguemos el siguiente caso aquí para los nodos de destino con un solo hijo. Aquí, tendremos que determinar si el único hijo es una rama izquierda o derecha en el árbol y luego establecer la referencia correcta en el padre para apuntar a este nodo. Además, consideremos el caso en el que el destino es el nodo raíz (esto significa que el nodo principal será <code>null</code> ). Siéntase libre de reemplazar todo el código de inicio con el suyo, siempre y cuando pase las pruebas.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,7 +27,7 @@ tests:
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function")})(), "The binary search tree has a method called <code>remove</code>.");'
   - text: Intentar eliminar un elemento que no existe devuelve <code>null</code> .
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; return (test.remove(100) == null); })(), "Trying to remove an element that does not exist returns <code>null</code>.");'
-  - text: &#39;Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> &#39;.
+  - text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(500); test.remove(500); return (test.inorder() == null); })(), "If the root node has no children, deleting it sets the root to <code>null</code>.");'
   - text: El método de <code>remove</code> elimina los nodos de hoja del árbol.
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(5); test.add(3); test.add(7); test.add(6); test.add(10); test.add(12); test.remove(3); test.remove(12); test.remove(10); return (test.inorder().join("") == "567"); })(), "The <code>remove</code> method removes leaf nodes from the tree");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.spanish.md
index 211fbb8ac6..3adb2211cf 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/delete-a-node-with-two-children-in-a-binary-search-tree.spanish.md
@@ -6,14 +6,14 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Eliminar los nodos que tienen dos hijos es el caso más difícil de implementar. La eliminación de un nodo como este produce dos subárboles que ya no están conectados a la estructura de árbol original. ¿Cómo podemos reconectarlos? Un método es encontrar el valor más pequeño en el subárbol derecho del nodo de destino y reemplazar el nodo de destino con este valor. Seleccionar el reemplazo de esta manera asegura que sea mayor que cada nodo en el subárbol izquierdo, se convierte en el nuevo padre, pero también en menos que cada nodo en el subárbol derecho se convierte en el nuevo padre. 
-Una vez que se realiza este reemplazo, el nodo de reemplazo debe eliminarse del subárbol derecho. Incluso esta operación es complicada porque el reemplazo puede ser una hoja o puede ser el padre de un subárbol derecho. Si es una hoja debemos eliminar la referencia de su padre. De lo contrario, debe ser el hijo derecho del objetivo. En este caso, debemos reemplazar el valor objetivo con el valor de reemplazo y hacer que la referencia objetivo sea el hijo derecho del reemplazo. 
-Instrucciones: Terminemos nuestro método de <code>remove</code> manejando el tercer caso. Hemos proporcionado un código nuevo para los dos primeros casos. Agregue un poco de código ahora para manejar los nodos de destino con dos hijos. ¿Algún caso de borde a tener en cuenta? ¿Qué pasa si el árbol tiene sólo tres nodos? Una vez que haya terminado, esto completará nuestra operación de eliminación de árboles de búsqueda binarios. Buen trabajo, este es un problema bastante difícil! 
+<section id='description'>
+Eliminar los nodos que tienen dos hijos es el caso más difícil de implementar. La eliminación de un nodo como este produce dos subárboles que ya no están conectados a la estructura de árbol original. ¿Cómo podemos reconectarlos? Un método es encontrar el valor más pequeño en el subárbol derecho del nodo de destino y reemplazar el nodo de destino con este valor. Seleccionar el reemplazo de esta manera asegura que sea mayor que cada nodo en el subárbol izquierdo, se convierte en el nuevo padre, pero también en menos que cada nodo en el subárbol derecho se convierte en el nuevo padre.
+Una vez que se realiza este reemplazo, el nodo de reemplazo debe eliminarse del subárbol derecho. Incluso esta operación es complicada porque el reemplazo puede ser una hoja o puede ser el padre de un subárbol derecho. Si es una hoja debemos eliminar la referencia de su padre. De lo contrario, debe ser el hijo derecho del objetivo. En este caso, debemos reemplazar el valor objetivo con el valor de reemplazo y hacer que la referencia objetivo sea el hijo derecho del reemplazo.
+Instrucciones: Terminemos nuestro método de <code>remove</code> manejando el tercer caso. Hemos proporcionado un código nuevo para los dos primeros casos. Agregue un poco de código ahora para manejar los nodos de destino con dos hijos. ¿Algún caso de borde a tener en cuenta? ¿Qué pasa si el árbol tiene sólo tres nodos? Una vez que haya terminado, esto completará nuestra operación de eliminación de árboles de búsqueda binarios. Buen trabajo, este es un problema bastante difícil!
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,7 +28,7 @@ tests:
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function")})(), "The binary search tree has a method called <code>remove</code>.");'
   - text: Intentar eliminar un elemento que no existe devuelve <code>null</code> .
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function") ? (test.remove(100) == null) : false})(), "Trying to remove an element that does not exist returns <code>null</code>.");'
-  - text: &#39;Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> &#39;.
+  - text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; test.add(500); test.remove(500); return (typeof test.remove == "function") ? (test.inorder() == null) : false})(), "If the root node has no children, deleting it sets the root to <code>null</code>.");'
   - text: El método de <code>remove</code> elimina los nodos de hoja del árbol.
     testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; test.add(5); test.add(3); test.add(7); test.add(6); test.add(10); test.add(12); test.remove(3); test.remove(12); test.remove(10); return (typeof test.remove == "function") ? (test.inorder().join("") == "567") : false})(), "The <code>remove</code> method removes leaf nodes from the tree");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/depth-first-search.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/depth-first-search.spanish.md
index 35d3cc2368..3fa53a3864 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/depth-first-search.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/depth-first-search.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-igual que <dfn>en la búsqueda de amplitud en primer lugar</dfn> , aquí aprenderemos sobre otro algoritmo de recorrido de gráficos llamado <dfn>búsqueda de primero en profundidad</dfn> . 
-Mientras que la búsqueda en amplitud busca las longitudes de borde incrementales lejos del nodo de origen, la <dfn>búsqueda en profundidad</dfn> primero recorre un camino de bordes lo más lejos posible. 
-Una vez que llega a un extremo de una ruta, la búsqueda volverá al último nodo con una ruta de borde no visitada y continuará la búsqueda. 
-Visualmente, esto es lo que hace el algoritmo donde el nodo superior es el punto de inicio de la búsqueda. 
-<img class='img-responsive' src='https://camo.githubusercontent.com/aaad9e39961daf34d967c616edeb50abf3bf1235/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f372f37662f44657074682d46697273742d5365617263682e676966'> 
-Una salida simple de este algoritmo es una lista de nodos a los que se puede acceder desde un nodo determinado. Entonces, al implementar este algoritmo, deberá realizar un seguimiento de los nodos que visita. 
+<section id='description'>
+igual que <dfn>en la búsqueda de amplitud en primer lugar</dfn> , aquí aprenderemos sobre otro algoritmo de recorrido de gráficos llamado <dfn>búsqueda de primero en profundidad</dfn> .
+Mientras que la búsqueda en amplitud busca las longitudes de borde incrementales lejos del nodo de origen, la <dfn>búsqueda en profundidad</dfn> primero recorre un camino de bordes lo más lejos posible.
+Una vez que llega a un extremo de una ruta, la búsqueda volverá al último nodo con una ruta de borde no visitada y continuará la búsqueda.
+Visualmente, esto es lo que hace el algoritmo donde el nodo superior es el punto de inicio de la búsqueda.
+<img class='img-responsive' src='https://camo.githubusercontent.com/aaad9e39961daf34d967c616edeb50abf3bf1235/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f372f37662f44657074682d46697273742d5365617263682e676966'>
+Una salida simple de este algoritmo es una lista de nodos a los que se puede acceder desde un nodo determinado. Entonces, al implementar este algoritmo, deberá realizar un seguimiento de los nodos que visita.
 </section>
 
 ## Instructions
-<section id='instructions'> 
-Escriba una función <code>dfs()</code> que tome un <code>graph</code> matriz de adyacencia no <code>graph</code> y una <code>root</code> etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor numérico del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico. 
-Su función debe generar una matriz de todos los nodos accesibles desde la <code>root</code> . 
+<section id='instructions'>
+Escriba una función <code>dfs()</code> que tome un <code>graph</code> matriz de adyacencia no <code>graph</code> y una <code>root</code> etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor numérico del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico.
+Su función debe generar una matriz de todos los nodos accesibles desde la <code>root</code> .
 </section>
 
 ## Tests
@@ -26,21 +26,21 @@ Su función debe generar una matriz de todos los nodos accesibles desde la <code
 
 ```yml
 tests:
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con <code>0</code> , <code>1</code> , <code>2</code> y <code>3</code> &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con <code>0</code> , <code>1</code> , <code>2</code> y <code>3</code> '
     testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 1);})(), [0, 1, 2, 3], "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return an array with <code>0</code>, <code>1</code>, <code>2</code>, and <code>3</code>.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con cuatro elementos &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con cuatro elementos '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 1);})().length === 4, "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return an array with four elements.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>3</code> &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>3</code> '
     testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; return dfs(graph, 3);})(), [3], "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>3</code> should return an array with <code>3</code>.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con un elemento &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con un elemento '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; return dfs(graph, 3);})().length === 1, "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>3</code> should return an array with one element.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>2</code> y <code>3</code> &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>2</code> y <code>3</code> '
     testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 3);})(), [2, 3], "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>3</code> should return an array with <code>2</code> and <code>3</code>.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con dos elementos &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con dos elementos '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 3);})().length === 2, "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>3</code> should return an array with two elements.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con <code>0</code> y <code>1</code> &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con <code>0</code> y <code>1</code> '
     testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 0);})(), [0, 1], "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return an array with <code>0</code> and <code>1</code>.");'
-  - text: &#39;El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con dos elementos &#39;.
+  - text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con dos elementos '
     testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 0);})().length === 2, "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return an array with two elements.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.spanish.md
index 9856a891b1..7fff22cea9 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/perform-a-subset-check-on-two-sets-of-data.spanish.md
@@ -6,13 +6,13 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-En este ejercicio vamos a realizar una prueba de subconjunto en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos <code>Set</code> llamada <code>subset</code> . Esto comparará el primer conjunto, contra el segundo y si el primer conjunto está completamente contenido dentro del Segundo, devolverá verdadero. 
-Por ejemplo, si <code>setA = [&#39;a&#39;,&#39;b&#39;]</code> y <code>setB = [&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;]</code> , entonces el subconjunto de setA y setB es: <code>setA.subset(setB)</code> debe ser <code>true</code> . 
+<section id='description'>
+En este ejercicio vamos a realizar una prueba de subconjunto en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos <code>Set</code> llamada <code>subset</code> . Esto comparará el primer conjunto, contra el segundo y si el primer conjunto está completamente contenido dentro del Segundo, devolverá verdadero.
+Por ejemplo, si <code>setA = [&#39;a&#39;,&#39;b&#39;]</code> y <code>setB = [&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;]</code> , entonces el subconjunto de setA y setB es: <code>setA.subset(setB)</code> debe ser <code>true</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,13 +25,13 @@ tests:
     testString: 'assert(function(){var test = new Set(); return (typeof test.subset === "function")}, "Your <code>Set</code> class should have a <code>union</code> method.");'
   - text: El primer Set () estaba contenido en el segundo Set
     testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setB.add("b"); setB.add("c"); setB.add("a"); setB.add("d"); var subsetSetAB = setA.subset(setB);return (subsetSetAB === true)}, "The first Set() was contained in the second Set");'
-  - text: &#39; <code>[&quot;a&quot;, &quot;b&quot;].subset([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;])</code> debe devolver <code>true</code> &quot;)&#39;
+  - text: ' <code>[&quot;a&quot;, &quot;b&quot;].subset([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;])</code> debe devolver <code>true</code> &quot;)'
     testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setA.add("b"); setB.add("a"); setB.add("b"); setB.add("c"); setB.add("d"); var subsetSetAB = setA.subset(setB); return (subsetSetAB === true)}, "<code>["a", "b"].subset(["a", "b", "c", "d"])</code> should return <code>true</code>");'
-  - text: &#39; <code>[&quot;a&quot;, &quot;b&quot;, &quot;c&quot;].subset([&quot;a&quot;, &quot;b&quot;])</code> debe devolver <code>false</code> &quot;)&#39;
+  - text: ' <code>[&quot;a&quot;, &quot;b&quot;, &quot;c&quot;].subset([&quot;a&quot;, &quot;b&quot;])</code> debe devolver <code>false</code> &quot;)'
     testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setA.add("b"); setA.add("c"); setB.add("a"); setB.add("b"); var subsetSetAB = setA.subset(setB); return (subsetSetAB === false)}, "<code>["a", "b", "c"].subset(["a", "b"])</code> should return <code>false</code>");'
-  - text: &#39; <code>[].subset([])</code> debe devolver <code>true</code> &#39;
+  - text: ' <code>[].subset([])</code> debe devolver <code>true</code> '
     testString: 'assert(function(){var setA = new Set(); var setB = new Set(); var subsetSetAB = setA.subset(setB); return (subsetSetAB === true)}, "<code>[].subset([])</code> should return <code>true</code>");'
-  - text: &#39; <code>[&quot;a&quot;, &quot;b&quot;].subset([&quot;c&quot;, &quot;d&quot;])</code> debe devolver <code>false</code> &quot;)&#39;
+  - text: ' <code>[&quot;a&quot;, &quot;b&quot;].subset([&quot;c&quot;, &quot;d&quot;])</code> debe devolver <code>false</code> &quot;)'
     testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setA.add("b"); setB.add("c"); setB.add("d"); var subsetSetAB = setA.subset(setB); return (subsetSetAB === false)}, "<code>["a", "b"].subset(["c", "d"])</code> should return <code>false</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.spanish.md
index 05e94693c8..43f5ed76fe 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/data-structures/use-.has-and-.size-on-an-es6-set.spanish.md
@@ -6,19 +6,19 @@ challengeType: 1
 ---
 
 ## Description
-<section id='description'> 
-Veamos los métodos .has y .size disponibles en el objeto ES6 Set. 
-Primero, cree un conjunto ES6 
-<code>var set = new Set([1,2,3]);</code> 
-El método .has comprobará si el valor está contenido dentro del conjunto. 
-<code>var hasTwo = set.has(2);</code> 
-El método .size devolverá un número entero que representa el tamaño del Set 
-<code>var howBig = set.size;</code> 
+<section id='description'>
+Veamos los métodos .has y .size disponibles en el objeto ES6 Set.
+Primero, cree un conjunto ES6
+<code>var set = new Set([1,2,3]);</code>
+El método .has comprobará si el valor está contenido dentro del conjunto.
+<code>var hasTwo = set.has(2);</code>
+El método .size devolverá un número entero que representa el tamaño del Set
+<code>var howBig = set.size;</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
-En este ejercicio pasaremos una matriz y un valor a la función checkSet (). Su función debe crear un conjunto ES6 a partir del argumento de la matriz. Encuentra si el conjunto contiene el argumento de valor. Encuentra el tamaño del conjunto. Y devuelve esos dos valores en una matriz. 
+<section id='instructions'>
+En este ejercicio pasaremos una matriz y un valor a la función checkSet (). Su función debe crear un conjunto ES6 a partir del argumento de la matriz. Encuentra si el conjunto contiene el argumento de valor. Encuentra el tamaño del conjunto. Y devuelve esos dos valores en una matriz.
 </section>
 
 ## Tests
@@ -26,7 +26,7 @@ En este ejercicio pasaremos una matriz y un valor a la función checkSet (). Su
 
 ```yml
 tests:
-  - text: &#39; <code>checkSet([4, 5, 6], 3)</code> debe devolver [false, 3]&#39;
+  - text: ' <code>checkSet([4, 5, 6], 3)</code> debe devolver [false, 3]'
     testString: 'assert(function(){var test = checkSet([4,5,6], 3); test === [ false, 3 ]}, "<code>checkSet([4, 5, 6], 3)</code> should return [ false, 3 ]");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-175-fractions-involving-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-175-fractions-involving-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.spanish.md
index f9be2331d3..23c5fb2d49 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-175-fractions-involving-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-175-fractions-involving-the-number-of-different-ways-a-number-can-be-expressed-as-a-sum-of-powers-of-2.spanish.md
@@ -6,21 +6,21 @@ title: 'Problem 175: Fractions involving the number of different ways a number c
 ---
 
 ## Description
-<section id='description'> 
-Defina f (0) = 1 y f (n) como el número de formas de escribir n como una suma de potencias de 2 donde no se produce potencia más de dos veces. 
+<section id='description'>
+Defina f (0) = 1 y f (n) como el número de formas de escribir n como una suma de potencias de 2 donde no se produce potencia más de dos veces.
 
-Por ejemplo, f (10) = 5 ya que hay cinco formas diferentes de expresar 10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1 
+Por ejemplo, f (10) = 5 ya que hay cinco formas diferentes de expresar 10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1
 
-Se puede mostrar que para cada fracción p / q (p&gt; 0, q&gt; 0) existe al menos un entero n tal que f (n) / f (n-1) = p / q. 
-Por ejemplo, la n más pequeña para la cual f (n) / f (n-1) = 13/17 es 241. 
-La expansión binaria de 241 es 11110001. 
-Leyendo este número binario del bit más significativo al menos significativo Bit hay 4 de uno, 3 ceros y 1 de uno. Llamaremos a la cadena 4,3,1 la Expansión Binaria Acortada de 241. 
-Halla la Expansión Binaria Acortada de la n más pequeña para la cual f (n) / f (n-1) = 123456789/987654321. 
-Da tu respuesta como enteros separados por comas, sin espacios en blanco. 
+Se puede mostrar que para cada fracción p / q (p&gt; 0, q&gt; 0) existe al menos un entero n tal que f (n) / f (n-1) = p / q.
+Por ejemplo, la n más pequeña para la cual f (n) / f (n-1) = 13/17 es 241.
+La expansión binaria de 241 es 11110001.
+Leyendo este número binario del bit más significativo al menos significativo Bit hay 4 de uno, 3 ceros y 1 de uno. Llamaremos a la cadena 4,3,1 la Expansión Binaria Acortada de 241.
+Halla la Expansión Binaria Acortada de la n más pequeña para la cual f (n) / f (n-1) = 123456789/987654321.
+Da tu respuesta como enteros separados por comas, sin espacios en blanco.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -29,7 +29,7 @@ Da tu respuesta como enteros separados por comas, sin espacios en blanco.
 
 ```yml
 tests:
-  - text: &#39; <code>euler175()</code> debe devolver 1, 13717420, 8.&#39;
+  - text: ' <code>euler175()</code> debe devolver 1, 13717420, 8.'
     testString: 'assert.strictEqual(euler175(), 1, 13717420, 8, "<code>euler175()</code> should return 1, 13717420, 8.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-19-counting-sundays.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-19-counting-sundays.spanish.md
index d1cd854c60..93edb04de2 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-19-counting-sundays.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-19-counting-sundays.spanish.md
@@ -6,14 +6,14 @@ title: 'Problem 19: Counting Sundays'
 ---
 
 ## Description
-<section id='description'> 
-Se le proporciona la siguiente información, pero es posible que prefiera hacer una investigación por sí mismo. 
-<ul><li> El 1 de enero de 1900 fue un lunes. </li><li> Treinta días tiene septiembre, <br> Abril, junio y noviembre. <br> Todos los demás tienen treinta y uno, <br> Salvando febrero solo, <br> Que tiene veintiocho, llueva o truene. <br> Y en años bisiestos, veintinueve. </li><li> Un año bisiesto ocurre en cualquier año divisible por 4, pero no en un siglo a menos que sea divisible por 400. </li> 
-¿Cuántos domingos cayeron el primer día del mes durante el siglo veinte (1 de enero de 1901 a 31 de diciembre de 2000)? 
+<section id='description'>
+Se le proporciona la siguiente información, pero es posible que prefiera hacer una investigación por sí mismo.
+<ul><li> El 1 de enero de 1900 fue un lunes. </li><li> Treinta días tiene septiembre, <br> Abril, junio y noviembre. <br> Todos los demás tienen treinta y uno, <br> Salvando febrero solo, <br> Que tiene veintiocho, llueva o truene. <br> Y en años bisiestos, veintinueve. </li><li> Un año bisiesto ocurre en cualquier año divisible por 4, pero no en un siglo a menos que sea divisible por 400. </li>
+¿Cuántos domingos cayeron el primer día del mes durante el siglo veinte (1 de enero de 1901 a 31 de diciembre de 2000)?
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,11 +22,11 @@ Se le proporciona la siguiente información, pero es posible que prefiera hacer
 
 ```yml
 tests:
-  - text: &#39; <code>countingSundays(1943, 1946)</code> debe devolver 6.&#39;
+  - text: ' <code>countingSundays(1943, 1946)</code> debe devolver 6.'
     testString: 'assert.strictEqual(countingSundays(1943, 1946), 6, "<code>countingSundays(1943, 1946)</code> should return 6.");'
-  - text: &#39; <code>countingSundays(1995, 2000)</code> debe devolver 9.&#39;
+  - text: ' <code>countingSundays(1995, 2000)</code> debe devolver 9.'
     testString: 'assert.strictEqual(countingSundays(1995, 2000), 9, "<code>countingSundays(1995, 2000)</code> should return 9.");'
-  - text: &#39; <code>countingSundays(1901, 2000)</code> debe devolver 171.&#39;
+  - text: ' <code>countingSundays(1901, 2000)</code> debe devolver 171.'
     testString: 'assert.strictEqual(countingSundays(1901, 2000), 171, "<code>countingSundays(1901, 2000)</code> should return 171.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-220-heighway-dragon.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-220-heighway-dragon.spanish.md
index a4fd906558..2cb7c62a40 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-220-heighway-dragon.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-220-heighway-dragon.spanish.md
@@ -6,27 +6,27 @@ title: 'Problem 220: Heighway Dragon'
 ---
 
 ## Description
-<section id='description'> 
-Sea D0 la cadena de dos letras &quot;Fa&quot;. Para n≥1, derive Dn de Dn-1 mediante las reglas de reescritura de cadenas: 
+<section id='description'>
+Sea D0 la cadena de dos letras &quot;Fa&quot;. Para n≥1, derive Dn de Dn-1 mediante las reglas de reescritura de cadenas:
 
-&quot;a&quot; → &quot;aRbFR&quot; 
-&quot;b&quot; → &quot;LFaLb&quot; 
+&quot;a&quot; → &quot;aRbFR&quot;
+&quot;b&quot; → &quot;LFaLb&quot;
 
-Por lo tanto, D0 = &quot;Fa&quot;, D1 = &quot;FaRbFR&quot; , D2 = &quot;FaRbFRRLFaLbFR&quot;, y así sucesivamente. 
+Por lo tanto, D0 = &quot;Fa&quot;, D1 = &quot;FaRbFR&quot; , D2 = &quot;FaRbFRRLFaLbFR&quot;, y así sucesivamente.
 
-Estas cadenas pueden interpretarse como instrucciones para un programa de gráficos de computadora, con &quot;F&quot; que significa &quot;dibujar una unidad&quot;, &quot;L&quot; que significa &quot;girar a la izquierda 90 grados&quot;, &quot;R&quot; que significa &quot;girar a la derecha 90 grados&quot;, y &quot;a&quot; y &quot;b&quot; se ignoran. La posición inicial del cursor de la computadora es (0,0), apuntando hacia arriba (0,1). 
+Estas cadenas pueden interpretarse como instrucciones para un programa de gráficos de computadora, con &quot;F&quot; que significa &quot;dibujar una unidad&quot;, &quot;L&quot; que significa &quot;girar a la izquierda 90 grados&quot;, &quot;R&quot; que significa &quot;girar a la derecha 90 grados&quot;, y &quot;a&quot; y &quot;b&quot; se ignoran. La posición inicial del cursor de la computadora es (0,0), apuntando hacia arriba (0,1).
 
-Entonces Dn es un dibujo exótico conocido como el Dragón Heighway de orden n. Por ejemplo, D10 se muestra a continuación; contando cada &quot;F&quot; como un paso, el punto resaltado en (18,16) es la posición alcanzada después de 500 pasos. 
+Entonces Dn es un dibujo exótico conocido como el Dragón Heighway de orden n. Por ejemplo, D10 se muestra a continuación; contando cada &quot;F&quot; como un paso, el punto resaltado en (18,16) es la posición alcanzada después de 500 pasos.
 
 
 
 
-¿Cuál es la posición del cursor después de 1012 pasos en D50? 
-Da tu respuesta en la forma x, y sin espacios. 
+¿Cuál es la posición del cursor después de 1012 pasos en D50?
+Da tu respuesta en la forma x, y sin espacios.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -35,7 +35,7 @@ Da tu respuesta en la forma x, y sin espacios.
 
 ```yml
 tests:
-  - text: &#39; <code>euler220()</code> debe devolver 139776, 963904.&#39;
+  - text: ' <code>euler220()</code> debe devolver 139776, 963904.'
     testString: 'assert.strictEqual(euler220(), 139776, 963904, "<code>euler220()</code> should return 139776, 963904.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-34-digit-factorials.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-34-digit-factorials.spanish.md
index 6577fba12b..7ece82a54d 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-34-digit-factorials.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-34-digit-factorials.spanish.md
@@ -6,14 +6,14 @@ title: 'Problem 34: Digit factorials'
 ---
 
 ## Description
-<section id='description'> 
-145 es un número curioso, como 1! + 4! + 5! = 1 + 24 + 120 = 145. 
-Encuentra los números y la suma de los números que son iguales a la suma del factorial de sus dígitos. 
-Nota: como 1! = 1 y 2! = 2 no son sumas que no están incluidas. 
+<section id='description'>
+145 es un número curioso, como 1! + 4! + 5! = 1 + 24 + 120 = 145.
+Encuentra los números y la suma de los números que son iguales a la suma del factorial de sus dígitos.
+Nota: como 1! = 1 y 2! = 2 no son sumas que no están incluidas.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,7 +22,7 @@ Nota: como 1! = 1 y 2! = 2 no son sumas que no están incluidas.
 
 ```yml
 tests:
-  - text: &#39; <code>digitFactorial()</code> debe devolver {suma: 40730, números: [145, 40585]}.&#39;
+  - text: ' <code>digitFactorial()</code> debe devolver {suma: 40730, números: [145, 40585]}.'
     testString: 'assert.deepEqual(digitFactorial(), { sum: 40730, numbers: [145, 40585] }, "<code>digitFactorial()</code> should return { sum: 40730, numbers: [145, 40585] }.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-399-squarefree-fibonacci-numbers.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-399-squarefree-fibonacci-numbers.spanish.md
index 67bbdecd63..5e10bc7acd 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-399-squarefree-fibonacci-numbers.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-399-squarefree-fibonacci-numbers.spanish.md
@@ -6,33 +6,33 @@ title: 'Problem 399: Squarefree Fibonacci Numbers'
 ---
 
 ## Description
-<section id='description'> 
-Los primeros 15 números de fibonacci son: 
-1,1,2,3,5,8,13,21,34,55,89,144,233,377,610. 
-Se puede ver que 8 y 144 no son cuadrados libres: 8 es divisible por 4 y 144 es divisible por 4 y por 9. 
-Así que los primeros 13 números de fibonacci cuadrados libres son: 
-1,1,2,3,5,13 , 21,34,55,89,233,377 y 610. 
+<section id='description'>
+Los primeros 15 números de fibonacci son:
+1,1,2,3,5,8,13,21,34,55,89,144,233,377,610.
+Se puede ver que 8 y 144 no son cuadrados libres: 8 es divisible por 4 y 144 es divisible por 4 y por 9.
+Así que los primeros 13 números de fibonacci cuadrados libres son:
+1,1,2,3,5,13 , 21,34,55,89,233,377 y 610.
 
 
-El número de fibonacci número 200 número cuadrado es: 
-971183874599339129547649988289594072811608739584170445. 
-Los últimos dieciséis dígitos de este número son: 1608739584170445 y en Scientific Number este número puede ser comprado. 
+El número de fibonacci número 200 número cuadrado es:
+971183874599339129547649988289594072811608739584170445.
+Los últimos dieciséis dígitos de este número son: 1608739584170445 y en Scientific Number este número puede ser comprado.
 
 
-Encuentre el número de 000 000 000 de fibonacci sin cuadrados. 
-Indique en su respuesta los últimos dieciséis dígitos seguidos de una coma seguida del número en notación científica (redondeado a un dígito después del punto decimal). 
-Para el número 200 de squarefree, la respuesta habría sido: 1608739584170445,9.7e53 
+Encuentre el número de 000 000 000 de fibonacci sin cuadrados.
+Indique en su respuesta los últimos dieciséis dígitos seguidos de una coma seguida del número en notación científica (redondeado a un dígito después del punto decimal).
+Para el número 200 de squarefree, la respuesta habría sido: 1608739584170445,9.7e53
 
 
 
-Nota: 
-Para este problema, suponga que para cada primo p, el primer número de fibonacci divisible por p no es divisible por p2 (esto es parte de la conjetura de Wall). Esto se ha verificado para números primos ≤ 3 · 1015, pero no se ha probado en general. 
+Nota:
+Para este problema, suponga que para cada primo p, el primer número de fibonacci divisible por p no es divisible por p2 (esto es parte de la conjetura de Wall). Esto se ha verificado para números primos ≤ 3 · 1015, pero no se ha probado en general.
 
-Si sucede que la conjetura es falsa, no se garantiza que la respuesta aceptada a este problema sea el número de 100 000 000 de fibonacci sin cuadrar cuadrado, sino que representa solo un límite inferior para ese número. 
+Si sucede que la conjetura es falsa, no se garantiza que la respuesta aceptada a este problema sea el número de 100 000 000 de fibonacci sin cuadrar cuadrado, sino que representa solo un límite inferior para ese número.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -41,7 +41,7 @@ Si sucede que la conjetura es falsa, no se garantiza que la respuesta aceptada a
 
 ```yml
 tests:
-  - text: &#39; <code>euler399()</code> debe devolver 1508395636674243, 6.5e27330467.&#39;
+  - text: ' <code>euler399()</code> debe devolver 1508395636674243, 6.5e27330467.'
     testString: 'assert.strictEqual(euler399(), 1508395636674243, 6.5e27330467, "<code>euler399()</code> should return 1508395636674243, 6.5e27330467.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-419-look-and-say-sequence.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-419-look-and-say-sequence.spanish.md
index 375606271a..5449fd22df 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-419-look-and-say-sequence.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-419-look-and-say-sequence.spanish.md
@@ -6,29 +6,29 @@ title: 'Problem 419: Look and say sequence'
 ---
 
 ## Description
-<section id='description'> 
-La secuencia de buscar y decir va 1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, ... 
-La secuencia comienza con 1 y todos los demás miembros se obtienen describiendo el miembro anterior en términos de dígitos consecutivos. 
-Ayuda hacer esto en voz alta: 
-1 es &#39;uno uno&#39; → 11 
-11 es &#39;dos ​​unos&#39; → 21 
-21 es &#39;uno dos y uno uno&#39; → 1211 
-1211 es &#39;uno uno, uno dos y dos ones &#39;→ 111221 
-111221 es&#39; tres one, two twos and one &#39;→ 312211 
-... 
+<section id='description'>
+La secuencia de buscar y decir va 1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, ...
+La secuencia comienza con 1 y todos los demás miembros se obtienen describiendo el miembro anterior en términos de dígitos consecutivos.
+Ayuda hacer esto en voz alta:
+1 es &#39;uno uno&#39; → 11
+11 es &#39;dos ​​unos&#39; → 21
+21 es &#39;uno dos y uno uno&#39; → 1211
+1211 es &#39;uno uno, uno dos y dos ones &#39;→ 111221
+111221 es&#39; tres one, two twos and one &#39;→ 312211
+...
 
 
-Defina A (n), B (n) y C (n) como el número de unidades, twos y threes en el elemento n &#39;n de la secuencia respectivamente. 
-Se puede verificar que A (40) = 31254, B (40) = 20259 y C (40) = 11625. 
+Defina A (n), B (n) y C (n) como el número de unidades, twos y threes en el elemento n &#39;n de la secuencia respectivamente.
+Se puede verificar que A (40) = 31254, B (40) = 20259 y C (40) = 11625.
 
 
-Encuentre A (n), B (n) y C (n) para n = 1012. 
-Da tu respuesta módulo 230 y separa tus valores para A, B y C con una coma. 
-Ej. Para n = 40 la respuesta sería 31254,20259,11625 
+Encuentre A (n), B (n) y C (n) para n = 1012.
+Da tu respuesta módulo 230 y separa tus valores para A, B y C con una coma.
+Ej. Para n = 40 la respuesta sería 31254,20259,11625
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -37,7 +37,7 @@ Ej. Para n = 40 la respuesta sería 31254,20259,11625
 
 ```yml
 tests:
-  - text: &#39; <code>euler419()</code> debe devolver 998567458, 1046245404, 43363922.&#39;
+  - text: ' <code>euler419()</code> debe devolver 998567458, 1046245404, 43363922.'
     testString: 'assert.strictEqual(euler419(), 998567458, 1046245404, 43363922, "<code>euler419()</code> should return 998567458, 1046245404, 43363922.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.spanish.md
index b7ae5f4e6f..ab8466202e 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-43-sub-string-divisibility.spanish.md
@@ -6,21 +6,21 @@ title: 'Problem 43: Sub-string divisibility'
 ---
 
 ## Description
-<section id='description'> 
-El número, 1406357289, es un número pandigital de 0 a 9 porque está formado por cada uno de los dígitos 0 a 9 en algún orden, pero también tiene una propiedad de divisibilidad de sub-cadena bastante interesante. 
-Sea d1 el primer dígito, d2 el segundo dígito, etc. De esta manera, notamos lo siguiente: 
-d2d3d4 = 406 es divisible por 2 
-d3d4d5 = 063 es divisible por 3 
-d4d5d6 = 635 es divisible por 5 
-d5d6d7 = 357 es divisible por 7 
-d6d7d8 = 572 es divisible por 11 
-d7d8d9 = 728 es divisible por 13 
-d8d9d10 = 289 es divisible por 17 
-Encuentra los números de todos los 0 a 9 números pandigitales con esta propiedad. 
+<section id='description'>
+El número, 1406357289, es un número pandigital de 0 a 9 porque está formado por cada uno de los dígitos 0 a 9 en algún orden, pero también tiene una propiedad de divisibilidad de sub-cadena bastante interesante.
+Sea d1 el primer dígito, d2 el segundo dígito, etc. De esta manera, notamos lo siguiente:
+d2d3d4 = 406 es divisible por 2
+d3d4d5 = 063 es divisible por 3
+d4d5d6 = 635 es divisible por 5
+d5d6d7 = 357 es divisible por 7
+d6d7d8 = 572 es divisible por 11
+d7d8d9 = 728 es divisible por 13
+d8d9d10 = 289 es divisible por 17
+Encuentra los números de todos los 0 a 9 números pandigitales con esta propiedad.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -29,7 +29,7 @@ Encuentra los números de todos los 0 a 9 números pandigitales con esta propied
 
 ```yml
 tests:
-  - text: &#39; <code>substringDivisibility()</code> debe devolver [1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289].&#39;
+  - text: ' <code>substringDivisibility()</code> debe devolver [1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289].'
     testString: 'assert.deepEqual(substringDivisibility(), [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ], "<code>substringDivisibility()</code> should return [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ].");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.spanish.md
index 4d4bec4855..3dced11eec 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-47-distinct-primes-factors.spanish.md
@@ -6,19 +6,19 @@ title: 'Problem 47: Distinct primes factors'
 ---
 
 ## Description
-<section id='description'> 
-Los dos primeros números consecutivos que tienen dos factores primos distintos son: 
-<div style='padding-left: 4em;'> 14 = 2 × 7 </div> 
-<div style='padding-left: 4em;'> 15 = 3 × 5 </div> 
-Los primeros tres números consecutivos que tienen tres factores primos distintos son: 
-<div style='padding-left: 4em;'> 644 = 2² × 7 × 23 </div> 
-<div style='padding-left: 4em;'> 645 = 3 × 5 × 43 </div> 
-<div style='padding-left: 4em;'> 646 = 2 × 17 × 19 </div> 
-Encuentre los primeros cuatro enteros consecutivos que tengan cuatro factores primos distintos cada uno. ¿Cuál es el primero de estos números? 
+<section id='description'>
+Los dos primeros números consecutivos que tienen dos factores primos distintos son:
+<div style='padding-left: 4em;'> 14 = 2 × 7 </div>
+<div style='padding-left: 4em;'> 15 = 3 × 5 </div>
+Los primeros tres números consecutivos que tienen tres factores primos distintos son:
+<div style='padding-left: 4em;'> 644 = 2² × 7 × 23 </div>
+<div style='padding-left: 4em;'> 645 = 3 × 5 × 43 </div>
+<div style='padding-left: 4em;'> 646 = 2 × 17 × 19 </div>
+Encuentre los primeros cuatro enteros consecutivos que tengan cuatro factores primos distintos cada uno. ¿Cuál es el primero de estos números?
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,11 +27,11 @@ Encuentre los primeros cuatro enteros consecutivos que tengan cuatro factores pr
 
 ```yml
 tests:
-  - text: &#39; <code>distinctPrimeFactors(2, 2)</code> debe devolver 14.&#39;
+  - text: ' <code>distinctPrimeFactors(2, 2)</code> debe devolver 14.'
     testString: 'assert.strictEqual(distinctPrimeFactors(2, 2), 14, "<code>distinctPrimeFactors(2, 2)</code> should return 14.");'
-  - text: &#39; <code>distinctPrimeFactors(3, 3)</code> debe devolver 644.&#39;
+  - text: ' <code>distinctPrimeFactors(3, 3)</code> debe devolver 644.'
     testString: 'assert.strictEqual(distinctPrimeFactors(3, 3), 644, "<code>distinctPrimeFactors(3, 3)</code> should return 644.");'
-  - text: &#39; <code>distinctPrimeFactors(4, 4)</code> debe devolver 134043.&#39;
+  - text: ' <code>distinctPrimeFactors(4, 4)</code> debe devolver 134043.'
     testString: 'assert.strictEqual(distinctPrimeFactors(4, 4), 134043, "<code>distinctPrimeFactors(4, 4)</code> should return 134043.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-48-self-powers.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-48-self-powers.spanish.md
index a66a450891..ee256e7243 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-48-self-powers.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-48-self-powers.spanish.md
@@ -6,13 +6,13 @@ title: 'Problem 48: Self powers'
 ---
 
 ## Description
-<section id='description'> 
-La serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 10 <sup>10</sup> = 10405071317. 
-Encuentre los últimos diez dígitos de la serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 1000 <sup>1000</sup> . 
+<section id='description'>
+La serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 10 <sup>10</sup> = 10405071317.
+Encuentre los últimos diez dígitos de la serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 1000 <sup>1000</sup> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -21,13 +21,13 @@ Encuentre los últimos diez dígitos de la serie, 1 <sup>1</sup> + 2 <sup>2</sup
 
 ```yml
 tests:
-  - text: &#39; <code>selfPowers(10, 3)</code> debe devolver 317.&#39;
+  - text: ' <code>selfPowers(10, 3)</code> debe devolver 317.'
     testString: 'assert.strictEqual(selfPowers(10, 3), 317, "<code>selfPowers(10, 3)</code> should return 317.");'
-  - text: &#39; <code>selfPowers(150, 6)</code> debe devolver 29045.&#39;
+  - text: ' <code>selfPowers(150, 6)</code> debe devolver 29045.'
     testString: 'assert.strictEqual(selfPowers(150, 6), 29045, "<code>selfPowers(150, 6)</code> should return 29045.");'
-  - text: &#39; <code>selfPowers(673, 7)</code> debe devolver 2473989.&#39;
+  - text: ' <code>selfPowers(673, 7)</code> debe devolver 2473989.'
     testString: 'assert.strictEqual(selfPowers(673, 7), 2473989, "<code>selfPowers(673, 7)</code> should return 2473989.");'
-  - text: &#39; <code>selfPowers(1000, 10)</code> debe devolver 9110846700.&#39;
+  - text: ' <code>selfPowers(1000, 10)</code> debe devolver 9110846700.'
     testString: 'assert.strictEqual(selfPowers(1000, 10), 9110846700, "<code>selfPowers(1000, 10)</code> should return 9110846700.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.spanish.md
index a85130c897..ab44ee3d52 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.spanish.md
@@ -6,20 +6,20 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Estos definen tres clasificaciones de enteros positivos basados ​​en sus <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> . </p> 
-<p> Sea $ P (n) $ la suma de los divisores apropiados de n, donde los divisores apropiados son todos enteros positivos n distintos de n en sí. </p> 
-<p> Si <code>P(n) &lt; n</code> entonces n se clasifica como &quot;deficiente&quot; </p> 
-<p> Si <code>P(n) === n</code> , n se clasifica como &quot;perfecto&quot; </p> 
-<p> Si <code>P(n) &gt; n</code> entonces n se clasifica como &quot;abundante&quot; </p> 
-<p> Ejemplo: </p> 
-<p> 6 tiene divisores propios de 1, 2 y 3. </p> 
-<p> 1 + 2 + 3 = 6, entonces 6 se clasifica como un número perfecto. </p> 
-<p> Implemente una función que calcula cuántos de los enteros de 1 a 20,000 (inclusive) están en cada una de las tres clases. Muestra el resultado como una matriz en el siguiente formato <code>[deficient, perfect, abundant]</code> . </p> 
+<section id='description'>
+<p> Estos definen tres clasificaciones de enteros positivos basados ​​en sus <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> . </p>
+<p> Sea $ P (n) $ la suma de los divisores apropiados de n, donde los divisores apropiados son todos enteros positivos n distintos de n en sí. </p>
+<p> Si <code>P(n) &lt; n</code> entonces n se clasifica como &quot;deficiente&quot; </p>
+<p> Si <code>P(n) === n</code> , n se clasifica como &quot;perfecto&quot; </p>
+<p> Si <code>P(n) &gt; n</code> entonces n se clasifica como &quot;abundante&quot; </p>
+<p> Ejemplo: </p>
+<p> 6 tiene divisores propios de 1, 2 y 3. </p>
+<p> 1 + 2 + 3 = 6, entonces 6 se clasifica como un número perfecto. </p>
+<p> Implemente una función que calcula cuántos de los enteros de 1 a 20,000 (inclusive) están en cada una de las tres clases. Muestra el resultado como una matriz en el siguiente formato <code>[deficient, perfect, abundant]</code> . </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -34,7 +34,7 @@ tests:
     testString: 'assert(Array.isArray(getDPA(100)), "<code>getDPA</code> should return an array.");'
   - text: <code>getDPA</code> valor de retorno de <code>getDPA</code> debe tener una longitud de 3.
     testString: 'assert(getDPA(100).length === 3, "<code>getDPA</code> return value should have a length of 3.");'
-  - text: &#39; <code>getDPA(20000)</code> debe ser igual a [15043, 4, 4953]&#39;
+  - text: ' <code>getDPA(20000)</code> debe ser igual a [15043, 4, 4953]'
     testString: 'assert.deepEqual(getDPA(20000), solution, "<code>getDPA(20000)</code> should equal [15043, 4, 4953]");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/accumulator-factory.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/accumulator-factory.spanish.md
index 9fdd3dc4fa..3a5980282a 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/accumulator-factory.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/accumulator-factory.spanish.md
@@ -6,16 +6,16 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Cree una función que tome un solo argumento (numérico) y devuelva otra función que sea un acumulador. La función del acumulador devuelto a su vez también toma un solo argumento numérico y devuelve la suma de todos los valores numéricos pasados ​​hasta ese acumulador (incluido el valor inicial pasado cuando se creó el acumulador). </p> 
-<p> Reglas: </p> 
-<p> No utilice variables globales. </p> 
-<p> Insinuación: </p> 
-<p> Los cierres salvan el estado exterior. </p> 
+<section id='description'>
+<p> Cree una función que tome un solo argumento (numérico) y devuelva otra función que sea un acumulador. La función del acumulador devuelto a su vez también toma un solo argumento numérico y devuelve la suma de todos los valores numéricos pasados ​​hasta ese acumulador (incluido el valor inicial pasado cuando se creó el acumulador). </p>
+<p> Reglas: </p>
+<p> No utilice variables globales. </p>
+<p> Insinuación: </p>
+<p> Los cierres salvan el estado exterior. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,7 +30,7 @@ tests:
     testString: 'assert(typeof accumulator(0) === "function", "<code>accumulator(0)</code> should return a function.");'
   - text: <code>accumulator(0)(2)</code> debe devolver un número.
     testString: 'assert(typeof accumulator(0)(2) === "number", "<code>accumulator(0)(2)</code> should return a number.");'
-  - text: &#39;Pasar los valores 3, -4, 1.5 y 5 debería devolver 5.5.&#39;
+  - text: 'Pasar los valores 3, -4, 1.5 y 5 debería devolver 5.5.'
     testString: 'assert(testFn(5) === 5.5, "Passing in the values 3, -4, 1.5, and 5 should return 5.5.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ackermann-function.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ackermann-function.spanish.md
index 3585646dc7..cdda2f34ee 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ackermann-function.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ackermann-function.spanish.md
@@ -6,20 +6,20 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> La función de Ackermann es un ejemplo clásico de una función recursiva, especialmente porque no es una función recursiva primitiva. Crece muy rápidamente en valor, al igual que el tamaño de su árbol de llamadas. </p> 
-<p> La función de Ackermann se define generalmente de la siguiente manera: </p> 
-$ A (m, n) = 
-\ begin {cases} 
-n + 1 &amp; \ mbox {if} m = 0 \\ 
-A (m-1, 1) &amp; \ mbox {if} m&gt; 0 \ mbox {y} n = 0 \\ 
-A (m-1, A (m, n-1)) &amp; \ mbox {if} m&gt; 0 \ mbox {y} n&gt; 0. 
-\ end {cases} $ $ 
-<p> Sus argumentos nunca son negativos y siempre termina. Escriba una función que devuelva el valor de $ A (m, n) $. Se prefiere la precisión arbitraria (ya que la función crece tan rápidamente), pero no es obligatoria. </p> 
+<section id='description'>
+<p> La función de Ackermann es un ejemplo clásico de una función recursiva, especialmente porque no es una función recursiva primitiva. Crece muy rápidamente en valor, al igual que el tamaño de su árbol de llamadas. </p>
+<p> La función de Ackermann se define generalmente de la siguiente manera: </p>
+$ A (m, n) =
+\ begin {cases}
+n + 1 &amp; \ mbox {if} m = 0 \\
+A (m-1, 1) &amp; \ mbox {if} m&gt; 0 \ mbox {y} n = 0 \\
+A (m-1, A (m, n-1)) &amp; \ mbox {if} m&gt; 0 \ mbox {y} n&gt; 0.
+\ end {cases} $ $
+<p> Sus argumentos nunca son negativos y siempre termina. Escriba una función que devuelva el valor de $ A (m, n) $. Se prefiere la precisión arbitraria (ya que la función crece tan rápidamente), pero no es obligatoria. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,13 +30,13 @@ A (m-1, A (m, n-1)) &amp; \ mbox {if} m&gt; 0 \ mbox {y} n&gt; 0.
 tests:
   - text: <code>ack</code> es una función.
     testString: 'assert(typeof ack === "function", "<code>ack</code> is a function.");'
-  - text: &#39; <code>ack(0, 0)</code> debe devolver 1.&#39;
+  - text: ' <code>ack(0, 0)</code> debe devolver 1.'
     testString: 'assert(ack(0, 0) === 1, "<code>ack(0, 0)</code> should return 1.");'
-  - text: &#39; <code>ack(1, 1)</code> debe devolver 3.&#39;
+  - text: ' <code>ack(1, 1)</code> debe devolver 3.'
     testString: 'assert(ack(1, 1) === 3, "<code>ack(1, 1)</code> should return 3.");'
-  - text: &#39; <code>ack(2, 5)</code> debe devolver 13.&#39;
+  - text: ' <code>ack(2, 5)</code> debe devolver 13.'
     testString: 'assert(ack(2, 5) === 13, "<code>ack(2, 5)</code> should return 13.");'
-  - text: &#39; <code>ack(3, 3)</code> debe devolver 61.&#39;
+  - text: ' <code>ack(3, 3)</code> debe devolver 61.'
     testString: 'assert(ack(3, 3) === 61, "<code>ack(3, 3)</code> should return 61.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/align-columns.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/align-columns.spanish.md
index 0157755acd..bb727953f3 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/align-columns.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/align-columns.spanish.md
@@ -6,32 +6,32 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Dado un archivo de texto de muchas líneas, donde los campos dentro de una línea están delineados por un solo carácter de <code>$</code> , escriba un programa que alinee cada columna de campos asegurándose de que las palabras en cada columna estén separadas por al menos un espacio. Además, permita que cada palabra en una columna se justifique a la izquierda, a la derecha o al centro dentro de su columna. </p> 
-<p> Usa el siguiente texto para probar tus programas: </p> 
-<pre> 
-Dado $ a $ texto $ archivo $ de $ muchas $ líneas 
-donde $ campos $ dentro de $ a $ línea $ 
-son $ delineados $ por $ a $ simple $ &#39;dólar&#39; $ carácter 
-escribe $ a $ programa 
-ese $ alinea $ cada $ columna $ de $ campos 
-por $ asegurando $ que $ palabras $ en $ cada $ 
-columna $ están $ separados $ por $ en $ al menos $ un $ espacio. 
-Además, $ permita $ por $ cada $ palabra $ en $ a $ columna $ a $ sea $ o bien $ dejó $ 
-justificado, $ derecho $ justificó 
-o $ centro $ justificado dentro de $ su $ columna. 
-</pre> 
-<p> Tenga en cuenta que: </p> 
-Las líneas de texto de entrada de ejemplo pueden, o no, tener caracteres de dólar al final. 
-Todas las columnas deben compartir la misma alineación. 
-Los caracteres de espacio consecutivo producidos adyacentes al final de las líneas son insignificantes para los propósitos de la tarea. 
-El texto de salida se verá en una fuente mono-espaciada en un editor de texto plano o terminal básico. 
-El espacio mínimo entre columnas debe calcularse a partir del texto y no estar codificado. 
-No es un requisito agregar caracteres de separación entre o alrededor de las columnas. 
+<section id='description'>
+<p> Dado un archivo de texto de muchas líneas, donde los campos dentro de una línea están delineados por un solo carácter de <code>$</code> , escriba un programa que alinee cada columna de campos asegurándose de que las palabras en cada columna estén separadas por al menos un espacio. Además, permita que cada palabra en una columna se justifique a la izquierda, a la derecha o al centro dentro de su columna. </p>
+<p> Usa el siguiente texto para probar tus programas: </p>
+<pre>
+Dado $ a $ texto $ archivo $ de $ muchas $ líneas
+donde $ campos $ dentro de $ a $ línea $
+son $ delineados $ por $ a $ simple $ &#39;dólar&#39; $ carácter
+escribe $ a $ programa
+ese $ alinea $ cada $ columna $ de $ campos
+por $ asegurando $ que $ palabras $ en $ cada $
+columna $ están $ separados $ por $ en $ al menos $ un $ espacio.
+Además, $ permita $ por $ cada $ palabra $ en $ a $ columna $ a $ sea $ o bien $ dejó $
+justificado, $ derecho $ justificó
+o $ centro $ justificado dentro de $ su $ columna.
+</pre>
+<p> Tenga en cuenta que: </p>
+Las líneas de texto de entrada de ejemplo pueden, o no, tener caracteres de dólar al final.
+Todas las columnas deben compartir la misma alineación.
+Los caracteres de espacio consecutivo producidos adyacentes al final de las líneas son insignificantes para los propósitos de la tarea.
+El texto de salida se verá en una fuente mono-espaciada en un editor de texto plano o terminal básico.
+El espacio mínimo entre columnas debe calcularse a partir del texto y no estar codificado.
+No es un requisito agregar caracteres de separación entre o alrededor de las columnas.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -42,11 +42,11 @@ No es un requisito agregar caracteres de separación entre o alrededor de las co
 tests:
   - text: <code>formatText</code> es una función.
     testString: 'assert(typeof formatText === "function", "<code>formatText</code> is a function.");'
-  - text: &#39; <code>formatText</code> con la entrada anterior y la justificación &quot;correcta&quot; debe producir lo siguiente:&#39;
+  - text: ' <code>formatText</code> con la entrada anterior y la justificación &quot;correcta&quot; debe producir lo siguiente:'
     testString: 'assert.strictEqual(formatText(testInput, "right"), rightAligned, "<code>formatText</code> with the above input and "right" justification should produce the following: ");'
-  - text: &#39; <code>formatText</code> con la entrada anterior y la justificación &quot;izquierda&quot; debe producir lo siguiente:&#39;
+  - text: ' <code>formatText</code> con la entrada anterior y la justificación &quot;izquierda&quot; debe producir lo siguiente:'
     testString: 'assert.strictEqual(formatText(testInput, "left"), leftAligned, "<code>formatText</code> with the above input and "left" justification should produce the following: ");'
-  - text: &#39; <code>formatText</code> con la entrada anterior y la justificación &quot;central&quot; debe producir lo siguiente:&#39;
+  - text: ' <code>formatText</code> con la entrada anterior y la justificación &quot;central&quot; debe producir lo siguiente:'
     testString: 'assert.strictEqual(formatText(testInput, "center"), centerAligned, "<code>formatText</code> with the above input and "center" justification should produce the following: ");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/amicable-pairs.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/amicable-pairs.spanish.md
index f4428d4588..88ac22ab83 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/amicable-pairs.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/amicable-pairs.spanish.md
@@ -6,22 +6,22 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Se dice que dos enteros $ N $ y $ M $ son <a href="https://en.wikipedia.org/wiki/Amicable numbers" title="wp: números amistosos">pares amigables</a> si $ N \ neq M $ y la suma de los <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> de $ N $ ($ \ mathrm {suma} (\ mathrm {propDivs} (N) ) $) $ = M $ así como $ \ mathrm {suma} (\ mathrm {propDivs} (M)) = N $. 
-Ejemplo: 
-1184 y 1210 son un par amigable, con divisores apropiados: 
-1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 y 
-1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605 respectivamente. 
-Tarea: 
-Calcula y muestra aquí los pares de amigos por debajo de 20,000 (hay ocho). 
-Tareas relacionadas 
-<a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">Divisores apropiados</a> 
-<a href="http://rosettacode.org/wiki/Abundant, deficient and perfect number classifications" title="Numerosas, deficientes y perfectas clasificaciones numéricas.">Clasificaciones numéricas abundantes, deficientes y perfectas</a> 
-<a href="http://rosettacode.org/wiki/Aliquot sequence classifications" title="Clasificaciones de secuencias alícuotas">Clasificaciones de secuencias de alícuotas</a> y su clasificación amistosa. 
+<section id='description'>
+Se dice que dos enteros $ N $ y $ M $ son <a href="https://en.wikipedia.org/wiki/Amicable numbers" title="wp: números amistosos">pares amigables</a> si $ N \ neq M $ y la suma de los <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> de $ N $ ($ \ mathrm {suma} (\ mathrm {propDivs} (N) ) $) $ = M $ así como $ \ mathrm {suma} (\ mathrm {propDivs} (M)) = N $.
+Ejemplo:
+1184 y 1210 son un par amigable, con divisores apropiados:
+1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 y
+1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605 respectivamente.
+Tarea:
+Calcula y muestra aquí los pares de amigos por debajo de 20,000 (hay ocho).
+Tareas relacionadas
+<a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">Divisores apropiados</a>
+<a href="http://rosettacode.org/wiki/Abundant, deficient and perfect number classifications" title="Numerosas, deficientes y perfectas clasificaciones numéricas.">Clasificaciones numéricas abundantes, deficientes y perfectas</a>
+<a href="http://rosettacode.org/wiki/Aliquot sequence classifications" title="Clasificaciones de secuencias alícuotas">Clasificaciones de secuencias de alícuotas</a> y su clasificación amistosa.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -32,11 +32,11 @@ Tareas relacionadas
 tests:
   - text: <code>amicablePairsUpTo</code> es una función.
     testString: 'assert(typeof amicablePairsUpTo === "function", "<code>amicablePairsUpTo</code> is a function.");'
-  - text: &#39; <code>amicablePairsUpTo(300)</code> debe devolver <code>[[220,284]]</code> .&#39;
+  - text: ' <code>amicablePairsUpTo(300)</code> debe devolver <code>[[220,284]]</code> .'
     testString: 'assert.deepEqual(amicablePairsUpTo(300), answer300, "<code>amicablePairsUpTo(300)</code> should return <code>[[220,284]]</code>.");'
-  - text: &#39; <code>amicablePairsUpTo(3000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924]]</code> .&#39;
+  - text: ' <code>amicablePairsUpTo(3000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924]]</code> .'
     testString: 'assert.deepEqual(amicablePairsUpTo(3000), answer3000, "<code>amicablePairsUpTo(3000)</code> should return <code>[[220,284],[1184,1210],[2620,2924]]</code>.");'
-  - text: &#39; <code>amicablePairsUpTo(20000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code> . &#39;
+  - text: ' <code>amicablePairsUpTo(20000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code> . '
     testString: 'assert.deepEqual(amicablePairsUpTo(20000), answer20000, "<code>amicablePairsUpTo(20000)</code> should return <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-mode.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-mode.spanish.md
index c9f9848fb8..5ebe83e871 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-mode.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-mode.spanish.md
@@ -6,12 +6,12 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escribe un programa para encontrar el valor de <a href="https://en.wikipedia.org/wiki/Mode (statistics)" title="wp: modo (estadísticas)">modo</a> de una colección. </p><p> El caso donde la colección está vacía puede ser ignorado. Se debe tener cuidado para manejar el caso donde el modo no es único. </p><p> Si no es apropiado o no es posible admitir una colección general, use un vector (matriz), si es posible. Si no es apropiado o no es posible admitir un tipo de valor no especificado, use números enteros. </p> 
+<section id='description'>
+<p> Escribe un programa para encontrar el valor de <a href="https://en.wikipedia.org/wiki/Mode (statistics)" title="wp: modo (estadísticas)">modo</a> de una colección. </p><p> El caso donde la colección está vacía puede ser ignorado. Se debe tener cuidado para manejar el caso donde el modo no es único. </p><p> Si no es apropiado o no es posible admitir una colección general, use un vector (matriz), si es posible. Si no es apropiado o no es posible admitir un tipo de valor no especificado, use números enteros. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -22,9 +22,9 @@ challengeType: 5
 tests:
   - text: <code>mode</code> es una función.
     testString: 'assert(typeof mode === "function", "<code>mode</code> is a function.");'
-  - text: &#39; <code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> debe ser igual a <code>[6]</code> &#39;
+  - text: ' <code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> debe ser igual a <code>[6]</code> '
     testString: 'assert.deepEqual(mode(arr1), [6], "<code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> should equal <code>[6]</code>");'
-  - text: &#39;el <code>mode([1, 2, 4, 4, 1])</code> debe ser igual a <code>[1, 4]</code> .&#39;
+  - text: 'el <code>mode([1, 2, 4, 4, 1])</code> debe ser igual a <code>[1, 4]</code> .'
     testString: 'assert.deepEqual(mode(arr2).sort(), [1, 4], "<code>mode([1, 2, 4, 4, 1])</code> should equal <code>[1, 4]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-pythagorean-means.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-pythagorean-means.spanish.md
index 2de4f7e96d..0a948cf326 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-pythagorean-means.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-pythagorean-means.spanish.md
@@ -6,24 +6,24 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p class='rosetta__paragraph'> Calcule los tres <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Pythagorean means' title="wp: medios pitagóricos">medios pitagóricos</a> del conjunto de enteros del <big>1</big> al <big>10</big> (inclusive). </p><p class='rosetta__paragraph'> Muestre que <big>$ A (x_1, \ ldots, x_n) \ geq G (x_1, \ ldots, x_n) \ geq H (x_1, \ ldots, x_n) $</big> para este conjunto de enteros positivos. </p> El más común de los tres medios, la <a class='rosetta__link--rosetta' href='http://rosettacode.org/wiki/Averages/Arithmetic mean' title="Medias / media aritmética">media aritmética</a> , es la suma de la lista dividida por su longitud: <big>$ A (x_1, \ ldots, x_n) = \ frac {x_1 + \ cdots + x_n} {n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Geometric mean' title="wp: media geométrica">geometría media</a> es la raíz $ n $ th del producto de la lista: <big>$ G (x_1, \ ldots, x_n) = \ sqrt [n] {x_1 \ cdots x_n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Harmonic mean' title="wp: media armónica">media armónica</a> es $ n $ dividida por la suma de el recíproco de cada elemento en la lista: <big>$ H (x_1, \ ldots, x_n) = \ frac {n} {\ frac {1} {x_1} + \ cdots + \ frac {1} {x_n}} $</big> 
-<p class='rosetta__paragraph'> Suponga que la entrada es una matriz ordenada de todos los números inclusivos. </p> 
-<p class='rosetta__paragraph'> Para la respuesta, envíe un objeto en el siguiente formato: </p> 
-<pre class='rosetta__pre'> 
-{ 
-valores: { 
-Aritmética: 5.5, 
-Geométrica: 4.528728688116765, 
-Armónica: 3.414171521474055 
-}, 
-prueba: &#39;es A&gt; = G&gt; = H? si &#39; 
-} 
-</pre> 
+<section id='description'>
+<p class='rosetta__paragraph'> Calcule los tres <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Pythagorean means' title="wp: medios pitagóricos">medios pitagóricos</a> del conjunto de enteros del <big>1</big> al <big>10</big> (inclusive). </p><p class='rosetta__paragraph'> Muestre que <big>$ A (x_1, \ ldots, x_n) \ geq G (x_1, \ ldots, x_n) \ geq H (x_1, \ ldots, x_n) $</big> para este conjunto de enteros positivos. </p> El más común de los tres medios, la <a class='rosetta__link--rosetta' href='http://rosettacode.org/wiki/Averages/Arithmetic mean' title="Medias / media aritmética">media aritmética</a> , es la suma de la lista dividida por su longitud: <big>$ A (x_1, \ ldots, x_n) = \ frac {x_1 + \ cdots + x_n} {n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Geometric mean' title="wp: media geométrica">geometría media</a> es la raíz $ n $ th del producto de la lista: <big>$ G (x_1, \ ldots, x_n) = \ sqrt [n] {x_1 \ cdots x_n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Harmonic mean' title="wp: media armónica">media armónica</a> es $ n $ dividida por la suma de el recíproco de cada elemento en la lista: <big>$ H (x_1, \ ldots, x_n) = \ frac {n} {\ frac {1} {x_1} + \ cdots + \ frac {1} {x_n}} $</big>
+<p class='rosetta__paragraph'> Suponga que la entrada es una matriz ordenada de todos los números inclusivos. </p>
+<p class='rosetta__paragraph'> Para la respuesta, envíe un objeto en el siguiente formato: </p>
+<pre class='rosetta__pre'>
+{
+valores: {
+Aritmética: 5.5,
+Geométrica: 4.528728688116765,
+Armónica: 3.414171521474055
+},
+prueba: &#39;es A&gt; = G&gt; = H? si &#39;
+}
+</pre>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -34,7 +34,7 @@ prueba: &#39;es A&gt; = G&gt; = H? si &#39;
 tests:
   - text: <code>pythagoreanMeans</code> es una función.
     testString: 'assert(typeof pythagoreanMeans === "function", "<code>pythagoreanMeans</code> is a function.");'
-  - text: &#39; <code>pythagoreanMeans([1, 2, ..., 10])</code> debe ser igual a la salida anterior.&#39;
+  - text: ' <code>pythagoreanMeans([1, 2, ..., 10])</code> debe ser igual a la salida anterior.'
     testString: 'assert.deepEqual(pythagoreanMeans(range1), answer1, "<code>pythagoreanMeans([1, 2, ..., 10])</code> should equal the same output above.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-root-mean-square.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-root-mean-square.spanish.md
index 8eaecb67e1..3a3e295713 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-root-mean-square.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-root-mean-square.spanish.md
@@ -6,14 +6,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Calcule el <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">cuadrado</a> de la <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">raíz</a> de los números del 1 al 10, ambos inclusive. </p> 
-<p> La raíz cuadrada media también se conoce por sus iniciales RMS (o rms) y como la media cuadrática. </p><p> El RMS se calcula como la media de los cuadrados de los números, con raíz cuadrada: </p> 
-<p> <big>$ x _ {\ mathrm {rms}} = \ sqrt {{{x_1} ^ 2 + {x_2} ^ 2 + \ cdots + {x_n} ^ 2} \ over n}. $</big> </p> 
+<section id='description'>
+<p> Calcule el <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">cuadrado</a> de la <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">raíz</a> de los números del 1 al 10, ambos inclusive. </p>
+<p> La raíz cuadrada media también se conoce por sus iniciales RMS (o rms) y como la media cuadrática. </p><p> El RMS se calcula como la media de los cuadrados de los números, con raíz cuadrada: </p>
+<p> <big>$ x _ {\ mathrm {rms}} = \ sqrt {{{x_1} ^ 2 + {x_2} ^ 2 + \ cdots + {x_n} ^ 2} \ over n}. $</big> </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,7 +24,7 @@ challengeType: 5
 tests:
   - text: <code>rms</code> es una función.
     testString: 'assert(typeof rms === "function", "<code>rms</code> is a function.");'
-  - text: &#39; <code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> debe ser igual a <code>6.2048368229954285</code> .&#39;
+  - text: ' <code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> debe ser igual a <code>6.2048368229954285</code> .'
     testString: 'assert.equal(rms(arr1), answer1, "<code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> should equal <code>6.2048368229954285</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/babbage-problem.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/babbage-problem.spanish.md
index 45415c21de..ef0f3c36fe 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/babbage-problem.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/babbage-problem.spanish.md
@@ -6,17 +6,17 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> <a href="https://en.wikipedia.org/wiki/Charles_Babbage" title="wp: Charles_Babbage">Charles Babbage</a> , mirando el tipo de problemas que su motor analítico podría resolver, dio este ejemplo: </p> 
-<blockquote> What is the smallest positive integer whose square ends in the digits 269,696?</blockquote> 
-<p> - Babbage, carta a Lord Bowden, 1837; ver Hollingdale y Tootill, <i>Electronic Computers</i> , segunda edición, 1970, pág. 125. </p> 
-<p> Pensó que la respuesta podría ser 99,736, cuyo cuadrado es 9,947,269,696; pero no podía estar seguro. </p> 
-<p> La tarea es averiguar si Babbage tuvo la respuesta correcta. </p> 
-<p> Implemente una función para devolver el entero más bajo que satisfaga el problema de Babbage. Si Babbage tenía razón, devuelve el número de Babbage. </p> 
+<section id='description'>
+<p> <a href="https://en.wikipedia.org/wiki/Charles_Babbage" title="wp: Charles_Babbage">Charles Babbage</a> , mirando el tipo de problemas que su motor analítico podría resolver, dio este ejemplo: </p>
+<blockquote> What is the smallest positive integer whose square ends in the digits 269,696?</blockquote>
+<p> - Babbage, carta a Lord Bowden, 1837; ver Hollingdale y Tootill, <i>Electronic Computers</i> , segunda edición, 1970, pág. 125. </p>
+<p> Pensó que la respuesta podría ser 99,736, cuyo cuadrado es 9,947,269,696; pero no podía estar seguro. </p>
+<p> La tarea es averiguar si Babbage tuvo la respuesta correcta. </p>
+<p> Implemente una función para devolver el entero más bajo que satisfaga el problema de Babbage. Si Babbage tenía razón, devuelve el número de Babbage. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,7 +27,7 @@ challengeType: 5
 tests:
   - text: <code>babbage</code> es una función.
     testString: 'assert(typeof babbage === "function", "<code>babbage</code> is a function.");'
-  - text: &#39; <code>babbage(99736, 269696)</code> no debe devolver 99736 (hay una respuesta más pequeña).&#39;
+  - text: ' <code>babbage(99736, 269696)</code> no debe devolver 99736 (hay una respuesta más pequeña).'
     testString: 'assert.equal(babbage(babbageAns, endDigits), answer, "<code>babbage(99736, 269696)</code> should not return 99736 (there is a smaller answer).");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/balanced-brackets.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/balanced-brackets.spanish.md
index 40729f5592..23a3280012 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/balanced-brackets.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/balanced-brackets.spanish.md
@@ -6,20 +6,20 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Determine si una cadena generada de corchetes está equilibrada; es decir, si consiste completamente en pares de paréntesis de apertura / cierre (en ese orden), ninguno de los cuales se equivoca. </p> 
-Ejemplos: 
-<p class='rosetta__paragraph'> (vacío) verdadero </p> 
-<p class='rosetta__paragraph'> <code>[]</code> verdadero </p> 
-<p class='rosetta__paragraph'> <code>][</code> falso </p> 
-<p class='rosetta__paragraph'> <code>[][]</code> verdadero </p> 
-<p class='rosetta__paragraph'> <code>][][</code> falso </p> 
-<p class='rosetta__paragraph'> <code>[]][[]</code> falso </p> 
-<p class='rosetta__paragraph'> <code>[[[[]]]]</code> verdadero </p> 
+<section id='description'>
+<p> Determine si una cadena generada de corchetes está equilibrada; es decir, si consiste completamente en pares de paréntesis de apertura / cierre (en ese orden), ninguno de los cuales se equivoca. </p>
+Ejemplos:
+<p class='rosetta__paragraph'> (vacío) verdadero </p>
+<p class='rosetta__paragraph'> <code>[]</code> verdadero </p>
+<p class='rosetta__paragraph'> <code>][</code> falso </p>
+<p class='rosetta__paragraph'> <code>[][]</code> verdadero </p>
+<p class='rosetta__paragraph'> <code>][][</code> falso </p>
+<p class='rosetta__paragraph'> <code>[]][[]</code> falso </p>
+<p class='rosetta__paragraph'> <code>[[[[]]]]</code> verdadero </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,39 +30,39 @@ Ejemplos:
 tests:
   - text: <code>isBalanced</code> es una función.
     testString: 'assert(typeof isBalanced === "function", "<code>isBalanced</code> is a function.");'
-  - text: &#39; <code>isBalanced(&quot;[]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(isBalanced(testCases[0]), "<code>isBalanced("[]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;]][[[][][][]][&quot;)</code> debe devolver falso.&#39;
+  - text: ' <code>isBalanced(&quot;]][[[][][][]][&quot;)</code> debe devolver falso.'
     testString: 'assert(!isBalanced(testCases[1]), "<code>isBalanced("]][[[][][][]][")</code> should return false.");'
-  - text: &#39; <code>isBalanced(&quot;[][[[[][][[[]]]]]]&quot;)</code> debe devolver verdadero).
+  - text: ' <code>isBalanced(&quot;[][[[[][][[[]]]]]]&quot;)</code> debe devolver verdadero).
     testString: 'assert(isBalanced(testCases[2]), "<code>isBalanced("[][[[[][][[[]]]]]]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;][&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;][&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[3]), "<code>isBalanced("][")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[[[]]]][[]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[[[]]]][[]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[4]), "<code>isBalanced("[[[]]]][[]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;][[]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;][[]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[5]), "<code>isBalanced("][[]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;][[][]][[[]]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;][[][]][[[]]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[6]), "<code>isBalanced("][[][]][[[]]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[[][]]][&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[[][]]][&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[7]), "<code>isBalanced("[[][]]][")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[[[]]][[]]]][][[&quot;)</code> debería devolver true.&#39;
+  - text: ' <code>isBalanced(&quot;[[[]]][[]]]][][[&quot;)</code> debería devolver true.'
     testString: 'assert(!isBalanced(testCases[8]), "<code>isBalanced("[[[]]][[]]]][][[")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[]][[]]][[[[][]]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[]][[]]][[[[][]]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[9]), "<code>isBalanced("[]][[]]][[[[][]]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;][]][[][&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;][]][[][&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[10]), "<code>isBalanced("][]][[][")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[[]][[][]]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[[]][[][]]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(isBalanced(testCases[11]), "<code>isBalanced("[[]][[][]]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[[]]&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[[]]&quot;)</code> debe devolver verdadero.'
     testString: 'assert(isBalanced(testCases[12]), "<code>isBalanced("[[]]")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;]][]][[]][[[&quot;)</code> debe devolver verdadero &quot;.
+  - text: ' <code>isBalanced(&quot;]][]][[]][[[&quot;)</code> debe devolver verdadero &quot;.
     testString: 'assert(!isBalanced(testCases[13]), "<code>isBalanced("]][]][[]][[[")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;][]][][[&quot;)</code> debería devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;][]][][[&quot;)</code> debería devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[14]), "<code>isBalanced("][]][][[")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;][][&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;][][&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[15]), "<code>isBalanced("][][")</code> should return true.");'
-  - text: &#39; <code>isBalanced(&quot;[[]]][][][[]][&quot;)</code> debe devolver verdadero.&#39;
+  - text: ' <code>isBalanced(&quot;[[]]][][][[]][&quot;)</code> debe devolver verdadero.'
     testString: 'assert(!isBalanced(testCases[16]), "<code>isBalanced("[[]]][][][[]][")</code> should return true.");'
   - text: <code>isBalanced(&quot;&quot;)</code> debe devolver true.
     testString: 'assert(isBalanced(testCases[17]), "<code>isBalanced("")</code> should return true.");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.spanish.md
index d6b6f79e97..702317d9b6 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.spanish.md
@@ -6,33 +6,33 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Dados dos puntos en un plano y un radio, generalmente se pueden dibujar dos círculos de un radio dado a través de los puntos. </p> 
-Excepciones: 
-Un radio de cero debe tratarse como si nunca describiera círculos (excepto en el caso de que los puntos coincidan). 
-Si los puntos son coincidentes, se puede dibujar un número infinito de círculos con el punto en su circunferencia, a menos que el radio también sea igual a cero, lo que luego colapsa los círculos en un punto. 
-Si los puntos forman un diámetro, devuelva un solo círculo. 
-Si los puntos están demasiado separados, no se pueden dibujar círculos. Tarea: 
-Implemente una función que tome dos puntos y un radio y devuelva los dos círculos a través de esos puntos. Para cada círculo resultante, proporcione las coordenadas para el centro de cada círculo redondeado a cuatro dígitos decimales. Devuelve cada coordenada como una matriz y las coordenadas como una matriz de matrices. 
-Para casos de borde, devuelva lo siguiente: 
-Si los puntos están en el diámetro, devuelva un punto. Sin embargo, si el radio también es cero, devuelve <code>&quot;Radius Zero&quot;</code> . 
-Si los puntos coinciden, devuelva <code>&quot;Coincident point. Infinite solutions&quot;</code> . 
-Si los puntos están más separados que el diámetro, regrese <code>&quot;No intersection. Points further apart than circle diameter&quot;</code> . 
-Entradas de muestra: 
-<pre> 
-p1 p2 r 
-0.1234, 0.9876 0.8765, 0.2345 2.0 
-0.0000, 2.0000 0.0000, 0.0000 1.0 
-0.1234, 0.9876 0.1234, 0.9876 2.0 
-0.1234, 0.9876 0.8765, 0.2345 0.5 
-0.1234, 0.9876 0.1234, 0.9876 0.0 
-</pre> 
-Ref: 
-<a href="http://mathforum.org/library/drmath/view/53027.html" title="enlace: http://mathforum.org/library/drmath/view/53027.html">Encontrar el centro de un círculo a partir de 2 puntos y el radio</a> en el foro de Matemáticas @ Drexel 
+<section id='description'>
+<p> Dados dos puntos en un plano y un radio, generalmente se pueden dibujar dos círculos de un radio dado a través de los puntos. </p>
+Excepciones:
+Un radio de cero debe tratarse como si nunca describiera círculos (excepto en el caso de que los puntos coincidan).
+Si los puntos son coincidentes, se puede dibujar un número infinito de círculos con el punto en su circunferencia, a menos que el radio también sea igual a cero, lo que luego colapsa los círculos en un punto.
+Si los puntos forman un diámetro, devuelva un solo círculo.
+Si los puntos están demasiado separados, no se pueden dibujar círculos. Tarea:
+Implemente una función que tome dos puntos y un radio y devuelva los dos círculos a través de esos puntos. Para cada círculo resultante, proporcione las coordenadas para el centro de cada círculo redondeado a cuatro dígitos decimales. Devuelve cada coordenada como una matriz y las coordenadas como una matriz de matrices.
+Para casos de borde, devuelva lo siguiente:
+Si los puntos están en el diámetro, devuelva un punto. Sin embargo, si el radio también es cero, devuelve <code>&quot;Radius Zero&quot;</code> .
+Si los puntos coinciden, devuelva <code>&quot;Coincident point. Infinite solutions&quot;</code> .
+Si los puntos están más separados que el diámetro, regrese <code>&quot;No intersection. Points further apart than circle diameter&quot;</code> .
+Entradas de muestra:
+<pre>
+p1 p2 r
+0.1234, 0.9876 0.8765, 0.2345 2.0
+0.0000, 2.0000 0.0000, 0.0000 1.0
+0.1234, 0.9876 0.1234, 0.9876 2.0
+0.1234, 0.9876 0.8765, 0.2345 0.5
+0.1234, 0.9876 0.1234, 0.9876 0.0
+</pre>
+Ref:
+<a href="http://mathforum.org/library/drmath/view/53027.html" title="enlace: http://mathforum.org/library/drmath/view/53027.html">Encontrar el centro de un círculo a partir de 2 puntos y el radio</a> en el foro de Matemáticas @ Drexel
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -43,15 +43,15 @@ Ref:
 tests:
   - text: <code>getCircles</code> es una función.
     testString: 'assert(typeof getCircles === "function", "<code>getCircles</code> is a function.");'
-  - text: &#39; <code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> debe devolver <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code> .&#39;
+  - text: ' <code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> debe devolver <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code> .'
     testString: 'assert.deepEqual(getCircles(...testCases[0]), answers[0], "<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> should return <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code>.");'
-  - text: &#39; <code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> debe devolver <code>[0, 1]</code> &#39;
+  - text: ' <code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> debe devolver <code>[0, 1]</code> '
     testString: 'assert.deepEqual(getCircles(...testCases[1]), answers[1], "<code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> should return <code>[0, 1]</code>");'
-  - text: &#39; <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> debe devolver el <code>Coincident point. Infinite solutions</code> &#39;
+  - text: ' <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> debe devolver el <code>Coincident point. Infinite solutions</code> '
     testString: 'assert.deepEqual(getCircles(...testCases[2]), answers[2], "<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> should return <code>Coincident point. Infinite solutions</code>");'
-  - text: &#39; <code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> debe devolver <code>No intersection. Points further apart than circle diameter</code> &#39;
+  - text: ' <code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> debe devolver <code>No intersection. Points further apart than circle diameter</code> '
     testString: 'assert.deepEqual(getCircles(...testCases[3]), answers[3], "<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> should return <code>No intersection. Points further apart than circle diameter</code>");'
-  - text: &#39; <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> debe devolver <code>Radius Zero</code> &#39;
+  - text: ' <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> debe devolver <code>Radius Zero</code> '
     testString: 'assert.deepEqual(getCircles(...testCases[4]), answers[4], "<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> should return <code>Radius Zero</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/combinations.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/combinations.spanish.md
index d03297288c..a2c750c400 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/combinations.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/combinations.spanish.md
@@ -6,27 +6,27 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Dado los enteros no negativos <big>m</big> y <big>n</big> , genere todas las <a href="http://mathworld.wolfram.com/Combination.html" title="enlace: http://mathworld.wolfram.com/Combination.html">combinaciones</a> de tamaño <big>m</big> de los enteros de <big>0</big> (cero) a <big>n-1</big> en orden ordenado (cada combinación está ordenada y la tabla completa está ordenada). </p> 
-Ejemplo: 
-<p> <big>3</big> peine <big>5</big> es: </p> 
-<pre> 
-0 1 2 
-0 1 3 
-0 1 4 
-0 2 2 
-0 2 4 
-0 3 4 
-1 2 3 
-1 2 4 
-1 3 4 
-2 3 4 
-</pre> 
+<section id='description'>
+Tarea:
+<p> Dado los enteros no negativos <big>m</big> y <big>n</big> , genere todas las <a href="http://mathworld.wolfram.com/Combination.html" title="enlace: http://mathworld.wolfram.com/Combination.html">combinaciones</a> de tamaño <big>m</big> de los enteros de <big>0</big> (cero) a <big>n-1</big> en orden ordenado (cada combinación está ordenada y la tabla completa está ordenada). </p>
+Ejemplo:
+<p> <big>3</big> peine <big>5</big> es: </p>
+<pre>
+0 1 2
+0 1 3
+0 1 4
+0 2 2
+0 2 4
+0 3 4
+1 2 3
+1 2 4
+1 3 4
+2 3 4
+</pre>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -37,9 +37,9 @@ Ejemplo:
 tests:
   - text: <code>combinations</code> son una función.
     testString: 'assert(typeof combinations === "function", "<code>combinations</code> is a function.");'
-  - text: &#39; <code>combinations(3, 5)</code> deben devolver <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code> . &#39;
+  - text: ' <code>combinations(3, 5)</code> deben devolver <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code> . '
     testString: 'assert.deepEqual(combinations(testInput1[0], testInput1[1]), testOutput1, "<code>combinations(3, 5)</code> should return <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code>.");'
-  - text: &#39; <code>combinations(4, 6)</code> deben devolver <code>[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]</code> &#39;
+  - text: ' <code>combinations(4, 6)</code> deben devolver <code>[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]</code> '
     testString: 'assert.deepEqual(combinations(testInput2[0], testInput2[1]), testOutput2, "<code>combinations(4, 6)</code> should return <code>[[0,1,2,3],  [0,1,2,4],  [0,1,2,5],  [0,1,3,4],  [0,1,3,5],  [0,1,4,5],  [0,2,3,4],  [0,2,3,5],  [0,2,4,5],  [0,3,4,5],  [1,2,3,4],  [1,2,3,5],  [1,2,4,5],  [1,3,4,5],  [2,3,4,5]]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/comma-quibbling.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/comma-quibbling.spanish.md
index 0cec4e2918..fca658af59 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/comma-quibbling.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/comma-quibbling.spanish.md
@@ -6,23 +6,23 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> La objeción de coma es una tarea establecida originalmente por Eric Lippert en su <a href="http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx" title="enlace: http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx">blog</a> . </p> 
-Tarea: <p> Escriba una función para generar una salida de cadena que sea la concatenación de palabras de entrada de una lista / secuencia donde: </p> 
-Una entrada sin palabras produce la cadena de salida de solo los dos caracteres de refuerzo &quot;{}&quot;. 
-Una entrada de una sola palabra, por ejemplo, [&quot;ABC&quot;], produce la cadena de salida de la palabra dentro de las dos llaves, por ejemplo, &quot;{ABC}&quot;. 
-Una entrada de dos palabras, por ejemplo, [&quot;ABC&quot;, &quot;DEF&quot;], produce la cadena de salida de las dos palabras dentro de las dos llaves con las palabras separadas por la cadena &quot;y&quot;, por ejemplo, &quot;{ABC y DEF}&quot;. 
-Una entrada de tres o más palabras, por ejemplo, [&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;], produce la cadena de salida de todos menos la última palabra separada por &quot;,&quot; con la última palabra separada por &quot; y &quot;y todo entre llaves; por ejemplo, &quot;{ABC, DEF, G y H}&quot;. 
-<p> Pruebe su función con la siguiente serie de entradas que muestran su salida aquí en esta página: </p> 
-[] # (No hay palabras de entrada). 
-[&quot;ABC&quot;] 
-[&quot;ABC&quot;, &quot;DEF&quot;] 
-[&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;] 
-<p> Nota: Suponga que las palabras son cadenas no vacías de caracteres en mayúscula para esta tarea. </p> 
+<section id='description'>
+<p> La objeción de coma es una tarea establecida originalmente por Eric Lippert en su <a href="http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx" title="enlace: http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx">blog</a> . </p>
+Tarea: <p> Escriba una función para generar una salida de cadena que sea la concatenación de palabras de entrada de una lista / secuencia donde: </p>
+Una entrada sin palabras produce la cadena de salida de solo los dos caracteres de refuerzo &quot;{}&quot;.
+Una entrada de una sola palabra, por ejemplo, [&quot;ABC&quot;], produce la cadena de salida de la palabra dentro de las dos llaves, por ejemplo, &quot;{ABC}&quot;.
+Una entrada de dos palabras, por ejemplo, [&quot;ABC&quot;, &quot;DEF&quot;], produce la cadena de salida de las dos palabras dentro de las dos llaves con las palabras separadas por la cadena &quot;y&quot;, por ejemplo, &quot;{ABC y DEF}&quot;.
+Una entrada de tres o más palabras, por ejemplo, [&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;], produce la cadena de salida de todos menos la última palabra separada por &quot;,&quot; con la última palabra separada por &quot; y &quot;y todo entre llaves; por ejemplo, &quot;{ABC, DEF, G y H}&quot;.
+<p> Pruebe su función con la siguiente serie de entradas que muestran su salida aquí en esta página: </p>
+[] # (No hay palabras de entrada).
+[&quot;ABC&quot;]
+[&quot;ABC&quot;, &quot;DEF&quot;]
+[&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;]
+<p> Nota: Suponga que las palabras son cadenas no vacías de caracteres en mayúscula para esta tarea. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -33,15 +33,15 @@ Una entrada de tres o más palabras, por ejemplo, [&quot;ABC&quot;, &quot;DEF&qu
 tests:
   - text: <code>quibble</code> es una función.
     testString: 'assert(typeof quibble === "function", "<code>quibble</code> is a function.");'
-  - text: &#39; <code>quibble([&quot;ABC&quot;])</code> debería devolver una cadena.&#39;
+  - text: ' <code>quibble([&quot;ABC&quot;])</code> debería devolver una cadena.'
     testString: 'assert(typeof quibble(["ABC"]) === "string", "<code>quibble(["ABC"])</code> should return a string.");'
-  - text: &#39; <code>quibble([])</code> debe devolver &quot;{}&quot;.&#39;
+  - text: ' <code>quibble([])</code> debe devolver &quot;{}&quot;.'
     testString: 'assert.equal(quibble(testCases[0]), results[0], "<code>quibble([])</code> should return "{}".");'
-  - text: &#39; <code>quibble([&quot;ABC&quot;])</code> debe devolver &quot;{ABC}&quot;.&#39;
+  - text: ' <code>quibble([&quot;ABC&quot;])</code> debe devolver &quot;{ABC}&quot;.'
     testString: 'assert.equal(quibble(testCases[1]), results[1], "<code>quibble(["ABC"])</code> should return "{ABC}".");'
-  - text: &#39; <code>quibble([&quot;ABC&quot;, &quot;DEF&quot;])</code> debe devolver &quot;{ABC and DEF}&quot;.&#39;
+  - text: ' <code>quibble([&quot;ABC&quot;, &quot;DEF&quot;])</code> debe devolver &quot;{ABC and DEF}&quot;.'
     testString: 'assert.equal(quibble(testCases[2]), results[2], "<code>quibble(["ABC", "DEF"])</code> should return "{ABC and DEF}".");'
-  - text: &#39; <code>quibble([&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;])</code> debe devolver &quot;{ABC, DEF, G y H}&quot;.&#39;
+  - text: ' <code>quibble([&quot;ABC&quot;, &quot;DEF&quot;, &quot;G&quot;, &quot;H&quot;])</code> debe devolver &quot;{ABC, DEF, G y H}&quot;.'
     testString: 'assert.equal(quibble(testCases[3]), results[3], "<code>quibble(["ABC", "DEF", "G", "H"])</code> should return "{ABC,DEF,G and H}".");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/compare-a-list-of-strings.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/compare-a-list-of-strings.spanish.md
index d2c288eab6..eb34a09d0a 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/compare-a-list-of-strings.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/compare-a-list-of-strings.spanish.md
@@ -6,13 +6,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Dada una <a href="https://en.wikipedia.org/wiki/List_(abstract_data_type)" title="wp: List_ (abstract_data_type)">lista</a> de muchas cadenas arbitrarias, implemente una función para cada una de las siguientes condiciones: </p> prueba si todos son léxicamente iguales 
-prueba si cada cadena es léxicamente menor que la siguiente (es decir, si la lista está en estricto orden ascendente) 
+<section id='description'>
+<p> Dada una <a href="https://en.wikipedia.org/wiki/List_(abstract_data_type)" title="wp: List_ (abstract_data_type)">lista</a> de muchas cadenas arbitrarias, implemente una función para cada una de las siguientes condiciones: </p> prueba si todos son léxicamente iguales
+prueba si cada cadena es léxicamente menor que la siguiente (es decir, si la lista está en estricto orden ascendente)
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,25 +25,25 @@ tests:
     testString: 'assert(typeof allEqual === "function", "<code>allEqual</code> is a function.");'
   - text: <code>azSorted</code> es una función.
     testString: 'assert(typeof azSorted === "function", "<code>azSorted</code> is a function.");'
-  - text: &#39; <code>allEqual([&quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;])</code> devuelve true.&#39;
+  - text: ' <code>allEqual([&quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;])</code> devuelve true.'
     testString: 'assert(allEqual(testCases[0]), "<code>allEqual(["AA", "AA", "AA", "AA"])</code> returns true.");'
-  - text: &#39; <code>azSorted([&quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;])</code> devuelve falso.&#39;
+  - text: ' <code>azSorted([&quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;, &quot;AA&quot;])</code> devuelve falso.'
     testString: 'assert(!azSorted(testCases[0]), "<code>azSorted(["AA", "AA", "AA", "AA"])</code> returns false.");'
-  - text: &#39; <code>allEqual([&quot;AA&quot;, &quot;ACB&quot;, &quot;BB&quot;, &quot;CC&quot;])</code> devuelve falso.&#39;
+  - text: ' <code>allEqual([&quot;AA&quot;, &quot;ACB&quot;, &quot;BB&quot;, &quot;CC&quot;])</code> devuelve falso.'
     testString: 'assert(!allEqual(testCases[1]), "<code>allEqual(["AA", "ACB", "BB", "CC"])</code> returns false.");'
-  - text: &#39; <code>azSorted([&quot;AA&quot;, &quot;ACB&quot;, &quot;BB&quot;, &quot;CC&quot;])</code> devuelve verdadero.&#39;
+  - text: ' <code>azSorted([&quot;AA&quot;, &quot;ACB&quot;, &quot;BB&quot;, &quot;CC&quot;])</code> devuelve verdadero.'
     testString: 'assert(azSorted(testCases[1]), "<code>azSorted(["AA", "ACB", "BB", "CC"])</code> returns true.");'
-  - text: &#39; <code>allEqual([])</code> devuelve true.&#39;
+  - text: ' <code>allEqual([])</code> devuelve true.'
     testString: 'assert(allEqual(testCases[2]), "<code>allEqual([])</code> returns true.");'
-  - text: &#39; <code>azSorted([])</code> devuelve true.&#39;
+  - text: ' <code>azSorted([])</code> devuelve true.'
     testString: 'assert(azSorted(testCases[2]), "<code>azSorted([])</code> returns true.");'
-  - text: &#39; <code>allEqual([&quot;AA&quot;])</code> devuelve true.&#39;
+  - text: ' <code>allEqual([&quot;AA&quot;])</code> devuelve true.'
     testString: 'assert(allEqual(testCases[3]), "<code>allEqual(["AA"])</code> returns true.");'
-  - text: &#39; <code>azSorted([&quot;AA&quot;])</code> devuelve verdadero.&#39;
+  - text: ' <code>azSorted([&quot;AA&quot;])</code> devuelve verdadero.'
     testString: 'assert(azSorted(testCases[3]), "<code>azSorted(["AA"])</code> returns true.");'
-  - text: &#39; <code>allEqual([&quot;BB&quot;, &quot;AA&quot;])</code> devuelve false. &quot;
+  - text: ' <code>allEqual([&quot;BB&quot;, &quot;AA&quot;])</code> devuelve false. &quot;
     testString: 'assert(!allEqual(testCases[4]), "<code>allEqual(["BB", "AA"])</code> returns false.");'
-  - text: &#39; <code>azSorted([&quot;BB&quot;, &quot;AA&quot;])</code> devuelve falso.&#39;
+  - text: ' <code>azSorted([&quot;BB&quot;, &quot;AA&quot;])</code> devuelve falso.'
     testString: 'assert(!azSorted(testCases[4]), "<code>azSorted(["BB", "AA"])</code> returns false.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.spanish.md
index e1a99f522c..861f251aa5 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.spanish.md
@@ -6,74 +6,74 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Implementar una función que: </p> 
-toma un entero positivo que representa una duración en segundos como entrada (por ejemplo, <code>100</code> ), y 
-devuelve una cadena que muestra la misma duración descompuesta en semanas, días, horas, minutos y segundos como se detalla a continuación (por ejemplo, &quot; <code>1 min, 40 sec</code> &quot;). 
-<p> Demostrar que pasa los siguientes tres casos de prueba: </p><p style="font-size:115%; margin:1em 0 0 0"> Casos de prueba </p> 
-<table> 
-<tbody> 
-<tr> 
-<th> número de entrada </th> 
-<th> número de salida </th> 
-</tr> 
-<tr> 
-<td> 7259 </td> 
-<td> <code>2 hr, 59 sec</code> </td> 
-</tr> 
-<tr> 
-<td> 86400 </td> 
-<td> <code>1 d</code> </td> 
-</tr> 
-<tr> 
-<td> 6000000 </td> 
-<td> <code>9 wk, 6 d, 10 hr, 40 min</code> </td> 
-</tr> 
-</tbody> 
-</table> 
-<p style="font-size:115%; margin:1em 0 0 0"> Detalles </p> 
-Se deben usar las siguientes cinco unidades: 
-<table> 
-<tbody> 
-<tr> 
-<th> unidad </th> 
-<th> sufijo utilizado en la salida </th> 
-<th> conversión </th> 
-</tr> 
-<tr> 
-<td> semana </td> 
-<td> <code>wk</code> </td> 
-<td> 1 semana = 7 días </td> 
-</tr> 
-<tr> 
-<td> día </td> 
-<td> <code>d</code> </td> 
-<td> 1 día = 24 horas </td> 
-</tr> 
-<tr> 
-<td> hora </td> 
-<td> <code>hr</code> </td> 
-<td> 1 hora = 60 minutos </td> 
-</tr> 
-<tr> 
-<td> minuto </td> 
-<td> <code>min</code> </td> 
-<td> 1 minuto = 60 segundos </td> 
-</tr> 
-<tr> 
-<td> segundo </td> 
-<td> <code>sec</code> </td> 
-<td> </td> 
-</tr> 
-</tbody> 
-</table> 
-Sin embargo, solo incluya cantidades con valores que no sean cero en la salida (por ejemplo, devuelva &quot; <code>1 d</code> &quot; y no &quot; <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code> &quot;). Dé prioridad a las unidades más grandes sobre las más pequeñas como tanto como sea posible (p. ej., devuelva <code>2 min, 10 sec</code> y no <code>1 min, 70 sec</code> o <code>130 sec</code> ) Imite el formato que se muestra en los casos de prueba (cantidades ordenadas de unidad mayor a menor y separadas por comas + espacio; valor y unidad de cada cantidad separada por espacio). 
-<p><hr style="margin:1em 0;"/></p> 
+<section id='description'>
+Tarea:
+<p> Implementar una función que: </p>
+toma un entero positivo que representa una duración en segundos como entrada (por ejemplo, <code>100</code> ), y
+devuelve una cadena que muestra la misma duración descompuesta en semanas, días, horas, minutos y segundos como se detalla a continuación (por ejemplo, &quot; <code>1 min, 40 sec</code> &quot;).
+<p> Demostrar que pasa los siguientes tres casos de prueba: </p><p style="font-size:115%; margin:1em 0 0 0"> Casos de prueba </p>
+<table>
+<tbody>
+<tr>
+<th> número de entrada </th>
+<th> número de salida </th>
+</tr>
+<tr>
+<td> 7259 </td>
+<td> <code>2 hr, 59 sec</code> </td>
+</tr>
+<tr>
+<td> 86400 </td>
+<td> <code>1 d</code> </td>
+</tr>
+<tr>
+<td> 6000000 </td>
+<td> <code>9 wk, 6 d, 10 hr, 40 min</code> </td>
+</tr>
+</tbody>
+</table>
+<p style="font-size:115%; margin:1em 0 0 0"> Detalles </p>
+Se deben usar las siguientes cinco unidades:
+<table>
+<tbody>
+<tr>
+<th> unidad </th>
+<th> sufijo utilizado en la salida </th>
+<th> conversión </th>
+</tr>
+<tr>
+<td> semana </td>
+<td> <code>wk</code> </td>
+<td> 1 semana = 7 días </td>
+</tr>
+<tr>
+<td> día </td>
+<td> <code>d</code> </td>
+<td> 1 día = 24 horas </td>
+</tr>
+<tr>
+<td> hora </td>
+<td> <code>hr</code> </td>
+<td> 1 hora = 60 minutos </td>
+</tr>
+<tr>
+<td> minuto </td>
+<td> <code>min</code> </td>
+<td> 1 minuto = 60 segundos </td>
+</tr>
+<tr>
+<td> segundo </td>
+<td> <code>sec</code> </td>
+<td> </td>
+</tr>
+</tbody>
+</table>
+Sin embargo, solo incluya cantidades con valores que no sean cero en la salida (por ejemplo, devuelva &quot; <code>1 d</code> &quot; y no &quot; <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code> &quot;). Dé prioridad a las unidades más grandes sobre las más pequeñas como tanto como sea posible (p. ej., devuelva <code>2 min, 10 sec</code> y no <code>1 min, 70 sec</code> o <code>130 sec</code> ) Imite el formato que se muestra en los casos de prueba (cantidades ordenadas de unidad mayor a menor y separadas por comas + espacio; valor y unidad de cada cantidad separada por espacio).
+<p><hr style="margin:1em 0;"/></p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -84,11 +84,11 @@ Sin embargo, solo incluya cantidades con valores que no sean cero en la salida (
 tests:
   - text: <code>convertSeconds</code> es una función.
     testString: 'assert(typeof convertSeconds === "function", "<code>convertSeconds</code> is a function.");'
-  - text: &#39; <code>convertSeconds(7259)</code> debe devolver <code>2 hr, 59 sec</code> .&#39;
+  - text: ' <code>convertSeconds(7259)</code> debe devolver <code>2 hr, 59 sec</code> .'
     testString: 'assert.equal(convertSeconds(testCases[0]), results[0], "<code>convertSeconds(7259)</code> should return <code>2 hr, 59 sec</code>.");'
   - text: <code>convertSeconds(86400)</code> debe devolver <code>1 d</code> .
     testString: 'assert.equal(convertSeconds(testCases[1]), results[1], "<code>convertSeconds(86400)</code> should return <code>1 d</code>.");'
-  - text: &#39; <code>convertSeconds(6000000)</code> debe devolver <code>9 wk, 6 d, 10 hr, 40 min</code> .&#39;
+  - text: ' <code>convertSeconds(6000000)</code> debe devolver <code>9 wk, 6 d, 10 hr, 40 min</code> .'
     testString: 'assert.equal(convertSeconds(testCases[2]), results[2], "<code>convertSeconds(6000000)</code> should return <code>9 wk, 6 d, 10 hr, 40 min</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.spanish.md
index 8077548531..d04d35dd28 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.spanish.md
@@ -6,17 +6,17 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Cree una función, o muestre una función incorporada, para contar el número de apariciones no superpuestas de una subcadena dentro de una cadena. </p><p> La función debe tomar dos argumentos: </p> 
-el primer argumento es la cadena a buscar, y 
-el segundo una subcadena a buscar. 
-<p> Debe devolver un número entero. </p> 
-<p> La coincidencia debe producir el mayor número de coincidencias no superpuestas. </p><p> En general, esto significa esencialmente hacer coincidir de izquierda a derecha o de derecha a izquierda. </p> 
+<section id='description'>
+Tarea:
+<p> Cree una función, o muestre una función incorporada, para contar el número de apariciones no superpuestas de una subcadena dentro de una cadena. </p><p> La función debe tomar dos argumentos: </p>
+el primer argumento es la cadena a buscar, y
+el segundo una subcadena a buscar.
+<p> Debe devolver un número entero. </p>
+<p> La coincidencia debe producir el mayor número de coincidencias no superpuestas. </p><p> En general, esto significa esencialmente hacer coincidir de izquierda a derecha o de derecha a izquierda. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -27,11 +27,11 @@ el segundo una subcadena a buscar.
 tests:
   - text: <code>countSubstring</code> es una función.
     testString: 'assert(typeof countSubstring === "function", "<code>countSubstring</code> is a function.");'
-  - text: &#39; <code>countSubstring(&quot;the three truths&quot;, &quot;th&quot;)</code> debe devolver <code>3</code> &#39;
+  - text: ' <code>countSubstring(&quot;the three truths&quot;, &quot;th&quot;)</code> debe devolver <code>3</code> '
     testString: 'assert.equal(countSubstring(testCases[0], searchString[0]), results[0], "<code>countSubstring("the three truths", "th")</code> should return <code>3</code>.");'
-  - text: &#39; <code>countSubstring(&quot;ababababab&quot;, &quot;abab&quot;)</code> debe devolver <code>2</code> &#39;
+  - text: ' <code>countSubstring(&quot;ababababab&quot;, &quot;abab&quot;)</code> debe devolver <code>2</code> '
     testString: 'assert.equal(countSubstring(testCases[1], searchString[1]), results[1], "<code>countSubstring("ababababab", "abab")</code> should return <code>2</code>.");'
-  - text: &#39; <code>countSubstring(&quot;abaabba*bbaba*bbab&quot;, &quot;a*b&quot;)</code> debe devolver <code>2</code> &#39;
+  - text: ' <code>countSubstring(&quot;abaabba*bbaba*bbab&quot;, &quot;a*b&quot;)</code> debe devolver <code>2</code> '
     testString: 'assert.equal(countSubstring(testCases[2], searchString[2]), results[2], "<code>countSubstring("abaabba*bbaba*bbab", "a*b")</code> should return <code>2</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/cramers-rule.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/cramers-rule.spanish.md
index 98e0e4391b..0fab083a3f 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/cramers-rule.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/cramers-rule.spanish.md
@@ -6,29 +6,29 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> En <a href="https://en.wikipedia.org/wiki/linear algebra" title="wp: álgebra lineal">álgebra lineal</a> , <a href="https://en.wikipedia.org/wiki/Cramer's rule" title="wp: la regla de cramer">la regla de Cramer</a> es una fórmula explícita para la solución de un <a href="https://en.wikipedia.org/wiki/system of linear equations" title="wp: sistema de ecuaciones lineales">sistema de ecuaciones lineales</a> con tantas ecuaciones como incógnitas, válida siempre que el sistema tenga una solución única. Expresa la solución en términos de los determinantes de la matriz del coeficiente (cuadrado) y de las matrices obtenidas de ella al reemplazar una columna por el vector de los lados derechos de las ecuaciones. </p> 
-<p> Dado </p> 
-<p> </p> 
-<p> $ \ left \ {\ begin {matrix} a_1x + b_1y + c_1z &amp; = {\ color {red} d_1} \\ a_2x + b_2y + c_2z &amp; = {\ color {red} d_2} \\ a_3x + b_3y + c_3z &amp; = {\ color {rojo} d_3} \ fin {matriz} \ derecha. $ </p> 
-<p> que en formato matricial es </p><p></p> 
-<p> $ \ begin {bmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {bmatrix} \ begin {bmatrix} x \\ y \\ z \ end {bmatrix} = \ begin {bmatrix} {\ color {rojo} d_1} \\ {\ color {rojo} d_2} \\ {\ color {rojo} d_3} \ fin {bmatrix}. $ </p> 
-<p> Luego, los valores de $ x, y $ y $ z $ se pueden encontrar de la siguiente manera: </p><p></p> 
-<p> $ x = \ frac {\ begin {vmatrix} {\ color {red} d_1} &amp; b_1 &amp; c_1 \\ {\ color {red} d_2} &amp; b_2 &amp; c_2 \\ {\ color {red} d_3} &amp; b_3 &amp; c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}, \ quad y = \ frac {\ begin {vmatrix } a_1 &amp; {\ color {red} d_1} &amp; c_1 \\ a_2 &amp; {\ color {red} d_2} &amp; c_2 \\ a_3 &amp; {\ color {red} d_3} &amp; c_3 \ end {vmatrix}} {\ comenzar {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}, \ text {and} z = \ frac {\ begin {vmatrix} a_1 &amp; b_1 &amp; {\ color {rojo} d_1} \\ a_2 &amp; b_2 &amp; {\ color {red} d_2} \\ a_3 &amp; b_3 &amp; {\ color {rojo} d_3} \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}. $ </p> 
+<section id='description'>
+<p> En <a href="https://en.wikipedia.org/wiki/linear algebra" title="wp: álgebra lineal">álgebra lineal</a> , <a href="https://en.wikipedia.org/wiki/Cramer's rule" title="wp: la regla de cramer">la regla de Cramer</a> es una fórmula explícita para la solución de un <a href="https://en.wikipedia.org/wiki/system of linear equations" title="wp: sistema de ecuaciones lineales">sistema de ecuaciones lineales</a> con tantas ecuaciones como incógnitas, válida siempre que el sistema tenga una solución única. Expresa la solución en términos de los determinantes de la matriz del coeficiente (cuadrado) y de las matrices obtenidas de ella al reemplazar una columna por el vector de los lados derechos de las ecuaciones. </p>
+<p> Dado </p>
+<p> </p>
+<p> $ \ left \ {\ begin {matrix} a_1x + b_1y + c_1z &amp; = {\ color {red} d_1} \\ a_2x + b_2y + c_2z &amp; = {\ color {red} d_2} \\ a_3x + b_3y + c_3z &amp; = {\ color {rojo} d_3} \ fin {matriz} \ derecha. $ </p>
+<p> que en formato matricial es </p><p></p>
+<p> $ \ begin {bmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {bmatrix} \ begin {bmatrix} x \\ y \\ z \ end {bmatrix} = \ begin {bmatrix} {\ color {rojo} d_1} \\ {\ color {rojo} d_2} \\ {\ color {rojo} d_3} \ fin {bmatrix}. $ </p>
+<p> Luego, los valores de $ x, y $ y $ z $ se pueden encontrar de la siguiente manera: </p><p></p>
+<p> $ x = \ frac {\ begin {vmatrix} {\ color {red} d_1} &amp; b_1 &amp; c_1 \\ {\ color {red} d_2} &amp; b_2 &amp; c_2 \\ {\ color {red} d_3} &amp; b_3 &amp; c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}, \ quad y = \ frac {\ begin {vmatrix } a_1 &amp; {\ color {red} d_1} &amp; c_1 \\ a_2 &amp; {\ color {red} d_2} &amp; c_2 \\ a_3 &amp; {\ color {red} d_3} &amp; c_3 \ end {vmatrix}} {\ comenzar {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}, \ text {and} z = \ frac {\ begin {vmatrix} a_1 &amp; b_1 &amp; {\ color {rojo} d_1} \\ a_2 &amp; b_2 &amp; {\ color {red} d_2} \\ a_3 &amp; b_3 &amp; {\ color {rojo} d_3} \ end {vmatrix}} {\ begin {vmatrix} a_1 &amp; b_1 &amp; c_1 \\ a_2 &amp; b_2 &amp; c_2 \\ a_3 &amp; b_3 &amp; c_3 \ end {vmatrix}}. $ </p>
 
-Tarea 
+Tarea
 <p> Dado el siguiente sistema de ecuaciones: </p><p> <big>
-$ \ begin {cases} 
-2w-x + 5y + z = -3 \\ 
-3w + 2x + 2y-6z = -32 \\ 
-w + 3x + 3y-z = -47 \\ 
-5w-2x -3y + 3z = 49 \\ 
-\ fin {casos} $ <code>0</code></big> </p> 
-<p> resuelve por <big>$ w $, $ x $, $ y $</big> y <big>$ z $</big> , usando la regla de Cramer. </p> 
+$ \ begin {cases}
+2w-x + 5y + z = -3 \\
+3w + 2x + 2y-6z = -32 \\
+w + 3x + 3y-z = -47 \\
+5w-2x -3y + 3z = 49 \\
+\ fin {casos} $ <code>0</code></big> </p>
+<p> resuelve por <big>$ w $, $ x $, $ y $</big> y <big>$ z $</big> , usando la regla de Cramer. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -39,9 +39,9 @@ w + 3x + 3y-z = -47 \\
 tests:
   - text: <code>cramersRule</code> es una función.
     testString: 'assert(typeof cramersRule === "function", "<code>cramersRule</code> is a function.");'
-  - text: &#39; <code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> debe devolver <code>[2, -12, -4, 1]</code> . &#39;
+  - text: ' <code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> debe devolver <code>[2, -12, -4, 1]</code> . '
     testString: 'assert.deepEqual(cramersRule(matrices[0], freeTerms[0]), answers[0], "<code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> should return <code>[2, -12, -4, 1]</code>.");'
-  - text: &#39; <code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> debe devolver <code>[1, 1, -1]</code> .
+  - text: ' <code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> debe devolver <code>[1, 1, -1]</code> .
     testString: 'assert.deepEqual(cramersRule(matrices[1], freeTerms[1]), answers[1], "<code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> should return <code>[1, 1, -1]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/date-manipulation.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/date-manipulation.spanish.md
index 86dc26b5dd..c232513d82 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/date-manipulation.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/date-manipulation.spanish.md
@@ -6,18 +6,18 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Dada una cadena de fecha en EST, genera la fecha dada como una cadena con 12 horas agregadas a la hora. </p> 
-<p> La zona horaria debe ser preservada. </p> 
-<p> Ejemplo de entrada: </p> 
-<p> <code>&quot;March 7 2009 7:30pm EST&quot;</code> </p> 
-<p> Ejemplo de salida: </p> 
-<p> <code>&quot;March 8 2009 7:30am EST&quot;</code> </p> 
+<section id='description'>
+Tarea:
+<p> Dada una cadena de fecha en EST, genera la fecha dada como una cadena con 12 horas agregadas a la hora. </p>
+<p> La zona horaria debe ser preservada. </p>
+<p> Ejemplo de entrada: </p>
+<p> <code>&quot;March 7 2009 7:30pm EST&quot;</code> </p>
+<p> Ejemplo de salida: </p>
+<p> <code>&quot;March 8 2009 7:30am EST&quot;</code> </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,15 +30,15 @@ tests:
     testString: 'assert(typeof add12Hours === "function", "<code>add12Hours</code> is a function.");'
   - text: <code>add12Hours(dateString)</code> debe devolver una cadena.
     testString: 'assert(typeof add12Hours(tests[0]) === "string", "<code>add12Hours(dateString)</code> should return a string.");'
-  - text: &#39; <code>add12Hours(&quot;&quot; + tests[0] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[0] + &quot;&quot;</code> &#39;
+  - text: ' <code>add12Hours(&quot;&quot; + tests[0] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[0] + &quot;&quot;</code> '
     testString: 'assert(add12Hours(tests[0]) === answers[0], "<code>add12Hours("" + tests[0] + "")</code> should return <code>"" + answers[0] + ""</code>");'
-  - text: Debería cambiar el día. <code>add12Hours(&quot;&quot; + tests[1] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[1] + &quot;&quot;</code> &#39;
+  - text: Debería cambiar el día. <code>add12Hours(&quot;&quot; + tests[1] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[1] + &quot;&quot;</code> '
     testString: 'assert(add12Hours(tests[1]) === answers[1], "Should handel day change. <code>add12Hours("" + tests[1] + "")</code> should return <code>"" + answers[1] + ""</code>");'
-  - text: &#39;Debe cambiar el mes en un año bisiesto. <code>add12Hours(&quot;&quot; + tests[2] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[2] + &quot;&quot;</code> &#39;
+  - text: 'Debe cambiar el mes en un año bisiesto. <code>add12Hours(&quot;&quot; + tests[2] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[2] + &quot;&quot;</code> '
     testString: 'assert(add12Hours(tests[2]) === answers[2], "Should handel month change in a leap years. <code>add12Hours("" + tests[2] + "")</code> should return <code>"" + answers[2] + ""</code>");'
-  - text: &#39;Debería cambiar el mes en un año común. <code>add12Hours(&quot;&quot; + tests[3] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[3] + &quot;&quot;</code> &#39;
+  - text: 'Debería cambiar el mes en un año común. <code>add12Hours(&quot;&quot; + tests[3] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[3] + &quot;&quot;</code> '
     testString: 'assert(add12Hours(tests[3]) === answers[3], "Should handel month change in a common years. <code>add12Hours("" + tests[3] + "")</code> should return <code>"" + answers[3] + ""</code>");'
-  - text: Debería cambiar de año. <code>add12Hours(&quot;&quot; + tests[4] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[4] + &quot;&quot;</code> &#39;
+  - text: Debería cambiar de año. <code>add12Hours(&quot;&quot; + tests[4] + &quot;&quot;)</code> debe devolver <code>&quot;&quot; + answers[4] + &quot;&quot;</code> '
     testString: 'assert(add12Hours(tests[4]) === answers[4], "Should handel year change. <code>add12Hours("" + tests[4] + "")</code> should return <code>"" + answers[4] + ""</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/day-of-the-week.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/day-of-the-week.spanish.md
index 886054e7c7..2955d6a257 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/day-of-the-week.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/day-of-the-week.spanish.md
@@ -6,14 +6,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Una empresa decide que cada vez que caiga un domingo en Navidad, les dará a sus trabajadores todos los días feriados extra pagados para que, junto con los días festivos, los trabajadores no tengan que trabajar la semana siguiente (entre el 25 de diciembre y el primero de enero). </p> 
-<p> Tarea: </p> 
-<p> Escriba una función que tome un año de inicio y un año de finalización y devuelva un conjunto de todos los años en los que el 25 de diciembre será un domingo. </p> 
+<section id='description'>
+<p> Una empresa decide que cada vez que caiga un domingo en Navidad, les dará a sus trabajadores todos los días feriados extra pagados para que, junto con los días festivos, los trabajadores no tengan que trabajar la semana siguiente (entre el 25 de diciembre y el primero de enero). </p>
+<p> Tarea: </p>
+<p> Escriba una función que tome un año de inicio y un año de finalización y devuelva un conjunto de todos los años en los que el 25 de diciembre será un domingo. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,11 +24,11 @@ challengeType: 5
 tests:
   - text: <code>findXmasSunday</code> es una función.
     testString: 'assert(typeof findXmasSunday === "function", "<code>findXmasSunday</code> is a function.");'
-  - text: &#39; <code>findChristmasSunday(2000, 2100)</code> debería devolver una matriz.&#39;
+  - text: ' <code>findChristmasSunday(2000, 2100)</code> debería devolver una matriz.'
     testString: 'assert(typeof findXmasSunday(2000, 2100) === "object", "<code>findChristmasSunday(2000, 2100)</code> should return an array.");'
-  - text: &#39; <code>findChristmasSunday(2008, 2121</code> debe devolver [1977, 1983, 1988, 1994, 2005, 2011, 2016]&#39;
+  - text: ' <code>findChristmasSunday(2008, 2121</code> debe devolver [1977, 1983, 1988, 1994, 2005, 2011, 2016]'
     testString: 'assert.deepEqual(findXmasSunday(1970, 2017), firstSolution, "<code>findChristmasSunday(2008, 2121</code> should return [1977, 1983, 1988, 1994, 2005, 2011, 2016]");'
-  - text: &#39; <code>findChristmasSunday(2008, 2121</code> debe devolver [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]&#39;
+  - text: ' <code>findChristmasSunday(2008, 2121</code> debe devolver [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]'
     testString: 'assert.deepEqual(findXmasSunday(2008, 2121), secondSolution, "<code>findChristmasSunday(2008, 2121</code> should return [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deal-cards-for-freecell.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deal-cards-for-freecell.spanish.md
index 461dccc04e..7d282374d7 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deal-cards-for-freecell.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deal-cards-for-freecell.spanish.md
@@ -6,59 +6,59 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Free Cell es el juego de cartas solitario que Paul Alfille introdujo al sistema PLATO en 1978. Jim Horne, de Microsoft, cambió el nombre a FreeCell y reimplementó el juego para <a href="http://rosettacode.org/wiki/DOS" title="DOS">DOS</a> , luego <a href="http://rosettacode.org/wiki/Windows" title="Windows">Windows</a> . </p> 
-<p> Esta versión introdujo 32000 ofertas numeradas. (Las <a href="http://www.solitairelaboratory.com/fcfaq.html" title="enlace: http://www.solitairelaboratory.com/fcfaq.html">preguntas frecuentes de FreeCell</a> cuentan esta historia). </p><p> A medida que el juego se hizo popular, Jim Horne reveló <a href="http://www.solitairelaboratory.com/mshuffle.txt" title="enlace: http://www.solitairelaboratory.com/mshuffle.txt">el algoritmo</a> y otras implementaciones de FreeCell comenzaron a reproducir los acuerdos de Microsoft. </p> 
-<p> Estas ofertas están numeradas del 1 al 32000. </p> 
-<p> Las versiones más nuevas de Microsoft tienen 1 millón de ofertas, numeradas del 1 al 1000000; Algunas implementaciones permiten números fuera de ese rango. </p><p> El algoritmo utiliza este <a href="http://rosettacode.org/wiki/linear congruential generator" title="generador lineal congruente">generador lineal congruente</a> de Microsoft C: </p> $ state_ {n + 1} \ equiv 214013 \ times state_n + 2531011 \ pmod {2 ^ {31}} $ 
-$ rand_n = state_n \ div 2 ^ {16} $ 
-$ rand_n $ está en el rango de 0 a 32767. 
-<p> El algoritmo sigue: </p> Siembra el RNG con el número de la oferta. 
-Crea una <a href="http://rosettacode.org/wiki/array" title="formación">serie</a> de 52 cartas: As of Clubs, As of Diamonds, As of Hearts, As of Spades, 2 of Clubs, 2 of Diamonds, y así sucesivamente a través de las filas: As, 2, 3, 4, 5, 6 , 7, 8, 9, 10, Jack, reina, rey. Los índices de matriz son de 0 a 51, con Ace of Clubs en 0 y King of Spades en 51. 
-Hasta que la matriz esté vacía: 
-Elija una tarjeta al azar en el índice ≡ siguiente número aleatorio (mod longitud de la matriz). 
-Intercambia esta carta aleatoria con la última carta de la matriz. 
-Eliminar esta tarjeta aleatoria de la matriz. (La longitud de la matriz se reduce en 1.) 
-Repartir esta carta aleatoria. 
-Reparte las 52 cartas, boca arriba, en 8 columnas. Las primeras 8 cartas van en 8 columnas, las siguientes 8 cartas van en las primeras 8 cartas, y así sucesivamente. 
-Ejemplo: 
-<p> Orden para repartir cartas </p> 
-<p> <pre> 1 2 3 4 5 6 7 8 
-9 10 11 12 13 14 15 16 
-17 18 19 20 21 22 23 24 
-25 26 27 28 29 30 31 32 
-33 34 35 36 37 38 39 40 
-41 42 43 44 45 46 47 48 
-49 50 51 52 </pre></p> 
-<p> Juego # 1 </p> 
-<p> <pre> [ 
-[&#39;JD&#39;, &#39;2D&#39;, &#39;9H&#39;, &#39;JC&#39;, &#39;5D&#39;, &#39;7H&#39;, &#39;7C&#39;, &#39;5H&#39;], 
-[&#39;KD&#39;, &#39;KC&#39;, &#39;9S&#39;, &#39;5S&#39;, &#39;AD&#39;, &#39;QC&#39;, &#39;KH&#39;, &#39;3H&#39;], 
-[&#39;2S&#39;, &#39;KS&#39;, &#39;9D&#39;, &#39;QD&#39;, &#39;JS&#39;, &#39;AS&#39;, &#39;AH&#39; , &#39;3C&#39;], 
-[&#39;4C&#39;, &#39;5C&#39;, &#39;TS&#39;, &#39;QH&#39;, &#39;4H&#39;, &#39;AC&#39;, &#39;4D&#39;, &#39;7S&#39;], 
-[&#39;3S&#39;, &#39;TD&#39; , &#39;4S&#39;, &#39;TH&#39;, &#39;8H&#39;, &#39;2C&#39;, &#39;JH&#39;, &#39;7D&#39;], 
-[&#39;6D&#39;, &#39;8S&#39;, &#39;8D&#39;, &#39;QS&#39;, &#39;6C&#39;, &#39;3D &#39;,&#39; 8C &#39;,&#39; TC &#39;], 
-[&#39; 6S &#39;,&#39; 9C &#39;,&#39; 2H &#39;,&#39; 6H &#39;] 
-] </pre></p> 
-<p> Juego # 617 </p> 
-<p> <pre> [ 
-[&#39;7D&#39;, &#39;AD&#39;, &#39;5C&#39;, &#39;3S&#39;, &#39;5S&#39;, &#39;8C&#39;, &#39;2D&#39;, &#39;AH&#39;], 
-[&#39;TD&#39;, &#39;7S&#39;, &#39;QD&#39;, &#39;AC&#39;, &#39;6D&#39;, &#39;8H&#39;, &#39;AS&#39;, &#39;KH&#39;], 
-[&#39;TH&#39;, &#39;QC&#39;, &#39;3H&#39;, &#39;9D&#39;, &#39;6S&#39;, &#39;8D&#39;, &#39;3D&#39; , &#39;TC&#39;], 
-[&#39;KD&#39;, &#39;5H&#39;, &#39;9S&#39;, &#39;3C&#39;, &#39;8S&#39;, &#39;7H&#39;, &#39;4D&#39;, &#39;JS&#39;], 
-[&#39;4C&#39;, &#39;QS&#39; , &#39;9C&#39;, &#39;9H&#39;, &#39;7C&#39;, &#39;6H&#39;, &#39;2C&#39;, &#39;2S&#39;], 
-[&#39;4S&#39;, &#39;TS&#39;, &#39;2H&#39;, &#39;5D&#39;, &#39;JC&#39;, &#39;6C &#39;,&#39; JH &#39;,&#39; QH &#39;], 
-[&#39; JD &#39;,&#39; KS &#39;,&#39; KC &#39;,&#39; 4H &#39;] 
-] </pre></p> 
-Tarea: 
-<p> Escriba una función para tomar un número de acuerdo y tarjetas de acuerdo en el mismo orden que este algoritmo. </p> 
-<p> La función debe devolver una matriz bidimensional que representa la placa FreeCell. </p> 
-<p> Las ofertas también pueden <a href="http://freecellgamesolutions.com/" title="enlace: http://freecellgamesolutions.com/">compararse con las soluciones FreeCell para 1000000 juegos</a> . </p> 
-<p> (Invoca una solución de video y muestra el trato inicial.) </p> 
+<section id='description'>
+<p> Free Cell es el juego de cartas solitario que Paul Alfille introdujo al sistema PLATO en 1978. Jim Horne, de Microsoft, cambió el nombre a FreeCell y reimplementó el juego para <a href="http://rosettacode.org/wiki/DOS" title="DOS">DOS</a> , luego <a href="http://rosettacode.org/wiki/Windows" title="Windows">Windows</a> . </p>
+<p> Esta versión introdujo 32000 ofertas numeradas. (Las <a href="http://www.solitairelaboratory.com/fcfaq.html" title="enlace: http://www.solitairelaboratory.com/fcfaq.html">preguntas frecuentes de FreeCell</a> cuentan esta historia). </p><p> A medida que el juego se hizo popular, Jim Horne reveló <a href="http://www.solitairelaboratory.com/mshuffle.txt" title="enlace: http://www.solitairelaboratory.com/mshuffle.txt">el algoritmo</a> y otras implementaciones de FreeCell comenzaron a reproducir los acuerdos de Microsoft. </p>
+<p> Estas ofertas están numeradas del 1 al 32000. </p>
+<p> Las versiones más nuevas de Microsoft tienen 1 millón de ofertas, numeradas del 1 al 1000000; Algunas implementaciones permiten números fuera de ese rango. </p><p> El algoritmo utiliza este <a href="http://rosettacode.org/wiki/linear congruential generator" title="generador lineal congruente">generador lineal congruente</a> de Microsoft C: </p> $ state_ {n + 1} \ equiv 214013 \ times state_n + 2531011 \ pmod {2 ^ {31}} $
+$ rand_n = state_n \ div 2 ^ {16} $
+$ rand_n $ está en el rango de 0 a 32767.
+<p> El algoritmo sigue: </p> Siembra el RNG con el número de la oferta.
+Crea una <a href="http://rosettacode.org/wiki/array" title="formación">serie</a> de 52 cartas: As of Clubs, As of Diamonds, As of Hearts, As of Spades, 2 of Clubs, 2 of Diamonds, y así sucesivamente a través de las filas: As, 2, 3, 4, 5, 6 , 7, 8, 9, 10, Jack, reina, rey. Los índices de matriz son de 0 a 51, con Ace of Clubs en 0 y King of Spades en 51.
+Hasta que la matriz esté vacía:
+Elija una tarjeta al azar en el índice ≡ siguiente número aleatorio (mod longitud de la matriz).
+Intercambia esta carta aleatoria con la última carta de la matriz.
+Eliminar esta tarjeta aleatoria de la matriz. (La longitud de la matriz se reduce en 1.)
+Repartir esta carta aleatoria.
+Reparte las 52 cartas, boca arriba, en 8 columnas. Las primeras 8 cartas van en 8 columnas, las siguientes 8 cartas van en las primeras 8 cartas, y así sucesivamente.
+Ejemplo:
+<p> Orden para repartir cartas </p>
+<p> <pre> 1 2 3 4 5 6 7 8
+9 10 11 12 13 14 15 16
+17 18 19 20 21 22 23 24
+25 26 27 28 29 30 31 32
+33 34 35 36 37 38 39 40
+41 42 43 44 45 46 47 48
+49 50 51 52 </pre></p>
+<p> Juego # 1 </p>
+<p> <pre> [
+[&#39;JD&#39;, &#39;2D&#39;, &#39;9H&#39;, &#39;JC&#39;, &#39;5D&#39;, &#39;7H&#39;, &#39;7C&#39;, &#39;5H&#39;],
+[&#39;KD&#39;, &#39;KC&#39;, &#39;9S&#39;, &#39;5S&#39;, &#39;AD&#39;, &#39;QC&#39;, &#39;KH&#39;, &#39;3H&#39;],
+[&#39;2S&#39;, &#39;KS&#39;, &#39;9D&#39;, &#39;QD&#39;, &#39;JS&#39;, &#39;AS&#39;, &#39;AH&#39; , &#39;3C&#39;],
+[&#39;4C&#39;, &#39;5C&#39;, &#39;TS&#39;, &#39;QH&#39;, &#39;4H&#39;, &#39;AC&#39;, &#39;4D&#39;, &#39;7S&#39;],
+[&#39;3S&#39;, &#39;TD&#39; , &#39;4S&#39;, &#39;TH&#39;, &#39;8H&#39;, &#39;2C&#39;, &#39;JH&#39;, &#39;7D&#39;],
+[&#39;6D&#39;, &#39;8S&#39;, &#39;8D&#39;, &#39;QS&#39;, &#39;6C&#39;, &#39;3D &#39;,&#39; 8C &#39;,&#39; TC &#39;],
+[&#39; 6S &#39;,&#39; 9C &#39;,&#39; 2H &#39;,&#39; 6H &#39;]
+] </pre></p>
+<p> Juego # 617 </p>
+<p> <pre> [
+[&#39;7D&#39;, &#39;AD&#39;, &#39;5C&#39;, &#39;3S&#39;, &#39;5S&#39;, &#39;8C&#39;, &#39;2D&#39;, &#39;AH&#39;],
+[&#39;TD&#39;, &#39;7S&#39;, &#39;QD&#39;, &#39;AC&#39;, &#39;6D&#39;, &#39;8H&#39;, &#39;AS&#39;, &#39;KH&#39;],
+[&#39;TH&#39;, &#39;QC&#39;, &#39;3H&#39;, &#39;9D&#39;, &#39;6S&#39;, &#39;8D&#39;, &#39;3D&#39; , &#39;TC&#39;],
+[&#39;KD&#39;, &#39;5H&#39;, &#39;9S&#39;, &#39;3C&#39;, &#39;8S&#39;, &#39;7H&#39;, &#39;4D&#39;, &#39;JS&#39;],
+[&#39;4C&#39;, &#39;QS&#39; , &#39;9C&#39;, &#39;9H&#39;, &#39;7C&#39;, &#39;6H&#39;, &#39;2C&#39;, &#39;2S&#39;],
+[&#39;4S&#39;, &#39;TS&#39;, &#39;2H&#39;, &#39;5D&#39;, &#39;JC&#39;, &#39;6C &#39;,&#39; JH &#39;,&#39; QH &#39;],
+[&#39; JD &#39;,&#39; KS &#39;,&#39; KC &#39;,&#39; 4H &#39;]
+] </pre></p>
+Tarea:
+<p> Escriba una función para tomar un número de acuerdo y tarjetas de acuerdo en el mismo orden que este algoritmo. </p>
+<p> La función debe devolver una matriz bidimensional que representa la placa FreeCell. </p>
+<p> Las ofertas también pueden <a href="http://freecellgamesolutions.com/" title="enlace: http://freecellgamesolutions.com/">compararse con las soluciones FreeCell para 1000000 juegos</a> . </p>
+<p> (Invoca una solución de video y muestra el trato inicial.) </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -73,9 +73,9 @@ tests:
     testString: 'assert(typeof dealFreeCell(1) === "object", "<code>dealFreeCell(seed)</code> should return an object.");'
   - text: <code>dealFreeCell(seed)</code> debe devolver una matriz de longitud 7.
     testString: 'assert(dealFreeCell(1).length === 7, "<code>dealFreeCell(seed)</code> should return an array of length 7.");'
-  - text: &#39; <code>dealFreeCell(1)</code> debe devolver una matriz idéntica al ejemplo &quot;Juego # 1&quot;&#39;
+  - text: ' <code>dealFreeCell(1)</code> debe devolver una matriz idéntica al ejemplo &quot;Juego # 1&quot;'
     testString: 'assert.deepEqual(dealFreeCell(1), game1, "<code>dealFreeCell(1)</code> should return an array identical to example "Game #1"");'
-  - text: &#39; <code>dealFreeCell(617)</code> debe devolver una matriz idéntica al ejemplo &quot;Juego # 617&quot;&#39;
+  - text: ' <code>dealFreeCell(617)</code> debe devolver una matriz idéntica al ejemplo &quot;Juego # 617&quot;'
     testString: 'assert.deepEqual(dealFreeCell(617), game617, "<code>dealFreeCell(617)</code> should return an array identical to example "Game #617"");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deepcopy.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deepcopy.spanish.md
index e4386ee21c..a61fb4ce20 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deepcopy.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deepcopy.spanish.md
@@ -6,19 +6,19 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Escribe una función que devuelva una copia profunda de un objeto dado. </p> 
-<p> La copia no debe ser el mismo objeto que se le dio. </p> 
-<p> Esta tarea no probará para: </p> 
-Objetos con propiedades que son funciones 
-Objetos de fecha u objeto con propiedades que son objetos de fecha 
-RegEx u objeto con propiedades que son objetos de RegEx 
-Copia de prototipo 
+<section id='description'>
+Tarea:
+<p> Escribe una función que devuelva una copia profunda de un objeto dado. </p>
+<p> La copia no debe ser el mismo objeto que se le dio. </p>
+<p> Esta tarea no probará para: </p>
+Objetos con propiedades que son funciones
+Objetos de fecha u objeto con propiedades que son objetos de fecha
+RegEx u objeto con propiedades que son objetos de RegEx
+Copia de prototipo
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -29,13 +29,13 @@ Copia de prototipo
 tests:
   - text: <code>deepcopy</code> debe ser una función.
     testString: 'assert(typeof deepcopy === "function", "<code>deepcopy</code> should be a function.");'
-  - text: &#39; <code>deepcopy({test: &quot;test&quot;})</code> debe devolver un objeto.&#39;
+  - text: ' <code>deepcopy({test: &quot;test&quot;})</code> debe devolver un objeto.'
     testString: 'assert(typeof deepcopy(obj1) === "object", "<code>deepcopy({test: "test"})</code> should return an object.");'
   - text: No debe devolver el mismo objeto que se proporcionó.
     testString: 'assert(deepcopy(obj2) != obj2, "Should not return the same object that was provided.");'
-  - text: &#39;Cuando se pasa un objeto que contiene una matriz, debe devolver una copia profunda del objeto&#39;.
+  - text: 'Cuando se pasa un objeto que contiene una matriz, debe devolver una copia profunda del objeto'
     testString: 'assert.deepEqual(deepcopy(obj2), obj2, "When passed an object containing an array, should return a deep copy of the object.");'
-  - text: &#39;Cuando se pasa un objeto que contiene otro objeto, debe devolver una copia profunda del objeto&#39;.
+  - text: 'Cuando se pasa un objeto que contiene otro objeto, debe devolver una copia profunda del objeto'
     testString: 'assert.deepEqual(deepcopy(obj3), obj3, "When passed an object containing another object, should return a deep copy of the object.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/define-a-primitive-data-type.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/define-a-primitive-data-type.spanish.md
index 401251bbd6..e777c09c97 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/define-a-primitive-data-type.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/define-a-primitive-data-type.spanish.md
@@ -6,18 +6,18 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Defina un tipo que se comporte como un entero pero que tenga un valor válido más bajo de 1 y un valor válido más alto de 10. </p> 
-Errores: 
-Si intenta crear una instancia de un <code>Num</code> con un valor fuera de 1 - 10 
-, debe lanzar un <code>TypeError</code> con un mensaje de error de <code>&#39;Out of range&#39;</code> . 
-Si intenta crear una instancia de un <code>Num</code> con un valor que no es un número 
-, debe lanzar un <code>TypeError</code> con un mensaje de error <code>&#39;Not a Number&#39;</code> . 
+<section id='description'>
+Tarea:
+<p> Defina un tipo que se comporte como un entero pero que tenga un valor válido más bajo de 1 y un valor válido más alto de 10. </p>
+Errores:
+Si intenta crear una instancia de un <code>Num</code> con un valor fuera de 1 - 10
+, debe lanzar un <code>TypeError</code> con un mensaje de error de <code>&#39;Out of range&#39;</code> .
+Si intenta crear una instancia de un <code>Num</code> con un valor que no es un número
+, debe lanzar un <code>TypeError</code> con un mensaje de error <code>&#39;Not a Number&#39;</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,15 +30,15 @@ tests:
     testString: 'assert(typeof Num === "function", "<code>Num</code> should be a function.");'
   - text: <code>new Num(4)</code> debe devolver un objeto.
     testString: 'assert(typeof (new Num(4)) === "object", "<code>new Num(4)</code> should return an object.");'
-  - text: <code>new Num(\&#39;test\&#39;)</code> debe lanzar un TypeError con el mensaje \ &#39;Not a Number \&#39;.
+  - text: <code>new Num(\&#39;test\&#39;)</code> debe lanzar un TypeError con el mensaje \ &#39;Not a Number \'
     testString: 'assert(throws(() => new Num("test"), TypeError, "Not a Number"), "<code>new Num(\"test\")</code> should throw a TypeError with message \"Not a Number\".");'
-  - text: <code>new Num(0)</code> debe lanzar un TypeError con el mensaje \ &#39;Fuera de rango \&#39;.
+  - text: <code>new Num(0)</code> debe lanzar un TypeError con el mensaje \ &#39;Fuera de rango \'
     testString: 'assert(throws(() => new Num(0), TypeError, "Out of range"), "<code>new Num(0)</code> should throw a TypeError with message \"Out of range\".");'
   - text: <code>new Num(-5)</code> debe lanzar un TypeError con el mensaje &quot;Fuera de rango&quot;.
     testString: 'assert(throws(() => new Num(-5), TypeError, "Out of range"), "<code>new Num(-5)</code> should throw a TypeError with message \"Out of range\".");'
-  - text: <code>new Num(10)</code> debe lanzar un TypeError con el mensaje \ &#39;Fuera de rango \&#39;.
+  - text: <code>new Num(10)</code> debe lanzar un TypeError con el mensaje \ &#39;Fuera de rango \'
     testString: 'assert(throws(() => new Num(11), TypeError, "Out of range"), "<code>new Num(10)</code> should throw a TypeError with message \"Out of range\".");'
-  - text: <code>new Num(20)</code> debe lanzar un TypeError con el mensaje \ &#39;Fuera de rango \&#39;.
+  - text: <code>new Num(20)</code> debe lanzar un TypeError con el mensaje \ &#39;Fuera de rango \'
     testString: 'assert(throws(() => new Num(20), TypeError, "Out of range"), "<code>new Num(20)</code> should throw a TypeError with message \"Out of range\".");'
   - text: <code>new Num(3) + new Num(4)</code> debe ser igual a 7.
     testString: 'assert.equal(new Num(3) + new Num(4), 7, "<code>new Num(3) + new Num(4)</code> should equal 7.");'
@@ -52,7 +52,7 @@ tests:
     testString: 'assert(new Num(3) < new Num(4), "<code>new Num(3) < new Num(4)</code> should be true.");'
   - text: <code>new Num(3) &gt; new Num(4)</code> debe ser falso.
     testString: 'assert(!(new Num(3) > new Num(4)), "<code>new Num(3) > new Num(4)</code> should be false.");'
-  - text: <code>(new Num(5)).toString()</code> debe devolver \ &#39;5 \&#39;
+  - text: <code>(new Num(5)).toString()</code> debe devolver \ &#39;5 \'
     testString: 'assert.equal((new Num(5)).toString(), "5", "<code>(new Num(5)).toString()</code> should return \"5\"");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/department-numbers.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/department-numbers.spanish.md
index cca0b8cf96..9c8663bfa5 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/department-numbers.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/department-numbers.spanish.md
@@ -6,32 +6,32 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Hay una ciudad altamente organizada que ha decidido asignar un número a cada uno de sus departamentos: </p> 
-Policía del departamento 
-Saneamiento departamento de 
-Cuerpo de bomberos 
-<p> Cada departamento puede tener un número entre 1 y 7 (inclusive). </p><p> Los tres números de departamento deben ser únicos (diferentes entre sí) y deben sumar hasta el número 12. </p><p> Al jefe de la policía no le gustan los números impares y quiere tener un número par para su departamento. </p> 
-Tarea: 
-<p> Escriba un programa que produzca todas las combinaciones válidas: </p> 
-<p> [2, 3, 7] </p> 
-<p> [2, 4, 6] </p> 
-<p> [2, 6, 4] </p> 
-<p> [2, 7, 3] </p> 
-<p> [4, 1, 7] </p> 
-<p> [4, 2, 6] </p> 
-<p> [4, 3, 5] </p> 
-<p> [4, 5, 3] </p> 
-<p> [4, 6, 2] </p> 
-<p> [4, 7, 1] </p> 
-<p> [6, 1, 5] </p> 
-<p> [6, 2, 4] </p> 
-<p> [6, 4, 2] </p> 
-<p> [6, 5, 1] </p> 
+<section id='description'>
+<p> Hay una ciudad altamente organizada que ha decidido asignar un número a cada uno de sus departamentos: </p>
+Policía del departamento
+Saneamiento departamento de
+Cuerpo de bomberos
+<p> Cada departamento puede tener un número entre 1 y 7 (inclusive). </p><p> Los tres números de departamento deben ser únicos (diferentes entre sí) y deben sumar hasta el número 12. </p><p> Al jefe de la policía no le gustan los números impares y quiere tener un número par para su departamento. </p>
+Tarea:
+<p> Escriba un programa que produzca todas las combinaciones válidas: </p>
+<p> [2, 3, 7] </p>
+<p> [2, 4, 6] </p>
+<p> [2, 6, 4] </p>
+<p> [2, 7, 3] </p>
+<p> [4, 1, 7] </p>
+<p> [4, 2, 6] </p>
+<p> [4, 3, 5] </p>
+<p> [4, 5, 3] </p>
+<p> [4, 6, 2] </p>
+<p> [4, 7, 1] </p>
+<p> [6, 1, 5] </p>
+<p> [6, 2, 4] </p>
+<p> [6, 4, 2] </p>
+<p> [6, 5, 1] </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -42,11 +42,11 @@ Tarea:
 tests:
   - text: <code>combinations</code> deben ser una función.
     testString: 'assert(typeof combinations === "function", "<code>combinations</code> should be a function.");'
-  - text: &#39; <code>combinations([1, 2, 3], 6)</code> deben devolver un Array.&#39;
+  - text: ' <code>combinations([1, 2, 3], 6)</code> deben devolver un Array.'
     testString: 'assert(Array.isArray(combinations([1, 2, 3], 6)), "<code>combinations([1, 2, 3], 6)</code> should return an Array.");'
-  - text: &#39; <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver una matriz de longitud 14.&#39;
+  - text: ' <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver una matriz de longitud 14.'
     testString: 'assert(combinations(nums, total).length === len, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return an array of length 14.");'
-  - text: &#39; <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver todas las combinaciones válidas.&#39;
+  - text: ' <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver todas las combinaciones válidas.'
     testString: 'assert.deepEqual(combinations(nums, total), result, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return all valid combinations.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/discordian-date.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/discordian-date.spanish.md
index ce3f3537b6..89e0c2c5a0 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/discordian-date.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/discordian-date.spanish.md
@@ -6,13 +6,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Convierte una fecha dada del <a href="https://en.wikipedia.org/wiki/Gregorian calendar" title="wp: calendario gregoriano">calendario gregoriano al calendario</a> <a href="https://en.wikipedia.org/wiki/Discordian calendar" title="wp: calendario discordiano">Discordiano</a> . </p> 
+<section id='description'>
+Tarea:
+<p> Convierte una fecha dada del <a href="https://en.wikipedia.org/wiki/Gregorian calendar" title="wp: calendario gregoriano">calendario gregoriano al calendario</a> <a href="https://en.wikipedia.org/wiki/Discordian calendar" title="wp: calendario discordiano">Discordiano</a> . </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,19 +23,19 @@ Tarea:
 tests:
   - text: <code>discordianDate</code> es una función.
     testString: 'assert(typeof discordianDate === "function", "<code>discordianDate</code> is a function.");'
-  - text: &#39; <code>discordianDate(new Date(2010, 6, 22))</code> debe devolver <code>&quot;Pungenday, the 57th day of Confusion in the YOLD 3176&quot;</code> .&#39;
+  - text: ' <code>discordianDate(new Date(2010, 6, 22))</code> debe devolver <code>&quot;Pungenday, the 57th day of Confusion in the YOLD 3176&quot;</code> .'
     testString: 'assert(discordianDate(new Date(2010, 6, 22)) === "Pungenday, the 57th day of Confusion in the YOLD 3176", "<code>discordianDate(new Date(2010, 6, 22))</code> should return <code>"Pungenday, the 57th day of Confusion in the YOLD 3176"</code>.");'
-  - text: &#39; <code>discordianDate(new Date(2012, 1, 28))</code> debe devolver <code>&quot;Prickle-Prickle, the 59th day of Chaos in the YOLD 3178&quot;</code> .&#39;
+  - text: ' <code>discordianDate(new Date(2012, 1, 28))</code> debe devolver <code>&quot;Prickle-Prickle, the 59th day of Chaos in the YOLD 3178&quot;</code> .'
     testString: 'assert(discordianDate(new Date(2012, 1, 28)) === "Prickle-Prickle, the 59th day of Chaos in the YOLD 3178", "<code>discordianDate(new Date(2012, 1, 28))</code> should return <code>"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"</code>.");'
-  - text: &#39; <code>discordianDate(new Date(2012, 1, 29))</code> debe devolver <code>&quot;Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\&quot;s Day!&quot;</code> .&#39;
+  - text: ' <code>discordianDate(new Date(2012, 1, 29))</code> debe devolver <code>&quot;Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\&quot;s Day!&quot;</code> .'
     testString: 'assert(discordianDate(new Date(2012, 1, 29)) === "Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!", "<code>discordianDate(new Date(2012, 1, 29))</code> should return <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!"</code>.");'
-  - text: &#39; <code>discordianDate(new Date(2012, 2, 1))</code> debe devolver <code>&quot;Setting Orange, the 60th day of Chaos in the YOLD 3178&quot;</code> .&#39;
+  - text: ' <code>discordianDate(new Date(2012, 2, 1))</code> debe devolver <code>&quot;Setting Orange, the 60th day of Chaos in the YOLD 3178&quot;</code> .'
     testString: 'assert(discordianDate(new Date(2012, 2, 1)) === "Setting Orange, the 60th day of Chaos in the YOLD 3178", "<code>discordianDate(new Date(2012, 2, 1))</code> should return <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178"</code>.");'
-  - text: &#39; <code>discordianDate(new Date(2010, 0, 5))</code> debe devolver <code>&quot;Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!&quot;</code> .
+  - text: ' <code>discordianDate(new Date(2010, 0, 5))</code> debe devolver <code>&quot;Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!&quot;</code> .
     testString: 'assert(discordianDate(new Date(2010, 0, 5)) === "Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!", "<code>discordianDate(new Date(2010, 0, 5))</code> should return <code>"Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!"</code>.");'
-  - text: &#39; <code>discordianDate(new Date(2011, 4, 3))</code> debe devolver <code>&quot;Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!&quot;</code> .
+  - text: ' <code>discordianDate(new Date(2011, 4, 3))</code> debe devolver <code>&quot;Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!&quot;</code> .
     testString: 'assert(discordianDate(new Date(2011, 4, 3)) === "Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!", "<code>discordianDate(new Date(2011, 4, 3))</code> should return <code>"Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!"</code>.");'
-  - text: &#39; <code>discordianDate(new Date(2015, 9, 19))</code> debe devolver <code>&quot;Boomtime, the 73rd day of Bureaucracy in the YOLD 3181&quot;</code> .
+  - text: ' <code>discordianDate(new Date(2015, 9, 19))</code> debe devolver <code>&quot;Boomtime, the 73rd day of Bureaucracy in the YOLD 3181&quot;</code> .
     testString: 'assert(discordianDate(new Date(2015, 9, 19)) === "Boomtime, the 73rd day of Bureaucracy in the YOLD 3181", "<code>discordianDate(new Date(2015, 9, 19))</code> should return <code>"Boomtime, the 73rd day of Bureaucracy in the YOLD 3181"</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/element-wise-operations.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/element-wise-operations.spanish.md
index 9e093b417b..9cb63a4e76 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/element-wise-operations.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/element-wise-operations.spanish.md
@@ -6,18 +6,18 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Implementar operaciones básicas de matriz de matriz de elementos y matriz escalar. </p><p> Implementar: </p> 
-<p> :: * Además </p> 
-<p> :: * resta </p> 
-<p> :: * multiplicación </p> 
-<p> :: * división </p> 
-<p> :: * exponenciación </p> 
-<p> El primer parámetro será la operación a realizar, por ejemplo: &quot;m_add&quot; para la adición de matriz y &quot;s_add&quot; para la adición escalar. Los parámetros segundo y tercero serán las matrices sobre las que se realizarán las operaciones. 
+<section id='description'>
+<p> Implementar operaciones básicas de matriz de matriz de elementos y matriz escalar. </p><p> Implementar: </p>
+<p> :: * Además </p>
+<p> :: * resta </p>
+<p> :: * multiplicación </p>
+<p> :: * división </p>
+<p> :: * exponenciación </p>
+<p> El primer parámetro será la operación a realizar, por ejemplo: &quot;m_add&quot; para la adición de matriz y &quot;s_add&quot; para la adición escalar. Los parámetros segundo y tercero serán las matrices sobre las que se realizarán las operaciones.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,19 +28,19 @@ challengeType: 5
 tests:
   - text: <code>operation</code> es una función.
     testString: 'assert(typeof operation === "function", "<code>operation</code> is a function.");'
-  - text: &#39; <code>operation(&quot;m_add&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[2,4],[6,8]]</code> .
+  - text: ' <code>operation(&quot;m_add&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[2,4],[6,8]]</code> .
     testString: 'assert.deepEqual(operation("m_add", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[2, 4], [6, 8]], "<code>operation("m_add",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[2,4],[6,8]]</code>.");'
-  - text: &#39; <code>operation(&quot;s_add&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[3,4],[5,6]]</code> .
+  - text: ' <code>operation(&quot;s_add&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[3,4],[5,6]]</code> .
     testString: 'assert.deepEqual(operation("s_add", [[1, 2], [3, 4]], 2), [[3, 4], [5, 6]], "<code>operation("s_add",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[3,4],[5,6]]</code>.");'
-  - text: &#39; <code>operation(&quot;m_sub&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[0,0],[0,0]]</code> .
+  - text: ' <code>operation(&quot;m_sub&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[0,0],[0,0]]</code> .
     testString: 'assert.deepEqual(operation("m_sub", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[0, 0], [0, 0]], "<code>operation("m_sub",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[0,0],[0,0]]</code>.");'
-  - text: &#39; <code>operation(&quot;m_mult&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[9,16]]</code> .
+  - text: ' <code>operation(&quot;m_mult&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[9,16]]</code> .
     testString: 'assert.deepEqual(operation("m_mult", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 4], [9, 16]], "<code>operation("m_mult",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,4],[9,16]]</code>.");'
-  - text: &#39; <code>operation(&quot;m_div&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,1],[1,1]]</code> .
+  - text: ' <code>operation(&quot;m_div&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,1],[1,1]]</code> .
     testString: 'assert.deepEqual(operation("m_div", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 1], [1, 1]], "<code>operation("m_div",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,1],[1,1]]</code>.");'
-  - text: &#39;la <code>operation(&quot;m_exp&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[27,256]]</code> .&#39;
+  - text: 'la <code>operation(&quot;m_exp&quot;,[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[27,256]]</code> .'
     testString: 'assert.deepEqual(operation("m_exp", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 4], [27, 256]], "<code>operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,4],[27,256]]</code>.");'
-  - text: &#39; <code>operation(&quot;m_add&quot;,[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> debe devolver <code>[[10,12,14,16],[18,20,22,24]]</code> . &#39;
+  - text: ' <code>operation(&quot;m_add&quot;,[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> debe devolver <code>[[10,12,14,16],[18,20,22,24]]</code> . '
     testString: 'assert.deepEqual(operation("m_add", [[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]), [[10, 12, 14, 16], [18, 20, 22, 24]], "<code>operation("m_add",[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> should return <code>[[10,12,14,16],[18,20,22,24]]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/emirp-primes.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/emirp-primes.spanish.md
index ff1a40b0db..15b4b52fee 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/emirp-primes.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/emirp-primes.spanish.md
@@ -6,13 +6,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Un emirp (primo deletreado al revés) son primos que cuando se invierten (en su representación decimal) son primos diferentes. </p> 
-<p> Escriba una función que debería ser capaz de: Mostrar los primeros <b>n</b> eprimes números. Mostrar los números de eprimes en un rango. Mostrar el número de eprimes en un rango. Mostrar el <b>n <sup>número de</sup></b> eprimes. <p> La función debe tener dos parámetros. El primero recibirá <b>n</b> o el rango como una matriz. El segundo recibirá un valor booleano, que especifica si la función devuelve los eprimes como una matriz o un único número (el número de números primos en el rango o la <b><sup>enésima</sup></b> primo). De acuerdo con los parámetros, la función debe devolver una matriz o un número. 
+<section id='description'>
+<p> Un emirp (primo deletreado al revés) son primos que cuando se invierten (en su representación decimal) son primos diferentes. </p>
+<p> Escriba una función que debería ser capaz de: Mostrar los primeros <b>n</b> eprimes números. Mostrar los números de eprimes en un rango. Mostrar el número de eprimes en un rango. Mostrar el <b>n <sup>número de</sup></b> eprimes. <p> La función debe tener dos parámetros. El primero recibirá <b>n</b> o el rango como una matriz. El segundo recibirá un valor booleano, que especifica si la función devuelve los eprimes como una matriz o un único número (el número de números primos en el rango o la <b><sup>enésima</sup></b> primo). De acuerdo con los parámetros, la función debe devolver una matriz o un número.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,13 +23,13 @@ challengeType: 5
 tests:
   - text: <code>emirps</code> es una función.
     testString: 'assert(typeof emirps === "function", "<code>emirps</code> is a function.");'
-  - text: &#39; <code>emirps(20,true)</code> debe devolver <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code> &#39;
+  - text: ' <code>emirps(20,true)</code> debe devolver <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code> '
     testString: 'assert.deepEqual(emirps(20, true), [13, 17, 31, 37, 71, 73, 79, 97, 107, 113, 149, 157, 167, 179, 199, 311, 337, 347, 359, 389], "<code>emirps(20,true)</code> should return <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code>");'
   - text: <code>emirps(10000)</code> deben devolver <code>948349</code>
     testString: 'assert.deepEqual(emirps(10000), 948349, "<code>emirps(10000)</code> should return <code>948349</code>");'
-  - text: &#39; <code>emirps([7700,8000],true)</code> debe devolver <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code> &#39;
+  - text: ' <code>emirps([7700,8000],true)</code> debe devolver <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code> '
     testString: 'assert.deepEqual(emirps([7700, 8000], true), [7717, 7757, 7817, 7841, 7867, 7879, 7901, 7927, 7949, 7951, 7963], "<code>emirps([7700,8000],true)</code> should return <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code>");'
-  - text: &#39; <code>emirps([7700,8000],true)</code> debe devolver <code>11</code> &#39;
+  - text: ' <code>emirps([7700,8000],true)</code> debe devolver <code>11</code> '
     testString: 'assert.deepEqual(emirps([7700, 8000], false), 11, "<code>emirps([7700,8000],true)</code> should return <code>11</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/equilibrium-index.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/equilibrium-index.spanish.md
index 25dc60a448..a3344c972a 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/equilibrium-index.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/equilibrium-index.spanish.md
@@ -6,20 +6,20 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Un índice de equilibrio de una secuencia es un índice en la secuencia tal que la suma de los elementos en los índices más bajos es igual a la suma de los elementos en los índices más altos. </p> 
-<p> Por ejemplo, en una secuencia <big>$ A $</big> : </p><p> <big>:::: $ A_0 = -7 $</big> </p> 
-<p> :::: <big>$ A_1 = 1 $</big> </p> 
-<p> <big>:::: $ A_2 = 5 $</big> </p> 
-<p> <big>:::: $ A_3 = 2 $</big> </p> 
-<p> <big>:::: $ A_4 = -4 $</big> </p> 
-<p> <big>:::: $ A_5 = 3 $</big> </p> 
-<p> <big>:::: $ A_6 = 0 $</big> </p><p> 3 es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 = A_4 + A_5 + A_6 $</big> </p><p> 6 también es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0 $</big> </p><p> (la suma de cero elementos es cero) </p><p> 7 no es un índice de equilibrio, porque no es un índice válido de secuencia <big>$ A $</big> . </p> 
-<p> Escriba una función que, dada una secuencia, devuelva sus índices de equilibrio (si los hay). </p><p> Supongamos que la secuencia puede ser muy larga. </p> 
+<section id='description'>
+<p> Un índice de equilibrio de una secuencia es un índice en la secuencia tal que la suma de los elementos en los índices más bajos es igual a la suma de los elementos en los índices más altos. </p>
+<p> Por ejemplo, en una secuencia <big>$ A $</big> : </p><p> <big>:::: $ A_0 = -7 $</big> </p>
+<p> :::: <big>$ A_1 = 1 $</big> </p>
+<p> <big>:::: $ A_2 = 5 $</big> </p>
+<p> <big>:::: $ A_3 = 2 $</big> </p>
+<p> <big>:::: $ A_4 = -4 $</big> </p>
+<p> <big>:::: $ A_5 = 3 $</big> </p>
+<p> <big>:::: $ A_6 = 0 $</big> </p><p> 3 es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 = A_4 + A_5 + A_6 $</big> </p><p> 6 también es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0 $</big> </p><p> (la suma de cero elementos es cero) </p><p> 7 no es un índice de equilibrio, porque no es un índice válido de secuencia <big>$ A $</big> . </p>
+<p> Escriba una función que, dada una secuencia, devuelva sus índices de equilibrio (si los hay). </p><p> Supongamos que la secuencia puede ser muy larga. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -30,17 +30,17 @@ challengeType: 5
 tests:
   - text: <code>equilibrium</code> es una función.
     testString: 'assert(typeof equilibrium === "function", "<code>equilibrium</code> is a function.");'
-  - text: &#39;el <code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> debe devolver <code>[3,6]</code> .&#39;
+  - text: 'el <code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> debe devolver <code>[3,6]</code> .'
     testString: 'assert.deepEqual(equilibrium(tests[0]), ans[0], "<code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> should return <code>[3,6]</code>.");'
-  - text: &#39;el <code>equilibrium([2, 4, 6])</code> debe devolver <code>[]</code> .&#39;
+  - text: 'el <code>equilibrium([2, 4, 6])</code> debe devolver <code>[]</code> .'
     testString: 'assert.deepEqual(equilibrium(tests[1]), ans[1], "<code>equilibrium([2, 4, 6])</code> should return <code>[]</code>.");'
-  - text: &#39;el <code>equilibrium([2, 9, 2])</code> debe devolver <code>[1]</code> .&#39;
+  - text: 'el <code>equilibrium([2, 9, 2])</code> debe devolver <code>[1]</code> .'
     testString: 'assert.deepEqual(equilibrium(tests[2]), ans[2], "<code>equilibrium([2, 9, 2])</code> should return <code>[1]</code>.");'
-  - text: &#39;el <code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> debe devolver <code>[0,1,2,3,4,5,6]</code> .&#39;
+  - text: 'el <code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> debe devolver <code>[0,1,2,3,4,5,6]</code> .'
     testString: 'assert.deepEqual(equilibrium(tests[3]), ans[3], "<code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> should return <code>[0,1,2,3,4,5,6]</code>.");'
-  - text: &#39;el <code>equilibrium([1])</code> debe devolver <code>[0]</code> .&#39;
+  - text: 'el <code>equilibrium([1])</code> debe devolver <code>[0]</code> .'
     testString: 'assert.deepEqual(equilibrium(tests[4]), ans[4], "<code>equilibrium([1])</code> should return <code>[0]</code>.");'
-  - text: &#39;el <code>equilibrium([])</code> debe devolver <code>[]</code> .&#39;
+  - text: 'el <code>equilibrium([])</code> debe devolver <code>[]</code> .'
     testString: 'assert.deepEqual(equilibrium(tests[5]), ans[5], "<code>equilibrium([])</code> should return <code>[]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ethiopian-multiplication.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ethiopian-multiplication.spanish.md
index 812d12f8e6..22221973b3 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ethiopian-multiplication.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ethiopian-multiplication.spanish.md
@@ -6,53 +6,53 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> La multiplicación etíope es un método para multiplicar enteros utilizando solo la suma, el doblado y la reducción a la mitad. </p> 
-<p> Método: </p> 
-Toma dos números para multiplicarlos y escríbelos en la parte superior de las dos columnas. 
-En la columna de la izquierda, reduzca a la mitad el último número, descartando cualquier resto, y escriba el resultado debajo del último en la misma columna, hasta que escriba un valor de 1. 
-En la columna de la derecha, doble el número de la última vez y Escribe el resultado a continuación. deténgase cuando agregue un resultado en la misma fila donde la columna de la izquierda muestra 1. 
-Examine la tabla producida y descarte cualquier fila donde el valor en la columna de la izquierda sea par. 
-Suma los valores en la columna de la derecha que quedan para producir el resultado de multiplicar los dos números originales juntos 
-<p> Por ejemplo: 17 × 34. </p> 
-<p> 17 34 </p> 
-<p> Reduciendo a la mitad la primera columna: </p> 
-<p> 17 34 </p> 
-<p> 8 </p> 
-<p> 4 </p> 
-<p> 2 </p> 
-<p> 1 </p> 
-<p> Duplicando la segunda columna: </p> 
-<p> 17 34 </p> 
-<p> 8 68 </p> 
-<p> 4 136 </p> 
-<p> 2 272 </p> 
-<p> 1 544 </p> 
-<p> Filas tachadas cuya primera celda es par: </p> 
-<p> 17 34 </p> 
-<p> 8 <strike>68</strike> </p> 
-<p> 4 <strike>136</strike> </p> 
-<p> 2 <strike>272</strike> </p> 
-<p> 1 544 </p> 
-<p> Suma los números restantes en la columna de la derecha: </p> 
-<p> 17 34 </p> 
-<p> 8 - </p> 
-<p> 4 --- </p> 
-<p> 2 --- </p> 
-<p> 1 544 </p> 
-<p> ==== </p> 
-<p> 578 </p> 
-<p> Entonces 17 multiplicado por 34, por el método etíope es 578. </p> 
-Tarea: 
-<p> La tarea es definir tres funciones nombradas / métodos / procedimientos / subrutinas: </p> 
-uno para reducir a la mitad un número entero, 
-uno para duplicar un número entero y 
-uno para indicar si un número entero es par. 
-<p> Usa estas funciones para crear una función que haga la multiplicación etíope. </p> 
+<section id='description'>
+<p> La multiplicación etíope es un método para multiplicar enteros utilizando solo la suma, el doblado y la reducción a la mitad. </p>
+<p> Método: </p>
+Toma dos números para multiplicarlos y escríbelos en la parte superior de las dos columnas.
+En la columna de la izquierda, reduzca a la mitad el último número, descartando cualquier resto, y escriba el resultado debajo del último en la misma columna, hasta que escriba un valor de 1.
+En la columna de la derecha, doble el número de la última vez y Escribe el resultado a continuación. deténgase cuando agregue un resultado en la misma fila donde la columna de la izquierda muestra 1.
+Examine la tabla producida y descarte cualquier fila donde el valor en la columna de la izquierda sea par.
+Suma los valores en la columna de la derecha que quedan para producir el resultado de multiplicar los dos números originales juntos
+<p> Por ejemplo: 17 × 34. </p>
+<p> 17 34 </p>
+<p> Reduciendo a la mitad la primera columna: </p>
+<p> 17 34 </p>
+<p> 8 </p>
+<p> 4 </p>
+<p> 2 </p>
+<p> 1 </p>
+<p> Duplicando la segunda columna: </p>
+<p> 17 34 </p>
+<p> 8 68 </p>
+<p> 4 136 </p>
+<p> 2 272 </p>
+<p> 1 544 </p>
+<p> Filas tachadas cuya primera celda es par: </p>
+<p> 17 34 </p>
+<p> 8 <strike>68</strike> </p>
+<p> 4 <strike>136</strike> </p>
+<p> 2 <strike>272</strike> </p>
+<p> 1 544 </p>
+<p> Suma los números restantes en la columna de la derecha: </p>
+<p> 17 34 </p>
+<p> 8 - </p>
+<p> 4 --- </p>
+<p> 2 --- </p>
+<p> 1 544 </p>
+<p> ==== </p>
+<p> 578 </p>
+<p> Entonces 17 multiplicado por 34, por el método etíope es 578. </p>
+Tarea:
+<p> La tarea es definir tres funciones nombradas / métodos / procedimientos / subrutinas: </p>
+uno para reducir a la mitad un número entero,
+uno para duplicar un número entero y
+uno para indicar si un número entero es par.
+<p> Usa estas funciones para crear una función que haga la multiplicación etíope. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -63,15 +63,15 @@ uno para indicar si un número entero es par.
 tests:
   - text: <code>eth_mult</code> es una función.
     testString: 'assert(typeof eth_mult === "function", "<code>eth_mult</code> is a function.");'
-  - text: &#39; <code>eth_mult(17,34)</code> debe devolver <code>578</code> &#39;.
+  - text: ' <code>eth_mult(17,34)</code> debe devolver <code>578</code> '
     testString: 'assert.equal(eth_mult(17, 34), 578, "<code>eth_mult(17,34)</code> should return <code>578</code>.");'
-  - text: &#39; <code>eth_mult(23,46)</code> debe devolver <code>1058</code> &#39;.
+  - text: ' <code>eth_mult(23,46)</code> debe devolver <code>1058</code> '
     testString: 'assert.equal(eth_mult(23, 46), 1058, "<code>eth_mult(23,46)</code> should return <code>1058</code>.");'
-  - text: &#39; <code>eth_mult(12,27)</code> debe devolver <code>324</code> &#39;
+  - text: ' <code>eth_mult(12,27)</code> debe devolver <code>324</code> '
     testString: 'assert.equal(eth_mult(12, 27), 324, "<code>eth_mult(12,27)</code> should return <code>324</code>.");'
-  - text: &#39; <code>eth_mult(56,98)</code> debe devolver <code>5488</code> &#39;.
+  - text: ' <code>eth_mult(56,98)</code> debe devolver <code>5488</code> '
     testString: 'assert.equal(eth_mult(56, 98), 5488, "<code>eth_mult(56,98)</code> should return <code>5488</code>.");'
-  - text: &#39; <code>eth_mult(63,74)</code> debe devolver <code>4662</code> &#39;.
+  - text: ' <code>eth_mult(63,74)</code> debe devolver <code>4662</code> '
     testString: 'assert.equal(eth_mult(63, 74), 4662, "<code>eth_mult(63,74)</code> should return <code>4662</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/euler-method.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/euler-method.spanish.md
index a7c0e0df66..034d8b9aac 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/euler-method.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/euler-method.spanish.md
@@ -6,28 +6,28 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> El método de Euler aproxima numéricamente las soluciones de ecuaciones diferenciales ordinarias de primer orden (EDO) con un valor inicial dado. Es un método explícito para resolver problemas de valor inicial (IVP), como se describe en <a href="https://en.wikipedia.org/wiki/Euler method" title="wp: método de euler">la página de wikipedia</a> . </p><p> La EDO debe ser proporcionada en la siguiente forma: </p><p> :: <big>$ \ frac {dy (t)} {dt} = f (t, y (t)) $</big> </p><p> con un valor inicial </p><p> :: <big>$ y (t_0) = y_0 $</big> </p><p> Para obtener una solución numérica, reemplazamos el derivado en LHS con una aproximación de diferencias finitas: </p><p> :: <big>$ \ frac {dy (t)} {dt} \ approx \ frac {y (t + h) -y (t)} {h} $</big> </p><p> luego resuelva por $ y (t + h) $: </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, \ frac {dy (t)} {dt} $</big> </p><p> que es lo mismo que </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, f (t, y (t)) $</big> </p><p> La regla de solución iterativa es entonces: </p><p> :: <big>$ y_ {n + 1} = y_n + h \, f (t_n, y_n) $</big> </p><p> donde <big>$ h $</big> es el tamaño del paso, el parámetro más relevante para la precisión de la solución. Un tamaño de paso más pequeño aumenta la precisión, pero también el costo de cómputo, por lo que siempre tiene que ser seleccionado de acuerdo con el problema en cuestión. </p> 
-<p> Ejemplo: Ley de enfriamiento de Newton </p><p> La ley de enfriamiento de Newton describe cómo un objeto de temperatura inicial <big>$ T (t_0) = T_0 $ se</big> enfría en un entorno de temperatura <big>$ T_R $</big> : </p><p> :: <big>$ \ frac {dT (t)} {dt} = -k \, \ Delta T $</big> </p> 
-<p> o </p> 
-<p> :: <big>$ \ frac {dT (t)} {dt} = -k \, (T (t) - T_R) $</big> </p> 
-<p> Dice que la tasa de enfriamiento <big>$ \ frac {dT (t)} {dt} $</big> del objeto es proporcional a la diferencia de temperatura actual <big>$ \ Delta T = (T (t) - T_R) $</big> al entorno circundante. </p><p> La solución analítica, que compararemos con la aproximación numérica, es </p> 
-<p> :: <big>$ T (t) = T_R + (T_0 - T_R) \; e ^ {- kt} $</big> </p> 
-Tarea: 
-<p> Implemente una rutina del método de Euler y luego úselo para resolver el ejemplo dado de la ley de enfriamiento de Newton para tres tamaños de pasos diferentes de: </p> 
-<p> :: * 2 s </p> 
-<p> :: * 5 sy </p> 
-<p> :: * 10 s </p> 
-<p> y comparar con la solución analítica. </p> 
-Valores iniciales: 
-<p> :: * temperatura inicial <big>$ T_0 $</big> será de 100 ° C </p> 
-<p> :: * temperatura ambiente <big>$ T_R $</big> será 20 ° C </p> 
-<p> :: * constante de refrigeración <big>$ k $</big> será 0.07 </p> 
-<p> :: * El intervalo de tiempo para calcular será de 0 s ──► 100 s </p> 
+<section id='description'>
+<p> El método de Euler aproxima numéricamente las soluciones de ecuaciones diferenciales ordinarias de primer orden (EDO) con un valor inicial dado. Es un método explícito para resolver problemas de valor inicial (IVP), como se describe en <a href="https://en.wikipedia.org/wiki/Euler method" title="wp: método de euler">la página de wikipedia</a> . </p><p> La EDO debe ser proporcionada en la siguiente forma: </p><p> :: <big>$ \ frac {dy (t)} {dt} = f (t, y (t)) $</big> </p><p> con un valor inicial </p><p> :: <big>$ y (t_0) = y_0 $</big> </p><p> Para obtener una solución numérica, reemplazamos el derivado en LHS con una aproximación de diferencias finitas: </p><p> :: <big>$ \ frac {dy (t)} {dt} \ approx \ frac {y (t + h) -y (t)} {h} $</big> </p><p> luego resuelva por $ y (t + h) $: </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, \ frac {dy (t)} {dt} $</big> </p><p> que es lo mismo que </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, f (t, y (t)) $</big> </p><p> La regla de solución iterativa es entonces: </p><p> :: <big>$ y_ {n + 1} = y_n + h \, f (t_n, y_n) $</big> </p><p> donde <big>$ h $</big> es el tamaño del paso, el parámetro más relevante para la precisión de la solución. Un tamaño de paso más pequeño aumenta la precisión, pero también el costo de cómputo, por lo que siempre tiene que ser seleccionado de acuerdo con el problema en cuestión. </p>
+<p> Ejemplo: Ley de enfriamiento de Newton </p><p> La ley de enfriamiento de Newton describe cómo un objeto de temperatura inicial <big>$ T (t_0) = T_0 $ se</big> enfría en un entorno de temperatura <big>$ T_R $</big> : </p><p> :: <big>$ \ frac {dT (t)} {dt} = -k \, \ Delta T $</big> </p>
+<p> o </p>
+<p> :: <big>$ \ frac {dT (t)} {dt} = -k \, (T (t) - T_R) $</big> </p>
+<p> Dice que la tasa de enfriamiento <big>$ \ frac {dT (t)} {dt} $</big> del objeto es proporcional a la diferencia de temperatura actual <big>$ \ Delta T = (T (t) - T_R) $</big> al entorno circundante. </p><p> La solución analítica, que compararemos con la aproximación numérica, es </p>
+<p> :: <big>$ T (t) = T_R + (T_0 - T_R) \; e ^ {- kt} $</big> </p>
+Tarea:
+<p> Implemente una rutina del método de Euler y luego úselo para resolver el ejemplo dado de la ley de enfriamiento de Newton para tres tamaños de pasos diferentes de: </p>
+<p> :: * 2 s </p>
+<p> :: * 5 sy </p>
+<p> :: * 10 s </p>
+<p> y comparar con la solución analítica. </p>
+Valores iniciales:
+<p> :: * temperatura inicial <big>$ T_0 $</big> será de 100 ° C </p>
+<p> :: * temperatura ambiente <big>$ T_R $</big> será 20 ° C </p>
+<p> :: * constante de refrigeración <big>$ k $</big> será 0.07 </p>
+<p> :: * El intervalo de tiempo para calcular será de 0 s ──► 100 s </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -38,13 +38,13 @@ Valores iniciales:
 tests:
   - text: <code>eulersMethod</code> es una función.
     testString: 'assert(typeof eulersMethod === "function", "<code>eulersMethod</code> is a function.");'
-  - text: &#39; <code>eulersMethod(0, 100, 100, 10)</code> debe devolver un número&#39;.
+  - text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver un número'
     testString: 'assert(typeof eulersMethod(0, 100, 100, 10) === "number", "<code>eulersMethod(0, 100, 100, 10)</code> should return a number.");'
-  - text: &#39; <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.0424631833732.&#39;
+  - text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.0424631833732.'
     testString: 'assert.equal(eulersMethod(0, 100, 100, 2), 20.0424631833732, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.0424631833732.");'
-  - text: &#39; <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.01449963666907.&#39;
+  - text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.01449963666907.'
     testString: 'assert.equal(eulersMethod(0, 100, 100, 5), 20.01449963666907, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.01449963666907.");'
-  - text: &#39; <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.000472392.&#39;
+  - text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.000472392.'
     testString: 'assert.equal(eulersMethod(0, 100, 100, 10), 20.000472392, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.000472392.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.spanish.md
index fe679f6a8e..34605b6ef1 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.spanish.md
@@ -6,13 +6,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escribe una función para calcular el coeficiente binomial para el valor dado de n y k. </p><p> Se recomienda esta fórmula: </p> 
-$ \ binom {n} {k} = \ frac {n!} {(Nk)! K!} = \ Frac {n (n-1) (n-2) \ ldots (n-k + 1)} {k (k-1) (k-2) \ ldots 1} $ 
+<section id='description'>
+<p> Escribe una función para calcular el coeficiente binomial para el valor dado de n y k. </p><p> Se recomienda esta fórmula: </p>
+$ \ binom {n} {k} = \ frac {n!} {(Nk)! K!} = \ Frac {n (n-1) (n-2) \ ldots (n-k + 1)} {k (k-1) (k-2) \ ldots 1} $
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,15 +23,15 @@ $ \ binom {n} {k} = \ frac {n!} {(Nk)! K!} = \ Frac {n (n-1) (n-2) \ ldots (n-k
 tests:
   - text: <code>binom</code> es una función.
     testString: 'assert(typeof binom === "function", "<code>binom</code> is a function.");'
-  - text: &#39; <code>binom(5,3)</code> debe devolver 10.&#39;
+  - text: ' <code>binom(5,3)</code> debe devolver 10.'
     testString: 'assert.equal(binom(5, 3), 10, "<code>binom(5,3)</code> should return 10.");'
-  - text: &#39; <code>binom(7,2)</code> debe devolver 21&#39;.
+  - text: ' <code>binom(7,2)</code> debe devolver 21'
     testString: 'assert.equal(binom(7, 2), 21, "<code>binom(7,2)</code> should return 21.");'
-  - text: &#39; <code>binom(10,4)</code> debe devolver 210.&#39;
+  - text: ' <code>binom(10,4)</code> debe devolver 210.'
     testString: 'assert.equal(binom(10, 4), 210, "<code>binom(10,4)</code> should return 210.");'
-  - text: &#39; <code>binom(6,1)</code> debe devolver 6.&#39;
+  - text: ' <code>binom(6,1)</code> debe devolver 6.'
     testString: 'assert.equal(binom(6, 1), 6, "<code>binom(6,1)</code> should return 6.");'
-  - text: &#39; <code>binom(12,8)</code> debe devolver 495.&#39;
+  - text: ' <code>binom(12,8)</code> debe devolver 495.'
     testString: 'assert.equal(binom(12, 8), 495, "<code>binom(12,8)</code> should return 495.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.spanish.md
index 25cb5e7186..912c561991 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.spanish.md
@@ -6,116 +6,116 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Crear un intérprete para un <a href="https://en.wikipedia.org/wiki/Markov algorithm" title="wp: algoritmo de Markov">algoritmo de Markov</a> . </p><p> Las reglas tienen la sintaxis: </p> 
-<p> <ruleset> :: = (( <comment> | <rule> ) <newline> +) * </p> 
-<p> <comment> :: = # { <any character> } </p> 
-<p> <rule> :: = <pattern><whitespace> -&gt; <whitespace> [.] <replacement></p> 
-<p> <whitespace> :: = ( <tab> | <space> ) [ <whitespace> ] </p> 
-<p> Hay una regla por línea. </p><p> Si hay un <b>.</b> (periodo) presente antes del <replacement> , entonces esta es una regla de terminación, en cuyo caso el intérprete debe detener la ejecución. </p><p> Un conjunto de reglas consiste en una secuencia de reglas, con comentarios opcionales. </p> 
-<p> <big><big>Reglas</big></big> </p><p> Utilice las siguientes pruebas en las entradas: </p> 
-Reglas 1: 
-<pre> 
-Este archivo de reglas se extrae de Wikipedia: 
-http://en.wikipedia.org/wiki/Markov_AlgorithmA -&gt; apple 
-B -&gt; bag 
-S -&gt; shop 
-T -&gt; the 
-the shop -&gt; my brother 
-a nunca usado -&gt; regla de terminación 
-</pre> 
-<p> Texto de ejemplo de: </p> 
-<p> <code>I bought a B of As from T S.</code> </p> 
-<p> Debe generar la salida: </p> 
-<p> <code>I bought a bag of apples from my brother.</code> </p> 
-Reglas 2: 
-<p> Una prueba de la regla de terminación. </p> 
-<pre> 
-Modificado ligeramente de las reglas de WikipediaA -&gt; manzana 
-B -&gt; bolsa 
-S -&gt; .shop 
-T -&gt; el 
-la tienda -&gt; mi hermano 
-una regla nunca utilizada -&gt; .terminating </pre> 
-<p> Texto de ejemplo de: </p> 
-<p> <code>I bought a B of As from T S.</code> </p> 
-<p> Debe generar: </p> 
-<p> <code>I bought a bag of apples from T shop.</code> </p> 
-Reglas 3: 
-<p> Esto prueba el orden de sustitución correcto y puede interceptar rutinas de reemplazo basadas en expresiones regulares simples si no se escapan los caracteres de expresiones regulares especiales. </p> 
-<pre> 
-BNF Reglas de prueba de sintaxisA -&gt; apple 
-WWWW -&gt; con 
-Bgage -&gt; -&gt;. * 
-B -&gt; bolsa 
--&gt;. * -&gt; money 
-W -&gt; WW 
-S -&gt; .shop 
-T -&gt; the 
-la tienda -&gt; mi hermano 
-a nunca usado -&gt; .terminando la regla 
-</pre> 
-<p> Texto de ejemplo de: </p> 
-<p> <code>I bought a B of As W my Bgage from T S.</code> </p> 
-<p> Debe generar: </p> 
-<p> <code>I bought a bag of apples with my money from T shop.</code> </p> 
-Reglas 4: 
-<p> Esto prueba el orden correcto de escaneo de las reglas y puede interceptar las rutinas de reemplazo que escanean en el orden incorrecto. Implementa un motor general de multiplicación unaria. (Tenga en cuenta que la expresión de entrada se debe colocar dentro de los guiones bajos en esta implementación). </p> 
-<pre> 
-## Unary Multiplication Engine, para probar las implementaciones del algoritmo de Markov 
-## Por Donal Fellows. 
-Motor de suma unitaria_ + 1 -&gt; _1 + 
-1 + 1 -&gt; 11+ 
-Pase para convertir de la división de la multiplicación en 
-suma ordinaria1! -&gt;! 1 
-,! -&gt;! + 
-_! -&gt; _ 
-Multiplicación unaria duplicando el lado izquierdo, lado derecho veces1 * 1 -&gt; x, @ y 
-1x -&gt; xX 
-X, -&gt; 1,1 
-X1 -&gt; 1X 
-_x -&gt; _X 
-, x -&gt; , X 
-y1 -&gt; 1y 
-y_ -&gt; _ 
-Siguiente fase de aplicación1 @ 1 -&gt; x, @ y 
-1 @ _ -&gt; @_ 
-, @ _ ​​-&gt;! _ 
-++ -&gt; + 
-Limpieza de terminación para el agregado_1 -&gt; 1 
-1 + _ -&gt; 1 
-_ + _ -&gt; 
-</pre> 
-<p> Texto de ejemplo de: </p> 
-<p> <code>_1111*11111_</code> </p> 
-<p> debe generar la salida: </p> 
-<p> <code>11111111111111111111</code> </p> 
-Reglas 5: 
-<p> Una simple <a href="http://en.wikipedia.org/wiki/Turing_machine" title="enlace: http://en.wikipedia.org/wiki/Turing_machine">máquina de Turing</a> , </p> 
-<p> Implementando un <a href="http://en.wikipedia.org/wiki/Busy_beaver" title="enlace: http://en.wikipedia.org/wiki/Busy_beaver">castor ocupado de</a> tres estados. </p><p> La cinta consta de 0s y 1s, los estados son A, B, C y H (para Halt), y la posición del encabezado se indica escribiendo la letra del estado antes del carácter donde está el encabezado. </p> 
-<p> Todas las partes de la cinta inicial en la que opera la máquina deben incluirse en la entrada. </p><p> Además de demostrar que el algoritmo de Markov está completo en Turing, también me hizo detectar un error en la implementación de C ++ que no se detectó en los primeros cuatro conjuntos de reglas. </p> 
-<pre> 
-Máquina de Turing: castor ocupado de tres estados 
-# estado A, símbolo 0 =&gt; escribir 1, mover a la derecha, nuevo estado BA0 -&gt; 1B 
-estado A, símbolo 1 =&gt; escribir 1, mover a la izquierda, nuevo estado C0A1 -&gt; C01 
-1A1 -&gt; C11 
-estado B, símbolo 0 =&gt; escritura 1, mover a la izquierda, nuevo estado A0B0 -&gt; A01 
-1B0 -&gt; A11 
-estado B, símbolo 1 =&gt; escribir 1, mover a la derecha, nuevo estado BB1 -&gt; 1B 
-estado C, símbolo 0 =&gt; escribir 1, mover a la izquierda, nuevo estado B0C0 -&gt; B01 
-1C0 -&gt; B11 
-estado C, símbolo 1 =&gt; escribir 1, mover a la izquierda, halt0C1 -&gt; H01 
-1C1 -&gt; H11 
-</pre> 
-<p> Este conjunto de reglas debe girar </p> 
-<p> <code>000000A000000</code> </p> 
-<p> dentro </p> 
-<p> <code>00011H1111000</code> </p> 
+<section id='description'>
+Tarea:
+<p> Crear un intérprete para un <a href="https://en.wikipedia.org/wiki/Markov algorithm" title="wp: algoritmo de Markov">algoritmo de Markov</a> . </p><p> Las reglas tienen la sintaxis: </p>
+<p> <ruleset> :: = (( <comment> | <rule> ) <newline> +) * </p>
+<p> <comment> :: = # { <any character> } </p>
+<p> <rule> :: = <pattern><whitespace> -&gt; <whitespace> [.] <replacement></p>
+<p> <whitespace> :: = ( <tab> | <space> ) [ <whitespace> ] </p>
+<p> Hay una regla por línea. </p><p> Si hay un <b>.</b> (periodo) presente antes del <replacement> , entonces esta es una regla de terminación, en cuyo caso el intérprete debe detener la ejecución. </p><p> Un conjunto de reglas consiste en una secuencia de reglas, con comentarios opcionales. </p>
+<p> <big><big>Reglas</big></big> </p><p> Utilice las siguientes pruebas en las entradas: </p>
+Reglas 1:
+<pre>
+Este archivo de reglas se extrae de Wikipedia:
+http://en.wikipedia.org/wiki/Markov_AlgorithmA -&gt; apple
+B -&gt; bag
+S -&gt; shop
+T -&gt; the
+the shop -&gt; my brother
+a nunca usado -&gt; regla de terminación
+</pre>
+<p> Texto de ejemplo de: </p>
+<p> <code>I bought a B of As from T S.</code> </p>
+<p> Debe generar la salida: </p>
+<p> <code>I bought a bag of apples from my brother.</code> </p>
+Reglas 2:
+<p> Una prueba de la regla de terminación. </p>
+<pre>
+Modificado ligeramente de las reglas de WikipediaA -&gt; manzana
+B -&gt; bolsa
+S -&gt; .shop
+T -&gt; el
+la tienda -&gt; mi hermano
+una regla nunca utilizada -&gt; .terminating </pre>
+<p> Texto de ejemplo de: </p>
+<p> <code>I bought a B of As from T S.</code> </p>
+<p> Debe generar: </p>
+<p> <code>I bought a bag of apples from T shop.</code> </p>
+Reglas 3:
+<p> Esto prueba el orden de sustitución correcto y puede interceptar rutinas de reemplazo basadas en expresiones regulares simples si no se escapan los caracteres de expresiones regulares especiales. </p>
+<pre>
+BNF Reglas de prueba de sintaxisA -&gt; apple
+WWWW -&gt; con
+Bgage -&gt; -&gt;. *
+B -&gt; bolsa
+-&gt;. * -&gt; money
+W -&gt; WW
+S -&gt; .shop
+T -&gt; the
+la tienda -&gt; mi hermano
+a nunca usado -&gt; .terminando la regla
+</pre>
+<p> Texto de ejemplo de: </p>
+<p> <code>I bought a B of As W my Bgage from T S.</code> </p>
+<p> Debe generar: </p>
+<p> <code>I bought a bag of apples with my money from T shop.</code> </p>
+Reglas 4:
+<p> Esto prueba el orden correcto de escaneo de las reglas y puede interceptar las rutinas de reemplazo que escanean en el orden incorrecto. Implementa un motor general de multiplicación unaria. (Tenga en cuenta que la expresión de entrada se debe colocar dentro de los guiones bajos en esta implementación). </p>
+<pre>
+## Unary Multiplication Engine, para probar las implementaciones del algoritmo de Markov
+## Por Donal Fellows.
+Motor de suma unitaria_ + 1 -&gt; _1 +
+1 + 1 -&gt; 11+
+Pase para convertir de la división de la multiplicación en
+suma ordinaria1! -&gt;! 1
+,! -&gt;! +
+_! -&gt; _
+Multiplicación unaria duplicando el lado izquierdo, lado derecho veces1 * 1 -&gt; x, @ y
+1x -&gt; xX
+X, -&gt; 1,1
+X1 -&gt; 1X
+_x -&gt; _X
+, x -&gt; , X
+y1 -&gt; 1y
+y_ -&gt; _
+Siguiente fase de aplicación1 @ 1 -&gt; x, @ y
+1 @ _ -&gt; @_
+, @ _ ​​-&gt;! _
+++ -&gt; +
+Limpieza de terminación para el agregado_1 -&gt; 1
+1 + _ -&gt; 1
+_ + _ -&gt;
+</pre>
+<p> Texto de ejemplo de: </p>
+<p> <code>_1111*11111_</code> </p>
+<p> debe generar la salida: </p>
+<p> <code>11111111111111111111</code> </p>
+Reglas 5:
+<p> Una simple <a href="http://en.wikipedia.org/wiki/Turing_machine" title="enlace: http://en.wikipedia.org/wiki/Turing_machine">máquina de Turing</a> , </p>
+<p> Implementando un <a href="http://en.wikipedia.org/wiki/Busy_beaver" title="enlace: http://en.wikipedia.org/wiki/Busy_beaver">castor ocupado de</a> tres estados. </p><p> La cinta consta de 0s y 1s, los estados son A, B, C y H (para Halt), y la posición del encabezado se indica escribiendo la letra del estado antes del carácter donde está el encabezado. </p>
+<p> Todas las partes de la cinta inicial en la que opera la máquina deben incluirse en la entrada. </p><p> Además de demostrar que el algoritmo de Markov está completo en Turing, también me hizo detectar un error en la implementación de C ++ que no se detectó en los primeros cuatro conjuntos de reglas. </p>
+<pre>
+Máquina de Turing: castor ocupado de tres estados
+# estado A, símbolo 0 =&gt; escribir 1, mover a la derecha, nuevo estado BA0 -&gt; 1B
+estado A, símbolo 1 =&gt; escribir 1, mover a la izquierda, nuevo estado C0A1 -&gt; C01
+1A1 -&gt; C11
+estado B, símbolo 0 =&gt; escritura 1, mover a la izquierda, nuevo estado A0B0 -&gt; A01
+1B0 -&gt; A11
+estado B, símbolo 1 =&gt; escribir 1, mover a la derecha, nuevo estado BB1 -&gt; 1B
+estado C, símbolo 0 =&gt; escribir 1, mover a la izquierda, nuevo estado B0C0 -&gt; B01
+1C0 -&gt; B11
+estado C, símbolo 1 =&gt; escribir 1, mover a la izquierda, halt0C1 -&gt; H01
+1C1 -&gt; H11
+</pre>
+<p> Este conjunto de reglas debe girar </p>
+<p> <code>000000A000000</code> </p>
+<p> dentro </p>
+<p> <code>00011H1111000</code> </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -126,15 +126,15 @@ estado C, símbolo 1 =&gt; escribir 1, mover a la izquierda, halt0C1 -&gt; H01
 tests:
   - text: <code>markov</code> es una función.
     testString: 'assert(typeof markov === "function", "<code>markov</code> is a function.");'
-  - text: &#39; <code>markov([&quot;A -&gt; apple&quot;,&quot;B -&gt; bag&quot;,&quot;S -&gt; shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As from T S.&quot;)</code> debería devolver&quot; Compré una bolsa de manzanas de mi hermano &quot;.
+  - text: ' <code>markov([&quot;A -&gt; apple&quot;,&quot;B -&gt; bag&quot;,&quot;S -&gt; shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As from T S.&quot;)</code> debería devolver&quot; Compré una bolsa de manzanas de mi hermano &quot;.
     testString: 'assert.deepEqual(markov(rules[0],tests[0]),outputs[0],"<code>markov(["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")</code> should return "I bought a bag of apples from my brother.".");'
-  - text: &#39; <code>markov([&quot;A -&gt; apple&quot;,&quot;B -&gt; bag&quot;,&quot;S -&gt; .shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As from T S.&quot;)</code> debería devolver&quot; Compré una bolsa de manzanas en la tienda de T &quot;.
+  - text: ' <code>markov([&quot;A -&gt; apple&quot;,&quot;B -&gt; bag&quot;,&quot;S -&gt; .shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As from T S.&quot;)</code> debería devolver&quot; Compré una bolsa de manzanas en la tienda de T &quot;.
     testString: 'assert.deepEqual(markov(rules[1],tests[1]),outputs[1],"<code>markov(["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As from T S.")</code> should return "I bought a bag of apples from T shop.".");'
-  - text: &#39; <code>markov([&quot;A -&gt; apple&quot;,&quot;WWWW -&gt; with&quot;,&quot;Bgage -&gt; -&gt;.*&quot;,&quot;B -&gt; bag&quot;,&quot;-&gt;.* -&gt; money&quot;,&quot;W -&gt; WW&quot;,&quot;S -&gt; .shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As W my Bgage from T S.&quot;)</code> debería devolver&quot; Compré una bolsa de manzanas con mi dinero de la tienda &quot;. &#39;
+  - text: ' <code>markov([&quot;A -&gt; apple&quot;,&quot;WWWW -&gt; with&quot;,&quot;Bgage -&gt; -&gt;.*&quot;,&quot;B -&gt; bag&quot;,&quot;-&gt;.* -&gt; money&quot;,&quot;W -&gt; WW&quot;,&quot;S -&gt; .shop&quot;,&quot;T -&gt; the&quot;,&quot;the shop -&gt; my brother&quot;,&quot;a never used -&gt; .terminating rule&quot;],&quot;I bought a B of As W my Bgage from T S.&quot;)</code> debería devolver&quot; Compré una bolsa de manzanas con mi dinero de la tienda &quot;. '
     testString: 'assert.deepEqual(markov(rules[2],tests[2]),outputs[2],"<code>markov(["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],"I bought a B of As W my Bgage from T S.")</code> should return "I bought a bag of apples with my money from T shop.".");'
-  - text: &#39; <code>markov([&quot;_+1 -&gt; _1+&quot;,&quot;1+1 -&gt; 11+&quot;,&quot;1! -&gt; !1&quot;,&quot;,! -&gt; !+&quot;,&quot;_! -&gt; _&quot;,&quot;1*1 -&gt; x,@y&quot;,&quot;1x -&gt; xX&quot;,&quot;X, -&gt; 1,1&quot;,&quot;X1 -&gt; 1X&quot;,&quot;_x -&gt; _X&quot;,&quot;,x -&gt; ,X&quot;,&quot;y1 -&gt; 1y&quot;,&quot;y_ -&gt; _&quot;,&quot;1@1 -&gt; x,@y&quot;,&quot;1@_ -&gt; @_&quot;,&quot;,@_ -&gt; !_&quot;,&quot;++ -&gt; +&quot;,&quot;_1 -&gt; 1&quot;,&quot;1+_ -&gt; 1&quot;,&quot;_+_ -&gt; &quot;],&quot;_1111*11111_&quot;)</code> debe devolver&quot; 11111111111111111111 &quot;. &#39;
+  - text: ' <code>markov([&quot;_+1 -&gt; _1+&quot;,&quot;1+1 -&gt; 11+&quot;,&quot;1! -&gt; !1&quot;,&quot;,! -&gt; !+&quot;,&quot;_! -&gt; _&quot;,&quot;1*1 -&gt; x,@y&quot;,&quot;1x -&gt; xX&quot;,&quot;X, -&gt; 1,1&quot;,&quot;X1 -&gt; 1X&quot;,&quot;_x -&gt; _X&quot;,&quot;,x -&gt; ,X&quot;,&quot;y1 -&gt; 1y&quot;,&quot;y_ -&gt; _&quot;,&quot;1@1 -&gt; x,@y&quot;,&quot;1@_ -&gt; @_&quot;,&quot;,@_ -&gt; !_&quot;,&quot;++ -&gt; +&quot;,&quot;_1 -&gt; 1&quot;,&quot;1+_ -&gt; 1&quot;,&quot;_+_ -&gt; &quot;],&quot;_1111*11111_&quot;)</code> debe devolver&quot; 11111111111111111111 &quot;. '
     testString: 'assert.deepEqual(markov(rules[3],tests[3]),outputs[3],"<code>markov(["_+1 -> _1+","1+1 -> 11+","1! -> !1",",! -> !+","_! -> _","1*1 -> x,@y","1x -> xX","X, -> 1,1","X1 -> 1X","_x -> _X",",x -> ,X","y1 -> 1y","y_ -> _","1@1 -> x,@y","1@_ -> @_",",@_ -> !_","++ -> +","_1 -> 1","1+_ -> 1","_+_ -> "],"_1111*11111_")</code> should return "11111111111111111111".");'
-  - text: &#39; <code>markov([&quot;A0 -&gt; 1B&quot;,&quot;0A1 -&gt; C01&quot;,&quot;1A1 -&gt; C11&quot;,&quot;0B0 -&gt; A01&quot;,&quot;1B0 -&gt; A11&quot;,&quot;B1 -&gt; 1B&quot;,&quot;0C0 -&gt; B01&quot;,&quot;1C0 -&gt; B11&quot;,&quot;0C1 -&gt; H01&quot;,&quot;1C1 -&gt; H11&quot;],&quot;&quot;)</code> debe devolver&quot; 00011H1111000 &quot;. &#39;
+  - text: ' <code>markov([&quot;A0 -&gt; 1B&quot;,&quot;0A1 -&gt; C01&quot;,&quot;1A1 -&gt; C11&quot;,&quot;0B0 -&gt; A01&quot;,&quot;1B0 -&gt; A11&quot;,&quot;B1 -&gt; 1B&quot;,&quot;0C0 -&gt; B01&quot;,&quot;1C0 -&gt; B11&quot;,&quot;0C1 -&gt; H01&quot;,&quot;1C1 -&gt; H11&quot;],&quot;&quot;)</code> debe devolver&quot; 00011H1111000 &quot;. '
     testString: 'assert.deepEqual(markov(rules[4],tests[4]),outputs[4],"<code>markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")</code> should return "00011H1111000".");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-brain.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-brain.spanish.md
index a216faf1d5..08bff77e70 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-brain.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-brain.spanish.md
@@ -6,35 +6,35 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escribe una función para implementar un intérprete de Brain ****. La función tomará una cadena como parámetro y debería devolver una cadena como salida. Se dan más detalles a continuación : </p> 
-<p> RCBF es un conjunto de compiladores e intérpretes <a href="http://rosettacode.org/wiki/Brainf***" title="Brainf ***">Brainf ***</a> escritos para Rosetta Code en varios idiomas. </p><p> A continuación hay enlaces a cada una de las versiones de RCBF. </p><p> Una implementación solo necesita implementar correctamente las siguientes instrucciones: </p> 
-<p> {| </p> 
-<p> !Mando </p> 
-<p> !Descripción </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>&gt;</code> || Mueve el puntero a la derecha </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>&lt;</code> || Mueve el puntero a la izquierda </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>+</code> || Incrementar la celda de memoria debajo del puntero. </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>-</code> || Disminuye la celda de memoria debajo del puntero. </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>.</code> || Muestra el carácter que significa la celda en el puntero. </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>,</code> || Ingrese un carácter y guárdelo en la celda en el puntero </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>[</code> || Salta la coincidencia <code>]</code> si la celda debajo del puntero es 0 </p> 
-<p> | - </p> 
-<p> | style = &quot;text-align: center&quot; | <code>]</code> || Saltar de nuevo a la coincidencia <code>[</code> si la celda debajo del puntero no es cero </p> 
-<p> |} </p> 
-<p> Se permite cualquier tamaño de celda, la compatibilidad con EOF ( <u>E</u> nd- <u>O</u> - <u>F</u> ) es opcional, ya que tiene memoria limitada o no limitada. </p> 
+<section id='description'>
+<p> Escribe una función para implementar un intérprete de Brain ****. La función tomará una cadena como parámetro y debería devolver una cadena como salida. Se dan más detalles a continuación : </p>
+<p> RCBF es un conjunto de compiladores e intérpretes <a href="http://rosettacode.org/wiki/Brainf***" title="Brainf ***">Brainf ***</a> escritos para Rosetta Code en varios idiomas. </p><p> A continuación hay enlaces a cada una de las versiones de RCBF. </p><p> Una implementación solo necesita implementar correctamente las siguientes instrucciones: </p>
+<p> {| </p>
+<p> !Mando </p>
+<p> !Descripción </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>&gt;</code> || Mueve el puntero a la derecha </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>&lt;</code> || Mueve el puntero a la izquierda </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>+</code> || Incrementar la celda de memoria debajo del puntero. </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>-</code> || Disminuye la celda de memoria debajo del puntero. </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>.</code> || Muestra el carácter que significa la celda en el puntero. </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>,</code> || Ingrese un carácter y guárdelo en la celda en el puntero </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>[</code> || Salta la coincidencia <code>]</code> si la celda debajo del puntero es 0 </p>
+<p> | - </p>
+<p> | style = &quot;text-align: center&quot; | <code>]</code> || Saltar de nuevo a la coincidencia <code>[</code> si la celda debajo del puntero no es cero </p>
+<p> |} </p>
+<p> Se permite cualquier tamaño de celda, la compatibilidad con EOF ( <u>E</u> nd- <u>O</u> - <u>F</u> ) es opcional, ya que tiene memoria limitada o no limitada. </p>
 
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -47,11 +47,11 @@ tests:
     testString: 'assert(typeof brain(bye) === "string", "<code>brain(bye)</code> should return a string");'
   - text: <html> &#39; <code>brain(&quot;++++++[&gt;++++++++++&lt;-]&gt;+++++.&quot;)</code>
     testString: 'assert.equal(brain("++++++[>++++++++++<-]>+++++."),"A", "<code>brain("++++++[>++++++++++<-]>+++++.")</code should return "A"");'
-  - text: &#39; <code>brain(bye)</code> debe devolver ¡ <code>Goodbye, World!\\r\\n</code> &#39;
+  - text: ' <code>brain(bye)</code> debe devolver ¡ <code>Goodbye, World!\\r\\n</code> '
     testString: 'assert.equal(brain(bye), "Goodbye, World!\r\n", "<code>brain(bye)</code> should return <code>Goodbye, World!\\r\\n</code>");'
-  - text: <code>brain(hello)</code> debería devolver <code>Hello World!\\n</code> &#39;
+  - text: <code>brain(hello)</code> debería devolver <code>Hello World!\\n</code> '
     testString: 'assert.equal(brain(hello), "Hello World!\n", "<code>brain(hello)</code> should return <code>Hello World!\\n</code>");'
-  - text: &#39; <code>brain(fib)</code> debe devolver <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code> &#39;
+  - text: ' <code>brain(fib)</code> debe devolver <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code> '
     testString: 'assert.equal(brain(fib), "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89", "<code>brain(fib)</code> should return <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factorial.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factorial.spanish.md
index 8e38d08f44..55a7821ba6 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factorial.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factorial.spanish.md
@@ -6,22 +6,22 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escribe una función para devolver el factorial de un número. </p> 
-<p> El factorial de un número viene dado por: </p> 
-n! = n * (n-1) * (n-2) * ..... * 1 
-<p> 
-Por ejemplo: 
-3! = 3 * 2 * 1 = 6 
-4! = 4 * 3 * 2 * 1 = 24 
-</p> 
-<p> Nota: 
-0! = 1 
-</p> 
+<section id='description'>
+<p> Escribe una función para devolver el factorial de un número. </p>
+<p> El factorial de un número viene dado por: </p>
+n! = n * (n-1) * (n-2) * ..... * 1
+<p>
+Por ejemplo:
+3! = 3 * 2 * 1 = 6
+4! = 4 * 3 * 2 * 1 = 24
+</p>
+<p> Nota:
+0! = 1
+</p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -38,7 +38,7 @@ tests:
     testString: 'assert.equal(factorial(3),results[0],"<code>factorial(3)</code> should return 6.");'
   - text: <code>factorial(3)</code> debe devolver 120. &quot;)
     testString: 'assert.equal(factorial(5),results[1],"<code>factorial(3)</code> should return 120.");'
-  - text: &#39; <code>factorial(3)</code> debe devolver 3,628,800. &quot;)&#39;
+  - text: ' <code>factorial(3)</code> debe devolver 3,628,800. &quot;)'
     testString: 'assert.equal(factorial(10),results[2],"<code>factorial(3)</code> should return 3,628,800.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factors-of-an-integer.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factors-of-an-integer.spanish.md
index e5e2e2a969..160ad7460e 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factors-of-an-integer.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factors-of-an-integer.spanish.md
@@ -6,13 +6,13 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escribe una función que devuelva los factores de un entero positivo. </p><p> Estos factores son los enteros positivos por los cuales el número que se factoriza puede dividirse para obtener un resultado entero positivo. </p> 
-/// 
+<section id='description'>
+<p> Escribe una función que devuelva los factores de un entero positivo. </p><p> Estos factores son los enteros positivos por los cuales el número que se factoriza puede dividirse para obtener un resultado entero positivo. </p>
+///
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -23,11 +23,11 @@ challengeType: 5
 tests:
   - text: <code>factors</code> son una función.
     testString: 'assert(typeof factors === "function", "<code>factors</code> is a function.");'
-  - text: &#39;Los <code>factors(45)</code> deben devolver <code>[1,3,5,9,15,45]</code> .&#39;
+  - text: 'Los <code>factors(45)</code> deben devolver <code>[1,3,5,9,15,45]</code> .'
     testString: 'assert.deepEqual(factors(45), ans[0], "<code>factors(45)</code> should return <code>[1,3,5,9,15,45]</code>.");'
-  - text: Los &#39; <code>factors(53)</code> deben devolver <code>[1,53]</code> .&#39;
+  - text: Los &#39; <code>factors(53)</code> deben devolver <code>[1,53]</code> .'
     testString: 'assert.deepEqual(factors(53), ans[1], "<code>factors(53)</code> should return <code>[1,53]</code>.");'
-  - text: Los &#39; <code>factors(64)</code> deberían devolver <code>[1,2,4,8,16,32,64]</code> .&#39;
+  - text: Los &#39; <code>factors(64)</code> deberían devolver <code>[1,2,4,8,16,32,64]</code> .'
     testString: 'assert.deepEqual(factors(64), ans[2], "<code>factors(64)</code> should return <code>[1,2,4,8,16,32,64]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/farey-sequence.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/farey-sequence.spanish.md
index f163298a90..adf4154afd 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/farey-sequence.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/farey-sequence.spanish.md
@@ -6,24 +6,24 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escriba una función que devuelva la secuencia Farey de orden n. La función debe tener un parámetro que sea n. Debe devolver la secuencia como una matriz. Lea lo siguiente para más detalles : </p><p> La <a href="https://en.wikipedia.org/wiki/Farey sequence" title="wp: secuencia de Farey">secuencia Farey</a> F <sub>n</sub> de orden n es la secuencia de fracciones completamente reducidas entre 0 y 1 que, cuando están en los términos más bajos, tienen denominadores menores o iguales a n, dispuestos en orden creciente de tamaño. </p><p> La secuencia de Farey a veces se llama incorrectamente una serie de Farey. </p> 
-<p> Cada secuencia de Farey: </p> 
-<p> :: * comienza con el valor 0, indicado por la fracción $ \ frac {0} {1} $ </p> 
-<p> :: * termina con el valor 1, indicado por la fracción $ \ frac {1} {1} $. </p> 
-<p> Las secuencias de Farey de las órdenes 1 a 5 son: </p><p> $ {\ bf \ it {F}} _ 1 = \ frac {0} {1}, \ frac {1} {1} $ </p> 
-<p> </p> 
-<p> $ {\ bf \ it {F}} _ 2 = \ frac {0} {1}, \ frac {1} {2}, \ frac {1} {1} $ </p> 
-<p> </p> 
-<p> $ {\ bf \ it {F}} _ 3 = \ frac {0} {1}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {1} {1} $ </p> 
-<p> </p> 
-<p> $ {\ bf \ it {F}} _ 4 = \ frac {0} {1}, \ frac {1} {4}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {3} {4}, \ frac {1} {1} $ </p> 
-<p> </p> 
-<p> $ {\ bf \ it {F}} _ 5 = \ frac {0} {1}, \ frac {1} {5}, \ frac {1} {4}, \ frac {1} {3}, \ frac {2} {5}, \ frac {1} {2}, \ frac {3} {5}, \ frac {2} {3}, \ frac {3} {4}, \ frac {4} {5 }, \ frac {1} {1} $ </p> 
+<section id='description'>
+<p> Escriba una función que devuelva la secuencia Farey de orden n. La función debe tener un parámetro que sea n. Debe devolver la secuencia como una matriz. Lea lo siguiente para más detalles : </p><p> La <a href="https://en.wikipedia.org/wiki/Farey sequence" title="wp: secuencia de Farey">secuencia Farey</a> F <sub>n</sub> de orden n es la secuencia de fracciones completamente reducidas entre 0 y 1 que, cuando están en los términos más bajos, tienen denominadores menores o iguales a n, dispuestos en orden creciente de tamaño. </p><p> La secuencia de Farey a veces se llama incorrectamente una serie de Farey. </p>
+<p> Cada secuencia de Farey: </p>
+<p> :: * comienza con el valor 0, indicado por la fracción $ \ frac {0} {1} $ </p>
+<p> :: * termina con el valor 1, indicado por la fracción $ \ frac {1} {1} $. </p>
+<p> Las secuencias de Farey de las órdenes 1 a 5 son: </p><p> $ {\ bf \ it {F}} _ 1 = \ frac {0} {1}, \ frac {1} {1} $ </p>
+<p> </p>
+<p> $ {\ bf \ it {F}} _ 2 = \ frac {0} {1}, \ frac {1} {2}, \ frac {1} {1} $ </p>
+<p> </p>
+<p> $ {\ bf \ it {F}} _ 3 = \ frac {0} {1}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {1} {1} $ </p>
+<p> </p>
+<p> $ {\ bf \ it {F}} _ 4 = \ frac {0} {1}, \ frac {1} {4}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {3} {4}, \ frac {1} {1} $ </p>
+<p> </p>
+<p> $ {\ bf \ it {F}} _ 5 = \ frac {0} {1}, \ frac {1} {5}, \ frac {1} {4}, \ frac {1} {3}, \ frac {2} {5}, \ frac {1} {2}, \ frac {3} {5}, \ frac {2} {3}, \ frac {3} {4}, \ frac {4} {5 }, \ frac {1} {1} $ </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -36,11 +36,11 @@ tests:
     testString: 'assert(typeof farey === "function", "<code>farey</code> is a function.");'
   - text: <code>farey(3)</code> debería devolver una matriz
     testString: 'assert(Array.isArray(farey(3)), "<code>farey(3)</code> should return an array");'
-  - text: &#39; <code>farey(3)</code> debe devolver <code>[&quot;1/3&quot;,&quot;1/2&quot;,&quot;2/3&quot;]</code> &#39;
+  - text: ' <code>farey(3)</code> debe devolver <code>[&quot;1/3&quot;,&quot;1/2&quot;,&quot;2/3&quot;]</code> '
     testString: 'assert.deepEqual(farey(3), ["1/3","1/2","2/3"], "<code>farey(3)</code> should return <code>["1/3","1/2","2/3"]</code>");'
-  - text: &#39; <code>farey(4)</code> debe devolver <code>[&quot;1/4&quot;,&quot;1/3&quot;,&quot;1/2&quot;,&quot;2/4&quot;,&quot;2/3&quot;,&quot;3/4&quot;]</code> &#39;
+  - text: ' <code>farey(4)</code> debe devolver <code>[&quot;1/4&quot;,&quot;1/3&quot;,&quot;1/2&quot;,&quot;2/4&quot;,&quot;2/3&quot;,&quot;3/4&quot;]</code> '
     testString: 'assert.deepEqual(farey(4), ["1/4","1/3","1/2","2/4","2/3","3/4"], "<code>farey(4)</code> should return <code>["1/4","1/3","1/2","2/4","2/3","3/4"]</code>");'
-  - text: &#39; <code>farey(5)</code> debe devolver <code>[&quot;1/5&quot;,&quot;1/4&quot;,&quot;1/3&quot;,&quot;2/5&quot;,&quot;1/2&quot;,&quot;2/4&quot;,&quot;3/5&quot;,&quot;2/3&quot;,&quot;3/4&quot;,&quot;4/5&quot;]</code> &#39;
+  - text: ' <code>farey(5)</code> debe devolver <code>[&quot;1/5&quot;,&quot;1/4&quot;,&quot;1/3&quot;,&quot;2/5&quot;,&quot;1/2&quot;,&quot;2/4&quot;,&quot;3/5&quot;,&quot;2/3&quot;,&quot;3/4&quot;,&quot;4/5&quot;]</code> '
     testString: 'assert.deepEqual(farey(5), ["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"], "<code>farey(5)</code> should return <code>["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.spanish.md
index 20bb35b2a7..e1c7b3869e 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.spanish.md
@@ -6,11 +6,11 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Escribe una función para generar secuencias numéricas de Fibonacci n-step y secuencias de Lucas. El primer parámetro será n. El segundo parámetro será el número de elementos a devolver. El tercer parámetro especificará si se debe generar la secuencia de Fibonacci o la secuencia de Lucas. Si el parámetro es &quot;f&quot;, devuelva la secuencia de Fibonacci y si es &quot;l&quot;, devuelva la secuencia de Lucas. Las secuencias deben devolverse como una matriz. Se dan más detalles a continuación : </p><p> Estas series de números son una expansión de la <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="secuencia Fibonacci">secuencia de Fibonacci</a> ordinaria donde: </p> 
-Para $ n = 2 $ tenemos la secuencia de Fibonacci; con los valores iniciales $ [1, 1] $ y $ F_k ^ 2 = F_ {k-1} ^ 2 + F_ {k-2} ^ 2 $ 
-Para $ n = 3 $ tenemos la secuencia tribonacci; con valores iniciales $ [1, 1, 2] $ y $ F_k ^ 3 = F_ {k-1} ^ 3 + F_ {k-2} ^ 3 + F_ {k-3} ^ 3 $ 
-Para $ n = 4 $ tenemos la secuencia tetranacci; con valores iniciales $ [1, 1, 2, 4] $ y $ F_k ^ 4 = F_ {k-1} ^ 4 + F_ {k-2} ^ 4 + F_ {k-3} ^ 4 + F_ {k -4} ^ 4 $ ... 
+<section id='description'>
+<p> Escribe una función para generar secuencias numéricas de Fibonacci n-step y secuencias de Lucas. El primer parámetro será n. El segundo parámetro será el número de elementos a devolver. El tercer parámetro especificará si se debe generar la secuencia de Fibonacci o la secuencia de Lucas. Si el parámetro es &quot;f&quot;, devuelva la secuencia de Fibonacci y si es &quot;l&quot;, devuelva la secuencia de Lucas. Las secuencias deben devolverse como una matriz. Se dan más detalles a continuación : </p><p> Estas series de números son una expansión de la <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="secuencia Fibonacci">secuencia de Fibonacci</a> ordinaria donde: </p>
+Para $ n = 2 $ tenemos la secuencia de Fibonacci; con los valores iniciales $ [1, 1] $ y $ F_k ^ 2 = F_ {k-1} ^ 2 + F_ {k-2} ^ 2 $
+Para $ n = 3 $ tenemos la secuencia tribonacci; con valores iniciales $ [1, 1, 2] $ y $ F_k ^ 3 = F_ {k-1} ^ 3 + F_ {k-2} ^ 3 + F_ {k-3} ^ 3 $
+Para $ n = 4 $ tenemos la secuencia tetranacci; con valores iniciales $ [1, 1, 2, 4] $ y $ F_k ^ 4 = F_ {k-1} ^ 4 + F_ {k-2} ^ 4 + F_ {k-3} ^ 4 + F_ {k -4} ^ 4 $ ...
 Para general $ n&gt; 2 $ tenemos la secuencia de pasos de Fibonacci $ n $ - $ F_k ^ n $; con valores iniciales de los primeros $ n $ valores de $ (n-1) $ &#39;th Fibonacci $ n $ -step secuencia $ F_k ^ {n-1} $; y el valor $ k $ &#39;th de esta secuencia $ n <section id='description'>
 <p>Write a function to generate Fibonacci n-step number sequences and Lucas sequences. The first parameter will be n. The second parameter will be the number of elements to be returned. The third parameter will specify whether to output the Fibonacci sequence or the Lucas sequence. If the parameter is "f" then return the Fibonacci sequence and if it is "l", then return the Lucas sequence. The sequences must be returned as an array. More details are given below : </p><p>These number series are an expansion of the ordinary <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="Fibonacci sequence">Fibonacci sequence</a> where:</p>
 For $n = 2$ we have the Fibonacci sequence; with initial values $[1, 1]$ and $F_k^2 = F_{k-1}^2 + F_{k-2}^2$
@@ -41,35 +41,35 @@ For general $n>2$ we have the Fibonacci $n$-step sequence - $F_k^n$; with initia
 <p>| 10 ||  decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...</p>
 <p>|}</p><p>Allied sequences can be generated where the initial values are changed:</p>
 <p> The <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: Lucas number">Lucas series</a> sums the two preceding values like the fibonacci series for $n=2$ but uses $[2, 1]$ as its initial values.</p><p><!-- Lucas numbers, Lucas number, Lucas series     [added to make searches easier.] --></p>
-</section>#39; th es $ F_k ^ n = \ sum_ {i = 1} ^ {(n)} {F_ {ki} ^ {(n)}} $ 
-<p> Para valores pequeños de $ n $, <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Número de prefijo # serie_griega">los prefijos numéricos griegos a</a> veces se usan para nombrar individualmente cada serie. </p><p> {| style = &quot;text-align: left;&quot; border = &quot;4&quot; cellpadding = &quot;2&quot; cellspacing = &quot;2&quot; </p> 
-<p> | + Fibonacci $ n $ -step secuencias </p> 
-<p> | - style = &quot;background-color: rgb (255, 204, 255);&quot; </p> 
-<p> ! $ n $ !! Nombre de serie !! Valores </p> 
-<p> | - </p> 
-<p> | 2 || fibonacci || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... </p> 
-<p> | - </p> 
-<p> | 3 || tribonacci || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... </p> 
-<p> | - </p> 
-<p> | 4 || tetranacci || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... </p> 
-<p> | - </p> 
-<p> | 5 || pentanacci || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... </p> 
-<p> | - </p> 
-<p> | 6 || hexanacci || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... </p> 
-<p> | - </p> 
-<p> | 7 || heptanacci || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... </p> 
-<p> | - </p> 
-<p> | 8 || octonacci || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... </p> 
-<p> | - </p> 
-<p> | 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... </p> 
-<p> | - </p> 
-<p> | 10 || decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... </p> 
-<p> |} </p><p> Se pueden generar secuencias aliadas donde se cambian los valores iniciales: </p> 
-<p> La <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: número de Lucas">serie de Lucas</a> suma los dos valores anteriores como la serie de fibonacci por $ n = 2 $, pero usa $ [2, 1] $ como sus valores iniciales. </p><p><!-- Lucas numbers, Lucas number, Lucas series     [added to make searches easier.] --></p> 
+</section>#39; th es $ F_k ^ n = \ sum_ {i = 1} ^ {(n)} {F_ {ki} ^ {(n)}} $
+<p> Para valores pequeños de $ n $, <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Número de prefijo # serie_griega">los prefijos numéricos griegos a</a> veces se usan para nombrar individualmente cada serie. </p><p> {| style = &quot;text-align: left;&quot; border = &quot;4&quot; cellpadding = &quot;2&quot; cellspacing = &quot;2&quot; </p>
+<p> | + Fibonacci $ n $ -step secuencias </p>
+<p> | - style = &quot;background-color: rgb (255, 204, 255);&quot; </p>
+<p> ! $ n $ !! Nombre de serie !! Valores </p>
+<p> | - </p>
+<p> | 2 || fibonacci || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... </p>
+<p> | - </p>
+<p> | 3 || tribonacci || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... </p>
+<p> | - </p>
+<p> | 4 || tetranacci || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... </p>
+<p> | - </p>
+<p> | 5 || pentanacci || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... </p>
+<p> | - </p>
+<p> | 6 || hexanacci || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... </p>
+<p> | - </p>
+<p> | 7 || heptanacci || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... </p>
+<p> | - </p>
+<p> | 8 || octonacci || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... </p>
+<p> | - </p>
+<p> | 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... </p>
+<p> | - </p>
+<p> | 10 || decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... </p>
+<p> |} </p><p> Se pueden generar secuencias aliadas donde se cambian los valores iniciales: </p>
+<p> La <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: número de Lucas">serie de Lucas</a> suma los dos valores anteriores como la serie de fibonacci por $ n = 2 $, pero usa $ [2, 1] $ como sus valores iniciales. </p><p><!-- Lucas numbers, Lucas number, Lucas series     [added to make searches easier.] --></p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -80,19 +80,19 @@ For general $n>2$ we have the Fibonacci $n$-step sequence - $F_k^n$; with initia
 tests:
   - text: <code>fib_luc</code> es una función.
     testString: 'assert(typeof fib_luc === "function", "<code>fib_luc</code> is a function.");'
-  - text: &#39; <code>fib_luc(2,10,&quot;f&quot;)</code> debe devolver <code>[1,1,2,3,5,8,13,21,34,55]</code> .&#39;
+  - text: ' <code>fib_luc(2,10,&quot;f&quot;)</code> debe devolver <code>[1,1,2,3,5,8,13,21,34,55]</code> .'
     testString: 'assert.deepEqual(fib_luc(2,10,"f"),ans[0],"<code>fib_luc(2,10,"f")</code> should return <code>[1,1,2,3,5,8,13,21,34,55]</code>.");'
-  - text: &#39; <code>fib_luc(3,15,&quot;f&quot;)</code> debe devolver <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code> .&#39;
+  - text: ' <code>fib_luc(3,15,&quot;f&quot;)</code> debe devolver <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code> .'
     testString: 'assert.deepEqual(fib_luc(3,15,"f"),ans[1],"<code>fib_luc(3,15,"f")</code> should return <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code>.");'
-  - text: &#39; <code>fib_luc(4,15,&quot;f&quot;)</code> debe devolver <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code> .&#39;
+  - text: ' <code>fib_luc(4,15,&quot;f&quot;)</code> debe devolver <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code> .'
     testString: 'assert.deepEqual(fib_luc(4,15,"f"),ans[2],"<code>fib_luc(4,15,"f")</code> should return <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code>.");'
-  - text: &#39; <code>fib_luc(2,10,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code> .&#39;
+  - text: ' <code>fib_luc(2,10,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code> .'
     testString: 'assert.deepEqual(fib_luc(2,10,"l"),ans[3],"<code>fib_luc(2,10,"l")</code> should return <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code>.");'
-  - text: &#39; <code>fib_luc(3,15,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code> .&#39;
+  - text: ' <code>fib_luc(3,15,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code> .'
     testString: 'assert.deepEqual(fib_luc(3,15,"l"),ans[4],"<code>fib_luc(3,15,"l")</code> should return <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code>.");'
-  - text: &#39; <code>fib_luc(4,15,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code> .&#39;
+  - text: ' <code>fib_luc(4,15,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code> .'
     testString: 'assert.deepEqual(fib_luc(4,15,"l"),ans[5],"<code>fib_luc(4,15,"l")</code> should return <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code>.");'
-  - text: &#39; <code>fib_luc(5,15,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code> .&#39;
+  - text: ' <code>fib_luc(5,15,&quot;l&quot;)</code> debe devolver <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code> .'
     testString: 'assert.deepEqual(fib_luc(5,15,"l"),ans[6],"<code>fib_luc(5,15,"l")</code> should return <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fractran.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fractran.spanish.md
index 351299235a..11617a022a 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fractran.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fractran.spanish.md
@@ -6,18 +6,18 @@ challengeType: 3
 ---
 
 ## Description
-<section id='description'> 
-<div class="rosetta"> <p class="rosetta__paragraph"> <span class="rosetta__text--bold"><a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/FRACTRAN" title="wp: FRACTRAN">FRACTRAN</a></span> es un lenguaje de programación esotérico completo de Turing inventado por el matemático <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/John Horton Conway" title="wp: John Horton Conway">John Horton Conway</a> . </p><br/><p class="rosetta__paragraph"> Un programa FRACTRAN es una lista ordenada de fracciones positivas $ P = (f_1, f_2, \ ldots, f_m) $, junto con una entrada de entero positiva inicial $ n $. </p> 
-<br/> <p class="rosetta__paragraph"> El programa se ejecuta actualizando el entero $ n $ de la siguiente manera: </p><br/><ul class="rosetta__unordered-list"><li class="rosetta__list-item--unordered"> para la primera fracción, $ f_i $, en la lista para la cual $ nf_i $ es un número entero, reemplace $ n $ con $ nf_i $; </li> 
-<li class="rosetta__list-item--unordered"> repita esta regla hasta que ninguna fracción de la lista produzca un número entero cuando se multiplique por $ n $, luego detenga. </li></ul> 
-<br> 
-<p class="rosetta__paragraph"> Conway dio un programa para primos en FRACTRAN: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 17/91 $, $ 78/85 $, $ 19/51 $, $ 23/38 $, $ 29/33 $, $ 77/29 $, $ 95/23 $, $ 77/19 $, $ 1/17 $, $ 11/13 $, $ 13/11 $, $ 15/14 $, $ 15/2 $, $ 55/1 $</span> </p><br/><p class="rosetta__paragraph"> Comenzando con $ n = 2 $, este programa de FRACTRAN cambiará de $ n $ a $ 15 = 2 \ times (15/2) $, luego $ 825 = 15 \ times (55/1) $, generando la siguiente secuencia de enteros: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 $, $ 15 $, $ 825 $, $ 725 $, $ 1925 $, $ 2275 $, $ 425 $, $ 390 $, $ 330 $, $ 290 $, $ 770 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> Después de 2, esta secuencia contiene las siguientes potencias de 2: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 ^ 2 = 4 $, $ 2 ^ 3 = 8 $, $ 2 ^ 5 = 32 $, $ 2 ^ 7 = 128 $, $ 2 ^ {11} = 2048 $, $ 2 ^ {13} = 8192 $, $ 2 ^ {17 } = 131072 $, $ 2 ^ {19} = 524288 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> cuales son las primeras potencias de 2. </p> 
-<br/> <dl class="rosetta__description-list"><dt class="rosetta__description-title"> Tarea: </dt></dl> 
-<p class="rosetta__paragraph"> Escriba una función que tome un programa de fractran como un parámetro de cadena y devuelva los primeros 10 números del programa como una matriz. Si el resultado no tiene 10 números, devuelva los números como están. </p></div> 
+<section id='description'>
+<div class="rosetta"> <p class="rosetta__paragraph"> <span class="rosetta__text--bold"><a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/FRACTRAN" title="wp: FRACTRAN">FRACTRAN</a></span> es un lenguaje de programación esotérico completo de Turing inventado por el matemático <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/John Horton Conway" title="wp: John Horton Conway">John Horton Conway</a> . </p><br/><p class="rosetta__paragraph"> Un programa FRACTRAN es una lista ordenada de fracciones positivas $ P = (f_1, f_2, \ ldots, f_m) $, junto con una entrada de entero positiva inicial $ n $. </p>
+<br/> <p class="rosetta__paragraph"> El programa se ejecuta actualizando el entero $ n $ de la siguiente manera: </p><br/><ul class="rosetta__unordered-list"><li class="rosetta__list-item--unordered"> para la primera fracción, $ f_i $, en la lista para la cual $ nf_i $ es un número entero, reemplace $ n $ con $ nf_i $; </li>
+<li class="rosetta__list-item--unordered"> repita esta regla hasta que ninguna fracción de la lista produzca un número entero cuando se multiplique por $ n $, luego detenga. </li></ul>
+<br>
+<p class="rosetta__paragraph"> Conway dio un programa para primos en FRACTRAN: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 17/91 $, $ 78/85 $, $ 19/51 $, $ 23/38 $, $ 29/33 $, $ 77/29 $, $ 95/23 $, $ 77/19 $, $ 1/17 $, $ 11/13 $, $ 13/11 $, $ 15/14 $, $ 15/2 $, $ 55/1 $</span> </p><br/><p class="rosetta__paragraph"> Comenzando con $ n = 2 $, este programa de FRACTRAN cambiará de $ n $ a $ 15 = 2 \ times (15/2) $, luego $ 825 = 15 \ times (55/1) $, generando la siguiente secuencia de enteros: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 $, $ 15 $, $ 825 $, $ 725 $, $ 1925 $, $ 2275 $, $ 425 $, $ 390 $, $ 330 $, $ 290 $, $ 770 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> Después de 2, esta secuencia contiene las siguientes potencias de 2: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 ^ 2 = 4 $, $ 2 ^ 3 = 8 $, $ 2 ^ 5 = 32 $, $ 2 ^ 7 = 128 $, $ 2 ^ {11} = 2048 $, $ 2 ^ {13} = 8192 $, $ 2 ^ {17 } = 131072 $, $ 2 ^ {19} = 524288 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> cuales son las primeras potencias de 2. </p>
+<br/> <dl class="rosetta__description-list"><dt class="rosetta__description-title"> Tarea: </dt></dl>
+<p class="rosetta__paragraph"> Escriba una función que tome un programa de fractran como un parámetro de cadena y devuelva los primeros 10 números del programa como una matriz. Si el resultado no tiene 10 números, devuelva los números como están. </p></div>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,17 +28,17 @@ challengeType: 3
 tests:
   - text: <code>fractran</code> debe ser una función.
     testString: 'assert(typeof fractran=="function","<code>fractran</code> should be a function.");'
-  - text: &#39; <code>fractran(&quot;&quot;+tests[0]+&quot;&quot;)</code> debe devolver una matriz.&#39;
+  - text: ' <code>fractran(&quot;&quot;+tests[0]+&quot;&quot;)</code> debe devolver una matriz.'
     testString: 'assert(Array.isArray(fractran(tests[0])),"<code>fractran(""+tests[0]+"")</code> should return an array.");'
-  - text: &#39; <code>fractran(&quot;&quot;+tests[0]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[0])+&quot;</code> .&#39;
+  - text: ' <code>fractran(&quot;&quot;+tests[0]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[0])+&quot;</code> .'
     testString: 'assert.deepEqual(fractran(tests[0]),results[0],"<code>fractran(""+tests[0]+"")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
-  - text: &#39; <code>fractran(&quot;&quot;+tests[1]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[1])+&quot;</code> .&#39;
+  - text: ' <code>fractran(&quot;&quot;+tests[1]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[1])+&quot;</code> .'
     testString: 'assert.deepEqual(fractran(tests[1]),results[1],"<code>fractran(""+tests[1]+"")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
-  - text: &#39; <code>fractran(&quot;&quot;+tests[2]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[2])+&quot;</code> .&#39;
+  - text: ' <code>fractran(&quot;&quot;+tests[2]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[2])+&quot;</code> .'
     testString: 'assert.deepEqual(fractran(tests[2]),results[2],"<code>fractran(""+tests[2]+"")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
-  - text: &#39; <code>fractran(&quot;&quot;+tests[3]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[3])+&quot;</code> .&#39;
+  - text: ' <code>fractran(&quot;&quot;+tests[3]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[3])+&quot;</code> .'
     testString: 'assert.deepEqual(fractran(tests[3]),results[3],"<code>fractran(""+tests[3]+"")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
-  - text: &#39; <code>fractran(&quot;&quot;+tests[4]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[4])+&quot;</code> .&#39;
+  - text: ' <code>fractran(&quot;&quot;+tests[4]+&quot;&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[4])+&quot;</code> .'
     testString: 'assert.deepEqual(fractran(tests[4]),results[4],"<code>fractran(""+tests[4]+"")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gamma-function.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gamma-function.spanish.md
index 9e163234bd..c1048baa72 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gamma-function.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gamma-function.spanish.md
@@ -6,14 +6,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Implemente un algoritmo (o más) para calcular la función <a href="https://en.wikipedia.org/wiki/Gamma function">Gamma</a> ($ \ Gamma $) (solo en el campo real). 
-La función Gamma se puede definir como: 
-<div style='padding-left: 4em;'> <big><big>$ \ Gamma (x) = \ displaystyle \ int_0 ^ \ infty t ^ {x-1} e ^ {- t} dt $</big></big> </div> 
+<section id='description'>
+Implemente un algoritmo (o más) para calcular la función <a href="https://en.wikipedia.org/wiki/Gamma function">Gamma</a> ($ \ Gamma $) (solo en el campo real).
+La función Gamma se puede definir como:
+<div style='padding-left: 4em;'> <big><big>$ \ Gamma (x) = \ displaystyle \ int_0 ^ \ infty t ^ {x-1} e ^ {- t} dt $</big></big> </div>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,17 +24,17 @@ La función Gamma se puede definir como:
 tests:
   - text: <code>gamma</code> debe ser una función.
     testString: 'assert(typeof gamma=="function","<code>gamma</code> should be a function.")'
-  - text: &#39; <code>gamma(&quot;+tests[0]+&quot;)</code> debe devolver un número.&#39;
+  - text: ' <code>gamma(&quot;+tests[0]+&quot;)</code> debe devolver un número.'
     testString: 'assert(typeof gamma(tests[0])=="number","<code>gamma("+tests[0]+")</code> should return a number.")'
-  - text: &#39; <code>gamma(&quot;+tests[0]+&quot;)</code> debe devolver <code>&quot;+results[0]+&quot;</code> .&#39;
+  - text: ' <code>gamma(&quot;+tests[0]+&quot;)</code> debe devolver <code>&quot;+results[0]+&quot;</code> .'
     testString: 'assert.equal(gamma(tests[0]),results[0],"<code>gamma("+tests[0]+")</code> should return <code>"+results[0]+"</code>.")'
-  - text: &#39; <code>gamma(&quot;+tests[1]+&quot;)</code> debe devolver <code>&quot;+results[1]+&quot;</code> .&#39;
+  - text: ' <code>gamma(&quot;+tests[1]+&quot;)</code> debe devolver <code>&quot;+results[1]+&quot;</code> .'
     testString: 'assert.equal(gamma(tests[1]),results[1],"<code>gamma("+tests[1]+")</code> should return <code>"+results[1]+"</code>.")'
-  - text: &#39; <code>gamma(&quot;+tests[2]+&quot;)</code> debe devolver <code>&quot;+results[2]+&quot;</code> .&#39;
+  - text: ' <code>gamma(&quot;+tests[2]+&quot;)</code> debe devolver <code>&quot;+results[2]+&quot;</code> .'
     testString: 'assert.equal(gamma(tests[2]),results[2],"<code>gamma("+tests[2]+")</code> should return <code>"+results[2]+"</code>.")'
-  - text: &#39; <code>gamma(&quot;+tests[3]+&quot;)</code> debe devolver <code>&quot;+results[3]+&quot;</code> .&#39;
+  - text: ' <code>gamma(&quot;+tests[3]+&quot;)</code> debe devolver <code>&quot;+results[3]+&quot;</code> .'
     testString: 'assert.equal(gamma(tests[3]),results[3],"<code>gamma("+tests[3]+")</code> should return <code>"+results[3]+"</code>.")'
-  - text: &#39; <code>gamma(&quot;+tests[4]+&quot;)</code> debe devolver <code>&quot;+results[4]+&quot;</code> .&#39;
+  - text: ' <code>gamma(&quot;+tests[4]+&quot;)</code> debe devolver <code>&quot;+results[4]+&quot;</code> .'
     testString: 'assert.equal(gamma(tests[4]),results[4],"<code>gamma("+tests[4]+")</code> should return <code>"+results[4]+"</code>.")'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.spanish.md
index dd1287d913..77d9be7b92 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.spanish.md
@@ -6,12 +6,12 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Escriba una función para generar una matriz de caracteres ASCII en minúsculas, para un rango determinado. Por ejemplo: para el rango 1 a 4, la función debe devolver <code>[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;]</code> . 
+<section id='description'>
+Escriba una función para generar una matriz de caracteres ASCII en minúsculas, para un rango determinado. Por ejemplo: para el rango 1 a 4, la función debe devolver <code>[&#39;a&#39;,&#39;b&#39;,&#39;c&#39;,&#39;d&#39;]</code> .
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -24,15 +24,15 @@ tests:
     testString: 'assert(typeof lascii=="function","<code>lascii</code> should be a function.");'
   - text: <code>lascii(&quot;a&quot;,&quot;d&quot;)</code> debe devolver una matriz.
     testString: 'assert(Array.isArray(lascii("a","d")),"<code>lascii("a","d")</code> should return an array.");'
-  - text: &#39;&quot; <code>lascii(&quot;a&quot;,&quot;d&quot;)</code> debe devolver <code>[ &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; ]</code> .&quot;&#39;
+  - text: '&quot; <code>lascii(&quot;a&quot;,&quot;d&quot;)</code> debe devolver <code>[ &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; ]</code> .&quot;'
     testString: 'assert.deepEqual(lascii("a","d"),results[0],"<code>lascii("a","d")</code> should return <code>[ "a", "b", "c", "d" ]</code>.");'
-  - text: &#39;&quot; <code>lascii(&quot;c&quot;,&quot;i&quot;)</code> debe devolver <code>[ &quot;c&quot;, &quot;d&quot;, &quot;e&quot;, &quot;f&quot;, &quot;g&quot;, &quot;h&quot;, &quot;i&quot; ]</code> .&quot;&#39;
+  - text: '&quot; <code>lascii(&quot;c&quot;,&quot;i&quot;)</code> debe devolver <code>[ &quot;c&quot;, &quot;d&quot;, &quot;e&quot;, &quot;f&quot;, &quot;g&quot;, &quot;h&quot;, &quot;i&quot; ]</code> .&quot;'
     testString: 'assert.deepEqual(lascii("c","i"),results[1],"<code>lascii("c","i")</code> should return <code>[ "c", "d", "e", "f", "g", "h", "i" ]</code>.");'
-  - text: &#39;&quot; <code>lascii(&quot;m&quot;,&quot;q&quot;)</code> debe devolver <code>[ &quot;m&quot;, &quot;n&quot;, &quot;o&quot;, &quot;p&quot;, &quot;q&quot; ]</code> .&quot;&#39;
+  - text: '&quot; <code>lascii(&quot;m&quot;,&quot;q&quot;)</code> debe devolver <code>[ &quot;m&quot;, &quot;n&quot;, &quot;o&quot;, &quot;p&quot;, &quot;q&quot; ]</code> .&quot;'
     testString: 'assert.deepEqual(lascii("m","q"),results[2],"<code>lascii("m","q")</code> should return <code>[ "m", "n", "o", "p", "q" ]</code>.");'
-  - text: &#39;&quot; <code>lascii(&quot;k&quot;,&quot;n&quot;)</code> debe devolver <code>[ &quot;k&quot;, &quot;l&quot;, &quot;m&quot;, &quot;n&quot; ]</code> .&quot;)&#39;
+  - text: '&quot; <code>lascii(&quot;k&quot;,&quot;n&quot;)</code> debe devolver <code>[ &quot;k&quot;, &quot;l&quot;, &quot;m&quot;, &quot;n&quot; ]</code> .&quot;)'
     testString: 'assert.deepEqual(lascii("k","n"),results[3],"<code>lascii("k","n")</code> should return <code>[ "k", "l", "m", "n" ]</code>.");'
-  - text: &#39;&quot; <code>lascii(&quot;t&quot;,&quot;z&quot;)</code> debe devolver <code>[ &quot;t&quot;, &quot;u&quot;, &quot;v&quot;, &quot;w&quot;, &quot;x&quot;, &quot;y&quot;, &quot;z&quot; ]</code> .&quot;&#39;
+  - text: '&quot; <code>lascii(&quot;t&quot;,&quot;z&quot;)</code> debe devolver <code>[ &quot;t&quot;, &quot;u&quot;, &quot;v&quot;, &quot;w&quot;, &quot;x&quot;, &quot;y&quot;, &quot;z&quot; ]</code> .&quot;'
     testString: 'assert.deepEqual(lascii("t","z"),results[4],"<code>lascii("t","z")</code> should return <code>[ "t", "u", "v", "w", "x", "y", "z" ]</code>.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hailstone-sequence.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hailstone-sequence.spanish.md
index dd9b60742c..344d43d279 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hailstone-sequence.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hailstone-sequence.spanish.md
@@ -6,21 +6,21 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> La secuencia de números de Hailstone se puede generar a partir de un entero positivo inicial, n mediante: </p> 
-Si n es 1, la secuencia termina. 
-Si n es par, entonces el siguiente n de la secuencia <code>= n/2</code> 
-Si n es impar, entonces el siguiente n de la secuencia <code>= (3 * n) + 1</code> <p> La <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">conjetura</a> (no probada) de <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">Collatz</a> es que la secuencia de granizo para cualquier número inicial siempre termina. </p> 
-<p> La secuencia de granizo también se conoce como números de granizo (porque los valores suelen estar sujetos a múltiples descensos y ascensos como granizos en una nube), o como la secuencia de Collatz. </p> 
-Tarea: 
-Crea una rutina para generar la secuencia de granizo para un número. 
-Use la rutina para mostrar que la secuencia de granizo para el número 27 tiene 112 elementos que comienzan con <code>27, 82, 41, 124</code> y que terminan con <code>8, 4, 2, 1</code> 
-Muestre el número menos de 100,000 que tiene la secuencia de granizo más larga en conjunto con la longitud de esa secuencia. (¡Pero no muestres la secuencia real!) Ver también: 
-<a href="http://xkcd.com/710" title="enlace: http://xkcd.com/710">xkcd</a> (humorístico). 
+<section id='description'>
+<p> La secuencia de números de Hailstone se puede generar a partir de un entero positivo inicial, n mediante: </p>
+Si n es 1, la secuencia termina.
+Si n es par, entonces el siguiente n de la secuencia <code>= n/2</code>
+Si n es impar, entonces el siguiente n de la secuencia <code>= (3 * n) + 1</code> <p> La <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">conjetura</a> (no probada) de <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">Collatz</a> es que la secuencia de granizo para cualquier número inicial siempre termina. </p>
+<p> La secuencia de granizo también se conoce como números de granizo (porque los valores suelen estar sujetos a múltiples descensos y ascensos como granizos en una nube), o como la secuencia de Collatz. </p>
+Tarea:
+Crea una rutina para generar la secuencia de granizo para un número.
+Use la rutina para mostrar que la secuencia de granizo para el número 27 tiene 112 elementos que comienzan con <code>27, 82, 41, 124</code> y que terminan con <code>8, 4, 2, 1</code>
+Muestre el número menos de 100,000 que tiene la secuencia de granizo más larga en conjunto con la longitud de esa secuencia. (¡Pero no muestres la secuencia real!) Ver también:
+<a href="http://xkcd.com/710" title="enlace: http://xkcd.com/710">xkcd</a> (humorístico).
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -31,7 +31,7 @@ Muestre el número menos de 100,000 que tiene la secuencia de granizo más larga
 tests:
   - text: <code>hailstoneSequence</code> es una función.
     testString: 'assert(typeof hailstoneSequence === "function", "<code>hailstoneSequence</code> is a function.");'
-  - text: &#39; <code>hailstoneSequence()</code> debe devolver <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code> &#39;
+  - text: ' <code>hailstoneSequence()</code> debe devolver <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code> '
     testString: 'assert.deepEqual(hailstoneSequence(), res, "<code>hailstoneSequence()</code> should return <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/happy-numbers.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/happy-numbers.spanish.md
index 04392a9c51..4b807a08f5 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/happy-numbers.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/happy-numbers.spanish.md
@@ -6,14 +6,14 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Un número feliz se define mediante el siguiente proceso: </p> 
-<p> Comenzando con cualquier entero positivo, reemplaza el número por la suma de los cuadrados de sus dígitos y repite el proceso hasta que el número sea igual a 1 (donde permanecerá), o se repite sin cesar en un ciclo que no incluye 1. Esos números por lo que este proceso termina en 1 son números felices, mientras que aquellos que no terminan en 1 son números infelices. </p> 
-<p> Implemente una función que devuelva verdadero si el número es feliz o falso si no lo es. </p> 
+<section id='description'>
+<p> Un número feliz se define mediante el siguiente proceso: </p>
+<p> Comenzando con cualquier entero positivo, reemplaza el número por la suma de los cuadrados de sus dígitos y repite el proceso hasta que el número sea igual a 1 (donde permanecerá), o se repite sin cesar en un ciclo que no incluye 1. Esos números por lo que este proceso termina en 1 son números felices, mientras que aquellos que no terminan en 1 son números infelices. </p>
+<p> Implemente una función que devuelva verdadero si el número es feliz o falso si no lo es. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -44,7 +44,7 @@ tests:
     testString: 'assert(happy(28), "<code>happy(28)</code> should return true.");'
   - text: <code>happy(31)</code> debe devolver verdadero.
     testString: 'assert(happy(31), "<code>happy(31)</code> should return true.");'
-  - text: &#39; <code>happy(32)</code> debe devolver verdadero :.&#39;
+  - text: ' <code>happy(32)</code> debe devolver verdadero :.'
     testString: 'assert(happy(32), "<code>happy(32)</code> should return true:.");'
   - text: <code>happy(33)</code> debe devolver falso.
     testString: 'assert(!happy(33), "<code>happy(33)</code> should return false.");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/harshad-or-niven-series.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/harshad-or-niven-series.spanish.md
index 2e7bb04899..15c67db363 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/harshad-or-niven-series.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/harshad-or-niven-series.spanish.md
@@ -6,15 +6,15 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Los números de <a href="http://mathworld.wolfram.com/HarshadNumber.html" title="enlace: http://mathworld.wolfram.com/HarshadNumber.html">Harshad</a> o Niven son enteros positivos ≥ 1 que son divisibles por la suma de sus dígitos. </p><p> Por ejemplo, 42 es un <a href="http://rosettacode.org/wiki/oeis:A005349" title="oeis: a005349">número de Harshad</a> ya que 42 es divisible por (4 + 2) sin resto. </p> 
-Supongamos que la serie se define como los números en orden creciente. 
-Tarea: 
-<p> Implementar una función para generar miembros sucesivos de la secuencia de Harshad. </p><p> Úselo para enumerar los primeros veinte miembros de la secuencia y enumerar el primer número de Harshad mayor que 1000. </p> 
+<section id='description'>
+<p> Los números de <a href="http://mathworld.wolfram.com/HarshadNumber.html" title="enlace: http://mathworld.wolfram.com/HarshadNumber.html">Harshad</a> o Niven son enteros positivos ≥ 1 que son divisibles por la suma de sus dígitos. </p><p> Por ejemplo, 42 es un <a href="http://rosettacode.org/wiki/oeis:A005349" title="oeis: a005349">número de Harshad</a> ya que 42 es divisible por (4 + 2) sin resto. </p>
+Supongamos que la serie se define como los números en orden creciente.
+Tarea:
+<p> Implementar una función para generar miembros sucesivos de la secuencia de Harshad. </p><p> Úselo para enumerar los primeros veinte miembros de la secuencia y enumerar el primer número de Harshad mayor que 1000. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,7 +25,7 @@ Tarea:
 tests:
   - text: <code>isHarshadOrNiven</code> es una función.
     testString: 'assert(typeof isHarshadOrNiven === "function", "<code>isHarshadOrNiven</code> is a function.");'
-  - text: &#39; <code>isHarshadOrNiven()</code> debe devolver <code>{&quot;firstTwenty&quot;: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42],&quot;firstOver1000&quot;: 1002}</code> &#39;
+  - text: ' <code>isHarshadOrNiven()</code> debe devolver <code>{&quot;firstTwenty&quot;: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42],&quot;firstOver1000&quot;: 1002}</code> '
     testString: 'assert.deepEqual(isHarshadOrNiven(), res, "<code>isHarshadOrNiven()</code> should return <code>{"firstTwenty": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42],"firstOver1000": 1002}</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-from-two-arrays.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-from-two-arrays.spanish.md
index b237714f4c..aeba4f6ee9 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-from-two-arrays.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-from-two-arrays.spanish.md
@@ -6,15 +6,15 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Utilizando dos matrices de igual longitud, cree un objeto Hash donde los elementos de una matriz (las claves) estén vinculados a los elementos de la otra (los valores) </p> 
-Tarea relacionada: 
-<a href="http://rosettacode.org/wiki/Associative arrays/Creation" title="Arrays asociativos / Creación">Arreglos asociativos / Creación</a> 
+<section id='description'>
+Tarea:
+<p> Utilizando dos matrices de igual longitud, cree un objeto Hash donde los elementos de una matriz (las claves) estén vinculados a los elementos de la otra (los valores) </p>
+Tarea relacionada:
+<a href="http://rosettacode.org/wiki/Associative arrays/Creation" title="Arrays asociativos / Creación">Arreglos asociativos / Creación</a>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -25,17 +25,17 @@ Tarea relacionada:
 tests:
   - text: <code>arrToObj</code> es una función.
     testString: 'assert(typeof arrToObj === "function", "<code>arrToObj</code> is a function.");'
-  - text: &#39; <code>arrToObj([1, 2, 3, 4, 5], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;])</code> debe devolver <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot;, 4: &quot;d&quot;, 5: &quot;e&quot; }</code> &#39;
+  - text: ' <code>arrToObj([1, 2, 3, 4, 5], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;])</code> debe devolver <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot;, 4: &quot;d&quot;, 5: &quot;e&quot; }</code> '
     testString: 'assert.deepEqual(arrToObj(...testCases[0]), res[0], "<code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])</code> should return <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }</code>");'
-  - text: &#39; <code>arrToObj([1, 2, 3, 4, 5], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;])</code> debe devolver <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot;, 4: &quot;d&quot;, 5: undefined }</code> &#39;
+  - text: ' <code>arrToObj([1, 2, 3, 4, 5], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;])</code> debe devolver <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot;, 4: &quot;d&quot;, 5: undefined }</code> '
     testString: 'assert.deepEqual(arrToObj(...testCases[1]), res[1], "<code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])</code> should return <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }</code>");'
-  - text: &#39; <code>arrToObj([1, 2, 3], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;])</code> debe devolver <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot; }</code>
+  - text: ' <code>arrToObj([1, 2, 3], [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;])</code> debe devolver <code>{ 1: &quot;a&quot;, 2: &quot;b&quot;, 3: &quot;c&quot; }</code>
     testString: 'assert.deepEqual(arrToObj(...testCases[2]), res[2], "<code>arrToObj([1, 2, 3], ["a", "b", "c", "d", "e"])</code> should return <code>{ 1: "a", 2: "b", 3: "c" }</code>");'
-  - text: &#39; <code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;], [1, 2, 3, 4, 5])</code> debe devolver <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 , &quot;d&quot;: 4, &quot;e&quot;: 5 }</code> &#39;
+  - text: ' <code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;], [1, 2, 3, 4, 5])</code> debe devolver <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 , &quot;d&quot;: 4, &quot;e&quot;: 5 }</code> '
     testString: 'assert.deepEqual(arrToObj(...testCases[3]), res[3], "<code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])</code> should return <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }</code>");'
-  - text: &#39; <code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;], [1, 2, 3, 4])</code> debe devolver <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 , &quot;d&quot;: 4, &quot;e&quot;: undefined }</code> &#39;
+  - text: ' <code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;], [1, 2, 3, 4])</code> debe devolver <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 , &quot;d&quot;: 4, &quot;e&quot;: undefined }</code> '
     testString: 'assert.deepEqual(arrToObj(...testCases[4]), res[4], "<code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])</code> should return <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }</code>");'
-  - text: &#39; <code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], [1, 2, 3, 4, 5])</code> debe devolver <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 }</code> &#39;
+  - text: ' <code>arrToObj([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], [1, 2, 3, 4, 5])</code> debe devolver <code>{ &quot;a&quot;: 1, &quot;b&quot;: 2, &quot;c&quot;: 3 }</code> '
     testString: 'assert.deepEqual(arrToObj(...testCases[5]), res[5], "<code>arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])</code> should return <code>{ "a": 1, "b": 2, "c": 3  }</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-join.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-join.spanish.md
index a193c2de46..6f982fca37 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-join.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-join.spanish.md
@@ -6,164 +6,164 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> Una <a href="https://en.wikipedia.org/wiki/Join_(SQL)#Inner_join" title="wp: Join_ (SQL) #Inner_join">unión interna</a> es una operación que combina dos tablas de datos en una tabla, basada en valores de columna coincidentes. La forma más sencilla de implementar esta operación es el algoritmo de <a href="https://en.wikipedia.org/wiki/Nested loop join" title="wp: unión de bucle anidado">unión de bucle anidado</a> , pero una alternativa más escalable es el algoritmo de <a href="https://en.wikipedia.org/wiki/hash join" title="wp: hash join">combinación de hash</a> . </p> 
-<p> Implemente el algoritmo de &quot;combinación hash&quot; y demuestre que pasa el caso de prueba que se indica a continuación. </p><p> Debe representar las tablas como estructuras de datos que se sienten naturales en su lenguaje de programación. </p> 
-<p> El algoritmo &quot;hash join&quot; consta de dos pasos: </p> 
-Fase de hash: <a href="https://en.wikipedia.org/wiki/Multimap" title="wp: Multimap">cree</a> un <a href="https://en.wikipedia.org/wiki/Multimap" title="wp: Multimap">multimapa a</a> partir de una de las dos tablas, asignando desde cada valor de columna de unión a todas las filas que lo contienen. 
-El multimapa debe admitir una búsqueda basada en hash que se amplíe mejor que una búsqueda lineal simple, porque ese es el punto central de este algoritmo. 
-Idealmente, deberíamos crear el multimapa para la tabla más pequeña, minimizando así el tiempo de creación y el tamaño de la memoria. 
-Fase de unión: escanee la otra tabla y busque filas coincidentes buscando en el multimapa creado anteriormente. 
-<p> En el pseudocódigo, el algoritmo podría expresarse como sigue: </p> 
-<pre> 
-sea ​​A = la primera tabla de entrada (o idealmente, la más grande) 
-sea ​​B = la segunda tabla de entrada (o idealmente, la más pequeña) 
-sea ​​j <sub>A</sub> = el ID de la columna de unión de la tabla A 
-sea ​​j <sub>B</sub> = unirse a la columna ID de la tabla B 
-dejar M <sub>B</sub> = un multimapa para la asignación de valores individuales a varias filas de la tabla B (comienza vacío) 
-dejar C = la tabla de salida (comienza vacío) 
-para cada fila b en la tabla B: 
-coloque b en el multimap M <sub>B</sub> debajo de la tecla b (j <sub>B</sub> ) 
-para cada fila a en la tabla A: 
-para cada fila b en el multimap M <sub>B</sub> debajo de la tecla a (j <sub>A</sub> ): 
-sea ​​c = la concatenación de la fila ay fila b 
-coloca la fila c en la tabla C </p> 
-</pre> 
-Caso de prueba 
-<p> Entrada </p> 
-<table> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 
-<table style="border:none; border-collapse:collapse;"> 
-<tr> 
-<td style="border:none"> <i>A =</i> 
-</td> 
-<td style="border:none"> 
-<table> 
-<tr> 
-<th style="padding: 4px; margin: 5px;"> Años </th> 
-<th style="padding: 4px; margin: 5px;"> Nombre 
-</th></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 27 </td> 
-<td style="padding: 4px; margin: 5px;"> Jonás 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 18 </td> 
-<td style="padding: 4px; margin: 5px;"> Alan 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 28 </td> 
-<td style="padding: 4px; margin: 5px;"> Gloria 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 18 </td> 
-<td style="padding: 4px; margin: 5px;"> Popeye 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 28 </td> 
-<td style="padding: 4px; margin: 5px;"> Alan 
-</td></tr></table> 
-</td> 
-<td style="border:none; padding-left:1.5em;" rowspan="2"> 
-</td> 
-<td style="border:none"> <i>B =</i> 
-</td> 
-<td style="border:none"> 
-<table> 
-<tr> 
-<th style="padding: 4px; margin: 5px;"> Personaje </th> 
-<th style="padding: 4px; margin: 5px;"> Nemesis 
-</th></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> Jonás </td> 
-<td style="padding: 4px; margin: 5px;"> Ballenas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> Jonás </td> 
-<td style="padding: 4px; margin: 5px;"> Arañas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Fantasmas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Zombies 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> Gloria </td> 
-<td style="padding: 4px; margin: 5px;"> Buffy 
-</td></tr></table> 
-</td> </tr> 
-<tr> 
-<td style="border:none"> <i>j <sub>A</sub> =</i> 
-</td> 
-<td style="border:none"> <i><code>Name</code> (es decir, columna 1)</i> 
-</td> 
-<td style="border:none"> <i>j <sub>B</sub> =</i> 
-</td> 
-<td style="border:none"> <i><code>Character</code> (es decir, columna 0)</i> 
-</td></tr></table> 
-</td> 
-<td style="padding: 4px; margin: 5px;"> 
-</td> </tr></table> 
-<p> Salida </p> 
-<table> 
-<tr> 
-<th style="padding: 4px; margin: 5px;"> A. Edad </th> 
-<th style="padding: 4px; margin: 5px;"> Un nombre </th> 
-<th style="padding: 4px; margin: 5px;"> B. Caracter </th> 
-<th style="padding: 4px; margin: 5px;"> B. nemesis 
-</th></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 27 </td> 
-<td style="padding: 4px; margin: 5px;"> Jonás </td> 
-<td style="padding: 4px; margin: 5px;"> Jonás </td> 
-<td style="padding: 4px; margin: 5px;"> Ballenas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 27 </td> 
-<td style="padding: 4px; margin: 5px;"> Jonás </td> 
-<td style="padding: 4px; margin: 5px;"> Jonás </td> 
-<td style="padding: 4px; margin: 5px;"> Arañas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 18 </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Fantasmas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 18 </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Zombies 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 28 </td> 
-<td style="padding: 4px; margin: 5px;"> Gloria </td> 
-<td style="padding: 4px; margin: 5px;"> Gloria </td> 
-<td style="padding: 4px; margin: 5px;"> Buffy 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 28 </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Fantasmas 
-</td></tr> 
-<tr> 
-<td style="padding: 4px; margin: 5px;"> 28 </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Alan </td> 
-<td style="padding: 4px; margin: 5px;"> Zombies 
-</td></tr></table> 
-<p> </p><p></p><p> El orden de las filas en la tabla de salida no es significativo. </p> 
-<p> Si está utilizando matrices indexadas numéricamente para representar filas de la tabla (en lugar de referirse a las columnas por su nombre), podría representar las filas de salida en la forma <code style="white-space:nowrap">[[27, &quot;Jonah&quot;], [&quot;Jonah&quot;, &quot;Whales&quot;]]</code> . </p><hr> 
+<section id='description'>
+<p> Una <a href="https://en.wikipedia.org/wiki/Join_(SQL)#Inner_join" title="wp: Join_ (SQL) #Inner_join">unión interna</a> es una operación que combina dos tablas de datos en una tabla, basada en valores de columna coincidentes. La forma más sencilla de implementar esta operación es el algoritmo de <a href="https://en.wikipedia.org/wiki/Nested loop join" title="wp: unión de bucle anidado">unión de bucle anidado</a> , pero una alternativa más escalable es el algoritmo de <a href="https://en.wikipedia.org/wiki/hash join" title="wp: hash join">combinación de hash</a> . </p>
+<p> Implemente el algoritmo de &quot;combinación hash&quot; y demuestre que pasa el caso de prueba que se indica a continuación. </p><p> Debe representar las tablas como estructuras de datos que se sienten naturales en su lenguaje de programación. </p>
+<p> El algoritmo &quot;hash join&quot; consta de dos pasos: </p>
+Fase de hash: <a href="https://en.wikipedia.org/wiki/Multimap" title="wp: Multimap">cree</a> un <a href="https://en.wikipedia.org/wiki/Multimap" title="wp: Multimap">multimapa a</a> partir de una de las dos tablas, asignando desde cada valor de columna de unión a todas las filas que lo contienen.
+El multimapa debe admitir una búsqueda basada en hash que se amplíe mejor que una búsqueda lineal simple, porque ese es el punto central de este algoritmo.
+Idealmente, deberíamos crear el multimapa para la tabla más pequeña, minimizando así el tiempo de creación y el tamaño de la memoria.
+Fase de unión: escanee la otra tabla y busque filas coincidentes buscando en el multimapa creado anteriormente.
+<p> En el pseudocódigo, el algoritmo podría expresarse como sigue: </p>
+<pre>
+sea ​​A = la primera tabla de entrada (o idealmente, la más grande)
+sea ​​B = la segunda tabla de entrada (o idealmente, la más pequeña)
+sea ​​j <sub>A</sub> = el ID de la columna de unión de la tabla A
+sea ​​j <sub>B</sub> = unirse a la columna ID de la tabla B
+dejar M <sub>B</sub> = un multimapa para la asignación de valores individuales a varias filas de la tabla B (comienza vacío)
+dejar C = la tabla de salida (comienza vacío)
+para cada fila b en la tabla B:
+coloque b en el multimap M <sub>B</sub> debajo de la tecla b (j <sub>B</sub> )
+para cada fila a en la tabla A:
+para cada fila b en el multimap M <sub>B</sub> debajo de la tecla a (j <sub>A</sub> ):
+sea ​​c = la concatenación de la fila ay fila b
+coloca la fila c en la tabla C </p>
+</pre>
+Caso de prueba
+<p> Entrada </p>
+<table>
+<tr>
+<td style="padding: 4px; margin: 5px;">
+<table style="border:none; border-collapse:collapse;">
+<tr>
+<td style="border:none"> <i>A =</i>
+</td>
+<td style="border:none">
+<table>
+<tr>
+<th style="padding: 4px; margin: 5px;"> Años </th>
+<th style="padding: 4px; margin: 5px;"> Nombre
+</th></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 27 </td>
+<td style="padding: 4px; margin: 5px;"> Jonás
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 18 </td>
+<td style="padding: 4px; margin: 5px;"> Alan
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 28 </td>
+<td style="padding: 4px; margin: 5px;"> Gloria
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 18 </td>
+<td style="padding: 4px; margin: 5px;"> Popeye
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 28 </td>
+<td style="padding: 4px; margin: 5px;"> Alan
+</td></tr></table>
+</td>
+<td style="border:none; padding-left:1.5em;" rowspan="2">
+</td>
+<td style="border:none"> <i>B =</i>
+</td>
+<td style="border:none">
+<table>
+<tr>
+<th style="padding: 4px; margin: 5px;"> Personaje </th>
+<th style="padding: 4px; margin: 5px;"> Nemesis
+</th></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> Jonás </td>
+<td style="padding: 4px; margin: 5px;"> Ballenas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> Jonás </td>
+<td style="padding: 4px; margin: 5px;"> Arañas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Fantasmas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Zombies
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> Gloria </td>
+<td style="padding: 4px; margin: 5px;"> Buffy
+</td></tr></table>
+</td> </tr>
+<tr>
+<td style="border:none"> <i>j <sub>A</sub> =</i>
+</td>
+<td style="border:none"> <i><code>Name</code> (es decir, columna 1)</i>
+</td>
+<td style="border:none"> <i>j <sub>B</sub> =</i>
+</td>
+<td style="border:none"> <i><code>Character</code> (es decir, columna 0)</i>
+</td></tr></table>
+</td>
+<td style="padding: 4px; margin: 5px;">
+</td> </tr></table>
+<p> Salida </p>
+<table>
+<tr>
+<th style="padding: 4px; margin: 5px;"> A. Edad </th>
+<th style="padding: 4px; margin: 5px;"> Un nombre </th>
+<th style="padding: 4px; margin: 5px;"> B. Caracter </th>
+<th style="padding: 4px; margin: 5px;"> B. nemesis
+</th></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 27 </td>
+<td style="padding: 4px; margin: 5px;"> Jonás </td>
+<td style="padding: 4px; margin: 5px;"> Jonás </td>
+<td style="padding: 4px; margin: 5px;"> Ballenas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 27 </td>
+<td style="padding: 4px; margin: 5px;"> Jonás </td>
+<td style="padding: 4px; margin: 5px;"> Jonás </td>
+<td style="padding: 4px; margin: 5px;"> Arañas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 18 </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Fantasmas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 18 </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Zombies
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 28 </td>
+<td style="padding: 4px; margin: 5px;"> Gloria </td>
+<td style="padding: 4px; margin: 5px;"> Gloria </td>
+<td style="padding: 4px; margin: 5px;"> Buffy
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 28 </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Fantasmas
+</td></tr>
+<tr>
+<td style="padding: 4px; margin: 5px;"> 28 </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Alan </td>
+<td style="padding: 4px; margin: 5px;"> Zombies
+</td></tr></table>
+<p> </p><p></p><p> El orden de las filas en la tabla de salida no es significativo. </p>
+<p> Si está utilizando matrices indexadas numéricamente para representar filas de la tabla (en lugar de referirse a las columnas por su nombre), podría representar las filas de salida en la forma <code style="white-space:nowrap">[[27, &quot;Jonah&quot;], [&quot;Jonah&quot;, &quot;Whales&quot;]]</code> . </p><hr>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -174,7 +174,7 @@ Caso de prueba
 tests:
   - text: <code>hashJoin</code> es una función.
     testString: 'assert(typeof hashJoin === "function", "<code>hashJoin</code> is a function.");'
-  - text: &#39; <code>hashJoin([{ age: 27, name: &quot;Jonah&quot; }, { age: 18, name: &quot;Alan&quot; }, { age: 28, name: &quot;Glory&quot; }, { age: 18, name: &quot;Popeye&quot; }, { age: 28, name: &quot;Alan&quot; }], [{ character: &quot;Jonah&quot;, nemesis: &quot;Whales&quot; }, { character: &quot;Jonah&quot;, nemesis: &quot;Spiders&quot; }, { character: &quot;Alan&quot;, nemesis: &quot;Ghosts&quot; }, { character:&quot;Alan&quot;, nemesis: &quot;Zombies&quot; }, { character: &quot;Glory&quot;, nemesis: &quot;Buffy&quot; }, { character: &quot;Bob&quot;, nemesis: &quot;foo&quot; }])</code> debe devolver <code>[{&quot;A_age&quot;: 27,&quot;A_name&quot;: &quot;Jonah&quot;, &quot;B_character&quot;: &quot;Jonah&quot;, &quot;B_nemesis&quot;: &quot;Whales&quot;}, {&quot;A_age&quot;: 27,&quot;A_name&quot;: &quot;Jonah&quot;, &quot;B_character&quot;: &quot;Jonah&quot;, &quot;B_nemesis&quot;: &quot;Spiders&quot;}, {&quot;A_age&quot;: 18,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Ghosts&quot;}, {&quot;A_age&quot;: 18,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Zombies&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Glory&quot;, &quot;B_character&quot;: &quot;Glory&quot;, &quot;B_nemesis&quot;: &quot;Buffy&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Ghosts&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Zombies&quot;}]</code> &#39;
+  - text: ' <code>hashJoin([{ age: 27, name: &quot;Jonah&quot; }, { age: 18, name: &quot;Alan&quot; }, { age: 28, name: &quot;Glory&quot; }, { age: 18, name: &quot;Popeye&quot; }, { age: 28, name: &quot;Alan&quot; }], [{ character: &quot;Jonah&quot;, nemesis: &quot;Whales&quot; }, { character: &quot;Jonah&quot;, nemesis: &quot;Spiders&quot; }, { character: &quot;Alan&quot;, nemesis: &quot;Ghosts&quot; }, { character:&quot;Alan&quot;, nemesis: &quot;Zombies&quot; }, { character: &quot;Glory&quot;, nemesis: &quot;Buffy&quot; }, { character: &quot;Bob&quot;, nemesis: &quot;foo&quot; }])</code> debe devolver <code>[{&quot;A_age&quot;: 27,&quot;A_name&quot;: &quot;Jonah&quot;, &quot;B_character&quot;: &quot;Jonah&quot;, &quot;B_nemesis&quot;: &quot;Whales&quot;}, {&quot;A_age&quot;: 27,&quot;A_name&quot;: &quot;Jonah&quot;, &quot;B_character&quot;: &quot;Jonah&quot;, &quot;B_nemesis&quot;: &quot;Spiders&quot;}, {&quot;A_age&quot;: 18,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Ghosts&quot;}, {&quot;A_age&quot;: 18,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Zombies&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Glory&quot;, &quot;B_character&quot;: &quot;Glory&quot;, &quot;B_nemesis&quot;: &quot;Buffy&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Ghosts&quot;}, {&quot;A_age&quot;: 28,&quot;A_name&quot;: &quot;Alan&quot;, &quot;B_character&quot;: &quot;Alan&quot;, &quot;B_nemesis&quot;: &quot;Zombies&quot;}]</code> '
     testString: 'assert.deepEqual(hashJoin(hash1, hash2), res, "<code>hashJoin([{ age: 27, name: "Jonah" }, { age: 18, name: "Alan" }, { age: 28, name: "Glory" }, { age: 18, name: "Popeye" }, { age: 28, name: "Alan" }], [{ character: "Jonah", nemesis: "Whales" }, { character: "Jonah", nemesis: "Spiders" }, { character: "Alan", nemesis: "Ghosts" }, { character:"Alan", nemesis: "Zombies" }, { character: "Glory", nemesis: "Buffy" }, { character: "Bob", nemesis: "foo" }])</code> should return <code>[{"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Whales"}, {"A_age": 27,"A_name": "Jonah", "B_character": "Jonah", "B_nemesis": "Spiders"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 18,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}, {"A_age": 28,"A_name": "Glory", "B_character": "Glory", "B_nemesis": "Buffy"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Ghosts"}, {"A_age": 28,"A_name": "Alan", "B_character": "Alan", "B_nemesis": "Zombies"}]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/heronian-triangles.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/heronian-triangles.spanish.md
index 67874cfb52..08af6de32d 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/heronian-triangles.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/heronian-triangles.spanish.md
@@ -6,18 +6,18 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> <a href="https://en.wikipedia.org/wiki/Heron's formula" title="wp: fórmula de Heron">La fórmula del héroe</a> para el área de un triángulo dada la longitud de sus tres lados <big>a,</big> <big>b</big> y <big>c</big> está dada por: </p><p> <big>$ A = \ sqrt {s (sa) (sb) (sc)}, $</big> </p><p> donde <big>s</big> es la mitad del perímetro del triángulo; es decir, </p><p> <big>$ s = \ frac {a + b + c} {2}. $</big> </p> 
-<p> <a href="http://www.had2know.com/academics/heronian-triangles-generator-calculator.html" title="enlace: http://www.had2know.com/academics/heronian-triangles-generator-calculator.html">Los triángulos heronianos</a> son triángulos cuyos lados y área son todos enteros. </p> 
-<p> Un ejemplo es el triángulo con lados 3, 4, 5 cuya área es 6 (y cuyo perímetro es 12). </p> 
-<p> Tenga en cuenta que cualquier triángulo cuyos lados son todos un entero múltiplo de 3, 4, 5; como 6, 8, 10, también será un triángulo heroniano. </p><p> Define un triángulo heroniano primitivo como un triángulo heroniano donde el mayor divisor común </p> 
-<p> De los tres lados es 1 (unidad). </p><p> Esto excluirá, por ejemplo, el triángulo 6, 8, 10. </p> 
-Tarea: 
-<p> Implementar una función basada en la fórmula de héroe que devuelve el primero <code>n <sub>th</sub></code> triángulos ordenadas en una matriz de matrices. </p> 
+<section id='description'>
+<p> <a href="https://en.wikipedia.org/wiki/Heron's formula" title="wp: fórmula de Heron">La fórmula del héroe</a> para el área de un triángulo dada la longitud de sus tres lados <big>a,</big> <big>b</big> y <big>c</big> está dada por: </p><p> <big>$ A = \ sqrt {s (sa) (sb) (sc)}, $</big> </p><p> donde <big>s</big> es la mitad del perímetro del triángulo; es decir, </p><p> <big>$ s = \ frac {a + b + c} {2}. $</big> </p>
+<p> <a href="http://www.had2know.com/academics/heronian-triangles-generator-calculator.html" title="enlace: http://www.had2know.com/academics/heronian-triangles-generator-calculator.html">Los triángulos heronianos</a> son triángulos cuyos lados y área son todos enteros. </p>
+<p> Un ejemplo es el triángulo con lados 3, 4, 5 cuya área es 6 (y cuyo perímetro es 12). </p>
+<p> Tenga en cuenta que cualquier triángulo cuyos lados son todos un entero múltiplo de 3, 4, 5; como 6, 8, 10, también será un triángulo heroniano. </p><p> Define un triángulo heroniano primitivo como un triángulo heroniano donde el mayor divisor común </p>
+<p> De los tres lados es 1 (unidad). </p><p> Esto excluirá, por ejemplo, el triángulo 6, 8, 10. </p>
+Tarea:
+<p> Implementar una función basada en la fórmula de héroe que devuelve el primero <code>n <sub>th</sub></code> triángulos ordenadas en una matriz de matrices. </p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -28,13 +28,13 @@ Tarea:
 tests:
   - text: <code>heronianTriangle</code> es una función.
     testString: 'assert(typeof heronianTriangle === "function", "<code>heronianTriangle</code> is a function.");'
-  - text: &#39; <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code> &#39;
+  - text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code> '
     testString: 'assert.deepEqual(heronianTriangle(testCases[0]), res[0], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code>");'
-  - text: &#39; <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>
+  - text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>
     testString: 'assert.deepEqual(heronianTriangle(testCases[1]), res[1], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>");'
-  - text: &#39; <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code> &#39;
+  - text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code> '
     testString: 'assert.deepEqual(heronianTriangle(testCases[2]), res[2], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code>");'
-  - text: &#39; <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code> &#39;
+  - text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code> '
     testString: 'assert.deepEqual(heronianTriangle(testCases[3]), res[3], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/s-expressions.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/s-expressions.spanish.md
index f89acbae7f..8ed816e9c4 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/s-expressions.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/s-expressions.spanish.md
@@ -6,50 +6,50 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> 
-<a href="https://en.wikipedia.org/wiki/S-Expression" title="wp: S-Expresión">S-Expressions</a> son una forma conveniente de analizar y almacenar datos. 
-</p> 
-Tarea: 
-<p> 
-Escriba un lector / analizador simple para S-Expressions que maneje cadenas, enteros y flotantes entre comillas y sin comillas. 
-</p> 
-<p> 
-La función debe leer una expresión-S única pero anidada de una cadena y 
-devolverla como una matriz (anidada). 
-</p> 
-<p> 
-líneas nuevas y otros espacios en blanco pueden ignorarse a menos que estén dentro de una cadena entre comillas. 
-</p> 
-<p> “ <tt>()</tt> ” Dentro de las cadenas entre comillas no se interpretan, sino que se tratan como parte de la cadena. 
-</p> 
-<p> 
-manejo de citas escapadas dentro de una cadena es opcional; por lo tanto, &quot; <tt>(foo&quot; barra)</tt> &quot;puede tratarse como una cadena&quot; <tt>foo &quot;barra</tt> &quot;, o como un error. 
-</p> 
-<p> 
-Para esto, el lector no necesita reconocer &quot; <tt>\</tt> &quot; por escapar, sino que, además, debe reconocer los números si el idioma tiene los tipos de datos apropiados. 
-</p> 
-<p> 
-Tenga en cuenta que con la excepción de &quot; <tt>()&quot;</tt> &quot;(&quot; <tt>\</tt> &quot;si se admite el escape) y espacios en blanco no hay caracteres especiales. Se permite cualquier otra cosa sin comillas. 
-</p> 
-<p> El lector debe poder leer la siguiente entrada </p> 
-<p> 
-<pre> 
-((datos &quot;datos citados&quot; 123 4.5) 
-(datos (! @ # (4.5) &quot;(más&quot; &quot;datos)&quot;))) 
-</pre> 
-</p> 
-<p> 
-y convertirlo en una estructura de datos nativa. (vea las implementaciones de 
-<a href="http://rosettacode.org/wiki/#Pike" title="#Lucio">Pike</a> , 
-<a href="http://rosettacode.org/wiki/#Python" title="#Pitón">Python</a> y 
-<a href="http://rosettacode.org/wiki/#Ruby" title="#Rubí">Ruby</a> 
-para ver ejemplos de estructuras de datos nativas). 
-</p> 
+<section id='description'>
+<p>
+<a href="https://en.wikipedia.org/wiki/S-Expression" title="wp: S-Expresión">S-Expressions</a> son una forma conveniente de analizar y almacenar datos.
+</p>
+Tarea:
+<p>
+Escriba un lector / analizador simple para S-Expressions que maneje cadenas, enteros y flotantes entre comillas y sin comillas.
+</p>
+<p>
+La función debe leer una expresión-S única pero anidada de una cadena y
+devolverla como una matriz (anidada).
+</p>
+<p>
+líneas nuevas y otros espacios en blanco pueden ignorarse a menos que estén dentro de una cadena entre comillas.
+</p>
+<p> “ <tt>()</tt> ” Dentro de las cadenas entre comillas no se interpretan, sino que se tratan como parte de la cadena.
+</p>
+<p>
+manejo de citas escapadas dentro de una cadena es opcional; por lo tanto, &quot; <tt>(foo&quot; barra)</tt> &quot;puede tratarse como una cadena&quot; <tt>foo &quot;barra</tt> &quot;, o como un error.
+</p>
+<p>
+Para esto, el lector no necesita reconocer &quot; <tt>\</tt> &quot; por escapar, sino que, además, debe reconocer los números si el idioma tiene los tipos de datos apropiados.
+</p>
+<p>
+Tenga en cuenta que con la excepción de &quot; <tt>()&quot;</tt> &quot;(&quot; <tt>\</tt> &quot;si se admite el escape) y espacios en blanco no hay caracteres especiales. Se permite cualquier otra cosa sin comillas.
+</p>
+<p> El lector debe poder leer la siguiente entrada </p>
+<p>
+<pre>
+((datos &quot;datos citados&quot; 123 4.5)
+(datos (! @ # (4.5) &quot;(más&quot; &quot;datos)&quot;)))
+</pre>
+</p>
+<p>
+y convertirlo en una estructura de datos nativa. (vea las implementaciones de
+<a href="http://rosettacode.org/wiki/#Pike" title="#Lucio">Pike</a> ,
+<a href="http://rosettacode.org/wiki/#Python" title="#Pitón">Python</a> y
+<a href="http://rosettacode.org/wiki/#Ruby" title="#Rubí">Ruby</a>
+para ver ejemplos de estructuras de datos nativas).
+</p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -60,7 +60,7 @@ para ver ejemplos de estructuras de datos nativas).
 tests:
   - text: <code>parseSexpr</code> es una función.
     testString: 'assert(typeof parseSexpr === "function", "<code>parseSexpr</code> is a function.");'
-  - text: &#39; <code>parseSexpr(&quot;(data1 data2 data3)&quot;)</code> debe devolver [&quot;data1&quot;, &quot;data2&quot;, &quot;data3&quot;] &quot;)&#39;
+  - text: ' <code>parseSexpr(&quot;(data1 data2 data3)&quot;)</code> debe devolver [&quot;data1&quot;, &quot;data2&quot;, &quot;data3&quot;] &quot;)'
     testString: 'assert.deepEqual(parseSexpr(simpleSExpr), simpleSolution, "<code>parseSexpr("(data1 data2 data3)")</code> should return ["data1", "data2", "data3"]");'
   - text: <code>parseSexpr(&#39;(data1 data2 data3)&#39;)</code> debe devolver una matriz con 3 elementos &quot;)
     testString: 'assert.deepEqual(parseSexpr(basicSExpr), basicSolution, "<code>parseSexpr("(data1 data2 data3)")</code> should return an array with 3 elements");'
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/taxicab-numbers.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/taxicab-numbers.spanish.md
index 4f043a8a0e..6ddddf1804 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/taxicab-numbers.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/taxicab-numbers.spanish.md
@@ -6,29 +6,29 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Un <a href="https://en.wikipedia.org/wiki/Hardy–Ramanujan number" title="wp: Hardy – número de Ramanujan">número de taxi</a> 
-(la definición que se usa aquí) es un entero positivo que se puede expresar como la suma de dos cubos positivos de más de una manera. 
-El primer número de taxi es 1729, que es: 
-1 <sup>3</sup> + 12 <sup>3</sup> y 
-9 <sup>3</sup> + 10 <sup>3</sup> . 
-números de Taxi también se conocen como: 
-* números de taxi 
-* Los números de taxis 
-* Los números de taxis 
-números * Hardy-Ramanujan 
-Tarea: 
-Escribir una función que devuelve el menor número de taxis N. 
-Para cada uno de los números de taxis, muestre el número y sus cubos constituyentes. 
-Vea también: 
-[http://oeis.org/A001235 A001235 números de taxis] en la Enciclopedia en línea de secuencias de números enteros. 
-<a href="http://mathworld.wolfram.com/Hardy-RamanujanNumber.html">Hardy-Ramanujan Number</a> en MathWorld. 
-<a href="http://mathworld.wolfram.com/TaxicabNumber.html">número de taxi</a> en MathWorld. 
-<a href="https://en.wikipedia.org/wiki/Taxicab_number">número de taxi</a> en Wikipedia. 
+<section id='description'>
+Un <a href="https://en.wikipedia.org/wiki/Hardy–Ramanujan number" title="wp: Hardy – número de Ramanujan">número de taxi</a>
+(la definición que se usa aquí) es un entero positivo que se puede expresar como la suma de dos cubos positivos de más de una manera.
+El primer número de taxi es 1729, que es:
+1 <sup>3</sup> + 12 <sup>3</sup> y
+9 <sup>3</sup> + 10 <sup>3</sup> .
+números de Taxi también se conocen como:
+* números de taxi
+* Los números de taxis
+* Los números de taxis
+números * Hardy-Ramanujan
+Tarea:
+Escribir una función que devuelve el menor número de taxis N.
+Para cada uno de los números de taxis, muestre el número y sus cubos constituyentes.
+Vea también:
+[http://oeis.org/A001235 A001235 números de taxis] en la Enciclopedia en línea de secuencias de números enteros.
+<a href="http://mathworld.wolfram.com/Hardy-RamanujanNumber.html">Hardy-Ramanujan Number</a> en MathWorld.
+<a href="http://mathworld.wolfram.com/TaxicabNumber.html">número de taxi</a> en MathWorld.
+<a href="https://en.wikipedia.org/wiki/Taxicab_number">número de taxi</a> en Wikipedia.
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -43,11 +43,11 @@ tests:
     testString: 'assert(typeof taxicabNumbers(2) === "object", "<code>taxicabNumbers </code> should return an array.");'
   - text: <code>taxicabNumbers</code> debe devolver una serie de números.
     testString: 'assert(typeof taxicabNumbers(100)[0] === "number", "<code>taxicabNumbers </code> should return an array of numbers.");'
-  - text: &#39; <code>taxicabNumbers(4)</code> debe devolver [1729, 4104, 13832, 20683].&#39;
+  - text: ' <code>taxicabNumbers(4)</code> debe devolver [1729, 4104, 13832, 20683].'
     testString: 'assert.deepEqual(taxicabNumbers(4), res4, "<code>taxicabNumbers(4) </code> must return [1729, 4104, 13832, 20683].");'
-  - text: &#39;taxicabNumbers (25) debe devolver [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110808, 134379, 149389, 165464, 171288, 196041, 216125, 262656, 31446, 320264, 327763, 373464, 402597] &#39;
+  - text: 'taxicabNumbers (25) debe devolver [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110808, 134379, 149389, 165464, 171288, 196041, 216125, 262656, 31446, 320264, 327763, 373464, 402597] '
     testString: 'assert.deepEqual(taxicabNumbers(25), res25, "taxicabNumbers(25) should return [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597]");'
-  - text: &#39;taxicabNumbers (39) los números resultantes del 20 al 29 deben ser [314496,320264,327763,373464,402597,439101,443889,513000,513856].&#39;
+  - text: 'taxicabNumbers (39) los números resultantes del 20 al 29 deben ser [314496,320264,327763,373464,402597,439101,443889,513000,513856].'
     testString: 'assert.deepEqual(taxicabNumbers(39).slice(20, 29), res39From20To29, "taxicabNumbers(39) resulting numbers from 20 - 29 should be [314496,320264,327763,373464,402597,439101,443889,513000,513856].");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.spanish.md
index a7aa828d08..1d69bb9ad0 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.spanish.md
@@ -6,36 +6,36 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-<p> 
-Escriba una función o programa que pueda dividir una cadena en cada aparición sin escape de un carácter separador. 
-</p> 
-<p> 
-Debe aceptar tres parámetros de entrada: 
-</p> 
-La <b>cadena</b> 
-El <b>carácter separador</b> 
-El <b>carácter de escape</b> 
-<p> Debe salir una lista de cadenas. </p> 
-<p> Reglas para dividir: </p> 
-Los campos que estaban separados por los separadores, se convierten en los elementos de la lista de salida. 
-campos vacíos deben conservarse, incluso al principio y al final. 
-<p> Reglas para escapar: </p> 
-&quot;Escapado&quot; significa precedido por una aparición del carácter de escape que aún no se ha escapado. 
-Cuando el personaje de escape precede a un personaje que no tiene un significado especial, todavía cuenta como un escape (pero no hace nada especial). 
-Cada aparición del carácter de escape que se utilizó para escapar de algo, no debe formar parte de la salida. 
-<p> Demuestre que su función satisface el siguiente caso de prueba: 
-Cadena dada <pre> uno ^ | uno || tres ^^^^ | cuatro ^^^ | ^ cuatro | </pre> y usando 
-<pre> | </pre> como separador y <pre> ^ </pre> como carácter de escape, su función 
-debería generar la siguiente matriz: 
-</p> 
-<pre> 
-[&#39;one | uno&#39;, &quot;, &#39;three ^^&#39;, &#39;four ^ | quatro&#39;,&quot;] 
-</pre> 
+<section id='description'>
+<p>
+Escriba una función o programa que pueda dividir una cadena en cada aparición sin escape de un carácter separador.
+</p>
+<p>
+Debe aceptar tres parámetros de entrada:
+</p>
+La <b>cadena</b>
+El <b>carácter separador</b>
+El <b>carácter de escape</b>
+<p> Debe salir una lista de cadenas. </p>
+<p> Reglas para dividir: </p>
+Los campos que estaban separados por los separadores, se convierten en los elementos de la lista de salida.
+campos vacíos deben conservarse, incluso al principio y al final.
+<p> Reglas para escapar: </p>
+&quot;Escapado&quot; significa precedido por una aparición del carácter de escape que aún no se ha escapado.
+Cuando el personaje de escape precede a un personaje que no tiene un significado especial, todavía cuenta como un escape (pero no hace nada especial).
+Cada aparición del carácter de escape que se utilizó para escapar de algo, no debe formar parte de la salida.
+<p> Demuestre que su función satisface el siguiente caso de prueba:
+Cadena dada <pre> uno ^ | uno || tres ^^^^ | cuatro ^^^ | ^ cuatro | </pre> y usando
+<pre> | </pre> como separador y <pre> ^ </pre> como carácter de escape, su función
+debería generar la siguiente matriz:
+</p>
+<pre>
+[&#39;one | uno&#39;, &quot;, &#39;three ^^&#39;, &#39;four ^ | quatro&#39;,&quot;]
+</pre>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -48,9 +48,9 @@ tests:
     testString: 'assert(typeof tokenize === "function", "<code>tokenize</code> is a function.");'
   - text: <code>tokenize</code> debería devolver una matriz.
     testString: 'assert(typeof tokenize("a", "b", "c") === "object", "<code>tokenize</code> should return an array.");'
-  - text: &#39; <code>tokenize(&quot;one^|uno||three^^^^|four^^^|^cuatro|&quot;, &quot;|&quot;, &quot;^&quot;)</code> debe devolver [&quot;one | uno&quot;, &quot;,, three ^^ &quot;,&quot; cuatro ^ | cuatro &quot;,&quot; &quot;]&quot;) &#39;
+  - text: ' <code>tokenize(&quot;one^|uno||three^^^^|four^^^|^cuatro|&quot;, &quot;|&quot;, &quot;^&quot;)</code> debe devolver [&quot;one | uno&quot;, &quot;,, three ^^ &quot;,&quot; cuatro ^ | cuatro &quot;,&quot; &quot;]&quot;) '
     testString: 'assert.deepEqual(tokenize(testStr1, "|", "^"), res1, "<code>tokenize("one^|uno||three^^^^|four^^^|^cuatro|", "|", "^") </code> should return ["one|uno", "", "three^^", "four^|cuatro", ""]");'
-  - text: &#39; <code>tokenize(&quot;a@&amp;bcd&amp;ef&amp;&amp;@@hi&quot;, &quot;&amp;&quot;, &quot;@&quot;)</code> debe devolver <code>[&quot;a&amp;bcd&quot;, &quot;ef&quot;, &quot;&quot;, &quot;@hi&quot;]</code> &#39;
+  - text: ' <code>tokenize(&quot;a@&amp;bcd&amp;ef&amp;&amp;@@hi&quot;, &quot;&amp;&quot;, &quot;@&quot;)</code> debe devolver <code>[&quot;a&amp;bcd&quot;, &quot;ef&quot;, &quot;&quot;, &quot;@hi&quot;]</code> '
     testString: 'assert.deepEqual(tokenize(testStr2, "&", "@"), res2, "<code>tokenize("a@&bcd&ef&&@@hi", "&", "@")</code> should return <code>["a&bcd", "ef", "", "@hi"]</code>");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/top-rank-per-group.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/top-rank-per-group.spanish.md
index c4848d3eb2..92d6a114c1 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/top-rank-per-group.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/top-rank-per-group.spanish.md
@@ -6,45 +6,45 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Encuentre los mejores datos clasificados de N en cada grupo, donde se proporciona N como parámetro. El nombre del rango y el grupo también se proporcionan como parámetro. </p> 
-Teniendo en cuenta los siguientes datos: 
-<pre> 
-[ 
-{nombre: &#39;Tyler Bennett&#39;, id: &#39;E10297&#39;, salario: 32000, departamento: &#39;D101&#39;}, 
-{nombre: &#39;John Rappl&#39;, id: &#39;E21437&#39;, salario: 47000, departamento: &#39; D050 &#39;}, 
-{nombre:&#39; George Woltman &#39;, id:&#39; E00127 &#39;, salario: 53500, dept:&#39; D101 &#39;}, 
-{nombre:&#39; Adam Smith &#39;, id:&#39; E63535 &#39;, salario: 18000, dept : &#39;D202&#39;}, 
-{nombre: &#39;Claire Buckman&#39;, id: &#39;E39876&#39;, salario: 27800, dept: &#39;D202&#39;}, 
-{nombre: &#39;David McClellan&#39;, id: &#39;E04242&#39;, salario: 41500 , departamento: &#39;D101&#39;}, 
-{nombre: &#39;Rich Holcomb&#39;, id: &#39;E01234&#39;, salario: 49500, departamento: &#39;D202&#39;}, 
-{nombre: &#39;Nathan Adams&#39;, id: &#39;E41298&#39;, salario : 21900, depto: &#39;D050&#39;}, 
-{nombre: &#39;Richard Potter&#39;, id: &#39;E43128&#39;, salario: 15900, depto: &#39;D101&#39;}, 
-{nombre: &#39;David Motsinger&#39;, id: &#39;E27002&#39; , salario: 19250, departamento: &#39;D202&#39;}, 
-{nombre: &#39;Tim Sampair&#39;, id: &#39;E03033&#39;, salario: 27000, departamento: &#39;D101&#39;}, 
-{nombre: &#39;Kim Arlich&#39;, id: &#39; E10001 &#39;, salario: 57000, departamento:&#39; D190 &#39;}, 
-{nombre:&#39; Timothy Grove &#39;, id:&#39; E16398 &#39;, salario: 29900, departamento:&#39; D190 &#39;} 
-]; 
-</pre> 
-se podrían clasificar los 10 empleados principales en cada departamento llamando a 
-<code>topRankPerGroup(10, data, &#39;dept&#39;, &#39;salary&#39;)</code> 
-Dados los siguientes datos: 
-<pre> 
-[ 
-{nombre: &#39;Viernes 13&#39;, género: &#39;horror&#39;, calificación: 9.9}, 
-{nombre: &quot;Nightmare on Elm&#39;s Street&quot;, género: &#39;horror&#39;, calificación: 5.7}, 
-{nombre: &#39;Titanic &#39;, género:&#39; drama &#39;, calificación: 7.3}, 
-{nombre:&#39; Maze Runner &#39;, género:&#39; scifi &#39;, ​​calificación: 7.1}, 
-{nombre:&#39; Blade runner &#39;, género:&#39; scifi &#39;, ​​calificación: 8.9} 
-]; 
-</pre> 
-uno podría clasificar la película mejor calificada en cada género llamando a 
-<code>topRankPerGroup(1, data, &#39;genre&#39;, &#39;rating&#39;)</code> 
+<section id='description'>
+Tarea:
+<p> Encuentre los mejores datos clasificados de N en cada grupo, donde se proporciona N como parámetro. El nombre del rango y el grupo también se proporcionan como parámetro. </p>
+Teniendo en cuenta los siguientes datos:
+<pre>
+[
+{nombre: &#39;Tyler Bennett&#39;, id: &#39;E10297&#39;, salario: 32000, departamento: &#39;D101&#39;},
+{nombre: &#39;John Rappl&#39;, id: &#39;E21437&#39;, salario: 47000, departamento: &#39; D050 &#39;},
+{nombre:&#39; George Woltman &#39;, id:&#39; E00127 &#39;, salario: 53500, dept:&#39; D101 &#39;},
+{nombre:&#39; Adam Smith &#39;, id:&#39; E63535 &#39;, salario: 18000, dept : &#39;D202&#39;},
+{nombre: &#39;Claire Buckman&#39;, id: &#39;E39876&#39;, salario: 27800, dept: &#39;D202&#39;},
+{nombre: &#39;David McClellan&#39;, id: &#39;E04242&#39;, salario: 41500 , departamento: &#39;D101&#39;},
+{nombre: &#39;Rich Holcomb&#39;, id: &#39;E01234&#39;, salario: 49500, departamento: &#39;D202&#39;},
+{nombre: &#39;Nathan Adams&#39;, id: &#39;E41298&#39;, salario : 21900, depto: &#39;D050&#39;},
+{nombre: &#39;Richard Potter&#39;, id: &#39;E43128&#39;, salario: 15900, depto: &#39;D101&#39;},
+{nombre: &#39;David Motsinger&#39;, id: &#39;E27002&#39; , salario: 19250, departamento: &#39;D202&#39;},
+{nombre: &#39;Tim Sampair&#39;, id: &#39;E03033&#39;, salario: 27000, departamento: &#39;D101&#39;},
+{nombre: &#39;Kim Arlich&#39;, id: &#39; E10001 &#39;, salario: 57000, departamento:&#39; D190 &#39;},
+{nombre:&#39; Timothy Grove &#39;, id:&#39; E16398 &#39;, salario: 29900, departamento:&#39; D190 &#39;}
+];
+</pre>
+se podrían clasificar los 10 empleados principales en cada departamento llamando a
+<code>topRankPerGroup(10, data, &#39;dept&#39;, &#39;salary&#39;)</code>
+Dados los siguientes datos:
+<pre>
+[
+{nombre: &#39;Viernes 13&#39;, género: &#39;horror&#39;, calificación: 9.9},
+{nombre: &quot;Nightmare on Elm&#39;s Street&quot;, género: &#39;horror&#39;, calificación: 5.7},
+{nombre: &#39;Titanic &#39;, género:&#39; drama &#39;, calificación: 7.3},
+{nombre:&#39; Maze Runner &#39;, género:&#39; scifi &#39;, ​​calificación: 7.1},
+{nombre:&#39; Blade runner &#39;, género:&#39; scifi &#39;, ​​calificación: 8.9}
+];
+</pre>
+uno podría clasificar la película mejor calificada en cada género llamando a
+<code>topRankPerGroup(1, data, &#39;genre&#39;, &#39;rating&#39;)</code>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -63,9 +63,9 @@ tests:
     testString: 'assert.equal(res1[0][1].salary, 21900, "First department must be D050");'
   - text: El último departamento debe ser D202.
     testString: 'assert.equal(res1[3][3].dept, "D202", "The last department must be D202");'
-  - text: &#39; <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.&#39;
+  - text: ' <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.'
     testString: 'assert.equal(res2[2].length, 1, "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
-  - text: &#39; <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.&#39;
+  - text: ' <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.'
     testString: 'assert.equal(res3[2][1].name, "Maze Runner", "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
 
 ```
diff --git a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/towers-of-hanoi.spanish.md b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/towers-of-hanoi.spanish.md
index 26181c42a6..bccb3362e6 100644
--- a/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/towers-of-hanoi.spanish.md
+++ b/curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/towers-of-hanoi.spanish.md
@@ -6,22 +6,22 @@ challengeType: 5
 ---
 
 ## Description
-<section id='description'> 
-Tarea: 
-<p> Resuelve el problema de las <a href="https://en.wikipedia.org/wiki/Towers_of_Hanoi" title="wp: torres_de_hanoi">Torres de Hanoi</a> . </p> 
-<p> 
-Su solución debe aceptar el número de discos como los primeros parámetros, y 
-tres cadenas utilizadas para identificar cada una de las tres pilas de discos, por ejemplo 
-<code>towerOfHanoi(4, &#39;A&#39;, &#39;B&#39;, &#39;C&#39;)</code> . La función debe devolver una matriz 
-de matrices que contiene la lista de movimientos, origen -&gt; destino. Para el ejemplo 
-, la matriz <code>[[&#39;A&#39;, &#39;C&#39;], [&#39;B&#39;, &#39;A&#39;]]</code> indica que el primer movimiento 
-fue mover un disco de la pila A a la C, y el segundo movimiento fue mueve un disco 
-de la pila B a A. 
-</p> 
+<section id='description'>
+Tarea:
+<p> Resuelve el problema de las <a href="https://en.wikipedia.org/wiki/Towers_of_Hanoi" title="wp: torres_de_hanoi">Torres de Hanoi</a> . </p>
+<p>
+Su solución debe aceptar el número de discos como los primeros parámetros, y
+tres cadenas utilizadas para identificar cada una de las tres pilas de discos, por ejemplo
+<code>towerOfHanoi(4, &#39;A&#39;, &#39;B&#39;, &#39;C&#39;)</code> . La función debe devolver una matriz
+de matrices que contiene la lista de movimientos, origen -&gt; destino. Para el ejemplo
+, la matriz <code>[[&#39;A&#39;, &#39;C&#39;], [&#39;B&#39;, &#39;A&#39;]]</code> indica que el primer movimiento
+fue mover un disco de la pila A a la C, y el segundo movimiento fue mueve un disco
+de la pila B a A.
+</p>
 </section>
 
 ## Instructions
-<section id='instructions'> 
+<section id='instructions'>
 
 </section>
 
@@ -32,13 +32,13 @@ de la pila B a A.
 tests:
   - text: <code>towerOfHanoi</code> es una función.
     testString: 'assert(typeof towerOfHanoi === "function", "<code>towerOfHanoi</code> is a function.");'
-  - text: &#39; <code>towerOfHanoi(3, ...)</code> debe devolver 7 movimientos.&#39;
+  - text: ' <code>towerOfHanoi(3, ...)</code> debe devolver 7 movimientos.'
     testString: 'assert(res3.length === 7, "<code>towerOfHanoi(3, ...)</code> should return 7 moves.");'
-  - text: &#39; <code>towerOfHanoi(3, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;)</code> debe devolver [[&quot;A&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;C&quot;], [&quot;B&quot;, &quot;C&quot;], [&quot;A&quot;, &quot;B&quot;], [&quot;C&quot;, &quot;A&quot;], [&quot;C&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;B&quot;]]. &quot;) &#39;
+  - text: ' <code>towerOfHanoi(3, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;)</code> debe devolver [[&quot;A&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;C&quot;], [&quot;B&quot;, &quot;C&quot;], [&quot;A&quot;, &quot;B&quot;], [&quot;C&quot;, &quot;A&quot;], [&quot;C&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;B&quot;]]. &quot;) '
     testString: 'assert.deepEqual(towerOfHanoi(3, "A", "B", "C"), res3Moves, "<code>towerOfHanoi(3, "A", "B", "C")</code> should return [["A","B"],["A","C"],["B","C"],["A","B"],["C","A"],["C","B"],["A","B"]].");'
-  - text: &#39; <code>towerOfHanoi(5, &quot;X&quot;, &quot;Y&quot;, &quot;Z&quot;)</code> décimo movimiento debe ser Y -&gt; X.&#39;
+  - text: ' <code>towerOfHanoi(5, &quot;X&quot;, &quot;Y&quot;, &quot;Z&quot;)</code> décimo movimiento debe ser Y -&gt; X.'
     testString: 'assert.deepEqual(res5[9], ["Y", "X"], "<code>towerOfHanoi(5, "X", "Y", "Z")</code> 10th move should be Y -> X.");'
-  - text: &#39; <code>towerOfHanoi(7, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;)</code> primeros diez movimientos son [[&quot;A&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;C&quot;], [&quot;B&quot;, &quot;C&quot; ], [&quot;A&quot;, &quot;B&quot;], [&quot;C&quot;, &quot;A&quot;], [&quot;C&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;C&quot; ], [&quot;B&quot;, &quot;C&quot;], [&quot;B&quot;, &quot;A&quot;]]. &quot;) &#39;
+  - text: ' <code>towerOfHanoi(7, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;)</code> primeros diez movimientos son [[&quot;A&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;C&quot;], [&quot;B&quot;, &quot;C&quot; ], [&quot;A&quot;, &quot;B&quot;], [&quot;C&quot;, &quot;A&quot;], [&quot;C&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;B&quot;], [&quot;A&quot;, &quot;C&quot; ], [&quot;B&quot;, &quot;C&quot;], [&quot;B&quot;, &quot;A&quot;]]. &quot;) '
     testString: 'assert.deepEqual(towerOfHanoi(7, "A", "B", "C").slice(0, 10), res7First10Moves, "<code>towerOfHanoi(7, "A", "B", "C")</code> first ten moves are [["A","B"],["A","C"],["B","C"],["A","B"],["C","A"],["C","B"],["A","B"],["A","C"],["B","C"],["B","A"]].");'
 
 ```