fix(guide): simplify directory structure

guide/spanish/certifications/coding-interview-prep/algorithms/find-the-symmetric-difference/index.md

@@ -0,0 +1,200 @@
+---
+title: Find the Symmetric Difference
+localeTitle: Encuentra la diferencia simétrica
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar [**`Read-Search-Ask`**](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/) si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+La diferencia simétrica (comúnmente denotada por Δ) de dos conjuntos es el conjunto de elementos que están en cualquiera de los dos conjuntos, pero no en ambos.
+
+Por ejemplo, `sym([1, 2, 3], [5, 2, 1, 4])` debe producir `[3, 4, 5]` .
+
+Siguiendo la definición anterior, la diferencia simétrica de los tres conjuntos _A_ , _B_ y _C_ se puede expresar como `(A Δ B) Δ C`
+
+#### Enlaces relevantes
+
+*   [Diferencia simétrica - Wikipedia](https://en.wikipedia.org/wiki/Symmetric_difference)
+*   [Diferencia simétrica - YouTube](https://www.youtube.com/watch?v=PxffSUQRkG4)
+
+[](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
+
+ [## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+El objeto de _argumentos_ es un objeto de tipo _Array_ que solo hereda la propiedad `Array.length` . Por lo tanto, considere convertirlo en una _matriz_ real.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Decida escribir una función auxiliar que devuelva la diferencia simétrica de dos matrices en cada llamada en lugar de intentar diferenciar todos los conjuntos simultáneamente.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Aplique la función de ayuda contra la matriz de argumentos creada, reduciendo sus elementos en forma recursiva por pares para formar el resultado esperado.
+
+**Nota** En el caso de _un número impar de conjuntos,_ la diferencia simétrica incluirá elementos idénticos presentes en todos los conjuntos dados. Por ejemplo;
+```
+A = {1, 2, 3} 
+ B = {2, 3, 4} 
+ C = {3, 4, 5} 
+ 
+ (A ⋂ B) ⋂ C = {1, 4} &Intersection {3, 4, 5} 
+ A ⋂ B = {1, 3, 5} 
+```
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![:warning:](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif ":advertencia:")
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+    function sym() { 
+      var args = []; 
+      for (var i = 0; i < arguments.length; i++) { 
+        args.push(arguments[i]); 
+      } 
+ 
+      function symDiff(arrayOne, arrayTwo) { 
+        var result = []; 
+ 
+        arrayOne.forEach(function(item) { 
+          if (arrayTwo.indexOf(item) < 0 && result.indexOf(item) < 0) { 
+            result.push(item); 
+          } 
+        }); 
+ 
+        arrayTwo.forEach(function(item) { 
+          if (arrayOne.indexOf(item) < 0 && result.indexOf(item) < 0) { 
+            result.push(item); 
+          } 
+        }); 
+ 
+        return result; 
+      } 
+ 
+      // Apply reduce method to args array, using the symDiff function 
+      return args.reduce(symDiff); 
+    } 
+
+```](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) 
+
+ [![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:")](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) [Ejecutar código](https://repl.it/C4II/0)
+
+### Explicación del código:
+
+*   `push()` se utiliza para desglosar el objeto de _argumentos_ en una matriz, _args_ .
+*   La función `symDiff` encuentra la diferencia simétrica entre dos conjuntos. Se utiliza como una función de devolución de llamada para el método `reduce()` llamado en _args_ .
+*   `arrayOne.forEach()` empuja los elementos al _resultado_ que están presentes solo en _arrayOne_ y que no forman parte del _resultado_ .
+*   `arrayTwo.forEach()` empuja los elementos al _resultado_ que están presentes solo en _arrayTwo_ y que no forman parte del _resultado_ .
+*   Se devuelve el _resultado_ , que es la diferencia simétrica. Esta solución funciona para cualquier número de conjuntos.
+
+#### Enlaces relevantes
+
+*   [JavaScript para](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/statements/for)
+*   [JavaScript Array.length](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+*   [JavaScript Array.prototype.push ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   [JavaScript Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
+*   [JavaScript Array.prototype.indexOf ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+```javascript
+    function sym() { 
+ 
+      // Convert the argument object into a proper array 
+      var args = Array.prototype.slice.call(arguments); 
+ 
+      // Return the symmetric difference of 2 arrays 
+      var getDiff = function(arr1, arr2) { 
+ 
+        // Returns items in arr1 that don't exist in arr2 
+        function filterFunction(arr1, arr2) { 
+          return arr1.filter(function(item) { 
+            return arr2.indexOf(item) === -1; 
+          }); 
+        } 
+ 
+        // Run filter function on each array against the other 
+        return filterFunction(arr1, arr2) 
+          .concat(filterFunction(arr2, arr1)); 
+      }; 
+ 
+      // Reduce all arguments getting the difference of them 
+      var summary = args.reduce(getDiff, []); 
+ 
+      // Run filter function to get the unique values 
+      var unique = summary.filter(function(elem, index, self) { 
+        return index === self.indexOf(elem); 
+        }); 
+      return unique; 
+    } 
+ 
+    // test here 
+    sym([1, 2, 3], [5, 2, 1, 4]); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLoc/0)
+
+### Explicación del código:
+
+*   El método `slice()` se utiliza para desglosar el objeto de _argumentos_ en una matriz, _args_ .
+*   La función `getDiff` encuentra la diferencia simétrica entre dos conjuntos, _arr1_ y _arr2_ . Se utiliza como una función de devolución de llamada para el método `reduce()` llamado en _args_ .
+*   El primer `filterFunction()` devuelve elementos en _arr1_ que no existen en _arr2_ .
+*   El siguiente `filterFunction()` se ejecuta en cada matriz contra la otra para verificar la inversa de la primera comprobación de singularidad y concatenarla.
+*   _El resumen_ consiste en los argumentos reducidos.
+*   `filter()` se usa en el _resumen_ para mantener solo los valores _únicos_ y se devuelve _unique_ .
+
+#### Enlaces relevantes
+
+*   [JavaScript Array.prototype.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+*   [JavaScript Array.prototype.filter ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
+*   [JavaScript Array.prototype.concat ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+
+```javascript
+    function sym() { 
+      let argv = Array.from(arguments).reduce(diffArray); 
+      return argv.filter((element, index, array) => index === array.indexOf(element));//remove duplicates 
+    } 
+ 
+    function diffArray(arr1, arr2) { 
+      return arr1 
+        .filter(element => !arr2.includes(element)) 
+        .concat(arr2.filter(element => !arr1.includes(element))); 
+    } 
+ 
+    // test here 
+    sym([1, 2, 3], [5, 2, 1, 4]); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/@ashenm/Symmetric-Difference)
+
+### Explicación del código:
+
+*   La función principal _sym ()_ crea una matriz a partir de _argumentos_ y reduce sus elementos utilizando la función helper _diffArray ()_ a una sola matriz.
+    
+*   La función _diffArray ()_ devuelve la diferencia simétrica de dos matrices seleccionando elementos únicos en matrices parametrizadas; _arr1_ y _arr2_ .
+    
+
+#### Enlaces relevantes
+
+*   [JavaScript Array.from ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from)
+*   [JavaScript Array.prototype.filter ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/coding-interview-prep/algorithms/implement-bubble-sort/index.md

@@ -0,0 +1,49 @@
+---
+title: Implement Bubble Sort
+localeTitle: Implementar Bubble Sort
+---
+## Implementar Bubble Sort
+
+### Método:
+
+*   Bubble Sort es un algoritmo de clasificación que ordena o _burbujea_ el número más grande como último elemento al final de cada pasada.
+*   Comparamos cada elemento con el anterior, si el elemento anterior es más pequeño, intercambiamos sus lugares.
+*   La complejidad del tiempo de Bubble Sort es **O (n 2 )** .
+*   Es un algoritmo **estable** .
+*   ![Tipo burbuja en acción](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
+
+### Solución:
+
+#### Solución 1: Básico
+
+```js
+function swap(a, b, arr){ 
+  let tmp = arr[a]; 
+  arr[a] = arr[b]; 
+  arr[b] = tmp; 
+ } 
+ function bubbleSort(array) { 
+  for (let i = 0; i < array.length; i++){ 
+    for (let j = 0; j < array.length-1-i; j++){ // -i because the largest element will be bubbled at the end so we don't have to compare. 
+      if (array[j] > array[j+1]){ 
+        swap(j, j+1, array); 
+      } 
+    } 
+  } 
+  return array; 
+ } 
+```
+
+#### Solución 2: Avanzado
+
+`js function bubbleSort(array) { for (let i = 0; i < array.length; i++){ for (let j = 0; j < array.length-1-i; j++){ if (array[j] > array[j+1]) [array[j], array[j+1]] = [array[j+1], array[j]]; // Using ES6 array destructuring to swap } } return array; }`
+
+*   [Ejecutar código](https://repl.it/@ezioda004/Bubble-Sort)
+    
+    ### Referencias:
+    
+*   [GeeksForGeeks](https://www.geeksforgeeks.org/bubble-sort/)
+    
+*   [Wikipedia](https://en.wikipedia.org/wiki/Bubble_sort)
+    
+*   Video de [HackerRank](https://www.youtube.com/watch?v=6Gv8vg0kcHc)

guide/spanish/certifications/coding-interview-prep/algorithms/implement-insertion-sort/index.md

@@ -0,0 +1,40 @@
+---
+title: Implement Insertion Sort
+localeTitle: Implementar orden de inserción
+---
+## Implementar orden de inserción
+
+### Método:
+
+*   El orden de inserción supone que la matriz se divide en dos partes:
+
+1.  Ordenado (Inicialmente el primer elemento)
+2.  Sin clasificar
+
+*   En cada paso, seleccionamos un elemento y lo comparamos con la matriz ordenada.
+*   Si el elemento seleccionado es más pequeño que el último elemento de la matriz ordenada, entonces cambiamos la matriz ordenada en 1 hasta que encontremos el lugar para _insertar_ el elemento seleccionado.
+*   ![Tipo de inserción en acción](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif) - [fuente](https://en.wikipedia.org/wiki/Insertion_sort)
+*   La complejidad de tiempo de la ordenación de inserción es de **O (n 2 )** .
+*   Es un algoritmo **estable** .
+
+### Solución:
+
+```js
+function insertionSort(array) { 
+  for (let i = 1; i < array.length; i++){ 
+    let curr = array[i]; 
+    for (var j = i-1; j >= 0 && array[j] > curr; j--){ 
+      array[j+1] = array[j]; 
+    } 
+    array[j+1] = curr; 
+  } 
+  return array; 
+ } 
+```
+
+*   [Ejecutar código](https://repl.it/@ezioda004/Insertion-Sort)
+
+### Referencias:
+
+*   [Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)
+*   [academia Khan](https://www.youtube.com/watch?v=lCzQvQr8Utw)

guide/spanish/certifications/coding-interview-prep/algorithms/implement-merge-sort/index.md

@@ -0,0 +1,56 @@
+---
+title: Implement Merge Sort
+localeTitle: Implementar Merge Sort
+---
+## Implementar Merge Sort
+
+### Método:
+
+*   Merge Sort es un problema clásico de dividir y vencer.
+*   Los siguientes pasos están involucrados:
+*   Dividir: Rompemos la matriz desde el medio usando recusión hasta que quedemos con 1 elemento.
+*   Conquistar: Entonces ordenamos estas pequeñas matrices.
+*   Combine: Finalmente, fusionamos estas pequeñas matrices en una matriz ordenada y seguimos haciéndolo hasta que combinemos todas las matrices.
+*   La complejidad del tiempo de Merge Sort es **O (nlogn)** .
+*   La complejidad de espacio de Merge Sort es **O (n)** .
+*   Es un algoritmo **estable** .
+*   ![Combinar Ordenar en acción](https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif)
+
+### Solución:
+
+```js
+//Merger function, which merges 2 sorted array into 1 sorted array 
+ function merger(arr1, arr2){ 
+  let i = 0, j = 0, mergedArr = []; 
+  while (i < arr1.length && j < arr2.length){ 
+    if (arr1[i] > arr2[j]) mergedArr.push(arr2[j++]); 
+    else mergedArr.push(arr1[i++]); 
+  } 
+  while (i < arr1.length){ 
+    mergedArr.push(arr1[i++]); 
+  } 
+  while (j < arr2.length){ 
+    mergedArr.push(arr2[j++]); 
+  } 
+  return mergedArr; 
+ } 
+ function mergeSort(array) { 
+  //Array of length 1 is sorted so we return the same array back 
+  if (array.length == 1) return array; 
+ 
+  //Break down the array to half from middle into left and right 
+  let middle = Math.floor(array.length/2); 
+  let left = mergeSort(array.slice(0, middle)); 
+  let right = mergeSort(array.slice(middle)); 
+ 
+  //Return the merged sorted array 
+  return merger(left, right); 
+ } 
+```
+
+*   [Ejecutar código](https://repl.it/@ezioda004/Merge-Sort)
+
+### Referencias:
+
+*   [Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)
+*   Video de [Hackerrank](https://www.youtube.com/watch?v=KF2j-9iSf4Q)

guide/spanish/certifications/coding-interview-prep/algorithms/implement-quick-sort/index.md

@@ -0,0 +1,56 @@
+---
+title: Implement Quick Sort
+localeTitle: Implementar ordenación rápida
+---
+## Implementar ordenación rápida
+
+### Método:
+
+*   La ordenación rápida es un algoritmo de clasificación eficiente. Es un algoritmo in situ, por lo que no ocupa ningún espacio auxiliar.
+*   Primero elija un punto de pivote al azar alrededor del cual mueva todos los elementos más pequeños hacia la izquierda y los elementos más grandes hacia la derecha.
+*   Después de obtener el pivotIndex que es esencialmente la posición fija de ese elemento, encontramos otro pivotIndex llamando de forma recusiva a esta función.
+*   El peor de los casos de ordenación rápida es **O (n 2 ),** pero eso puede evitarse si seleccionamos un punto de pivote aleatorio, por lo que de esa forma es O grande **(nlogn)** .
+*   Su complejidad de espacio es **O (logn)** .
+*   Es un algoritmo **inestable** .
+*   ![Ordenación rápida en acción](https://upload.wikimedia.org/wikipedia/commons/6/6a/Sorting_quicksort_anim.gif)
+
+### Solución:
+
+```js
+//Swapping array elements via ES6 array destructuring 
+ function swap(arr, x, y){ 
+  [arr[x], arr[y]] = [arr[y], arr[x]]; 
+ } 
+ 
+ //Pivot function returns the fixed pivot point 
+ function pivot(arr, left = 0, right = arr.length-1){ 
+  let shift = left; 
+  for (let i = left+1; i <= right; i++){ 
+ 
+    //Move all the small elements on the left side 
+    if (arr[i] < arr[left]) swap(arr, i, ++shift); 
+  } 
+ 
+  //Finally swapping the last element with the left 
+  swap(arr, left, shift); 
+  return shift; 
+ } 
+ 
+ function quickSort(array, left = 0, right = array.length-1) { 
+  if (left < right){ 
+    let pivotIndex = pivot(array, left, right); 
+ 
+    //Recusrively calling the function to the left of the pivot and to the right of the pivot 
+    quickSort(array, left, pivotIndex-1); 
+    quickSort(array, pivotIndex+1, right); 
+  } 
+  return array; 
+ } 
+```
+
+*   [Ejecutar código](https://repl.it/@ezioda004/Quick-Sort)
+
+### Referencia:
+
+*   [Wikipedia](https://en.wikipedia.org/wiki/Quicksort)
+*   [academia Khan](https://www.khanacademy.org/computing/computer-science/algorithms/quick-sort/a/overview-of-quicksort)

guide/spanish/certifications/coding-interview-prep/algorithms/implement-selection-sort/index.md

@@ -0,0 +1,41 @@
+---
+title: Implement Selection Sort
+localeTitle: Implementar Selección Ordenar
+---
+## Implementar Selección Ordenar
+
+### Método:
+
+*   El ordenamiento por selección es uno de los algoritmos de clasificación más fáciles de entender e implementar.
+*   Este algoritmo divide la matriz en dos partes:
+
+1.  Ordenados
+2.  Sin clasificar
+
+*   La parte ordenada se encuentra al principio de la matriz y la parte sin clasificar después.
+*   Cada paso, inicialmente asumimos que el primer elemento es el más pequeño, luego hacemos un ciclo a través de toda la matriz y _seleccionamos_ el elemento más pequeño. Al final del paso, intercambiamos el elemento más pequeño a la matriz ordenada.
+*   Tiene **O (n 2 )** complejidad de tiempo.
+
+### Solución:
+
+```js
+function swap(a, b, arr){ 
+  let tmp = arr[a]; 
+  arr[a] = arr[b]; 
+  arr[b] = tmp; 
+ } 
+ function selectionSort(array) { 
+  for (let i = 0; i < array.length-1; i++){ 
+    let min = i; 
+    for (let j = i+1; j < array.length; j++){ 
+      if (array[min] > array[j]) min = j; 
+    } 
+    swap(i, min, array); 
+  } 
+  return array; 
+ } 
+```
+
+### Referencias:
+
+*   Lea acerca de la selección de selección en [Wikipedia](https://en.wikipedia.org/wiki/Selection_sort)

guide/spanish/certifications/coding-interview-prep/algorithms/index.md

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

guide/spanish/certifications/coding-interview-prep/algorithms/inventory-update/index.md

@@ -0,0 +1,294 @@
+---
+title: Inventory Update
+localeTitle: Actualización de inventario
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+En este problema, debe comparar y actualizar 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 `arr1` ). 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.
+
+El inventario actual y el nuevo inventario estarán en este formato: `[[2, "item-0"], [3, "item-1"], [67, "item-2"], [7, "item-3"]]` .
+
+#### Enlaces relevantes
+
+*   [JS Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Debe revisar cada elemento del nuevo inventario para ver si existe en el inventario actual o no. Recuerde que el nombre del producto se almacena como el segundo elemento de cada sub-array: `array[0][1] = "item-name"` .
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Si el artículo existe, debe agregar la cantidad del nuevo inventario. Si el elemento no existe, debe agregar todo el elemento.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Devuelve el inventario completado en orden alfabético.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+    function updateInventory(arr1, arr2) { 
+ 
+        // Variable for location of product 
+        var index; 
+ 
+        // A helper method to return the index of a specified product (undefined if not found) 
+        var getProductIndex = function (name) { 
+            for (var i = 0; i < this.length; i++) { 
+                if (this<a href='https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":rocket:"' target='_blank' rel='nofollow'>i][1] === name) { 
+                    return i; 
+                } 
+            } 
+            return undefined; 
+        } 
+ 
+        // For each item of the new Inventory 
+        for (var i = 0; i < arr2.length; i++) { 
+ 
+            // Invoke our helper function using arr1 as this 
+            index = getProductIndex.call(arr1, arr2[i][1]); 
+ 
+            // If the item doesn't exist 
+            if (index === undefined) { 
+                // Push the entire item 
+                arr1.push(arr2[i]); 
+            } else { 
+                // Add the new quantity of the current item 
+                arr1[index][0] += arr2[i][0]; 
+            } 
+ 
+        } 
+ 
+        // Sort alphabetically, by the product name of each item 
+        arr1.sort(function (a, b) { 
+            if (a[1] > b[1]) { 
+                return 1; 
+            } 
+            if (a[1] < b[1]) { 
+                return -1; 
+            } 
+            return 0; 
+        }); 
+ 
+        return arr1; 
+    } 
+ 
+    // test here 
+    // Example inventory lists 
+    var curInv = [ 
+        [21, "Bowling Ball"], 
+        [2, "Dirty Sock"], 
+        [1, "Hair Pin"], 
+        [5, "Microphone"] 
+    ]; 
+ 
+    var newInv = [ 
+        [2, "Hair Pin"], 
+        [3, "Half-Eaten Apple"], 
+        [67, "Bowling Ball"], 
+        [7, "Toothpaste"] 
+    ]; 
+ 
+    updateInventory(curInv, newInv); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLok/0)
+
+### Explicación del código:
+
+*   El **índice** variable almacena la ubicación (índice) de un producto.
+*   La función auxiliar `getProductIndex()` devuelve el índice de un producto especificado. Recorre cada elemento de la matriz en la que se llama hasta que puede encontrar el parámetro de nombre. Si el producto no se encuentra en el inventario, se devuelve `undefined` .
+*   Luego, cada artículo en el nuevo inventario (entrega) se trabaja a través de:
+*   **el índice** se establece en el resultado de invocar la función auxiliar, es decir, buscar el nuevo inventario para ese nombre de producto y devolver su índice.
+*   Si se encuentra el artículo, la cantidad del producto se agrega a la cantidad del mismo producto en el inventario actual.
+*   Si no se encuentra el artículo, el producto completo (nombre y cantidad) se agrega al inventario actual.
+*   El inventario actualizado, **arr1** , se clasifica por nombre de producto (contenido en `arr1[x][1]` ).
+*   A continuación, se devuelve el final, así como la matriz ordenada.
+
+#### Enlaces relevantes
+
+*   [JS esto](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/this)
+*   [JS Array.length](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+*   [JS Array.prototype.push ()](http://forum.freecodecamp.com/t/javascript-array-prototype-push/14298)
+*   [JS Array.prototype.sort ()](http://forum.freecodecamp.com/t/javascript-array-prototype-sort/14306)
+
+## ![:sunflower:](https://forum.freecodecamp.com/images/emoji/emoji_one/sunflower.png?v=3 ":girasol:") Solución de código intermedio:
+
+```javascript
+    function updateInventory(arr1, arr2) { 
+      // All inventory must be accounted for or you're fired! 
+ 
+      var index; 
+      var arrCurInvName = <a href='https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":rocket:"' target='_blank' rel='nofollow'>]; // Names of arr1's items 
+      var arrNeInvName = []; // Names of arr2's items 
+ 
+      // Same as using two for loops, this takes care of increasing the number of stock quantity. 
+      arr1.map(function(item1) { 
+        return arr2.map(function(item2) { 
+          if (item1[1] === item2[1]) { 
+            item1[0] = item1[0] + item2[0]; //Increase number of stock 
+          } 
+        }); 
+      }); 
+ 
+      // Get item's name for new Inventory 
+      arr2.map(function(item) { 
+        arrNeInvName.push(item[1]); 
+      }); 
+ 
+      // Get item's name for Current Inventory 
+      arr1.map(function(item) { 
+        arrCurInvName.push(item[1]); 
+      }); 
+ 
+      // Add new inventory items to current inventory. 
+      arrNeInvName.map(function(item) { 
+        if (arrCurInvName.indexOf(item) === -1) { 
+          index = arrNeInvName.indexOf(item); 
+          arr1.push(arr2[index]); 
+        } 
+      }); 
+ 
+      // Sort the array alphabetically using the second element of the array as base. 
+      arr1.sort(function(currItem, nextItem) { 
+ 
+        //Ternary function to avoid using if else 
+        return currItem[1] > nextItem[1] ? 1 : -1; 
+      }); 
+ 
+      return arr1; 
+    } 
+ 
+    // test here 
+    // Example inventory lists 
+    var curInv = [ 
+        [21, "Bowling Ball"], 
+        [2, "Dirty Sock"], 
+        [1, "Hair Pin"], 
+        [5, "Microphone"] 
+    ]; 
+ 
+    var newInv = [ 
+        [2, "Hair Pin"], 
+        [3, "Half-Eaten Apple"], 
+        [67, "Bowling Ball"], 
+        [7, "Toothpaste"] 
+    ]; 
+ 
+    updateInventory(curInv, newInv); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLol/0)
+
+### Explicación del código:
+
+*   El **índice** variable almacena la ubicación (índice) de un producto.
+*   **arrCurInvName** tiene los nombres de los **elementos** de **arr1** .
+*   **arrNeInvName** tiene los nombres de los **elementos** de **arr2** .
+*   `arr1.map(function(item1))` se ocupa de los artículos que ya existen en el inventario, es decir, aumenta la cantidad en el inventario.
+*   A continuación, `arr2.map(function(item))` y `arr1.map(function(item))` obtienen los nombres de los artículos para el inventario nuevo y actual respectivamente.
+*   `arrNeInvName.map(function(item))` maneja artículos que no existen en el inventario, es decir, agrega nuevos artículos al inventario.
+*   La matriz actualizada **arr1** se clasifica alfabéticamente por nombre de producto (contenido en `arr1[x][1]` ) y se devuelve.
+
+#### Enlaces relevantes
+
+*   [JS Array.prototype.map ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
+*   [JS Array.prototype.indexOf ()](http://forum.freecodecamp.com/t/javascript-array-prototype-indexof/14291)
+*   [Operador Ternario JS](http://forum.freecodecamp.com/t/javascript-ternary-operator/15973)
+
+## ![:rotating_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/rotating_light.png?v=3 ": rotando luz:") Solución avanzada de código:
+
+```javascript
+    function updateInventory(arr1, arr2) { 
+      // All inventory must be accounted for or you're fired! 
+ 
+      // convert current inventory (arr1) to an one-dimensional array 
+      const inventory = Array.prototype.concat.apply([], arr1); 
+ 
+      // loop through new delivery (arr2) 
+      for (let i = 0; i < arr2.length; i++) { 
+ 
+        // extract item properties for easy reference 
+        const item = arr2[i][1]; 
+        const quantity = arr2[i][0]; 
+ 
+        // check if item already exists in inventory 
+        const position = inventory.indexOf(item); 
+ 
+        // exsisting item: update quantity 
+        if (position !== -1) { 
+          const row = Math.floor(position / 2); 
+          arr1[row][0] += quantity; 
+          continue; 
+        } 
+ 
+        // alien item: add to inventory 
+        arr1.push([quantity, item]); 
+ 
+      } 
+ 
+      // sort inventory in alphabetical order 
+      arr1.sort((previous, next) => (previous[1] > [next[1]]) ? 1 : -1); 
+ 
+      return arr1; 
+ 
+    } 
+ 
+ 
+    // test here 
+    // Example inventory lists 
+    var curInv = [ 
+        [21, "Bowling Ball"], 
+        [2, "Dirty Sock"], 
+        [1, "Hair Pin"], 
+        [5, "Microphone"] 
+    ]; 
+ 
+    var newInv = [ 
+        [2, "Hair Pin"], 
+        [3, "Half-Eaten Apple"], 
+        [67, "Bowling Ball"], 
+        [7, "Toothpaste"] 
+    ]; 
+ 
+    updateInventory(curInv, newInv); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/MQvv/latest)
+
+### Explicación del código:
+
+*   Convierta la matriz de inventario actual **arr1** en una matriz unidimensional para que el método `indexOf()` pueda usarse para verificar la existencia de nuevos elementos de entrega en el inventario actual.
+*   Verifique si el artículo ya existe en el inventario actual usando `indexOf()` .
+*   Si el ítem existe, actualizar la cantidad y continuar la ejecución del bucle.
+*   De lo contrario, agregue el artículo al inventario.
+*   Finalmente, ordene la matriz alfabéticamente y devuelva el inventario actualizado.
+
+#### Enlaces relevantes
+
+*   [JS Function.prototype.apply ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply)
+*   [JS continuar](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/continue)
+*   [JS Array.prototype.sort ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/coding-interview-prep/algorithms/no-repeats-please/index.md

@@ -0,0 +1,177 @@
+---
+title: No Repeats Please
+localeTitle: No se repite por favor
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Esta tarea requiere que devolvamos el número de permutaciones totales de la cadena proporcionada que no tienen letras consecutivas repetidas. Se debe asumir que todos los caracteres en la cadena proporcionada son únicos. Por ejemplo, `aab` debe devolver 2 porque tiene 6 permutaciones totales ( `aab` , `aab` , `aba` , `aba` , `baa` , `baa` ), pero solo 2 de ellas ( `aba` y `aba` ) no tienen la misma letra (en este caso `a` ) repitiendo
+
+Para lograrlo, tendremos que ver cada posible permutación de una cadena. Hay varias maneras de hacer eso. Una pregunta de entrevista común es crear una función que recopile todas las permutaciones de una cadena. Hay varios tutoriales disponibles en Internet sobre cómo hacerlo.
+
+#### Métodos potenciales utilizados como solución
+
+##### Método recursivo
+
+Esta tarea puede ser desalentadora incluso después de ver un tutorial. Para escribir una solución recursiva, deseará enviar a cada nuevo uso de la función tres entradas:
+
+1.  Una nueva cadena (o matriz de caracteres) que se está construyendo.
+2.  Una posición en su nueva cadena que se va a llenar a continuación.
+3.  Una idea de qué caracteres (más específicamente las posiciones) de la cadena original aún no se han utilizado.
+
+El pseudo código se verá así:
+```
+var str = ???; 
+ permAlone(current position in original string, characters used already in original string, created string) { 
+  if (current string is finished) { 
+    print current string; 
+  } else { 
+    for (var i = 0; i < str.length; i++) { 
+      if (str[i] has not been used) { 
+        put str[i] into the current position of new string; 
+        mark str[i] as used; 
+        permAlone(current position in original string, characters used already in original string, created string); 
+        remove str[i] as used because another branch in the tree for i + 1 will likely use it; 
+      } 
+    } 
+  } 
+ } 
+ permAlone(0, nothing used yet, empty new string (or array the same size as str)); 
+```
+
+Otra forma de pensar sobre este problema es comenzar desde un espacio vacío. Introduce la primera letra al espacio. Este espacio ahora contendrá la primera sub-permutación. Aquí hay un diagrama que ilustra la idea:
+
+![diagrama](//discourse-user-assets.s3.amazonaws.com/original/2X/6/69896bacc8bd3b2e347beb4b304a7f97caa6d9ab.png)
+
+##### Método no recursivo
+```
+// An approach to introduce a new character to a permutation 
+ var ch = '?'; 
+ var source = ['?', '?', '?'];     // Current sub-permutation 
+ var temp, dest = []; 
+ 
+ for (var i = 0; i <= source.length; ++i) { 
+  temp = source.slice(0);         // Copy the array 
+  temp.splice(i, 0, ch);          // Insert the new character 
+  dest.push(temp);                // Store the new sub-permutation 
+ } 
+```
+
+Encontrar cada permutación se podría hacer de manera no recursiva al incluir lo anterior en una función que toma una matriz de origen y devuelve una matriz de destino. Para cada letra de la cadena de entrada, pase ese carácter, así como la matriz devuelta de la llamada anterior de la función.
+
+Una forma de visualizar esto es considerando un árbol que comienza con el primer carácter de la cadena:
+
+![Árbol de permutación](//discourse-user-assets.s3.amazonaws.com/original/2X/8/8187f2b06cdc02cf62286c18ce15bfcdc99bc68c.png)
+
+#### Enlaces relevantes
+
+*   [Permutaciones](https://www.mathsisfun.com/combinatorics/combinations-permutations.html)
+*   [Algoritmo de Heap](https://en.wikipedia.org/wiki/Heap%27s_algorithm)
+*   Recursos JS Regex
+*   [Objeto String JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+*   La forma más fácil es usar el algoritmo de Heap para obtener recursivamente una lista de todas las permutaciones.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+*   Una vez que tenga la lista, simplemente cree una expresión regular para capturar los caracteres que se repiten.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+*   Querrá tener las permutaciones como una matriz de cadenas unidas en lugar de caracteres separados.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function permAlone(str) { 
+ 
+  // Create a regex to match repeated consecutive characters. 
+  var regex = /(.)\1+/g; 
+ 
+  // Split the string into an array of characters. 
+  var arr = str.split(''); 
+  var permutations = <a href='https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":rocket:"' target='_blank' rel='nofollow'>]; 
+  var tmp; 
+ 
+  // Return 0 if str contains same character. 
+  if (str.match(regex) !== null && str.match(regex)[0] === str) return 0; 
+ 
+  // Function to swap variables' content. 
+  function swap(index1, index2) { 
+    tmp = arr[index1]; 
+    arr[index1] = arr[index2]; 
+    arr[index2] = tmp; 
+  } 
+ 
+  // Generate arrays of permutations using the algorithm. 
+  function generate(int) { 
+    if (int === 1) { 
+      // Make sure to join the characters as we create  the permutation arrays 
+      permutations.push(arr.join('')); 
+    } else { 
+      for (var i = 0; i != int; ++i) { 
+        generate(int - 1); 
+        swap(int % 2 ? 0 : i, int - 1); 
+      } 
+    } 
+  } 
+ 
+  generate(arr.length); 
+ 
+  // Filter the array of repeated permutations. 
+  var filtered = permutations.filter(function(string) { 
+    return !string.match(regex); 
+  }); 
+ 
+  // Return how many have no repetitions. 
+  return filtered.length; 
+ } 
+ 
+ // Test here. 
+ permAlone('aab'); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":cohete:") [Ejecutar código](https://repl.it/CLop/0)
+
+### Explicación del código:
+
+*   **expresiones regulares** contiene la expresión regular para que coincida con caracteres consecutivos repetidos.
+*   La cadena **str** se divide en una serie de personajes, **arr.**
+*   Se devuelve 0 si **str** contiene los mismos caracteres.
+*   La función `swap()` se utiliza con el propósito de intercambiar los contenidos de los contenidos de dos variables.
+*   El siguiente bloque de código utiliza el algoritmo de Heap para generar matrices de permutaciones en **permutaciones** .
+*   La variable **filtrada** filtra las **permutaciones** para incluir solo permutaciones no repetidas.
+*   `filtered.length` devuelve el número de permutaciones totales de la cadena proporcionada que no tienen letras consecutivas repetidas.
+
+#### Enlaces relevantes
+
+*   [JS String Prototype Split](http://forum.freecodecamp.com/t/javascript-string-prototype-split/15944)
+*   [JS String Prototype Match](http://forum.freecodecamp.com/t/javascript-string-prototype-match/15941)
+*   [JS Array Prototype Push](http://forum.freecodecamp.com/t/javascript-array-prototype-push/14298)
+*   [JS Array Prototype Join](http://forum.freecodecamp.com/t/javascript-array-prototype-join/14292)
+*   [JS For Loops Explicado](http://forum.freecodecamp.com/t/javascript-for-loop/14666s-Explained)
+*   [array.length](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+*   [JS Array Prototype Filter](http://forum.freecodecamp.com/t/javascript-array-prototype-filter/14289)
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/certifications/coding-interview-prep/algorithms/pairwise/index.md

@@ -0,0 +1,9 @@
+---
+title: Pairwise
+localeTitle: Por pares
+---
+## Por pares
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/coding-interview-prep/algorithms/pairwise/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .