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

docs: add Spanish docs

Browse Source
This commit is contained in:
Beau Carnes
2018-10-08 13:34:43 -04:00
parent 46d8d61776
commit fcced4a6c3
912 changed files with 80339 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/100-doors.spanish.md Normal file
View File

@@ -0,0 +1,79 @@
---
title: 100 doors
id: 594810f028c0303b75339acb
localeTitle: 594810f028c0303b75339acb
challengeType: 5
---
## Description
<section id='description'>
<p> Hay 100 puertas seguidas que están inicialmente cerradas. Haces 100 pases por las puertas. La primera vez, visite todas las puertas y &quot;active&quot; la puerta (si la puerta está cerrada, ábrala; si está abierta, ciérrela). La segunda vez, solo visite cada segunda puerta (es decir, la puerta # 2, # 4, # 6, ...) y actívela. La tercera vez, visite cada tercera puerta (es decir, la puerta # 3, # 6, # 9, ...), etc., hasta que solo visite la puerta número 100. </p>
<p> Implementar una función para determinar el estado de las puertas después de la última pasada. Devuelva el resultado final en una matriz, con solo el número de puerta incluido en la matriz si está abierta. </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>getFinalOpenedDoors</code> es una función.
testString: 'assert(typeof getFinalOpenedDoors === "function", "<code>getFinalOpenedDoors</code> is a function.");'
- text: <code>getFinalOpenedDoors</code> debe devolver una matriz.
testString: 'assert(Array.isArray(getFinalOpenedDoors(100)), "<code>getFinalOpenedDoors</code> should return an array.");'
- text: <code>getFinalOpenedDoors</code> no produjo los resultados correctos.
testString: 'assert.deepEqual(getFinalOpenedDoors(100), solution, "<code>getFinalOpenedDoors</code> did not produce the correct results.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function getFinalOpenedDoors (numDoors) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function getFinalOpenedDoors (numDoors) {
// this is the final pattern (always squares).
// thus, the most efficient solution simply returns an array of squares up to numDoors).
const finalState = [];
let i = 1;
while (Math.pow(i, 2) <= numDoors) {
finalState.push(Math.pow(i, 2));
i++;
}
return finalState;
}
```
</section>

156
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/24-game.spanish.md Normal file
View File

@@ -0,0 +1,156 @@
---
title: 24 game
id: 5951e88f64ebf159166a1176
localeTitle: 5951e88f64ebf159166a1176
challengeType: 5
---
## Description
<section id='description'>
<p> Implemente una función que tome una cadena de cuatro dígitos como su argumento, con cada dígito de 1 ──► 9 (inclusive) con repeticiones permitidas, y devuelva una expresión aritmética que se evalúe al número 24. Si no existe tal solución, devuelva &quot; no existe ninguna solución &quot;. </p>
<p> Reglas: </p>
Solo se permiten los siguientes operadores / funciones: multiplicación, división, suma, resta
división debe usar coma flotante o aritmética racional, etc., para preservar los residuos.
se permite formar números de varios dígitos a partir de los dígitos suministrados. (Entonces, una respuesta de 12 + 12 cuando se da 1, 2, 2 y 1 es incorrecta).
El orden de los dígitos cuando se dan no tiene que ser preservado.
<p> Entradas de ejemplo: </p>
<code>solve24(&quot;4878&quot;);</code>
<code>solve24(&quot;1234&quot;);</code>
<code>solve24(&quot;6789&quot;);</code>
<code>solve24(&quot;1127&quot;);</code>
<p> Ejemplos de salidas (cadenas): </p>
<code>(7-8/8)*4</code>
<code>3*1*4*2</code>
<code>(6*8)/(9-7)</code>
<code>(1+7)*(2+1)</code>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>solve24</code> es una función
testString: 'assert(typeof solve24 === "function", "<code>solve24</code> is a function.");'
- text: <code>solve24(&quot;4878&quot;)</code> debe devolver <code>(7-8/8)*4</code> o <code>4*(7-8/8)</code>
testString: 'assert(include(answers[0], solve24(testCases[0])), "<code>solve24("4878")</code> should return <code>(7-8/8)*4</code> or <code>4*(7-8/8)</code>");'
- text: <code>solve24(&quot;1234&quot;)</code> debe devolver cualquier arreglo de <code>1*2*3*4</code>
testString: 'assert(include(answers[1], solve24(testCases[1])), "<code>solve24("1234")</code> should return any arrangement of <code>1*2*3*4</code>");'
- text: <code>solve24(&quot;6789&quot;)</code> debe devolver <code>(6*8)/(9-7)</code> o <code>(8*6)/(9-7)</code>
testString: 'assert(include(answers[2], solve24(testCases[2])), "<code>solve24("6789")</code> should return <code>(6*8)/(9-7)</code> or <code>(8*6)/(9-7)</code>");'
- text: <code>solve24(&quot;1127&quot;)</code> debe devolver una permutación de <code>(1+7)*(1*2)</code>
testString: 'assert(include(answers[3], solve24(testCases[3])), "<code>solve24("1127")</code> should return a permutation of <code>(1+7)*(1*2)</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function solve24 (numStr) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
function solve24 (numStr) {
const digitsArr = numStr.split('');
const answers = [];
const digitPermutations = [];
const operatorPermutations = [];
function generateDigitPermutations (digits, permutations = []) {
if (digits.length === 0) {
digitPermutations.push(permutations);
}
else {
for (let i = 0; i < digits.length; i++) {
const curr = digits.slice();
const next = curr.splice(i, 1);
generateDigitPermutations(curr.slice(), permutations.concat(next));
}
}
}
function generateOperatorPermutations (permutations = []) {
const operators = ['+', '-', '*', '/'];
if (permutations.length === 3) {
operatorPermutations.push(permutations);
}
else {
for (let i = 0; i < operators.length; i++) {
const curr = permutations.slice();
curr.push(operators[i]);
generateOperatorPermutations(curr);
}
}
}
generateDigitPermutations(digitsArr);
generateOperatorPermutations();
interleave();
return answers[0];
function interleave () {
for (let i = 0; i < digitPermutations.length; i++) {
for (let j = 0; j < operatorPermutations.length; j++) {
const d = digitPermutations[i];
const o = operatorPermutations[j];
const perm = [
`${d[0]}${o[0]}${d[1]}${o[1]}${d[2]}${o[2]}${d[3]}`,
`(${d[0]}${o[0]}${d[1]})${o[1]}${d[2]}${o[2]}${d[3]}`,
`${d[0]}${o[0]}(${d[1]}${o[1]}${d[2]})${o[2]}${d[3]}`,
`${d[0]}${o[0]}${d[1]}${o[1]}(${d[2]}${o[2]}${d[3]})`,
`${d[0]}${o[0]}(${d[1]}${o[1]}${d[2]}${o[2]}${d[3]})`,
`(${d[0]}${o[0]}${d[1]}${o[1]}${d[2]})${o[2]}${d[3]}`,
`(${d[0]}${o[0]}${d[1]})${o[1]}(${d[2]}${o[2]}${d[3]})`
];
perm.forEach(combination => {
const res = eval(combination);
if (res === 24) {
return answers.push(combination);
}
});
}
}
}
}
```
</section>

103
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/9-billion-names-of-god-the-integer.spanish.md Normal file
View File

@@ -0,0 +1,103 @@
---
title: 9 billion names of God the integer
id: 5949b579404977fbaefcd736
localeTitle: 5949b579404977fbaefcd736
challengeType: 5
---
## Description
<section id='description'>
<p> Esta tarea es una variación de la <a href="https://en.wikipedia.org/wiki/The Nine Billion Names of God#Plot_summary" title="wp: Los nueve mil millones de nombres de Dios # Plot_summary">historia corta de Arthur C. Clarke</a> . </p>
<p> (Los solucionadores deben ser conscientes de las consecuencias de completar esta tarea). </p>
<p> En detalle, para especificar qué se entiende por un &quot;nombre&quot;: </p>
<p> El entero 1 tiene 1 nombre &quot;1&quot;. </p>
<p> El número entero 2 tiene 2 nombres &quot;1 + 1&quot; y &quot;2&quot;. </p>
<p> El número entero 3 tiene 3 nombres &quot;1 + 1 + 1&quot;, &quot;2 + 1&quot; y &quot;3&quot;. </p>
<p> El número entero 4 tiene 5 nombres “1 + 1 + 1 + 1”, “2 + 1 + 1”, “2 + 2”, “3 + 1”, “4”. </p>
<p> El número entero 5 tiene 7 nombres “1 + 1 + 1 + 1 + 1”, “2 + 1 + 1 + 1”, “2 + 2 + 1”, “3 + 1 + 1”, “3 + 2”, “4 + 1”, “5”. </p>
<p> Esto se puede visualizar de la siguiente forma: </p>
<pre>
1
1 1
1 1 1
1 2 1 1
1 2 2 1 1
1 3 3 2 1 1
</pre>
<p> Donde la fila $ n $ corresponde al entero $ n $, y cada columna $ C $ en la fila $ m $ de izquierda a derecha corresponde al número de nombres que comienzan con $ C $. </p>
<p> Opcionalmente, tenga en cuenta que la suma de $ n $ -th row $ P (n) $ es la <a href="http://mathworld.wolfram.com/PartitionFunctionP.html" title="enlace: http://mathworld.wolfram.com/PartitionFunctionP.html">función de partición entera</a> . </p>
Tarea
<p> Implementar una función que devuelve la suma de la fila $ n $ -th. </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>numberOfNames</code> es una función.
testString: 'assert(typeof numberOfNames === "function", "<code>numberOfNames</code> is a function.");'
- text: <code>numberOfNames(5)</code> debe ser igual a 7.
testString: 'assert.equal(numberOfNames(5), 7, "<code>numberOfNames(5)</code> should equal 7.");'
- text: <code>numberOfNames(12)</code> debe ser igual a 77.
testString: 'assert.equal(numberOfNames(12), 77, "<code>numberOfNames(12)</code> should equal 77.");'
- text: <code>numberOfNames(18)</code> debe ser igual a 385.
testString: 'assert.equal(numberOfNames(18), 385, "<code>numberOfNames(18)</code> should equal 385.");'
- text: <code>numberOfNames(23)</code> debe ser igual a 1255.
testString: 'assert.equal(numberOfNames(23), 1255, "<code>numberOfNames(23)</code> should equal 1255.");'
- text: <code>numberOfNames(42)</code> debe ser igual a 53174.
testString: 'assert.equal(numberOfNames(42), 53174, "<code>numberOfNames(42)</code> should equal 53174.");'
- text: <code>numberOfNames(123)</code> debe ser igual a 2552338241.
testString: 'assert.equal(numberOfNames(123), 2552338241, "<code>numberOfNames(123)</code> should equal 2552338241.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function numberOfNames (num) {
// Good luck!
return true;
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function numberOfNames (num) {
const cache = [
[1]
];
for (let l = cache.length; l < num + 1; l++) {
let Aa;
let Mi;
const r = [0];
for (let x = 1; x < l + 1; x++) {
r.push(r[r.length - 1] + (Aa = cache[l - x < 0 ? cache.length - (l - x) : l - x])[(Mi = Math.min(x, l - x)) < 0 ? Aa.length - Mi : Mi]);
}
cache.push(r);
}
return cache[num][cache[num].length - 1];
}
```
</section>

122
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/abc-problem.spanish.md Normal file
View File

@@ -0,0 +1,122 @@
---
title: ABC Problem
id: 594810f028c0303b75339acc
localeTitle: 594810f028c0303b75339acc
challengeType: 5
---
## Description
<section id='description'>
<p> Se le entrega una colección de bloques ABC (por ejemplo, bloques del alfabeto infantil). Hay 20 bloques con dos letras en cada bloque. Un alfabeto completo está garantizado entre todos los lados de los bloques. La colección de muestras de bloques: </p>
<p> (BO) </p>
<p> (XK) </p>
<p> (DQ) </p>
<p> (CP) </p>
<p> (N / A) </p>
<p> (GT) </p>
<p> (RE) </p>
<p> (TG) </p>
<p> (QD) </p>
<p> (FS) </p>
<p> (JW) </p>
<p> (HU) </p>
<p> (VI) </p>
<p> (UN) </p>
<p> (TRANSMISIÓN EXTERIOR) </p>
<p> (ER) </p>
<p> (FS) </p>
<p> (LY) </p>
<p> (ORDENADOR PERSONAL) </p>
<p> (ZM) </p>
<p> Algunas reglas a tener en cuenta: </p>
Una vez que se usa una letra en un bloque, ese bloque no se puede usar de nuevo.
La función debe ser insensible a mayúsculas y minúsculas.
<p> Implementar una función que toma una cadena (palabra) y determina si la palabra se puede deletrear con la colección de bloques dada. </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>canMakeWord</code> es una función.
testString: 'assert(typeof canMakeWord === "function", "<code>canMakeWord</code> is a function.");'
- text: <code>canMakeWord</code> debería devolver un booleano.
testString: 'assert(typeof canMakeWord("hi") === "boolean", "<code>canMakeWord</code> should return a boolean.");'
- text: <code>canMakeWord(&quot;bark&quot;)</code> debe devolver verdadero.
testString: 'assert(canMakeWord(words[0]), "<code>canMakeWord("bark")</code> should return true.");'
- text: <code>canMakeWord(&quot;BooK&quot;)</code> debe devolver falso.
testString: 'assert(!canMakeWord(words[1]), "<code>canMakeWord("BooK")</code> should return false.");'
- text: <code>canMakeWord(&quot;TReAT&quot;)</code> debe devolver verdadero.
testString: 'assert(canMakeWord(words[2]), "<code>canMakeWord("TReAT")</code> should return true.");'
- text: <code>canMakeWord(&quot;COMMON&quot;)</code> debe devolver falso.
testString: 'assert(!canMakeWord(words[3]), "<code>canMakeWord("COMMON")</code> should return false.");'
- text: <code>canMakeWord(&quot;squAD&quot;)</code> debe devolver true.
testString: 'assert(canMakeWord(words[4]), "<code>canMakeWord("squAD")</code> should return true.");'
- text: <code>canMakeWord(&quot;conFUSE&quot;)</code> debe devolver verdadero.
testString: 'assert(canMakeWord(words[5]), "<code>canMakeWord("conFUSE")</code> should return true.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function canMakeWord (word) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function canMakeWord (word) {
const characters = 'BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM';
const blocks = characters.split(' ').map(pair => pair.split(''));
const letters = [...word.toUpperCase()];
let length = letters.length;
const copy = new Set(blocks);
letters.forEach(letter => {
for (let block of copy) {
const index = block.indexOf(letter);
if (index !== -1) {
length--;
copy.delete(block);
break;
}
}
});
return !length;
}
```
</section>

94
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/abundant-deficient-and-perfect-number-classifications.spanish.md Normal file
View File

@@ -0,0 +1,94 @@
---
title: 'Abundant, deficient and perfect number classifications'
id: 594810f028c0303b75339acd
localeTitle: 594810f028c0303b75339acd
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>getDPA</code> es una función.
testString: 'assert(typeof getDPA === "function", "<code>getDPA</code> is a function.");'
- text: <code>getDPA</code> debería devolver una matriz.
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;
testString: 'assert.deepEqual(getDPA(20000), solution, "<code>getDPA(20000)</code> should equal [15043, 4, 4953]");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function getDPA (num) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function getDPA (num) {
const dpa = [1, 0, 0];
for (let n = 2; n <= num; n += 1) {
let ds = 1;
const e = Math.sqrt(n);
for (let d = 2; d < e; d += 1) {
if (n % d === 0) {
ds += d + (n / d);
}
}
if (n % e === 0) {
ds += e;
}
dpa[ds < n ? 0 : ds === n ? 1 : 2] += 1;
}
return dpa;
}
```
</section>

78
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/accumulator-factory.spanish.md Normal file
View File

@@ -0,0 +1,78 @@
---
title: Accumulator factory
id: 594810f028c0303b75339ace
localeTitle: 594810f028c0303b75339ace
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>accumulator</code> es una función.
testString: 'assert(typeof accumulator === "function", "<code>accumulator</code> is a function.");'
- text: <code>accumulator(0)</code> debe devolver una función.
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;
testString: 'assert(testFn(5) === 5.5, "Passing in the values 3, -4, 1.5, and 5 should return 5.5.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function accumulator (sum) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function accumulator (sum) {
return function (n) {
return sum += n;
};
}
```
</section>

74
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ackermann-function.spanish.md Normal file
View File

@@ -0,0 +1,74 @@
---
title: Ackermann function
id: 594810f028c0303b75339acf
localeTitle: 594810f028c0303b75339acf
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
testString: 'assert(ack(3, 3) === 61, "<code>ack(3, 3)</code> should return 61.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function ack (m, n) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function ack (m, n) {
return m === 0 ? n + 1 : ack(m - 1, n === 0 ? 1 : ack(m, n - 1));
}
```
</section>

153
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/align-columns.spanish.md Normal file
View File

@@ -0,0 +1,153 @@
---
title: Align columns
id: 594810f028c0303b75339ad0
localeTitle: 594810f028c0303b75339ad0
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
testString: 'assert.strictEqual(formatText(testInput, "center"), centerAligned, "<code>formatText</code> with the above input and "center" justification should produce the following: ");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
const testArr = [
'Given$a$text$file$of$many$lines',
'where$fields$within$a$line$',
'are$delineated$by$a$single$"dollar"$character',
'write$a$program',
'that$aligns$each$column$of$fields$',
'by$ensuring$that$words$in$each$',
'column$are$separated$by$at$least$one$space.',
'Further,$allow$for$each$word$in$a$column$to$be$either$left$',
'justified,$right$justified',
'or$center$justified$within$its$column.'
];
function formatText (input, justification) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
const testArr = [
'Given$a$text$file$of$many$lines',
'where$fields$within$a$line$',
'are$delineated$by$a$single$"dollar"$character',
'write$a$program',
'that$aligns$each$column$of$fields$',
'by$ensuring$that$words$in$each$',
'column$are$separated$by$at$least$one$space.',
'Further,$allow$for$each$word$in$a$column$to$be$either$left$',
'justified,$right$justified',
'or$center$justified$within$its$column.'
];
String.prototype.repeat = function (n) { return new Array(1 + parseInt(n)).join(this); };
function formatText (input, justification) {
let x, y, max, cols = 0, diff, left, right;
for (x = 0; x < input.length; x++) {
input[x] = input[x].split('$');
if (input[x].length > cols) {
cols = input[x].length;
}
}
for (x = 0; x < cols; x++) {
max = 0;
for (y = 0; y < input.length; y++) {
if (input[y][x] && max < input[y][x].length) {
max = input[y][x].length;
}
}
for (y = 0; y < input.length; y++) {
if (input[y][x]) {
diff = (max - input[y][x].length) / 2;
left = ' '.repeat(Math.floor(diff));
right = ' '.repeat(Math.ceil(diff));
if (justification === 'left') {
right += left; left = ";
}
if (justification === 'right') {
left += right; right = ";
}
input[y][x] = left + input[y][x] + right;
}
}
}
for (x = 0; x < input.length; x++) {
input[x] = input[x].join(' ');
}
input = input.join('\n');
return input;
}
```
</section>

119
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/amicable-pairs.spanish.md Normal file
View File

@@ -0,0 +1,119 @@
---
title: Amicable pairs
id: 5949b579404977fbaefcd737
localeTitle: 5949b579404977fbaefcd737
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function amicablePairsUpTo (maxNum) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// amicablePairsUpTo :: Int -> [(Int, Int)]
function amicablePairsUpTo (maxNum) {
return range(1, maxNum)
.map(x => properDivisors(x)
.reduce((a, b) => a + b, 0))
.reduce((a, m, i, lst) => {
const n = i + 1;
return (m > n) && lst[m - 1] === n ?
a.concat([
[n, m]
]) : a;
}, []);
}
// properDivisors :: Int -> [Int]
function properDivisors (n) {
if (n < 2) return [];
const rRoot = Math.sqrt(n);
const intRoot = Math.floor(rRoot);
const blnPerfectSquare = rRoot === intRoot;
const lows = range(1, intRoot)
.filter(x => (n % x) === 0);
return lows.concat(lows.slice(1)
.map(x => n / x)
.reverse()
.slice(blnPerfectSquare | 0));
}
// Int -> Int -> Maybe Int -> [Int]
function range (m, n, step) {
const d = (step || 1) * (n >= m ? 1 : -1);
return Array.from({
length: Math.floor((n - m) / d) + 1
}, (_, i) => m + (i * d));
}
```
</section>

89
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-mode.spanish.md Normal file
View File

@@ -0,0 +1,89 @@
---
title: Averages-Mode
id: 594d8d0ab97724821379b1e6
localeTitle: 594d8d0ab97724821379b1e6
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
testString: 'assert.deepEqual(mode(arr2).sort(), [1, 4], "<code>mode([1, 2, 4, 4, 1])</code> should equal <code>[1, 4]</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function mode (arr) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function mode(arr) {
const counter = {};
let result = [];
let max = 0;
// for (const i in arr) {
arr.forEach(el => {
if (!(el in counter)) {
counter[el] = 0;
}
counter[el]++;
if (counter[el] === max) {
result.push(el);
}
else if (counter[el] > max) {
max = counter[el];
result = [el];
}
});
return result;
}
```
</section>

139
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-pythagorean-means.spanish.md Normal file
View File

@@ -0,0 +1,139 @@
---
title: Averages-Pythagorean means
id: 594d966a1467eb84194f0086
localeTitle: 594d966a1467eb84194f0086
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
testString: 'assert.deepEqual(pythagoreanMeans(range1), answer1, "<code>pythagoreanMeans([1, 2, ..., 10])</code> should equal the same output above.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function pythagoreanMeans (rangeArr) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function pythagoreanMeans (rangeArr) {
// arithmeticMean :: [Number] -> Number
const arithmeticMean = xs =>
foldl((sum, n) => sum + n, 0, xs) / length(xs);
// geometricMean :: [Number] -> Number
const geometricMean = xs =>
raise(foldl((product, x) => product * x, 1, xs), 1 / length(xs));
// harmonicMean :: [Number] -> Number
const harmonicMean = xs =>
length(xs) / foldl((invSum, n) => invSum + (1 / n), 0, xs);
// GENERIC FUNCTIONS ------------------------------------------------------
// A list of functions applied to a list of arguments
// <*> :: [(a -> b)] -> [a] -> [b]
const ap = (fs, xs) => //
Array.prototype.concat(...fs.map(f => //
Array.prototype.concat(...xs.map(x => [f(x)]))));
// foldl :: (b -> a -> b) -> b -> [a] -> b
const foldl = (f, a, xs) => xs.reduce(f, a);
// length :: [a] -> Int
const length = xs => xs.length;
// mapFromList :: [(k, v)] -> Dictionary
const mapFromList = kvs =>
foldl((a, [k, v]) =>
(a[(typeof k === 'string' && k)] = v, a), {}, kvs);
// raise :: Num -> Int -> Num
const raise = (n, e) => Math.pow(n, e);
/*
// show :: a -> String
// show :: a -> Int -> String
const show = (...x) =>
JSON.stringify.apply(
null, x.length > 1 ? [x[0], null, x[1]] : x
);
*/
// zip :: [a] -> [b] -> [(a,b)]
const zip = (xs, ys) =>
xs.slice(0, Math.min(xs.length, ys.length))
.map((x, i) => [x, ys[i]]);
// TEST -------------------------------------------------------------------
// mean :: Dictionary
const mean = mapFromList(zip(
['Arithmetic', 'Geometric', 'Harmonic'],
ap([arithmeticMean, geometricMean, harmonicMean], [
rangeArr
])
));
return {
values: mean,
test: `is A >= G >= H ? ${mean.Arithmetic >= mean.Geometric &&
mean.Geometric >= mean.Harmonic ? 'yes' : 'no'}`
};
}
```
</section>

71
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/averages-root-mean-square.spanish.md Normal file
View File

@@ -0,0 +1,71 @@
---
title: Averages-Root mean square
id: 594da033de4190850b893874
localeTitle: 594da033de4190850b893874
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function rms (arr) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function rms (arr) {
const sumOfSquares = arr.reduce((s, x) => s + x * x, 0);
return Math.sqrt(sumOfSquares / arr.length);
}
```
</section>

87
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/babbage-problem.spanish.md Normal file
View File

@@ -0,0 +1,87 @@
---
title: Babbage problem
id: 594db4d0dedb4c06a2a4cefd
localeTitle: 594db4d0dedb4c06a2a4cefd
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
testString: 'assert.equal(babbage(babbageAns, endDigits), answer, "<code>babbage(99736, 269696)</code> should not return 99736 (there is a smaller answer).");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function babbage (babbageNum, endDigits) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function babbage (babbageAns, endDigits) {
const babbageNum = Math.pow(babbageAns, 2);
const babbageStartDigits = parseInt(babbageNum.toString().replace('269696', "));
let answer = 99736;
// count down from this answer and save any sqrt int result. return lowest one
for (let i = babbageStartDigits; i >= 0; i--) {
const num = parseInt(i.toString().concat('269696'));
const result = Math.sqrt(num);
if (result === Math.floor(Math.sqrt(num))) {
answer = result;
}
}
return answer;
}
```
</section>

118
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/balanced-brackets.spanish.md Normal file
View File

@@ -0,0 +1,118 @@
---
title: Balanced brackets
id: 594dc6c729e5700999302b45
localeTitle: 594dc6c729e5700999302b45
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
testString: 'assert(isBalanced(testCases[0]), "<code>isBalanced("[]")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;]][[[][][][]][&quot;)</code> debe devolver falso.&#39;
testString: 'assert(!isBalanced(testCases[1]), "<code>isBalanced("]][[[][][][]][")</code> should return false.");'
- text: &#39; <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;
testString: 'assert(!isBalanced(testCases[3]), "<code>isBalanced("][")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[[[]]]][[]&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[4]), "<code>isBalanced("[[[]]]][[]")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;][[]&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[5]), "<code>isBalanced("][[]")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;][[][]][[[]]&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[6]), "<code>isBalanced("][[][]][[[]]")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[[][]]][&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[7]), "<code>isBalanced("[[][]]][")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[[[]]][[]]]][][[&quot;)</code> debería devolver true.&#39;
testString: 'assert(!isBalanced(testCases[8]), "<code>isBalanced("[[[]]][[]]]][][[")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[]][[]]][[[[][]]&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[9]), "<code>isBalanced("[]][[]]][[[[][]]")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;][]][[][&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[10]), "<code>isBalanced("][]][[][")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[[]][[][]]&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(isBalanced(testCases[11]), "<code>isBalanced("[[]][[][]]")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[[]]&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(isBalanced(testCases[12]), "<code>isBalanced("[[]]")</code> should return true.");'
- text: &#39; <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;
testString: 'assert(!isBalanced(testCases[14]), "<code>isBalanced("][]][][[")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;][][&quot;)</code> debe devolver verdadero.&#39;
testString: 'assert(!isBalanced(testCases[15]), "<code>isBalanced("][][")</code> should return true.");'
- text: &#39; <code>isBalanced(&quot;[[]]][][][[]][&quot;)</code> debe devolver verdadero.&#39;
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.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function isBalanced (str) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function isBalanced (str) {
if (str === ") return true;
let a = str;
let b;
do {
b = a;
a = a.replace(/\[\]/g, ");
} while (a !== b);
return !a;
}
```
</section>

130
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/circles-of-given-radius-through-two-points.spanish.md Normal file
View File

@@ -0,0 +1,130 @@
---
title: Circles of given radius through two points
id: 5951815dd895584b06884620
localeTitle: 5951815dd895584b06884620
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function getCircles (...args) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
const hDist = (p1, p2) => Math.hypot(...p1.map((e, i) => e - p2[i])) / 2;
const pAng = (p1, p2) => Math.atan(p1.map((e, i) => e - p2[i]).reduce((p, c) => c / p, 1));
const solveF = (p, r) => t => [parseFloat((r * Math.cos(t) + p[0]).toFixed(4)), parseFloat((r * Math.sin(t) + p[1]).toFixed(4))];
const diamPoints = (p1, p2) => p1.map((e, i) => parseFloat((e + (p2[i] - e) / 2).toFixed(4)));
function getCircles (...args) {
const [p1, p2, s] = args;
const solve = solveF(p1, s);
const halfDist = hDist(p1, p2);
let msg = [];
switch (Math.sign(s - halfDist)) {
case 0:
msg = s ? diamPoints(p1, p2) :
'Radius Zero';
break;
case 1:
if (!halfDist) {
msg = 'Coincident point. Infinite solutions';
}
else {
const theta = pAng(p1, p2);
const theta2 = Math.acos(halfDist / s);
[1, -1].map(e => solve(theta + e * theta2)).forEach(
e => msg.push(e));
}
break;
case -1:
msg = 'No intersection. Points further apart than circle diameter';
break;
default:
msg = 'Reached the default';
}
return msg;
}
```
</section>

258
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/closest-pair-problem.spanish.md Normal file
View File

@@ -0,0 +1,258 @@
---
title: Closest-pair problem
id: 5951a53863c8a34f02bf1bdc
localeTitle: 5951a53863c8a34f02bf1bdc
challengeType: 5
---
## Description
<section id='description'>
Tarea:
<p> Proporcione una función para encontrar los dos puntos más cercanos entre un conjunto de puntos dados en dos dimensiones, es decir, para resolver el problema del <a href="https://en.wikipedia.org/wiki/Closest pair of points problem" title="wp: problema de par de puntos más cercano">par de puntos más cercano</a> en el caso plano. </p><p> La solución directa es un algoritmo O (n <sup>2</sup> ) (que podemos llamar algoritmo de fuerza bruta); El pseudocódigo (utilizando índices) podría ser simplemente: </p>
<pre>
bruteForceClosestPair de P (1), P (2), ... P (N)
si N &lt;2 entonces
retorno ∞
otro
minDistance ← | P (1) - P (2) |
minPuntos ← {P (1), P (2)}
foreach i ∈ [1, N-1]
foreach j ∈ [i + 1, N]
si | P (i) - P (j) | &lt;minDistance luego
minDistance ← | P (i) - P (j) |
minPuntos ← {P (i), P (j)}
endif
endfor
endfor
return minDistance, minPoints
endif
</pre>
<p> Un mejor algoritmo se basa en el enfoque recursivo de divide y vencerás, como se explica también en <a href="https://en.wikipedia.org/wiki/Closest pair of points problem#Planar_case" title="wp: problema de par de puntos más cercano # Planar_case">el problema del par de puntos más cercanos de Wikipedia</a> , que es O (n log n); Un pseudocódigo podría ser: </p>
<pre>
par más cercano de (xP, yP)
donde xP es P (1) .. P (N) ordenada por la coordenada x, y
yP es P (1) .. P (N) ordenada por la coordenada y (orden ascendente)
si N ≤ 3 entonces
devuelve los puntos más cercanos de xP utilizando el algoritmo de fuerza bruta
más
xL ← puntos de xP de 1 a ⌈N / 2⌉
xR ← puntos de xP de ⌈N / 2⌉ + 1 a N
xm ← xP (⌈N / 2⌉) <sub>x</sub>
yL ← {p ∈ yP: p <sub>x</sub> ≤ xm}
yR ← {p ∈ yP: p <sub>x</sub> &gt; xm}
(dL, pairL) ← closestPar de (xL, yL)
(dR, pairR) ← par más cercano de (xR, yR)
(dmin, pairMin) ← (dR, pairR)
si dL &lt;dR luego
(dmin, pairMin) ← (dL, pairL)
endif
yS ← { p ∈ yP: | xm - p <sub>x</sub> | &lt;dmin}
nS ← número de puntos en yS
(la par más cercana, más cercana) ← (dmin, pairMin)
para i de 1 a nS - 1
k ← i + 1
mientras k ≤ nS e yS (k) <sub>y</sub> - yS (i) <sub>y</sub> &lt;dmin
si | yS (k) - yS (i) | &lt;más cercano entonces
(más cercano, más cercano) ← (| yS (k) - yS (i) |, {yS (k), yS (i)})
endif
k ← k + 1
endwhile
endfor
return más cercano más cercano par
endif
</pre>
Referencias y otras lecturas:
<a href="https://en.wikipedia.org/wiki/Closest pair of points problem" title="wp: problema de par de puntos más cercano">Par de puntos</a> <a href="http://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairDQ.html" title="enlace: http://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairDQ.html">más cercanos</a> <a href="https://en.wikipedia.org/wiki/Closest pair of points problem" title="wp: problema de par de puntos más cercano">problema</a>
<a href="http://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairDQ.html" title="enlace: http://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairDQ.html">Par más cercano (McGill)</a>
<a href="http://www.cs.ucsb.edu/~suri/cs235/ClosestPair.pdf" title="enlace: http://www.cs.ucsb.edu/~suri/cs235/ClosestPair.pdf">Par más cercano (UCSB)</a>
<a href="http://classes.cec.wustl.edu/~cse241/handouts/closestpair.pdf" title="enlace: http://classes.cec.wustl.edu/~cse241/handouts/closestpair.pdf">Par más cercano (WUStL)</a>
<a href="http://www.cs.iupui.edu/~xkzou/teaching/CS580/Divide-and-conquer-closestPair.ppt" title="enlace: http://www.cs.iupui.edu/~xkzou/teaching/CS580/Divide-and-conquer-closestPair.ppt">Par más cercano (IUPUI)</a>
<p> Para la entrada, espere que el argumento sea una matriz de objetos (puntos) con los miembros <code>x</code> e <code>y</code> establecidos en números. Para la salida, devuelva un objeto que contenga los pares clave: valor para la <code>distance</code> y el <code>pair</code> (es decir, el par de dos puntos más cercanos). </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>getClosestPair</code> es una función.
testString: 'assert(typeof getClosestPair === "function", "<code>getClosestPair</code> is a function.");'
- text: La distancia debe ser la siguiente.
testString: 'assert.equal(getClosestPair(points1).distance, answer1.distance, "Distance should be the following.");'
- text: Los puntos deben ser los siguientes.
testString: 'assert.deepEqual(JSON.parse(JSON.stringify(getClosestPair(points1))).pair, answer1.pair, "Points should be the following.");'
- text: La distancia debe ser la siguiente.
testString: 'assert.equal(getClosestPair(points2).distance, answer2.distance, "Distance should be the following.");'
- text: Los puntos deben ser los siguientes.
testString: 'assert.deepEqual(JSON.parse(JSON.stringify(getClosestPair(points2))).pair, answer2.pair, "Points should be the following.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
const Point = function (x, y) {
this.x = x;
this.y = y;
};
Point.prototype.getX = function () {
return this.x;
};
Point.prototype.getY = function () {
return this.y;
};
function getClosestPair (pointsArr) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
const Point = function (x, y) {
this.x = x;
this.y = y;
};
Point.prototype.getX = function () {
return this.x;
};
Point.prototype.getY = function () {
return this.y;
};
const mergeSort = function mergeSort(points, comp) {
if(points.length < 2) return points;
var n = points.length,
i = 0,
j = 0,
leftN = Math.floor(n / 2),
rightN = leftN;
var leftPart = mergeSort( points.slice(0, leftN), comp),
rightPart = mergeSort( points.slice(rightN), comp );
var sortedPart = [];
while((i < leftPart.length) && (j < rightPart.length)) {
if(comp(leftPart[i], rightPart[j]) < 0) {
sortedPart.push(leftPart[i]);
i += 1;
}
else {
sortedPart.push(rightPart[j]);
j += 1;
}
}
while(i < leftPart.length) {
sortedPart.push(leftPart[i]);
i += 1;
}
while(j < rightPart.length) {
sortedPart.push(rightPart[j]);
j += 1;
}
return sortedPart;
};
const closestPair = function _closestPair(Px, Py) {
if(Px.length < 2) return { distance: Infinity, pair: [ new Point(0, 0), new Point(0, 0) ] };
if(Px.length < 3) {
//find euclid distance
var d = Math.sqrt( Math.pow(Math.abs(Px[1].x - Px[0].x), 2) + Math.pow(Math.abs(Px[1].y - Px[0].y), 2) );
return {
distance: d,
pair: [ Px[0], Px[1] ]
};
}
var n = Px.length,
leftN = Math.floor(n / 2),
rightN = leftN;
var Xl = Px.slice(0, leftN),
Xr = Px.slice(rightN),
Xm = Xl[leftN - 1],
Yl = [],
Yr = [];
//separate Py
for(var i = 0; i < Py.length; i += 1) {
if(Py[i].x <= Xm.x)
Yl.push(Py[i]);
else
Yr.push(Py[i]);
}
var dLeft = _closestPair(Xl, Yl),
dRight = _closestPair(Xr, Yr);
var minDelta = dLeft.distance,
closestPair = dLeft.pair;
if(dLeft.distance > dRight.distance) {
minDelta = dRight.distance;
closestPair = dRight.pair;
}
//filter points around Xm within delta (minDelta)
var closeY = [];
for(i = 0; i < Py.length; i += 1) {
if(Math.abs(Py[i].x - Xm.x) < minDelta) closeY.push(Py[i]);
}
//find min within delta. 8 steps max
for(i = 0; i < closeY.length; i += 1) {
for(var j = i + 1; j < Math.min( (i + 8), closeY.length ); j += 1) {
var d = Math.sqrt( Math.pow(Math.abs(closeY[j].x - closeY[i].x), 2) + Math.pow(Math.abs(closeY[j].y - closeY[i].y), 2) );
if(d < minDelta) {
minDelta = d;
closestPair = [ closeY[i], closeY[j] ]
}
}
}
return {
distance: minDelta,
pair: closestPair
};
};
function getClosestPair (points) {
const sortX = function (a, b) { return (a.x < b.x) ? -1 : ((a.x > b.x) ? 1 : 0); }
const sortY = function (a, b) { return (a.y < b.y) ? -1 : ((a.y > b.y) ? 1 : 0); }
const Px = mergeSort(points, sortX);
const Py = mergeSort(points, sortY);
return closestPair(Px, Py);
}
```
</section>

105
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/combinations.spanish.md Normal file
View File

@@ -0,0 +1,105 @@
---
title: Combinations
id: 5958469238c0d8d2632f46db
localeTitle: 5958469238c0d8d2632f46db
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function combinations (m, n) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function combinations (m, n) {
const nArr = [...Array(n).keys()];
return (function generateCombinations (size, numArr) {
const ret = [];
for (let i = 0; i < numArr.length; i++) {
if (size === 1) {
ret.push([numArr[i]]);
}
else {
const sub = generateCombinations(size - 1, numArr.slice(i + 1, numArr.length));
for (let subI = 0; subI < sub.length; subI++) {
const next = sub[subI];
next.unshift(numArr[i]);
ret.push(next);
}
}
}
return ret;
}(m, nArr));
}
```
</section>

92
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/comma-quibbling.spanish.md Normal file
View File

@@ -0,0 +1,92 @@
---
title: Comma quibbling
id: 596e414344c3b2872167f0fe
localeTitle: 596e414344c3b2872167f0fe
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
testString: 'assert(typeof quibble(["ABC"]) === "string", "<code>quibble(["ABC"])</code> should return a string.");'
- text: &#39; <code>quibble([])</code> debe devolver &quot;{}&quot;.&#39;
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;
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;
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;
testString: 'assert.equal(quibble(testCases[3]), results[3], "<code>quibble(["ABC", "DEF", "G", "H"])</code> should return "{ABC,DEF,G and H}".");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function quibble (words) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function quibble (words) {
return "{" +
words.slice(0, words.length - 1).join(",") +
(words.length > 1 ? " and " : "") +
(words[words.length - 1] || ") +
"}";
}
```
</section>

107
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/compare-a-list-of-strings.spanish.md Normal file
View File

@@ -0,0 +1,107 @@
---
title: Compare a list of strings
id: 596e457071c35c882915b3e4
localeTitle: 596e457071c35c882915b3e4
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>allEqual</code> es una función.
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;
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;
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;
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;
testString: 'assert(azSorted(testCases[1]), "<code>azSorted(["AA", "ACB", "BB", "CC"])</code> returns true.");'
- text: &#39; <code>allEqual([])</code> devuelve true.&#39;
testString: 'assert(allEqual(testCases[2]), "<code>allEqual([])</code> returns true.");'
- text: &#39; <code>azSorted([])</code> devuelve true.&#39;
testString: 'assert(azSorted(testCases[2]), "<code>azSorted([])</code> returns true.");'
- text: &#39; <code>allEqual([&quot;AA&quot;])</code> devuelve true.&#39;
testString: 'assert(allEqual(testCases[3]), "<code>allEqual(["AA"])</code> returns true.");'
- text: &#39; <code>azSorted([&quot;AA&quot;])</code> devuelve verdadero.&#39;
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;
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;
testString: 'assert(!azSorted(testCases[4]), "<code>azSorted(["BB", "AA"])</code> returns false.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function allEqual (arr) {
// Good luck!
return true;
}
function azSorted (arr) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function allEqual(a) {
let out = true;
let i = 0;
while (++i < a.length) {
out = out && (a[i - 1] === a[i]);
} return out;
}
function azSorted(a) {
let out = true;
let i = 0;
while (++i < a.length) {
out = out && (a[i - 1] < a[i]);
} return out;
}
```
</section>

161
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/convert-seconds-to-compound-duration.spanish.md Normal file
View File

@@ -0,0 +1,161 @@
---
title: Convert seconds to compound duration
id: 596fd036dc1ab896c5db98b1
localeTitle: 596fd036dc1ab896c5db98b1
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
testString: 'assert.equal(convertSeconds(testCases[2]), results[2], "<code>convertSeconds(6000000)</code> should return <code>9 wk, 6 d, 10 hr, 40 min</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function convertSeconds (sec) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function convertSeconds (sec) {
const localNames = ['wk', 'd', 'hr', 'min', 'sec'];
// compoundDuration :: [String] -> Int -> String
const compoundDuration = (labels, intSeconds) =>
weekParts(intSeconds)
.map((v, i) => [v, labels[i]])
.reduce((a, x) =>
a.concat(x[0] ? [`${x[0]} ${x[1] || '?'}`] : []), []
)
.join(', ');
// weekParts :: Int -> [Int]
const weekParts = intSeconds => [0, 7, 24, 60, 60]
.reduceRight((a, x) => {
const r = a.rem;
const mod = x !== 0 ? r % x : r;
return {
rem: (r - mod) / (x || 1),
parts: [mod].concat(a.parts)
};
}, {
rem: intSeconds,
parts: []
})
.parts;
return compoundDuration(localNames, sec);
}
```
</section>

80
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/count-occurrences-of-a-substring.spanish.md Normal file
View File

@@ -0,0 +1,80 @@
---
title: Count occurrences of a substring
id: 596fda99c69f779975a1b67d
localeTitle: 596fda99c69f779975a1b67d
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
testString: 'assert.equal(countSubstring(testCases[2], searchString[2]), results[2], "<code>countSubstring("abaabba*bbaba*bbab", "a*b")</code> should return <code>2</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function countSubstring (str, subStr) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function countSubstring(str, subStr) {
const escapedSubStr = subStr.replace(/[.+*?^$[\]{}()|/]/g, '\\$&');
const matches = str.match(new RegExp(escapedSubStr, 'g'));
return matches ? matches.length : 0;
}
```
</section>

92
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/count-the-coins.spanish.md Normal file
View File

@@ -0,0 +1,92 @@
---
title: Count the coins
id: 59713bd26bdeb8a594fb9413
localeTitle: 59713bd26bdeb8a594fb9413
challengeType: 5
---
## Description
<section id='description'>
<p> Hay cuatro tipos de monedas comunes en moneda <a href="https://en.wikipedia.org/wiki/United_States" title="enlace: https://en.wikipedia.org/wiki/United_States">estadounidense</a> : </p>
trimestres (25 centavos)
monedas de diez centavos (10 centavos)
centavos (5 centavos) y
centavos (1 centavo)
<p> Hay seis formas de hacer cambio por 15 centavos: </p>
Un centavo y un centavo
Un centavo y 5 centavos
3 centavos
2 centavos y 5 centavos
Un centavo y 10 centavos
15 centavos
Tarea:
<p> Implemente una función para determinar cuántas maneras hay de hacer un cambio por un dólar usando estas monedas comunes. (1 dólar = 100 centavos). </p>
Referencia:
<a href="http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html#%_sec_Temp_52" title="enlace: http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html#%_sec_Temp_52">un algoritmo de MIT Press</a> .
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>countCoins</code> es una función.
testString: 'assert(typeof countCoins === "function", "<code>countCoins</code> is a function.");'
- text: <code>countCoints()</code> debe devolver 242.
testString: 'assert.equal(countCoins(), 242, "<code>countCoints()</code> should return 242.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function countCoins () {
// Good luck!
return true;
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function countCoins () {
let t = 100;
const operands = [1, 5, 10, 25];
const targetsLength = t + 1;
const operandsLength = operands.length;
t = [1];
for (let a = 0; a < operandsLength; a++) {
for (let b = 1; b < targetsLength; b++) {
// initialise undefined target
t[b] = t[b] ? t[b] : 0;
// accumulate target + operand ways
t[b] += (b < operands[a]) ? 0 : t[b - operands[a]];
}
}
return t[targetsLength - 1];
}
```
</section>

164
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/cramers-rule.spanish.md Normal file
View File

@@ -0,0 +1,164 @@
---
title: Cramer's rule
id: 59713da0a428c1a62d7db430
localeTitle: 59713da0a428c1a62d7db430
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>
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>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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> .
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>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function cramersRule (matrix, freeTerms) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
/**
* Compute Cramer's Rule
* @param {array} matrix x,y,z, etc. terms
* @param {array} freeTerms
* @return {array} solution for x,y,z, etc.
*/
function cramersRule(matrix, freeTerms) {
const det = detr(matrix);
const returnArray = [];
let i;
for (i = 0; i < matrix[0].length; i++) {
const tmpMatrix = insertInTerms(matrix, freeTerms, i);
returnArray.push(detr(tmpMatrix) / det);
}
return returnArray;
}
/**
* Inserts single dimensional array into
* @param {array} matrix multidimensional array to have ins inserted into
* @param {array} ins single dimensional array to be inserted vertically into matrix
* @param {array} at zero based offset for ins to be inserted into matrix
* @return {array} New multidimensional array with ins replacing the at column in matrix
*/
function insertInTerms(matrix, ins, at) {
const tmpMatrix = clone(matrix);
let i;
for (i = 0; i < matrix.length; i++) {
tmpMatrix[i][at] = ins[i];
}
return tmpMatrix;
}
/**
* Compute the determinate of a matrix. No protection, assumes square matrix
* function borrowed, and adapted from MIT Licensed numericjs library (www.numericjs.com)
* @param {array} m Input Matrix (multidimensional array)
* @return {number} result rounded to 2 decimal
*/
function detr(m) {
let ret = 1;
let j;
let k;
const A = clone(m);
const n = m[0].length;
let alpha;
for (j = 0; j < n - 1; j++) {
k = j;
for (let i = j + 1; i < n; i++) { if (Math.abs(A[i][j]) > Math.abs(A[k][j])) { k = i; } }
if (k !== j) {
const temp = A[k]; A[k] = A[j]; A[j] = temp;
ret *= -1;
}
const Aj = A[j];
for (let i = j + 1; i < n; i++) {
const Ai = A[i];
alpha = Ai[j] / Aj[j];
for (k = j + 1; k < n - 1; k += 2) {
const k1 = k + 1;
Ai[k] -= Aj[k] * alpha;
Ai[k1] -= Aj[k1] * alpha;
}
if (k !== n) { Ai[k] -= Aj[k] * alpha; }
}
if (Aj[j] === 0) { return 0; }
ret *= Aj[j];
}
return Math.round(ret * A[j][j] * 100) / 100;
}
/**
* Clone two dimensional Array using ECMAScript 5 map function and EcmaScript 3 slice
* @param {array} m Input matrix (multidimensional array) to clone
* @return {array} New matrix copy
*/
function clone(m) {
return m.map(a => a.slice());
}
```
</section>

82
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/date-format.spanish.md Normal file
View File

@@ -0,0 +1,82 @@
---
title: Date format
id: 59669d08d75b60482359409f
localeTitle: 59669d08d75b60482359409f
challengeType: 5
---
## Description
<section id='description'>
Tarea:
<p> Devuelve una matriz con la fecha actual en los formatos: </p>
<p> - 2007-11-23 y </p>
<p> - Domingo 23 de noviembre de 2007. </p>
<p> Salida de ejemplo: <code>[&#39;2007-11-23&#39;, &#39;Sunday, November 23, 2007&#39;]</code> </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>getDateFormats</code> es una función.
testString: 'assert(typeof getDateFormats === "function", "<code>getDateFormats</code> is a function.");'
- text: Debe devolver un objeto.
testString: 'assert(typeof getDateFormats() === "object", "Should return an object.");'
- text: Debe devolverse una matriz con 2 elementos.
testString: 'assert(getDateFormats().length === 2, "Should returned an array with 2 elements.");'
- text: Debe devolver la fecha correcta en el formato correcto.
testString: 'assert.deepEqual(getDateFormats(), dates, equalsMessage);'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function getDateFormats () {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function getDateFormats () {
const date = new Date();
const weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
const months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
const fmt1 = `${date.getFullYear()}-${(1 + date.getMonth())}-${date.getDate()}`;
const fmt2 = `${weekdays[date.getDay()]}, ${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
return [fmt1, fmt2];
}
```
</section>

112
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/date-manipulation.spanish.md Normal file
View File

@@ -0,0 +1,112 @@
---
title: Date manipulation
id: 5966c21cf732a95f1b67dd28
localeTitle: 5966c21cf732a95f1b67dd28
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>add12Hours</code> es una función.
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;
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;
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;
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;
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;
testString: 'assert(add12Hours(tests[4]) === answers[4], "Should handel year change. <code>add12Hours("" + tests[4] + "")</code> should return <code>"" + answers[4] + ""</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function add12Hours (dateString) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function add12Hours (dateString) {
const months = ['January', 'February', 'March', 'April', 'May', 'June',
'July', 'August', 'September', 'October', 'November', 'December'];
// Get the parts of the string
const parts = dateString.split(' ');
const month = months.indexOf(parts[0]);
const day = parseInt(parts[1], 10);
const year = parseInt(parts[2], 10);
const time = parts[3].split(':');
let hours = parseInt(time[0], 10);
if (time[1].slice(-2) === 'pm') {
hours += 12;
}
const minutes = parseInt(time[1].slice(0, -2), 10);
// Create a date with given parts, and updated hours
const date = new Date();
date.setFullYear(year, month, day);
date.setHours(hours + 12); // Add 12 hours
date.setMinutes(minutes);
let hoursOutput = date.getHours();
let abbreviation = 'am';
if (hoursOutput > 12) {
hoursOutput -= 12;
abbreviation = 'pm';
}
return `${months[date.getMonth()]} ${date.getDate()} ${date.getFullYear()} ${hoursOutput}:${date.getMinutes()}${abbreviation} EST`;
}
```
</section>

82
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/day-of-the-week.spanish.md Normal file
View File

@@ -0,0 +1,82 @@
---
title: Day of the week
id: 5966f99c45e8976909a85575
localeTitle: 5966f99c45e8976909a85575
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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]");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function findXmasSunday (start, end) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function findXmasSunday (start, end) {
const xmasSunday = [];
for (let year = start; year <= end; year++) {
const xmas = new Date(year, 11, 25);
if (xmas.getDay() === 0) {
xmasSunday.push(year);
}
}
return xmasSunday;
}
```
</section>

175
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deal-cards-for-freecell.spanish.md Normal file
View File

@@ -0,0 +1,175 @@
---
title: Deal cards for FreeCell
id: 59694356a6e7011f7f1c5f4e
localeTitle: 59694356a6e7011f7f1c5f4e
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>dealFreeCell</code> es una función.
testString: 'assert(typeof dealFreeCell === "function", "<code>dealFreeCell</code> is a function.");'
- text: <code>dealFreeCell(seed)</code> debe devolver un objeto.
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;
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;
testString: 'assert.deepEqual(dealFreeCell(617), game617, "<code>dealFreeCell(617)</code> should return an array identical to example "Game #617"");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function dealFreeCell (seed) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// RNG
function FreeCellRNG (seed) {
return {
lastNum: seed,
next() {
this.lastNum = ((214013 * this.lastNum) + 2531011) % (Math.pow(2, 31));
return this.lastNum >> 16;
}
};
}
// Get cards
function getDeck() {
const ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K'];
const suits = ['C', 'D', 'H', 'S'];
const cards = [];
for (let i = 0; i < ranks.length; i += 1) {
for (let j = 0; j < suits.length; j += 1) {
cards.push(`${ranks[i]}${suits[j]}`);
}
}
return cards;
}
function dealFreeCell(seed) {
const rng = FreeCellRNG(seed);
const deck = getDeck();
const deltCards = [[], [], [], [], [], [], []];
let currentColumn = 0;
let currentRow = 0;
let rand;
let temp;
let card;
while (deck.length > 0) {
// Choose a random card
rand = rng.next() % deck.length;
// Swap this random card with the last card in the array
temp = deck[deck.length - 1];
deck[deck.length - 1] = deck[rand];
deck[rand] = temp;
// Remove this card from the array
card = deck.pop();
// Deal this card
deltCards[currentRow].push(card);
currentColumn += 1;
if (currentColumn === 8) {
currentColumn = 0;
currentRow += 1;
}
}
return deltCards;
}
```
</section>

83
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/deepcopy.spanish.md Normal file
View File

@@ -0,0 +1,83 @@
---
title: Deepcopy
id: 596a8888ab7c01048de257d5
localeTitle: 596a8888ab7c01048de257d5
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;.
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;.
testString: 'assert.deepEqual(deepcopy(obj3), obj3, "When passed an object containing another object, should return a deep copy of the object.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function deepcopy (obj) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function deepcopy(obj) {
return JSON.parse(JSON.stringify(obj));
}
```
</section>

118
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/define-a-primitive-data-type.spanish.md Normal file
View File

@@ -0,0 +1,118 @@
---
title: Define a primitive data type
id: 597089c87eec450c68aa1643
localeTitle: 597089c87eec450c68aa1643
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>Num</code> debería ser una función.
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;.
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;.
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;.
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;.
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.");'
- text: <code>new Num(3) - new Num(4)</code> debe ser igual a -1.
testString: 'assert.equal(new Num(3) - new Num(4), -1, "<code>new Num(3) - new Num(4)</code> should equal -1.");'
- text: <code>new Num(3) * new Num(4)</code> debe ser igual a 12.
testString: 'assert.equal(new Num(3) * new Num(4), 12, "<code>new Num(3) * new Num(4)</code> should equal 12.");'
- text: <code>new Num(3) / new Num(4)</code> debe ser igual a 0.75.
testString: 'assert.equal(new Num(3) / new Num(4), 0.75, "<code>new Num(3) / new Num(4)</code> should equal 0.75.");'
- text: <code>new Num(3) &lt; new Num(4)</code> debe ser verdadero.
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;
testString: 'assert.equal((new Num(5)).toString(), "5", "<code>(new Num(5)).toString()</code> should return \"5\"");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function Num (n) {
// Good luck!
return n;
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function Num(n) {
const num = Math.floor(n);
if (isNaN(num)) {
throw new TypeError('Not a Number');
}
if (num < 1 || num > 10) {
throw new TypeError('Out of range');
}
this._value = num;
}
Num.prototype.valueOf = function() { return this._value; };
Num.prototype.toString = function () { return this._value.toString(); };
function throws(func, errorType, msg) {
let hasThrown = false;
let errorMsg = ";
let correctType = false;
try {
func();
}
catch (e) {
hasThrown = true;
errorMsg = e.message;
if (e instanceof errorType) {
correctType = true;
}
}
return hasThrown && correctType && msg === errorMsg;
}
```
</section>

115
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/department-numbers.spanish.md Normal file
View File

@@ -0,0 +1,115 @@
---
title: Department Numbers
id: 59f40b17e79dbf1ab720ed7a
localeTitle: 59f40b17e79dbf1ab720ed7a
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
testString: 'assert.deepEqual(combinations(nums, total), result, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return all valid combinations.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function combinations (possibleNumbers, total) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function combinations (possibleNumbers, total) {
let firstNumber;
let secondNumber;
let thridNumber;
const allCombinations = [];
for (let i = 0; i < possibleNumbers.length; i += 1) {
firstNumber = possibleNumbers[i];
if (firstNumber % 2 === 0) {
for (let j = 0; j < possibleNumbers.length; j += 1) {
secondNumber = possibleNumbers[j];
if (j !== i && firstNumber + secondNumber <= total) {
thridNumber = total - firstNumber - secondNumber;
if (thridNumber !== firstNumber && thridNumber !== secondNumber && possibleNumbers.includes(thridNumber)) {
allCombinations.push([firstNumber, secondNumber, thridNumber]);
}
}
}
}
}
return allCombinations;
}
```
</section>

169
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/discordian-date.spanish.md Normal file
View File

@@ -0,0 +1,169 @@
---
title: Discordian date
id: 59f4eafba0343628bb682785
localeTitle: 59f4eafba0343628bb682785
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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> .
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> .
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> .
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>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function discordianDate (date) {
// Good luck!
return true;
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
/**
* All Hail Discordia! - this script prints Discordian date using system date.
*
* lang: JavaScript
* author: jklu
* contributors: JamesMcGuigan
*
* source: https://rosettacode.org/wiki/Discordian_date#JavaScript
*/
const seasons = [
'Chaos', 'Discord', 'Confusion',
'Bureaucracy', 'The Aftermath'
];
const weekday = [
'Sweetmorn', 'Boomtime', 'Pungenday',
'Prickle-Prickle', 'Setting Orange'
];
const apostle = [
'Mungday', 'Mojoday', 'Syaday',
'Zaraday', 'Maladay'
];
const holiday = [
'Chaoflux', 'Discoflux', 'Confuflux',
'Bureflux', 'Afflux'
];
Date.prototype.isLeapYear = function() {
const year = this.getFullYear();
if ((year & 3) !== 0) { return false; }
return ((year % 100) !== 0 || (year % 400) === 0);
};
// Get Day of Year
Date.prototype.getDOY = function() {
const dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
const mn = this.getMonth();
const dn = this.getDate();
let dayOfYear = dayCount[mn] + dn;
if (mn > 1 && this.isLeapYear()) { dayOfYear += 1; }
return dayOfYear;
};
Date.prototype.isToday = function() {
const today = new Date();
return this.getDate() === today.getDate()
&& this.getMonth() === today.getMonth()
&& this.getFullYear() === today.getFullYear()
;
};
function discordianDate(date) {
if (!date) { date = new Date(); }
const y = date.getFullYear();
const yold = y + 1166;
let dayOfYear = date.getDOY();
let celebrateHoliday = null;
if (date.isLeapYear()) {
if (dayOfYear === 60) {
celebrateHoliday = 'St. Tib\'s Day';
}
else if (dayOfYear > 60) {
dayOfYear--;
}
}
dayOfYear--;
const divDay = Math.floor(dayOfYear / 73);
const seasonDay = (dayOfYear % 73) + 1;
if (seasonDay === 5) {
celebrateHoliday = apostle[divDay];
}
if (seasonDay === 50) {
celebrateHoliday = holiday[divDay];
}
const season = seasons[divDay];
const dayOfWeek = weekday[dayOfYear % 5];
const nth = (seasonDay % 10 === 1) ? 'st'
: (seasonDay % 10 === 2) ? 'nd'
: (seasonDay % 10 === 3) ? 'rd'
: 'th';
return "
+ dayOfWeek
+ ', the ' + seasonDay + nth
+ ' day of ' + season
+ ' in the YOLD ' + yold
+ (celebrateHoliday ? '. Celebrate ' + celebrateHoliday + '!' : ")
;
}
```
</section>

92
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/element-wise-operations.spanish.md Normal file
View File

@@ -0,0 +1,92 @@
---
title: Element-wise operations
id: 599c333915e0ea32d04d4bec
localeTitle: 599c333915e0ea32d04d4bec
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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> .
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> .
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> .
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> .
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> .
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;
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;
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>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function operation (op, arr1, arr2) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function operation(op, arr1, arr2) {
const ops = {
add: ((a, b) => a + b),
sub: ((a, b) => a - b),
mult: ((a, b) => a * b),
div: ((a, b) => a / b),
exp: ((a, b) => Math.pow(a, b))
};
const ifm = op.startsWith('m');
const doOp = ops[op.substring(2)];
for (let i = 0; i < arr1.length; i++) {
for (let j = 0; j < arr1[0].length; j++) {
arr1[i][j] = doOp(arr1[i][j], (ifm) ? (arr2[i][j]) : (arr2));
}
}
return arr1;
}
```
</section>

99
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/emirp-primes.spanish.md Normal file
View File

@@ -0,0 +1,99 @@
---
title: Emirp primes
id: 599d0ba974141b0f508b37d5
localeTitle: 599d0ba974141b0f508b37d5
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
testString: 'assert.deepEqual(emirps([7700, 8000], false), 11, "<code>emirps([7700,8000],true)</code> should return <code>11</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function emirps(n) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
function emirps(num, showEmirps)
{
const is_prime = function(n)
{
if (!(n % 2) || !(n % 3)) return false;
let p = 1;
while (p * p < n)
{ if (n % (p += 4) == 0 || n % (p += 2) == 0)
{ return false; } }
return true;
};
const is_emirp = function(n) {
const r = parseInt(n.toString().split('').reverse().join(''));
return r != n && is_prime(n) && is_prime(r);
};
let i,
arr = [];
if (typeof num === 'number') {
for (i = 0; arr.length < num; i++) if (is_emirp(i)) arr.push(i);
// first x emirps
if (showEmirps) return arr;
// xth emirp
return arr.pop();
}
if (Array.isArray(num)) {
for (i = num[0]; i <= num[1]; i++) if (is_emirp(i)) arr.push(i);
// emirps between x .. y
if (showEmirps) return arr;
// number of emirps between x .. y
return arr.length;
}
}
```
</section>

89
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/entropy.spanish.md Normal file
View File

@@ -0,0 +1,89 @@
---
title: Entropy
id: 599d15309e88c813a40baf58
localeTitle: 599d15309e88c813a40baf58
challengeType: 5
---
## Description
<section id='description'>
Tarea:
<p> Calcule la entropía H de Shannon de una cadena de entrada dada. </p><p> Dada la discreta variable aleatoria $ X $ que es una cadena de $ N $ &quot;símbolos&quot; (caracteres totales) que consta de $ n $ caracteres diferentes (n = 2 para binario), la entropía de X de Shannon en bits / símbolo es: </p>
<p> $ H_2 (X) = - \ sum_ {i = 1} ^ n \ frac {count_i} {N} \ log_2 \ left (\ frac {count_i} {N} \ right) $ </p><p> donde $ count_i $ es el conteo del carácter $ n_i $. </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>entropy</code> es una función.
testString: 'assert(typeof entropy === "function", "<code>entropy</code> is a function.");'
- text: <code>entropy(&quot;0&quot;)</code> debe devolver <code>0</code>
testString: 'assert.equal(entropy("0"), 0, "<code>entropy("0")</code> should return <code>0</code>");'
- text: <code>entropy(&quot;01&quot;)</code> debe devolver <code>1</code>
testString: 'assert.equal(entropy("01"), 1, "<code>entropy("01")</code> should return <code>1</code>");'
- text: <code>entropy(&quot;0123&quot;)</code> debe devolver <code>2</code>
testString: 'assert.equal(entropy("0123"), 2, "<code>entropy("0123")</code> should return <code>2</code>");'
- text: <code>entropy(&quot;01234567&quot;)</code> debe devolver <code>3</code>
testString: 'assert.equal(entropy("01234567"), 3, "<code>entropy("01234567")</code> should return <code>3</code>");'
- text: <code>entropy(&quot;0123456789abcdef&quot;)</code> debe devolver <code>4</code>
testString: 'assert.equal(entropy("0123456789abcdef"), 4, "<code>entropy("0123456789abcdef")</code> should return <code>4</code>");'
- text: <code>entropy(&quot;1223334444&quot;)</code> debe devolver <code>1.8464393446710154</code>
testString: 'assert.equal(entropy("1223334444"), 1.8464393446710154, "<code>entropy("1223334444")</code> should return <code>1.8464393446710154</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function entropy (s) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function entropy(s) {
// Create a dictionary of character frequencies and iterate over it.
function process(s, evaluator) {
let h = Object.create(null),
k;
s.split('').forEach(c => {
h[c] && h[c]++ || (h[c] = 1); });
if (evaluator) for (k in h) evaluator(k, h[k]);
return h;
}
// Measure the entropy of a string in bits per symbol.
let sum = 0,
len = s.length;
process(s, (k, f) => {
const p = f / len;
sum -= p * Math.log(p) / Math.log(2);
});
return sum;
}
```
</section>

95
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/equilibrium-index.spanish.md Normal file
View File

@@ -0,0 +1,95 @@
---
title: Equilibrium index
id: 5987fd532b954e0f21b5d3f6
localeTitle: 5987fd532b954e0f21b5d3f6
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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;
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;
testString: 'assert.deepEqual(equilibrium(tests[5]), ans[5], "<code>equilibrium([])</code> should return <code>[]</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function equilibrium (a) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function equilibrium(a) {
let N = a.length,
i,
l = [],
r = [],
e = [];
for (l[0] = a[0], r[N - 1] = a[N - 1], i = 1; i < N; i++)
{ l[i] = l[i - 1] + a[i], r[N - i - 1] = r[N - i] + a[N - i - 1]; }
for (i = 0; i < N; i++)
{ if (l[i] === r[i]) e.push(i); }
return e;
}
```
</section>

124
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/ethiopian-multiplication.spanish.md Normal file
View File

@@ -0,0 +1,124 @@
---
title: Ethiopian multiplication
id: 599d1566a02b571412643b84
localeTitle: 599d1566a02b571412643b84
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;.
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;.
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;
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;.
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;.
testString: 'assert.equal(eth_mult(63, 74), 4662, "<code>eth_mult(63,74)</code> should return <code>4662</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function eth_mult (a, b) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function eth_mult(a, b) {
let sum = 0; a = [a]; b = [b];
let half = a => a / 2,
double = a => a * 2,
is_even = a => a % 2 == 0;
while (a[0] !== 1) {
a.unshift(Math.floor(half(a[0])));
b.unshift(double(b[0]));
}
for (let i = a.length - 1; i > 0; i -= 1) {
if (!is_even(a[i])) {
sum += b[i];
}
}
return sum + b[0];
}
```
</section>

90
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/euler-method.spanish.md Normal file
View File

@@ -0,0 +1,90 @@
---
title: Euler method
id: 59880443fb36441083c6c20e
localeTitle: 59880443fb36441083c6c20e
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;.
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;
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;
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;
testString: 'assert.equal(eulersMethod(0, 100, 100, 10), 20.000472392, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.000472392.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function eulersMethod (x1, y1, x2, h) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function eulersMethod(x1, y1, x2, h) {
let x = x1;
let y = y1;
while ((x < x2 && x1 < x2) || (x > x2 && x1 > x2)) {
y += h * (-0.07 * (y - 20));
x += h;
}
return y;
}
```
</section>

72
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/evaluate-binomial-coefficients.spanish.md Normal file
View File

@@ -0,0 +1,72 @@
---
title: Evaluate binomial coefficients
id: 598de241872ef8353c58a7a2
localeTitle: 598de241872ef8353c58a7a2
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;.
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;
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;
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;
testString: 'assert.equal(binom(12, 8), 495, "<code>binom(12,8)</code> should return 495.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function binom (n, k) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function binom(n, k) {
let coeff = 1;
for (let i = n - k + 1; i <= n; i++) coeff *= i;
for (let i = 1; i <= k; i++) coeff /= i;
return coeff;
}
```
</section>

212
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-a-markov-algorithm.spanish.md Normal file
View File

@@ -0,0 +1,212 @@
---
title: Execute a Markov algorithm
id: 59e09e6d412c5939baa02d16
localeTitle: 59e09e6d412c5939baa02d16
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;.
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;.
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;
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;
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;
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".");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function markov (rules,test) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function markov(rules,test) {
let pattern = new RegExp("^([^#]*?)\\s+->\\s+(\\.?)(.*)");
let origTest = test;
let captures = [];
rules.forEach(function(rule){
let m = pattern.exec(rule);
for (let j = 0; j < m.length; j++)
m[j] = m[j + 1];
captures.push(m);
});
test = origTest;
let copy = test;
for (let j = 0; j < captures.length; j++) {
let c = captures[j];
test = test.replace(c[0], c[2]);
if (c[1]==".")
break;
if (test!=copy) {
j = -1;
copy = test;
}
}
return test;
}
// tail:
let rules=[["A -> apple","B -> bag","S -> shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],
["A -> apple","B -> bag","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],
["A -> apple","WWWW -> with","Bgage -> ->.*","B -> bag","->.* -> money","W -> WW","S -> .shop","T -> the","the shop -> my brother","a never used -> .terminating rule"],
["_+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","_+_ -> "],
["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"]];
let tests=["I bought a B of As from T S.",
"I bought a B of As from T S.",
"I bought a B of As W my Bgage from T S.",
"_1111*11111_",
"000000A000000"];
let outputs=["I bought a bag of apples from my brother.",
"I bought a bag of apples from T shop.",
"I bought a bag of apples with my money from T shop.",
"11111111111111111111",
"00011H1111000"];
```
</section>

213
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/execute-brain.spanish.md Normal file
View File

@@ -0,0 +1,213 @@
---
title: Execute Brain****
id: 59e0a8df964e4540d5abe599
localeTitle: 59e0a8df964e4540d5abe599
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>brain(bye)</code> debe retuen una cuerda
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;
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;
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function brain (prog) {
// Good luck!
}
```
</div>
### Before Test
<div id='js-setup'>
```js
let fib=`+
++
+++
++++
+>+>>
>>++++
+++++++
++++++++
+++++++++
++++++++++
++++++>++++
++++++++++++
+++++++++++++
+++<<<<<<[>[>>
>>>>+>+<<<<<<<-
]>>>>>>>[<<<<<<<
+>>>>>>>-]<[>++++
++++++[-<-[>>+>+<<
<-]>>>[<<<+>>>-]+<[
>[-]<[-]]>[<<[>>>+<<
<-]>>[-]]<<]>>>[>>+>+
<<<-]>>>[<<<+>>>-]+<[>
[-]<[-]]>[<<+>>[-]]<<<<
<<<]>>>>>[++++++++++++++
+++++++++++++++++++++++++
+++++++++.[-]]++++++++++<[
->-<]>+++++++++++++++++++++
+++++++++++++++++++++++++++.
[-]<<<<<<<<<<<<[>>>+>+<<<<-]>
>>>[<<<<+>>>>-]<-[>>.>.<<<[-]]
<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+
>-]>[<+>-]<<<-]`;
let hello='++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.'
let bye='++++++++++[>+>+++>++++>+++++++>++++++++>+++++++++>++++++++++>+++++++++++>++++++++++++<<<<<<<<<-]>>>>+.>>>>+..<.<++++++++.>>>+.<<+.<<<<++++.<++.>>>+++++++.>>>.+++.<+++++++.--------.<<<<<+.<+++.---.';
```
</div>
</section>
## Solution
<section id='solution'>
```js
function brain(prog){
var output="";
var code; // formatted code
var ip = 0; // current instruction within code
var nest = 0; // current bracket nesting (for Out button)
var ahead = []; // locations of matching brackets
var data = [0]; // data array (mod by +, -)
var dp = 0; // index into data (mod by <, >)
var inp = 0; // current input character (fetch with ,)
var quit = 0;
var commands = {
'>':function() { if (++dp >= data.length) data[dp]=0 },
'<':function() { if (--dp < 0) quit++ },
'+':function() { ++data[dp] },
'-':function() { --data[dp] },
'[':function() { if (!data[dp]) ip = ahead[ip]; else ++nest },
']':function() { if ( data[dp]) ip = ahead[ip]; else --nest },
',':function() {
var c = document.getElementById("input").value.charCodeAt(inp++);
data[dp] = isNaN(c) ? 0 : c; // EOF: other options are -1 or no change
},
'.':function() {
output+=String.fromCharCode(data[dp]);
/*var s = document.getElementById("output").innerHTML)
+ String.fromCharCode(data[dp]);
s = s.replace(/\n/g,"<br>").replace(/ /g,"&amp;nbsp;");
document.getElementById("output").innerHTML = s;*/
},
};
let ar=prog.split('');
var st = [], back, error = -1;
for (ip=0; ip<ar.length; ip++) {
switch(ar[ip]) {
case '[':
st.push(ip);
break;
case ']':
if (st.length == 0) error = ip;
back = st.pop();
ahead[ip] = back;
ahead[back] = ip;
break;
}
}
for(ip=0;ip<ar.length;ip++){
if(commands.hasOwnProperty(ar[ip]))
commands[ar[ip]]();
}
return output;
}
```
</section>

102
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/extensible-prime-generator.spanish.md Normal file
View File

@@ -0,0 +1,102 @@
---
title: Extensible prime generator
id: 598ee8b91b410510ae82efef
localeTitle: 598ee8b91b410510ae82efef
challengeType: 5
---
## Description
<section id='description'>
<p> Escriba un generador de números primos, en orden, que se ajustará automáticamente para adaptarse a la generación de cualquier primo razonablemente alto. </p> El generador debe ser capaz de: Mostrar los primeros <b>n</b> números primos. Mostrar los números primos en un rango. Mostrar el número de números primos en un rango. Mostrar el <b><sup>número</sup></b> primo n. <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 números primos 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.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>primeGenerator</code> es una función.
testString: 'assert(typeof primeGenerator === "function", "<code>primeGenerator</code> is a function.");'
- text: <code>primeGenerator</code> es una función.
testString: 'assert.deepEqual(primeGenerator(20, true), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71], "<code>primeGenerator</code> is a function.");'
- text: <code>primeGenerator</code> es una función.
testString: 'assert.deepEqual(primeGenerator([100, 150], true), [101, 103, 107, 109, 113, 127, 131, 137, 139, 149], "<code>primeGenerator</code> is a function.");'
- text: <code>primeGenerator</code> es una función.
testString: 'assert.equal(primeGenerator([7700, 8000], false), 30, "<code>primeGenerator</code> is a function.");'
- text: <code>primeGenerator</code> es una función.
testString: 'assert.equal(primeGenerator(10000, false), 104729, "<code>primeGenerator</code> is a function.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function primeGenerator (num, showPrimes) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
function primeGenerator(num, showPrimes) {
let i,
arr = [];
function isPrime(num) {
// try primes <= 16
if (num <= 16) { return (
num == 2 || num == 3 || num == 5 || num == 7 || num == 11 || num == 13
); }
// cull multiples of 2, 3, 5 or 7
if (num % 2 == 0 || num % 3 == 0 || num % 5 == 0 || num % 7 == 0)
{ return false; }
// cull square numbers ending in 1, 3, 7 or 9
for (let i = 10; i * i <= num; i += 10) {
if (num % (i + 1) == 0) return false;
if (num % (i + 3) == 0) return false;
if (num % (i + 7) == 0) return false;
if (num % (i + 9) == 0) return false;
}
return true;
}
if (typeof num === 'number') {
for (i = 0; arr.length < num; i++) if (isPrime(i)) arr.push(i);
// first x primes
if (showPrimes) return arr;
// xth prime
return arr.pop();
}
if (Array.isArray(num)) {
for (i = num[0]; i <= num[1]; i++) if (isPrime(i)) arr.push(i);
// primes between x .. y
if (showPrimes) return arr;
// number of primes between x .. y
return arr.length;
}
}
```
</section>

90
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factorial.spanish.md Normal file
View File

@@ -0,0 +1,90 @@
---
title: Factorial
id: 597b2b2a2702b44414742771
localeTitle: 597b2b2a2702b44414742771
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>factorial</code> es una función.
testString: 'assert(typeof factorial === "function", "<code>factorial</code> is a function.");'
- text: <code>factorial(2)</code> debe devolver un número.
testString: 'assert(typeof factorial(2) === "number", "<code>factorial(2)</code> should return a number.");'
- text: <code>factorial(3)</code> debe devolver 6. &quot;)
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;
testString: 'assert.equal(factorial(10),results[2],"<code>factorial(3)</code> should return 3,628,800.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function factorial (n) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function factorial(n) {
let sum = 1;
while (n > 1) {
sum *= n;
n--;
}
return sum;
}
```
</section>

135
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factors-of-a-mersenne-number.spanish.md Normal file
View File

@@ -0,0 +1,135 @@
---
title: Factors of a Mersenne number
id: 598eea87e5cf4b116c3ff81a
localeTitle: 598eea87e5cf4b116c3ff81a
challengeType: 5
---
## Description
<section id='description'>
<p> Un número de Mersenne es un número en forma de 2 <sup>P</sup> -1. </p><p> Si P es primo, el número de Mersenne puede ser un primo de Mersenne </p>
<p> (Si P no es primo, el número de Mersenne tampoco es primo). </p><p> En la búsqueda de números primos de Mersenne es ventajoso eliminar los exponentes al encontrar un factor pequeño antes de comenzar una <a href="http://rosettacode.org/wiki/Lucas-Lehmer test" title="Prueba de Lucas-Lehmer">prueba de Lucas-Lehmer</a> potencialmente larga. </p><p> Hay algoritmos muy eficientes para determinar si un número divide 2 <sup>P</sup> -1 (o equivalentemente, si 2 <sup>P</sup> mod (el número) = 1). </p>
<p> Algunos idiomas ya tienen implementaciones integradas de esta operación de exponente y mod (llamada modPow o similar). </p><p> Lo siguiente es cómo implementar este modPow usted mismo: </p><p> Por ejemplo, vamos a calcular 2 <sup>23</sup> mod 47. </p>
<p> Convierte el exponente 23 a binario, obtienes 10111. Comenzando con <tt>square</tt> = 1, cuadrándolo repetidamente. </p>
<p> Elimine el bit superior del exponente y, si es 1, multiplique el <tt>cuadrado</tt> por la base de la exponenciación (2), luego calcule el módulo <tt>cuadrado</tt> 47. </p>
<p> Utilice el resultado del módulo del último paso como el valor inicial del <tt>cuadrado</tt> en el siguiente paso: </p><p> Eliminar opcional </p>
<p> bit cuadrado superior multiplicar por 2 mod 47 </p>
<p> ------------ ------- ------------- ------ </p>
<p> 1 * 1 = 1 1 0111 1 * 2 = 2 2 </p>
<p> 2 * 2 = 4 0 111 no 4 </p>
<p> 4 * 4 = 16 1 11 16 * 2 = 32 32 </p>
<p> 32 * 32 = 1024 1 1 1024 * 2 = 2048 27 </p>
<p> 27 * 27 = 729 1 729 * 2 = 1458 1 </p><p> Dado que 2 <sup>23</sup> mod 47 = 1, 47 es un factor de 2 <sup>P</sup> -1. </p>
<p> (Para ver esto, reste 1 de ambos lados: 2 <sup>23</sup> -1 = 0 mod 47.) </p>
<p> Como hemos demostrado que 47 es un factor, 2 <sup>23</sup> -1 no es primo. </p>
<p> Otras propiedades de los números de Mersenne nos permiten refinar el proceso aún más. </p>
<p> Cualquier factor q de 2 <sup>P</sup> -1 debe tener la forma 2kP + 1, siendo k un entero positivo o cero. Además, q debe ser 1 o 7 mod 8. </p>
<p> Finalmente cualquier factor potencial q debe ser <a href="http://rosettacode.org/wiki/Primality by Trial Division" title="Primalidad por división de prueba">primo</a> . </p>
<p> Como en otros algoritmos de división de prueba, el algoritmo se detiene cuando 2kP + 1&gt; sqrt (N). </p><p> Estas pruebas de primalidad solo funcionan en los números de Mersenne donde P es primo. Por ejemplo, M <sub>4</sub> = 15 no produce factores utilizando estas técnicas, sino factores en 3 y 5, ninguno de los cuales se ajusta a 2kP + 1. </p>
Tarea:
<p> Usando el método anterior, encuentre un factor de 2 <sup>929</sup> -1 (también conocido como M929) </p>
Tareas relacionadas:
<a href="http://rosettacode.org/wiki/count in factors" title="contar en factores">recuento en factores</a>
<a href="http://rosettacode.org/wiki/prime decomposition" title="descomposición principal">descomposición principal</a>
<a href="http://rosettacode.org/wiki/factors of an integer" title="factores de un entero">factores de un entero</a>
<a href="http://rosettacode.org/wiki/Sieve of Eratosthenes" title="Tamiz de Eratóstenes">Tamiz de eratóstenes</a>
<a href="http://rosettacode.org/wiki/primality by trial division" title="primalidad por división de prueba">primalidad por división de</a> <a href="http://rosettacode.org/wiki/trial factoring of a Mersenne number" title="factoraje de prueba de un número de Mersenne">prueba</a>
<a href="http://rosettacode.org/wiki/trial factoring of a Mersenne number" title="factoraje de prueba de un número de Mersenne">factorización de prueba de un número Mersenne</a>
<a href="http://rosettacode.org/wiki/partition an integer X into N primes" title="particionar un entero X en N primos">partición de un entero X en N primos</a>
<a href="http://rosettacode.org/wiki/sequence of primes by Trial Division" title="Secuencia de números primos por división de prueba.">secuencia de primos por División de Juicio</a>
<a href="https://www.youtube.com/watch?v=SNwvJ7psoow" title="enlace: https://www.youtube.com/watch?v=SNwvJ7psoow">Computadoras en 1948: 2¹²⁷-1</a>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>check_mersenne</code> es una función.
testString: 'assert(typeof check_mersenne === "function", "<code>check_mersenne</code> is a function.");'
- text: <code>check_mersenne(3)</code> debería devolver una cadena.
testString: 'assert(typeof check_mersenne(3) == "string", "<code>check_mersenne(3)</code> should return a string.");'
- text: <code>check_mersenne(3)</code> debe devolver &quot;M3 = 2 ^ 3-1 es primo&quot;.
testString: 'assert.equal(check_mersenne(3),"M3 = 2^3-1 is prime","<code>check_mersenne(3)</code> should return "M3 = 2^3-1 is prime".");'
- text: <code>check_mersenne(23)</code> debe devolver &quot;M23 = 2 ^ 23-1 es compuesto con factor 47&quot;.
testString: 'assert.equal(check_mersenne(23),"M23 = 2^23-1 is composite with factor 47","<code>check_mersenne(23)</code> should return "M23 = 2^23-1 is composite with factor 47".");'
- text: <code>check_mersenne(929)</code> debe devolver &quot;M929 = 2 ^ 929-1 es compuesto con factor 13007
testString: 'assert.equal(check_mersenne(929),"M929 = 2^929-1 is composite with factor 13007","<code>check_mersenne(929)</code> should return "M929 = 2^929-1 is composite with factor 13007");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function check_mersenne (p) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function check_mersenne(p){
function isPrime(value){
for (let i=2; i < value; i++){
if (value % i == 0){
return false;
}
if (value % i != 0){
return true;
}
}
}
function trial_factor(base, exp, mod){
let square, bits;
square = 1;
bits = exp.toString(2).split('');
for (let i=0,ln=bits.length; i<ln; i++){
square = Math.pow(square, 2) * (bits[i] == 1 ? base : 1) % mod;
}
return (square == 1);
}
function mersenne_factor(p){
let limit, k, q;
limit = Math.sqrt(Math.pow(2,p) - 1);
k = 1;
while ((2*k*p - 1) < limit){
q = 2*k*p + 1;
if (isPrime(q) && (q % 8 == 1 || q % 8 == 7) && trial_factor(2,p,q)){
return q; // q is a factor of 2**p-1
}
k++;
}
return null;
}
let f, result;
result="M"+p+" = 2^"+p+"-1 is ";
f = mersenne_factor(p);
result+=f == null ? "prime" : "composite with factor "+f;
return result;
}
```
</section>

84
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/factors-of-an-integer.spanish.md Normal file
View File

@@ -0,0 +1,84 @@
---
title: Factors of an integer
id: 597f1e7fbc206f0e9ba95dc4
localeTitle: 597f1e7fbc206f0e9ba95dc4
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
testString: 'assert.deepEqual(factors(64), ans[2], "<code>factors(64)</code> should return <code>[1,2,4,8,16,32,64]</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function factors (num) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function factors(num)
{
let n_factors = [], i, sqr=Math.floor(Math.sqrt(num));
for (i = 1; i <=sqr ; i += 1)
if (num % i === 0)
{
n_factors.push(i);
if (num / i !== i)
n_factors.push(num / i);
}
n_factors.sort(function(a, b){return a - b;});
return n_factors;
}
```
</section>

92
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/farey-sequence.spanish.md Normal file
View File

@@ -0,0 +1,92 @@
---
title: Farey sequence
id: 59c3ec9f15068017c96eb8a3
localeTitle: 59c3ec9f15068017c96eb8a3
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>farey</code> es una función.
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;
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;
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function farey (n) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function farey(n){
let farSeq=[];
for(let den = 1; den <= n; den++){
for(let num = 1; num < den; num++){
farSeq.push({
str:num+"/"+den,
val:num/den});
}
}
farSeq.sort(function(a,b){
return a.val-b.val;
});
farSeq=farSeq.map(function(a){
return a.str;
});
return farSeq;
}
```
</section>

151
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-n-step-number-sequences.spanish.md Normal file
View File

@@ -0,0 +1,151 @@
---
title: Fibonacci n-step number sequences
id: 598eef80ba501f1268170e1e
localeTitle: 598eef80ba501f1268170e1e
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 $ ...
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$
For $n = 3$ we have the tribonacci sequence; with initial values $[1, 1, 2]$ and $F_k^3 = F_{k-1}^3 + F_{k-2}^3 + F_{k-3}^3$
For $n = 4$ we have the tetranacci sequence; with initial values $[1, 1, 2, 4]$ and $F_k^4 = F_{k-1}^4 + F_{k-2}^4 + F_{k-3}^4 + F_{k-4}^4$...
For general $n>2$ we have the Fibonacci $n$-step sequence - $F_k^n$; with initial values of the first $n$ values of the $(n-1)$'th Fibonacci $n$-step sequence $F_k^{n-1}$; and $k$'th value of this $n$'th sequence being $F_k^n = \sum_{i=1}^{(n)} {F_{k-i}^{(n)}}$
<p>For small values of $n$, <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Number prefix#Greek_series">Greek numeric prefixes</a> are sometimes used to individually name each series.</p><p>{| style="text-align: left;" border="4" cellpadding="2" cellspacing="2"</p>
<p>|+ Fibonacci $n$-step sequences</p>
<p>|- style="background-color: rgb(255, 204, 255);"</p>
<p>! $n$ !! Series name !! Values</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>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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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;
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;
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;
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>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function fib_luc (n, len, w) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function fib_luc(n, len, w) {
function nacci(a, n, len) {
while (a.length < len) {
let sum = 0;
for (let i = Math.max(0, a.length - n); i < a.length; i++)
sum += a[i];
a.push(sum);
}
return a;
}
if(w=="f"){
return nacci(nacci([1,1], n, n), n, len);
}else{
return nacci(nacci([2,1], n, n), n, len);
}
}
```
</section>

77
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-sequence.spanish.md Normal file
View File

@@ -0,0 +1,77 @@
---
title: Fibonacci sequence
id: 597f24c1dda4e70f53c79c81
localeTitle: 597f24c1dda4e70f53c79c81
challengeType: 5
---
## Description
<section id='description'>
<p> Escribe una función para generar el <big>n <sup>º</sup></big> número de Fibonacci. </p>
/// <p> El <big><sup>número</sup> n de</big> Fibonacci viene dado por:
/// <p> F <sub>n</sub> = F <sub>n-1</sub> + F <sub>n-2</sub> </p>
/// <p> Los dos primeros términos de la serie son 0, 1. </p>
/// <p> Por lo tanto, la serie es: 0, 1, 1, 2, 3, 5, 8, 13 ... </p>
///
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>fibonacci</code> es una función.
testString: 'assert(typeof fibonacci === "function", "<code>fibonacci</code> is a function.");'
- text: <code>fibonacci(2)</code> debe devolver un número.
testString: 'assert(typeof fibonacci(2) == "number", "<code>fibonacci(2)</code> should return a number.");'
- text: <code>fibonacci(3)</code> debe devolver 1. &quot;)
testString: 'assert.equal(fibonacci(3),1,"<code>fibonacci(3)</code> should return 1.");'
- text: <code>fibonacci(5)</code> debe devolver 3. &quot;)
testString: 'assert.equal(fibonacci(5),3,"<code>fibonacci(5)</code> should return 3.");'
- text: <code>fibonacci(10)</code> debe devolver 34. &quot;)
testString: 'assert.equal(fibonacci(10),34,"<code>fibonacci(10)</code> should return 34.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function fibonacci(n) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function fibonacci(n) {
let a = 0, b = 1, t;
while (--n > 0) {
t = a;
a = b;
b += t;
}
return a;
}
```
</section>

121
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fibonacci-word.spanish.md Normal file
View File

@@ -0,0 +1,121 @@
---
title: Fibonacci word
id: 5992e222d397f00d21122931
localeTitle: 5992e222d397f00d21122931
challengeType: 5
---
## Description
<section id='description'>
<p> Escriba una función para devolver las palabras de Fibonacci hasta N. N se proporcionará como un parámetro a la función. La función debe devolver una matriz de objetos. Los objetos deben tener la forma: {N: 1, Longitud: 1, Entropía: 0, Palabra: &#39;1&#39;}. Se dan más detalles a continuación : </p><p> La Palabra de Fibonacci puede crearse de manera análoga a la Secuencia de Fibonacci <a href="http://hal.archives-ouvertes.fr/docs/00/36/79/72/PDF/The_Fibonacci_word_fractal.pdf" title="enlace: http://hal.archives-ouvertes.fr/docs/00/36/79/72/PDF/The_Fibonacci_word_fractal.pdf">como se describe aquí</a> : </p><p> Define F_Word <sub>1</sub> como 1 </p>
<p> Define F_Word <sub>2</sub> como 0 </p>
<p> Forma F_Word <sub>3</sub> como F_Word <sub>2</sub> concatenada con F_Word <sub>1,</sub> es decir: 01 </p>
<p> Forma F_Word <sub>n</sub> como F_Word <sub>n-1</sub> concatenada con F_word <sub>n-2</sub> </p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>fibWord</code> es una función.
testString: 'assert(typeof fibWord === "function", "<code>fibWord</code> is a function.");'
- text: <code>fibWord(5)</code> debe devolver una matriz.
testString: 'assert(Array.isArray(fibWord(5)),"<code>fibWord(5)</code> should return an array.");'
- text: <code>fibWord(5)</code> debe devolver <code>&#39;+JSON.stringify(ans)+&#39;</code> .
testString: 'assert.deepEqual(fibWord(5),ans,"<code>fibWord(5)</code> should return <code>"+JSON.stringify(ans)+"</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function fibWord (n) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function fibWord(n) {
function entropy(s) {
//create an object containing each individual char
//and the amount of iterations per char
function prob(s) {
var h = Object.create(null);
s.split('').forEach(function(c) {
h[c] && h[c]++ || (h[c] = 1);
});
return h;
}
s = s.toString(); //just in case
var e = 0, l = s.length, h = prob(s);
for (var i in h ) {
var p = h[i]/l;
e -= p * Math.log(p) / Math.log(2);
}
return e;
}
var wOne = "1", wTwo = "0", wNth = [wOne, wTwo], w = "", o = [];
for (var i = 0; i < n; i++) {
if (i === 0 || i === 1) {
w = wNth[i];
} else {
w = wNth[i - 1] + wNth[i - 2];
wNth.push(w);
}
var l = w.length;
var e = entropy(w);
if (l <= 21) {
o.push({
N: i + 1,
Length: l,
Entropy: e,
Word: w
});
} else {
o.push({
N: i + 1,
Length: l,
Entropy: e,
Word: "..."
});
}
}
return o;
}
```
</section>

118
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/fractran.spanish.md Normal file
View File

@@ -0,0 +1,118 @@
---
title: Fractran
id: 5a7dad05be01840e1778a0d1
localeTitle: 5a7dad05be01840e1778a0d1
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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;
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;
testString: 'assert.deepEqual(fractran(tests[4]),results[4],"<code>fractran(""+tests[4]+"")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function fractran (progStr) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function fractran(progStr){
var num = new Array();
var den = new Array();
var val ;
var out="";
function compile(prog){
var regex = /\s*(\d*)\s*\/\s*(\d*)\s*(.*)/m;
while(regex.test(prog)){
num.push(regex.exec(prog)[1]);
den.push(regex.exec(prog)[2]);
prog = regex.exec(prog)[3];
}
}
function step(val){
var i=0;
while(i<den.length && val%den[i] != 0) i++;
return num[i]*val/den[i];
}
var seq=[]
function exec(val){
var i = 0;
while(val && i<limit){
seq.push(val)
val = step(val);
i ++;
}
}
// Main
compile(progStr);
var limit = 10;
exec(2);
return seq;
}
```
</section>

99
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gamma-function.spanish.md Normal file
View File

@@ -0,0 +1,99 @@
---
title: Gamma function
id: 5a23c84252665b21eecc7e76
localeTitle: 5a23c84252665b21eecc7e76
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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;
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;
testString: 'assert.equal(gamma(tests[4]),results[4],"<code>gamma("+tests[4]+")</code> should return <code>"+results[4]+"</code>.")'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function gamma (x) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function gamma(x) {
var p = [0.99999999999980993, 676.5203681218851, -1259.1392167224028,
771.32342877765313, -176.61502916214059, 12.507343278686905,
-0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7
];
var g = 7;
if (x < 0.5) {
return Math.PI / (Math.sin(Math.PI * x) * gamma(1 - x));
}
x -= 1;
var a = p[0];
var t = x + g + 0.5;
for (var i = 1; i < p.length; i++) {
a += p[i] / (x + i);
}
var result=Math.sqrt(2 * Math.PI) * Math.pow(t, x + 0.5) * Math.exp(-t) * a;
return result;
}
```
</section>

177
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gaussian-elimination.spanish.md Normal file
View File

@@ -0,0 +1,177 @@
---
title: Gaussian elimination
id: 5a23c84252665b21eecc7e77
localeTitle: 5a23c84252665b21eecc7e77
challengeType: 5
---
## Description
<section id='description'>
Escribe una función para resolver \ (Ax = b \) usando la eliminación de Gauss y luego la sustitución hacia atrás. \ (A \) siendo una matriz \ (n \ veces n \). Además, \ (x \) y \ (b \) son \ (n \) por 1 vectores. Para mejorar la precisión, use pivote parcial y escalado.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>gaussianElimination</code> debería ser una función.
testString: 'assert(typeof gaussianElimination=="function","<code>gaussianElimination</code> should be a function.");'
- text: <code>gaussianElimination(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+JSON.stringify(tests[0][1])+&quot;)</code> debe devolver una matriz.
testString: 'assert(Array.isArray(gaussianElimination(tests[0][0],tests[0][1])),"<code>gaussianElimination("+JSON.stringify(tests[0][0])+","+JSON.stringify(tests[0][1])+")</code> should return an array.");'
- text: <code>gaussianElimination(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+JSON.stringify(tests[0][1])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[0])+&quot;</code> .
testString: 'assert.deepEqual(gaussianElimination(tests[0][0],tests[0][1]),results[0],"<code>gaussianElimination("+JSON.stringify(tests[0][0])+","+JSON.stringify(tests[0][1])+")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
- text: <code>gaussianElimination(&quot;+JSON.stringify(tests[1][0])+&quot;,&quot;+JSON.stringify(tests[1][1])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[1])+&quot;</code> .
testString: 'assert.deepEqual(gaussianElimination(tests[1][0],tests[1][1]),results[1],"<code>gaussianElimination("+JSON.stringify(tests[1][0])+","+JSON.stringify(tests[1][1])+")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
- text: <code>gaussianElimination(&quot;+JSON.stringify(tests[2][0])+&quot;,&quot;+JSON.stringify(tests[2][1])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[2])+&quot;</code> .
testString: 'assert.deepEqual(gaussianElimination(tests[2][0],tests[2][1]),results[2],"<code>gaussianElimination("+JSON.stringify(tests[2][0])+","+JSON.stringify(tests[2][1])+")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
- text: <code>gaussianElimination(&quot;+JSON.stringify(tests[3][0])+&quot;,&quot;+JSON.stringify(tests[3][1])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[3])+&quot;</code> .
testString: 'assert.deepEqual(gaussianElimination(tests[3][0],tests[3][1]),results[3],"<code>gaussianElimination("+JSON.stringify(tests[3][0])+","+JSON.stringify(tests[3][1])+")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
- text: <code>gaussianElimination(&quot;+JSON.stringify(tests[4][0])+&quot;,&quot;+JSON.stringify(tests[4][1])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[4])+&quot;</code> .
testString: 'assert.deepEqual(gaussianElimination(tests[4][0],tests[4][1]),results[4],"<code>gaussianElimination("+JSON.stringify(tests[4][0])+","+JSON.stringify(tests[4][1])+")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function gaussianElimination (A,b) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function gaussianElimination(A, b) {
// Lower Upper Decomposition
function ludcmp(A) {
// A is a matrix that we want to decompose into Lower and Upper matrices.
var d = true
var n = A.length
var idx = new Array(n) // Output vector with row permutations from partial pivoting
var vv = new Array(n) // Scaling information
for (var i=0; i<n; i++) {
var max = 0
for (var j=0; j<n; j++) {
var temp = Math.abs(A[i][j])
if (temp > max) max = temp
}
if (max == 0) return // Singular Matrix!
vv[i] = 1 / max // Scaling
}
var Acpy = new Array(n)
for (var i=0; i<n; i++) {
var Ai = A[i]
let Acpyi = new Array(Ai.length)
for (j=0; j<Ai.length; j+=1) Acpyi[j] = Ai[j]
Acpy[i] = Acpyi
}
A = Acpy
var tiny = 1e-20 // in case pivot element is zero
for (var i=0; ; i++) {
for (var j=0; j<i; j++) {
var sum = A[j][i]
for (var k=0; k<j; k++) sum -= A[j][k] * A[k][i];
A[j][i] = sum
}
var jmax = 0
var max = 0;
for (var j=i; j<n; j++) {
var sum = A[j][i]
for (var k=0; k<i; k++) sum -= A[j][k] * A[k][i];
A[j][i] = sum
var temp = vv[j] * Math.abs(sum)
if (temp >= max) {
max = temp
jmax = j
}
}
if (i <= jmax) {
for (var j=0; j<n; j++) {
var temp = A[jmax][j]
A[jmax][j] = A[i][j]
A[i][j] = temp
}
d = !d;
vv[jmax] = vv[i]
}
idx[i] = jmax;
if (i == n-1) break;
var temp = A[i][i]
if (temp == 0) A[i][i] = temp = tiny
temp = 1 / temp
for (var j=i+1; j<n; j++) A[j][i] *= temp
}
return {A:A, idx:idx, d:d}
}
// Lower Upper Back Substitution
function lubksb(lu, b) {
// solves the set of n linear equations A*x = b.
// lu is the object containing A, idx and d as determined by the routine ludcmp.
var A = lu.A
var idx = lu.idx
var n = idx.length
var bcpy = new Array(n)
for (var i=0; i<b.length; i+=1) bcpy[i] = b[i]
b = bcpy
for (var ii=-1, i=0; i<n; i++) {
var ix = idx[i]
var sum = b[ix]
b[ix] = b[i]
if (ii > -1)
for (var j=ii; j<i; j++) sum -= A[i][j] * b[j]
else if (sum)
ii = i
b[i] = sum
}
for (var i=n-1; i>=0; i--) {
var sum = b[i]
for (var j=i+1; j<n; j++) sum -= A[i][j] * b[j]
b[i] = sum / A[i][i]
}
return b // solution vector x
}
var lu = ludcmp(A)
if (lu === undefined) return // Singular Matrix!
return lubksb(lu, b)
}
```
</section>

99
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/general-fizzbuzz.spanish.md Normal file
View File

@@ -0,0 +1,99 @@
---
title: General FizzBuzz
id: 5a23c84252665b21eecc7e78
localeTitle: 5a23c84252665b21eecc7e78
challengeType: 5
---
## Description
<section id='description'>
Escriba una versión generalizada de <a href="http://rosettacode.org/wiki/FizzBuzz">FizzBuzz</a> que funcione para cualquier lista de factores, junto con sus palabras.
Esta es básicamente una implementación &quot;fizzbuzz&quot; donde las reglas del juego se suministran al usuario. Crea una función para implementar esto. La función debe tener dos parámetros.
El primero será una matriz con las reglas de FizzBuzz. Por ejemplo: <code>[ [3,&quot;Fizz&quot;] , [5,&quot;Buzz&quot;] ]</code> .
Esto indica que se debe imprimir <code>Fizz</code> si el número es un múltiplo de 3 y <code>Buzz</code> si es un múltiplo de 5. Si es un múltiplo de ambos, las cadenas deben concatenarse en el orden especificado en la matriz. En este caso, <code>FizzBuzz</code> si el número es un múltiplo de 3 y 5.
El segundo parámetro es el número para el cual la función debe devolver una cadena como se indicó anteriormente.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>genFizzBuzz</code> debería ser una función.
testString: 'assert(typeof genFizzBuzz=="function","<code>genFizzBuzz</code> should be a function.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+tests[0][1]+&quot;)</code> debe devolver un tipo.
testString: 'assert(typeof genFizzBuzz(tests[0][0],tests[0][1])=="string","<code>genFizzBuzz("+JSON.stringify(tests[0][0])+","+tests[0][1]+")</code> should return a type.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[0][0])+&quot;,&quot;+tests[0][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[0]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[0][0],tests[0][1]),results[0],"<code>genFizzBuzz("+JSON.stringify(tests[0][0])+","+tests[0][1]+")</code> should return <code>""+results[0]+""</code>.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[1][0])+&quot;,&quot;+tests[1][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[1]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[1][0],tests[1][1]),results[1],"<code>genFizzBuzz("+JSON.stringify(tests[1][0])+","+tests[1][1]+")</code> should return <code>""+results[1]+""</code>.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[2][0])+&quot;,&quot;+tests[2][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[2]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[2][0],tests[2][1]),results[2],"<code>genFizzBuzz("+JSON.stringify(tests[2][0])+","+tests[2][1]+")</code> should return <code>""+results[2]+""</code>.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[3][0])+&quot;,&quot;+tests[3][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[3]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[3][0],tests[3][1]),results[3],"<code>genFizzBuzz("+JSON.stringify(tests[3][0])+","+tests[3][1]+")</code> should return <code>""+results[3]+""</code>.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[4][0])+&quot;,&quot;+tests[4][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[4]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[4][0],tests[4][1]),results[4],"<code>genFizzBuzz("+JSON.stringify(tests[4][0])+","+tests[4][1]+")</code> should return <code>""+results[4]+""</code>.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[5][0])+&quot;,&quot;+tests[5][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[5]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[5][0],tests[5][1]),results[5],"<code>genFizzBuzz("+JSON.stringify(tests[5][0])+","+tests[5][1]+")</code> should return <code>""+results[5]+""</code>.");'
- text: <code>genFizzBuzz(&quot;+JSON.stringify(tests[6][0])+&quot;,&quot;+tests[6][1]+&quot;)</code> debe devolver <code>&quot;&quot;+results[6]+&quot;&quot;</code> .
testString: 'assert.equal(genFizzBuzz(tests[6][0],tests[6][1]),results[6],"<code>genFizzBuzz("+JSON.stringify(tests[6][0])+","+tests[6][1]+")</code> should return <code>""+results[6]+""</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function genFizzBuzz (rules, num) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function genFizzBuzz(rules, num) {
let res=";
rules.forEach(function (e) {
if(num % e[0] == 0)
res+=e[1];
})
if(res=="){
res=num.toString();
}
return res;
}
```
</section>

92
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/generate-lower-case-ascii-alphabet.spanish.md Normal file
View File

@@ -0,0 +1,92 @@
---
title: Generate lower case ASCII alphabet
id: 5a23c84252665b21eecc7e7a
localeTitle: 5a23c84252665b21eecc7e7a
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>lascii</code> debería ser una función.
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;
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;
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;
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;
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;
testString: 'assert.deepEqual(lascii("t","z"),results[4],"<code>lascii("t","z")</code> should return <code>[ "t", "u", "v", "w", "x", "y", "z" ]</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function lascii (cFrom, cTo) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function lascii(cFrom, cTo) {
function cRange(cFrom, cTo) {
var iStart = cFrom.charCodeAt(0);
return Array.apply(
null, Array(cTo.charCodeAt(0) - iStart + 1)
).map(function (_, i) {
return String.fromCharCode(iStart + i);
});
}
return cRange(cFrom, cTo);
}
```
</section>

107
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/generatorexponential.spanish.md Normal file
View File

@@ -0,0 +1,107 @@
---
title: GeneratorExponential
id: 5a23c84252665b21eecc7e7b
localeTitle: 5a23c84252665b21eecc7e7b
challengeType: 5
---
## Description
<section id='description'>
Un generador es una entidad ejecutable (como una función o procedimiento) que contiene código que produce una secuencia de valores, uno a la vez, de modo que cada vez que llama al generador, se proporciona el siguiente valor en la secuencia.
generadores a menudo se construyen sobre coroutines u objetos para que el estado interno del objeto se maneje &quot;naturalmente&quot;.
generadores a menudo se usan en situaciones donde una secuencia es potencialmente infinita, y donde es posible construir el siguiente valor de la secuencia con solo un estado mínimo.
Escribe una función que usa generadores para generar cuadrados y cubos. Crea un nuevo generador que filtre todos los cubos del generador de cuadrados.
La función debe devolver el valor \ (n ^ {th} \) del generador filtrado.
Por ejemplo, para \ (n = 7 \), la función debería devolver 81 ya que la secuencia sería 4,9,16,25,36,49,81. Aquí se filtra 64, ya que es un cubo.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>exponentialGenerator</code> debe ser una función.
testString: 'assert(typeof exponentialGenerator=="function","<code>exponentialGenerator</code> should be a function.");'
- text: <code>exponentialGenerator()</code> debe devolver un número.
testString: 'assert(typeof exponentialGenerator(10)=="number","<code>exponentialGenerator()</code> should return a number.");'
- text: <code>exponentialGenerator(10)</code> debe devolver <code>144</code> .
testString: 'assert.equal(exponentialGenerator(10),144,"<code>exponentialGenerator(10)</code> should return <code>144</code>.");'
- text: <code>exponentialGenerator(12)</code> debe devolver <code>196</code> .
testString: 'assert.equal(exponentialGenerator(12),196,"<code>exponentialGenerator(12)</code> should return <code>196</code>.");'
- text: <code>exponentialGenerator(14)</code> debe devolver <code>256</code> .
testString: 'assert.equal(exponentialGenerator(14),256,"<code>exponentialGenerator(14)</code> should return <code>256</code>.");'
- text: <code>exponentialGenerator(20)</code> debe devolver <code>484</code> .
testString: 'assert.equal(exponentialGenerator(20),484,"<code>exponentialGenerator(20)</code> should return <code>484</code>.");'
- text: <code>exponentialGenerator(25)</code> debe devolver <code>784</code> .
testString: 'assert.equal(exponentialGenerator(25),784,"<code>exponentialGenerator(25)</code> should return <code>784</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function exponentialGenerator (n) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function exponentialGenerator(n){
function* PowersGenerator(m) {
var n=0;
while(1) {
yield Math.pow(n, m);
n += 1;
}
}
function* FilteredGenerator(g, f){
var value = g.next().value;
var filter = f.next().value;
while(1) {
if( value < filter ) {
yield value;
value = g.next().value;
} else if ( value > filter ) {
filter = f.next().value;
} else {
value = g.next().value;
filter = f.next().value;
}
}
}
var squares = PowersGenerator(2);
var cubes = PowersGenerator(3);
var filtered = FilteredGenerator(squares, cubes);
var curr=0;
for(var i=0;i<n;i++) curr=filtered.next();
return curr.value;
}
```
</section>

89
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/gray-code.spanish.md Normal file
View File

@@ -0,0 +1,89 @@
---
title: Gray code
id: 5a23c84252665b21eecc7e80
localeTitle: 5a23c84252665b21eecc7e80
challengeType: 5
---
## Description
<section id='description'>
<a href="https://en.wikipedia.org/wiki/Gray code">El código gris</a> es una forma de codificación binaria donde las transiciones entre números consecutivos difieren solo en un bit.
Esta es una codificación útil para reducir riesgos de datos de hardware con valores que cambian rápidamente y / o se conectan a hardware más lento como entradas.
También es útil para generar entradas para los <a href="https://en.wikipedia.org/wiki/Karnaugh map">mapas de Karnaugh</a> en orden de izquierda a derecha o de arriba a abajo.
Cree una función para codificar un número y decodificar un número del código Gray. La función deberá tener 2 parámetros.
El primero sería un booleano. La función debe codificar para verdadero y decodificar para falso. El segundo parámetro sería el número a codificar / decodificar.
Muestre las representaciones binarias normales, las representaciones de código de Gray y los valores de código de Gray descodificados para todos los números binarios de 5 bits (0-31 inclusive, no es necesario llevar 0).
Hay muchos códigos grises posibles. Lo siguiente codifica lo que se llama &quot;código gris reflejado en binario&quot;. <br> Codificación (MSB es el bit 0, b es binario, g es el código gris):
<code><br> if b[i-1] = 1 <br> <span style="padding-left:1em">g[i] = not b[i]</span> <br> else <br> <span style="padding-left:1em">g[i] = b[i]</span> <br> <code>0</code></code> O <br> <code>g = b xor (b logically right shifted 1 time)</code> <br> Decodificación (MSB es el bit 0, b es binario, g es el código gris): <br>
<code>b[0] = g[0] <br> for other bits: <br> b[i] = g[i] xor b[i-1] <br></code>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>gray</code> debería ser una función.
testString: 'assert(typeof gray=="function","<code>gray</code> should be a function.");'
- text: <code>gray(true,177)</code> debe devolver un número.
testString: 'assert(typeof gray(true,177)=="number","<code>gray(true,177)</code> should return a number.");'
- text: <code>gray(true,177)</code> debe devolver <code>233</code> .
testString: 'assert.equal(gray(true,177),233,"<code>gray(true,177)</code> should return <code>233</code>.");'
- text: <code>gray(true,425)</code> debe devolver <code>381</code> .
testString: 'assert.equal(gray(true,425),381,"<code>gray(true,425)</code> should return <code>381</code>.");'
- text: <code>gray(true,870)</code> debe devolver <code>725</code> .
testString: 'assert.equal(gray(true,870),725,"<code>gray(true,870)</code> should return <code>725</code>.");'
- text: <code>gray(false,233)</code> debe devolver <code>177</code> .
testString: 'assert.equal(gray(false,233),177,"<code>gray(false,233)</code> should return <code>177</code>.");'
- text: <code>gray(false,381)</code> debe devolver <code>425</code> .
testString: 'assert.equal(gray(false,381),425,"<code>gray(false,381)</code> should return <code>425</code>.");'
- text: <code>gray(false,725)</code> debe devolver <code>870</code> .
testString: 'assert.equal(gray(false,725),870,"<code>gray(false,725)</code> should return <code>870</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function gray(enc, number) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function gray(enc, number){
if(enc){
return number ^ (number >> 1);
}else{
let n = number;
while (number >>= 1) {
n ^= number;
}
return n;
}
}
```
</section>

72
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/greatest-common-divisor.spanish.md Normal file
View File

@@ -0,0 +1,72 @@
---
title: Greatest common divisor
id: 5a23c84252665b21eecc7e82
localeTitle: 5a23c84252665b21eecc7e82
challengeType: 5
---
## Description
<section id='description'>
Escribe una función que devuelva el mayor divisor común de dos enteros.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>gcd</code> debería ser una función.
testString: 'assert(typeof gcd=="function","<code>gcd</code> should be a function.");'
- text: <code>gcd(24,36)</code> debe devolver un número.
testString: 'assert(typeof gcd(24,36)=="number","<code>gcd(24,36)</code> should return a number.");'
- text: <code>gcd(24,36)</code> debe devolver <code>12</code> .
testString: 'assert.equal(gcd(24,36),12,"<code>gcd(24,36)</code> should return <code>12</code>.");'
- text: <code>gcd(30,48)</code> debe devolver <code>6</code> .
testString: 'assert.equal(gcd(30,48),6,"<code>gcd(30,48)</code> should return <code>6</code>.");'
- text: <code>gcd(10,15)</code> debe devolver <code>5</code> .
testString: 'assert.equal(gcd(10,15),5,"<code>gcd(10,15)</code> should return <code>5</code>.");'
- text: <code>gcd(100,25)</code> debe devolver <code>25</code> .
testString: 'assert.equal(gcd(100,25),25,"<code>gcd(100,25)</code> should return <code>25</code>.");'
- text: <code>gcd(13,250)</code> debe devolver <code>1</code> .
testString: 'assert.equal(gcd(13,250),1,"<code>gcd(13,250)</code> should return <code>1</code>.");'
- text: <code>gcd(1300,250)</code> debe devolver <code>50</code> .
testString: 'assert.equal(gcd(1300,250),50,"<code>gcd(1300,250)</code> should return <code>50</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function gcd(a, b) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function gcd(a, b) {
return b==0 ? Math.abs(a):gcd(b, a % b);
}
```
</section>

105
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/greatest-subsequential-sum.spanish.md Normal file
View File

@@ -0,0 +1,105 @@
---
title: Greatest subsequential sum
id: 5a23c84252665b21eecc7e84
localeTitle: 5a23c84252665b21eecc7e84
challengeType: 5
---
## Description
<section id='description'>
Dada una secuencia de enteros, encuentre una subsecuencia continua que maximice la suma de sus elementos, es decir, los elementos de ninguna otra subsecuencia única suman un valor más grande que este.
Se considera que una subsecuencia vacía tiene la suma de \ (0 \); por lo tanto, si todos los elementos son negativos, el resultado debe ser la secuencia vacía.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>maximumSubsequence</code> debería ser una función.
testString: 'assert(typeof maximumSubsequence=="function","<code>maximumSubsequence</code> should be a function.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[0])+&quot;)</code> debe devolver una matriz.
testString: 'assert(Array.isArray(maximumSubsequence(tests[0])),"<code>maximumSubsequence("+JSON.stringify(tests[0])+")</code> should return an array.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[0])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[0])+&quot;</code> .
testString: 'assert.deepEqual(maximumSubsequence(tests[0]),results[0],"<code>maximumSubsequence("+JSON.stringify(tests[0])+")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[1])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[1])+&quot;</code> .
testString: 'assert.deepEqual(maximumSubsequence(tests[1]),results[1],"<code>maximumSubsequence("+JSON.stringify(tests[1])+")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[2])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[2])+&quot;</code> .
testString: 'assert.deepEqual(maximumSubsequence(tests[2]),results[2],"<code>maximumSubsequence("+JSON.stringify(tests[2])+")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[3])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[3])+&quot;</code> .
testString: 'assert.deepEqual(maximumSubsequence(tests[3]),results[3],"<code>maximumSubsequence("+JSON.stringify(tests[3])+")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[4])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[4])+&quot;</code> .
testString: 'assert.deepEqual(maximumSubsequence(tests[4]),results[4],"<code>maximumSubsequence("+JSON.stringify(tests[4])+")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
- text: <code>maximumSubsequence(&quot;+JSON.stringify(tests[5])+&quot;)</code> debe devolver <code>&quot;+JSON.stringify(results[5])+&quot;</code> .
testString: 'assert.deepEqual(maximumSubsequence(tests[5]),results[5],"<code>maximumSubsequence("+JSON.stringify(tests[5])+")</code> should return <code>"+JSON.stringify(results[5])+"</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function maximumSubsequence (population) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function maximumSubsequence(population) {
function sumValues(arr) {
var result = 0;
for (var i = 0, len = arr.length; i < len; i++) {
result += arr[i];
}
return result;
}
var greatest;
var maxValue = 0;
var subsequence = [];
for (var i = 0, len = population.length; i < len; i++) {
for (var j = i; j <= len; j++) {
var subsequence = population.slice(i, j);
var value = sumValues(subsequence);
if (value > maxValue) {
maxValue = value;
greatest = subsequence;
};
}
}
return greatest;
}
```
</section>

110
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hailstone-sequence.spanish.md Normal file
View File

@@ -0,0 +1,110 @@
---
title: Hailstone sequence
id: 595608ff8bcd7a50bd490181
localeTitle: 595608ff8bcd7a50bd490181
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
testString: 'assert.deepEqual(hailstoneSequence(), res, "<code>hailstoneSequence()</code> should return <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
// noprotect
function hailstoneSequence () {
const res = [];
// Good luck!
return res;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
function hailstoneSequence () {
const res = [];
function hailstone(n) {
const seq = [n];
while (n > 1) {
n = n % 2 ? 3 * n + 1 : n / 2;
seq.push(n);
}
return seq;
}
const h = hailstone(27);
const hLen = h.length;
res.push([...h.slice(0, 4), ...h.slice(hLen - 4, hLen)]);
let n = 0;
let max = 0;
for (let i = 100000; --i;) {
const seq = hailstone(i);
const sLen = seq.length;
if (sLen > max) {
n = i;
max = sLen;
}
}
res.push([max, n]);
return res;
}
```
</section>

98
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/happy-numbers.spanish.md Normal file
View File

@@ -0,0 +1,98 @@
---
title: Happy numbers
id: 594810f028c0303b75339ad1
localeTitle: 594810f028c0303b75339ad1
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>happy</code> es una función.
testString: 'assert(typeof happy === "function", "<code>happy</code> is a function.");'
- text: <code>happy(1)</code> debe devolver un booleano.
testString: 'assert(typeof happy(1) === "boolean", "<code>happy(1)</code> should return a boolean.");'
- text: <code>happy(1)</code> debe devolver verdadero.
testString: 'assert(happy(1), "<code>happy(1)</code> should return true.");'
- text: <code>happy(2)</code> debe devolver falso.
testString: 'assert(!happy(2), "<code>happy(2)</code> should return false.");'
- text: <code>happy(7)</code> debe devolver verdadero.
testString: 'assert(happy(7), "<code>happy(7)</code> should return true.");'
- text: <code>happy(10)</code> debe devolver verdadero.
testString: 'assert(happy(10), "<code>happy(10)</code> should return true.");'
- text: <code>happy(13)</code> debe devolver el verdadero.
testString: 'assert(happy(13), "<code>happy(13)</code> should return true.");'
- text: <code>happy(19)</code> debe devolver el verdadero.
testString: 'assert(happy(19), "<code>happy(19)</code> should return true.");'
- text: <code>happy(23)</code> debe devolver verdadero.
testString: 'assert(happy(23), "<code>happy(23)</code> should return true.");'
- text: <code>happy(28)</code> debe devolver verdadero.
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;
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.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function happy (number) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function happy (number) {
let m;
let digit;
const cycle = [];
while (number !== 1 && cycle[number] !== true) {
cycle[number] = true;
m = 0;
while (number > 0) {
digit = number % 10;
m += Math.pow(digit, 2);
number = (number - digit) / 10;
}
number = m;
}
return (number === 1);
}
```
</section>

107
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/harshad-or-niven-series.spanish.md Normal file
View File

@@ -0,0 +1,107 @@
---
title: Harshad or Niven series
id: 595668ca4cfe1af2fb9818d4
localeTitle: 595668ca4cfe1af2fb9818d4
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function isHarshadOrNiven () {
const res = {
firstTwenty: [],
firstOver1000: undefined
};
// Change after this line
return res;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function isHarshadOrNiven() {
const res = {
firstTwenty: [],
firstOver1000: undefined
};
function isHarshad(n) {
let s = 0;
const nStr = n.toString();
for (let i = 0; i < nStr.length; ++i) {
s += parseInt(nStr.charAt(i), 10);
}
return n % s === 0;
}
let count = 0;
const harshads = [];
for (let n = 1; count < 20; ++n) {
if (isHarshad(n)) {
count++;
harshads.push(n);
}
}
res.firstTwenty = harshads;
let h = 1000;
while (!isHarshad(++h));
res.firstOver1000 = h;
return res;
}
```
</section>

84
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-from-two-arrays.spanish.md Normal file
View File

@@ -0,0 +1,84 @@
---
title: Hash from two arrays
id: 595671d4d2cdc305f0d5b36f
localeTitle: 595671d4d2cdc305f0d5b36f
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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>
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;
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;
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function arrToObj (keys, vals) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function arrToObj (keys, vals) {
return keys.reduce((map, key, index) => {
map[key] = vals[index];
return map;
}, {});
}
```
</section>

250
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hash-join.spanish.md Normal file
View File

@@ -0,0 +1,250 @@
---
title: Hash join
id: 5956795bc9e2c415eb244de1
localeTitle: 5956795bc9e2c415eb244de1
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function hashJoin (hash1, hash2) {
// Good luck!
return [];
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function hashJoin (hash1, hash2) {
const hJoin = (tblA, tblB, strJoin) => {
const [jA, jB] = strJoin.split('=');
const M = tblB.reduce((a, x) => {
const id = x[jB];
return (
a[id] ? a[id].push(x) : (a[id] = [x]),
a
);
}, {});
return tblA.reduce((a, x) => {
const match = M[x[jA]];
return match ? (
a.concat(match.map(row => dictConcat(x, row)))
) : a;
}, []);
};
const dictConcat = (dctA, dctB) => {
const ok = Object.keys;
return ok(dctB).reduce(
(a, k) => (a[`B_${k}`] = dctB[k]) && a,
ok(dctA).reduce(
(a, k) => (a[`A_${k}`] = dctA[k]) && a, {}
)
);
};
return hJoin(hash1, hash2, 'name=character');
}
```
</section>

141
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/heronian-triangles.spanish.md Normal file
View File

@@ -0,0 +1,141 @@
---
title: Heronian triangles
id: 595b98f8b5a2245e243aa831
localeTitle: 595b98f8b5a2245e243aa831
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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>
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;
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;
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>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
// noprotect
function heronianTriangle (n) {
// Good luck!
return [];
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
function heronianTriangle (n) {
const list = [];
const result = [];
let j = 0;
for (let c = 1; c <= 200; c++) {
for (let b = 1; b <= c; b++) {
for (let a = 1; a <= b; a++) {
if (gcd(gcd(a, b), c) === 1 && isHeron(heronArea(a, b, c))) {
list[j++] = new Array(a, b, c, heronArea(a, b, c));
}
}
}
}
sort(list);
for (let i = 0; i < n; i++) {
result[i] = [list[i][0], list[i][1], list[i][2]];
}
return result;
function heronArea(a, b, c) {
const s = (a + b + c) / 2;
return Math.sqrt(s * (s - a) * (s - b) * (s - c));
}
function isHeron(h) { return h % 1 === 0 && h > 0; }
function gcd(a, b) {
let leftover = 1;
let dividend = a > b ? a : b;
let divisor = a > b ? b : a;
while (leftover !== 0) {
leftover = dividend % divisor;
if (leftover > 0) {
dividend = divisor;
divisor = leftover;
}
}
return divisor;
}
function sort(arg) {
let swapped = true;
let temp = [];
while (swapped) {
swapped = false;
for (let i = 1; i < arg.length; i++) {
if (arg[i][4] < arg[i - 1][4] || arg[i][4] === arg[i - 1][4] && arg[i][3] < arg[i - 1][3]) {
temp = arg[i];
arg[i] = arg[i - 1];
arg[i - 1] = temp;
swapped = true;
}
}
}
}
}
```
</section>

128
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hofstadter-figure-figure-sequences.spanish.md Normal file
View File

@@ -0,0 +1,128 @@
---
title: Hofstadter Figure-Figure sequences
id: 59622f89e4e137560018a40e
localeTitle: 59622f89e4e137560018a40e
challengeType: 5
---
## Description
<section id='description'>
<p> Estas dos secuencias de enteros positivos se definen como: </p>
<p> <big>$ R (1) = 1 \; \ S (1) = 2 \\ R (n) = R (n-1) + S (n-1), \ quad n&gt; 1. $</big> </p>
<p> La secuencia <big>$ S (n) $</big> se define además como la secuencia de enteros positivos que no están presentes en <big>$ R (n) $</big> . </p><p> Secuencia <big>$ R $</big> comienza: </p>
<p> 1, 3, 7, 12, 18, ... </p>
<p> Secuencia <big>$ S $</big> comienza: </p>
<p> 2, 4, 5, 6, 8, ... </p>
Tarea:
Crea dos funciones denominadas ffr y ffs que cuando se dan n devuelven R (n) o S (n) respectivamente. (Ten en cuenta que R (1) = 1 y S (1) = 2 para evitar el apagado por uno errores).
No se debe asumir ningún valor máximo para n.
<a href="http://oeis.org/A005228" title="enlace: http://oeis.org/A005228">A005228</a> y <a href="http://oeis.org/A030124" title="enlace: http://oeis.org/A030124">A030124 de Sloane</a> .
<a href="http://mathworld.wolfram.com/HofstadterFigure-FigureSequence.html" title="enlace: http://mathworld.wolfram.com/HofstadterFigure-FigureSequence.html">Wolfram MathWorld</a>
Wikipedia: <a href="https://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Figure-Figure_sequences" title="wp: Hofstadter_sequence # Hofstadter_Figure-Figure_sequences">Hofstadter Figura-Figura secuencias</a> .
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>ffr</code> es una función.
testString: 'assert(typeof ffr === "function", "<code>ffr</code> is a function.");'
- text: <code>ffs</code> es una función.
testString: 'assert(typeof ffs === "function", "<code>ffs</code> is a function.");'
- text: <code>ffr</code> debería devolver entero.
testString: 'assert(Number.isInteger(ffr(1)), "<code>ffr</code> should return integer.");'
- text: <code>ffs</code> debe devolver entero.
testString: 'assert(Number.isInteger(ffs(1)), "<code>ffs</code> should return integer.");'
- text: <code>ffr()</code> debe devolver <code>69</code>
testString: 'assert.equal(ffr(ffrParamRes[0][0]), ffrParamRes[0][1], "<code>ffr()</code> should return <code>69</code>");'
- text: <code>ffr()</code> debe devolver <code>1509</code>
testString: 'assert.equal(ffr(ffrParamRes[1][0]), ffrParamRes[1][1], "<code>ffr()</code> should return <code>1509</code>");'
- text: <code>ffr()</code> debe devolver <code>5764</code>
testString: 'assert.equal(ffr(ffrParamRes[2][0]), ffrParamRes[2][1], "<code>ffr()</code> should return <code>5764</code>");'
- text: <code>ffr()</code> debe devolver <code>526334</code>
testString: 'assert.equal(ffr(ffrParamRes[3][0]), ffrParamRes[3][1], "<code>ffr()</code> should return <code>526334</code>");'
- text: <code>ffs()</code> debe devolver <code>14</code>
testString: 'assert.equal(ffs(ffsParamRes[0][0]), ffsParamRes[0][1], "<code>ffs()</code> should return <code>14</code>");'
- text: <code>ffs()</code> debe devolver <code>59</code>
testString: 'assert.equal(ffs(ffsParamRes[1][0]), ffsParamRes[1][1], "<code>ffs()</code> should return <code>59</code>");'
- text: <code>ffs()</code> debe devolver <code>112</code>
testString: 'assert.equal(ffs(ffsParamRes[2][0]), ffsParamRes[2][1], "<code>ffs()</code> should return <code>112</code>");'
- text: <code>ffs()</code> debe devolver <code>1041</code>
testString: 'assert.equal(ffs(ffsParamRes[3][0]), ffsParamRes[3][1], "<code>ffs()</code> should return <code>1041</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
// noprotect
function ffr(n) {
return n;
}
function ffs(n) {
return n;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
const R = [null, 1];
const S = [null, 2];
function extendSequences (n) {
let current = Math.max(R[R.length - 1], S[S.length - 1]);
let i;
while (R.length <= n || S.length <= n) {
i = Math.min(R.length, S.length) - 1;
current += 1;
if (current === R[i] + S[i]) {
R.push(current);
} else {
S.push(current);
}
}
}
function ffr (n) {
extendSequences(n);
return R[n];
}
function ffs (n) {
extendSequences(n);
return S[n];
}
```
</section>

90
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/hofstadter-q-sequence.spanish.md Normal file
View File

@@ -0,0 +1,90 @@
---
title: Hofstadter Q sequence
id: 59637c4d89f6786115efd814
localeTitle: 59637c4d89f6786115efd814
challengeType: 5
---
## Description
<section id='description'>
<p> La <a href="https://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Q_sequence" title="wp: Hofstadter_sequence # Hofstadter_Q_sequence">secuencia de Hofstadter Q</a> se define como: </p>
<p> $ Q (1) = Q (2) = 1, \\ Q (n) = Q \ big (nQ (n-1) \ big) + Q \ big (nQ (n-2)), \ quad n&gt; 2. $ </p>
<p> Se define como la <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="secuencia Fibonacci">secuencia de Fibonacci</a> , pero mientras que el siguiente término en la secuencia de Fibonacci es la suma de los dos términos anteriores, en la secuencia Q los dos términos anteriores le dicen a qué distancia retroceder en la secuencia Q para encontrar los dos números Para sumar hacer el siguiente término de la secuencia. </p>
Tarea:
Implementar la ecuación de secuencia Q de Hofstadter en JavaScript
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>hofstadterQ</code> es una función.
testString: 'assert(typeof hofstadterQ === "function", "<code>hofstadterQ</code> is a function.");'
- text: <code>hofstadterQ()</code> debe devolver un <code>integer</code>
testString: 'assert(Number.isInteger(hofstadterQ(1000)), "<code>hofstadterQ()</code> should return <code>integer</code>");'
- text: <code>hofstadterQ(1000)</code> debe devolver <code>502</code>
testString: 'assert.equal(hofstadterQ(testCase[0]), res[0], "<code>hofstadterQ(1000)</code> should return <code>502</code>");'
- text: <code>hofstadterQ(1500)</code> debe devolver <code>755</code>
testString: 'assert.equal(hofstadterQ(testCase[1]), res[1], "<code>hofstadterQ(1500)</code> should return <code>755</code>");'
- text: <code>hofstadterQ(2000)</code> debe devolver <code>1005</code>
testString: 'assert.equal(hofstadterQ(testCase[2]), res[2], "<code>hofstadterQ(2000)</code> should return <code>1005</code>");'
- text: <code>hofstadterQ(2500)</code> debe devolver <code>1261</code>
testString: 'assert.equal(hofstadterQ(testCase[3]), res[3], "<code>hofstadterQ(2500)</code> should return <code>1261</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function hofstadterQ (n) {
// Good luck!
return n;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function hofstadterQ (n) {
const memo = [1, 1, 1];
const Q = function (i) {
let result = memo[i];
if (typeof result !== 'number') {
result = Q(i - Q(i - 1)) + Q(i - Q(i - 2));
memo[i] = result;
}
return result;
};
return Q(n);
}
```
</section>

81
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/i-before-e-except-after-c.spanish.md Normal file
View File

@@ -0,0 +1,81 @@
---
title: I before E except after C
id: 5a23c84252665b21eecc7eb0
localeTitle: 5a23c84252665b21eecc7eb0
challengeType: 5
---
## Description
<section id='description'>
La frase <a href="https://en.wikipedia.org/wiki/I before E except after C">&quot;I antes de E, excepto después de C&quot;</a> es una mnemotécnica muy conocida que se supone que ayuda cuando se deletrean palabras en inglés.
Usando las palabras proporcionadas, verifique si las dos sub-cláusulas de la frase son plausibles individualmente:
<ol><li style='margin-bottom: 5px;'> <i>&quot;I antes de E cuando no está precedido por C&quot;.</i> </li><li> <i>&quot;E antes que yo cuando está precedido por C&quot;.</i> </li></ol>
Si ambas subfrases son plausibles, entonces se puede decir que la frase original es plausible.
Escriba una función que acepte una palabra y verifique si la palabra sigue esta regla. La función debería devolver verdadero si sigue la regla de lo contrario falso.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>IBeforeExceptC</code> debería ser una función.
testString: 'assert(typeof IBeforeExceptC=="function","<code>IBeforeExceptC</code> should be a function.");'
- text: <code>IBeforeExceptC(&quot;receive&quot;)</code> debe devolver un valor booleano.
testString: 'assert(typeof IBeforeExceptC("receive")=="boolean","<code>IBeforeExceptC("receive")</code> should return a boolean.");'
- text: <code>IBeforeExceptC(&quot;receive&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(IBeforeExceptC("receive"),true,"<code>IBeforeExceptC("receive")</code> should return <code>true</code>.");'
- text: <code>IBeforeExceptC(&quot;science&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(IBeforeExceptC("science"),false,"<code>IBeforeExceptC("science")</code> should return <code>false</code>.");'
- text: <code>IBeforeExceptC(&quot;imperceivable&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(IBeforeExceptC("imperceivable"),true,"<code>IBeforeExceptC("imperceivable")</code> should return <code>true</code>.");'
- text: <code>IBeforeExceptC(&quot;inconceivable&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(IBeforeExceptC("inconceivable"),true,"<code>IBeforeExceptC("inconceivable")</code> should return <code>true</code>.");'
- text: <code>IBeforeExceptC(&quot;insufficient&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(IBeforeExceptC("insufficient"),false,"<code>IBeforeExceptC("insufficient")</code> should return <code>false</code>.");'
- text: <code>IBeforeExceptC(&quot;omniscient&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(IBeforeExceptC("omniscient"),false,"<code>IBeforeExceptC("omniscient")</code> should return <code>false</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function IBeforeExceptC (word) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function IBeforeExceptC (word)
{
if(word.indexOf("c")==-1 && word.indexOf("ie")!=-1)
return true;
else if(word.indexOf("cei")!=-1)
return true;
return false;
}
```
</section>

103
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/iban.spanish.md Normal file
View File

@@ -0,0 +1,103 @@
---
title: IBAN
id: 5a23c84252665b21eecc7eaf
localeTitle: 5a23c84252665b21eecc7eaf
challengeType: 5
---
## Description
<section id='description'>
El <a href="https://en.wikipedia.org/wiki/International_Bank_Account_Number">Número de cuenta bancaria internacional (IBAN)</a> es un medio acordado internacionalmente para identificar cuentas bancarias a través de las fronteras nacionales con un riesgo reducido de propagar <a href="https://en.wikipedia.org/wiki/Transcription_error">errores de transcripción</a> .
El IBAN consta de hasta 34 caracteres alfanuméricos:
<ul>
<li> Primero, el código de país de dos letras ISO 3166-1 alfa-2. </li>
<li> luego dos dígitos de control, y </li>
<li> finalmente, un número de cuenta bancaria básica (BBAN) específico del país. </li>
</ul>
Los dígitos de verificación permiten una verificación de validez del número de cuenta bancaria para confirmar su integridad incluso antes de enviar una transacción.
Escribir una función que toma la cadena IBAN como parámetro. Si es válido devuelve verdadero. De lo contrario, devuelve falso.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>isValid</code> debería ser una función.
testString: 'assert(typeof isValid=="function","<code>isValid</code> should be a function.");'
- text: <code>isValid(&quot;&quot;+tests[0]+&quot;&quot;)</code> debe devolver un valor booleano.
testString: 'assert(typeof isValid(tests[0])=="boolean","<code>isValid(""+tests[0]+"")</code> should return a boolean.");'
- text: <code>isValid(&quot;&quot;+tests[0]+&quot;&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(isValid(tests[0]),true,"<code>isValid(""+tests[0]+"")</code> should return <code>true</code>.");'
- text: <code>isValid(&quot;&quot;+tests[1]+&quot;&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(isValid(tests[1]),false,"<code>isValid(""+tests[1]+"")</code> should return <code>false</code>.");'
- text: <code>isValid(&quot;&quot;+tests[2]+&quot;&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(isValid(tests[2]),false,"<code>isValid(""+tests[2]+"")</code> should return <code>false</code>.");'
- text: <code>isValid(&quot;&quot;+tests[3]+&quot;&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(isValid(tests[3]),false,"<code>isValid(""+tests[3]+"")</code> should return <code>false</code>.");'
- text: <code>isValid(&quot;&quot;+tests[4]+&quot;&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(isValid(tests[4]),true,"<code>isValid(""+tests[4]+"")</code> should return <code>true</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function isValid (iban) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function isValid (iban) {
var ibanLen = {
NO:15, BE:16, DK:18, FI:18, FO:18, GL:18, NL:18, MK:19,
SI:19, AT:20, BA:20, EE:20, KZ:20, LT:20, LU:20, CR:21,
CH:21, HR:21, LI:21, LV:21, BG:22, BH:22, DE:22, GB:22,
GE:22, IE:22, ME:22, RS:22, AE:23, GI:23, IL:23, AD:24,
CZ:24, ES:24, MD:24, PK:24, RO:24, SA:24, SE:24, SK:24,
VG:24, TN:24, PT:25, IS:26, TR:26, FR:27, GR:27, IT:27,
MC:27, MR:27, SM:27, AL:28, AZ:28, CY:28, DO:28, GT:28,
HU:28, LB:28, PL:28, BR:29, PS:29, KW:30, MU:30, MT:31
}
iban = iban.replace(/\s/g, ")
if (!iban.match(/^[\dA-Z]+$/)) return false
var len = iban.length
if (len != ibanLen[iban.substr(0,2)]) return false
iban = iban.substr(4) + iban.substr(0,4)
for (var s=", i=0; i<len; i+=1) s+=parseInt(iban.charAt(i),36)
for (var m=s.substr(0,15)%97, s=s.substr(15); s; s=s.substr(13)) m=(m+s.substr(0,13))%97
return m == 1
}
```
</section>

84
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/identity-matrix.spanish.md Normal file
View File

@@ -0,0 +1,84 @@
---
title: Identity matrix
id: 5a23c84252665b21eecc7eb1
localeTitle: 5a23c84252665b21eecc7eb1
challengeType: 5
---
## Description
<section id='description'>
Una <i>matriz de identidad</i> es una matriz cuadrada de tamaño \ (n \ veces n \),
donde los elementos diagonales son todos <b>1</b> s (unos),
y todos los demás elementos son todos <b>0</b> s (ceros).
\ begin {bmatrix} 1 &amp; 0 &amp; 0 \ cr 0 &amp; 1 &amp; 0 \ cr 0 &amp; 0 &amp; 1 \ cr \ end {bmatrix}
Escribe una función que toma un número &#39;n&#39; como parámetro y devuelve la identidad matriz de orden nx n.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>idMatrix</code> debería ser una función.
testString: 'assert(typeof idMatrix=="function","<code>idMatrix</code> should be a function.");'
- text: <code>idMatrix(1)</code> debería devolver una matriz.
testString: 'assert(Array.isArray(idMatrix(1)),"<code>idMatrix(1)</code> should return an array.");'
- text: <code>idMatrix(1)</code> debe devolver <code>&quot;+JSON.stringify(results[0])+&quot;</code> .
testString: 'assert.deepEqual(idMatrix(1),results[0],"<code>idMatrix(1)</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
- text: <code>idMatrix(2)</code> debe devolver <code>&quot;+JSON.stringify(results[1])+&quot;</code> .
testString: 'assert.deepEqual(idMatrix(2),results[1],"<code>idMatrix(2)</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
- text: <code>idMatrix(3)</code> debe devolver <code>&quot;+JSON.stringify(results[2])+&quot;</code> .
testString: 'assert.deepEqual(idMatrix(3),results[2],"<code>idMatrix(3)</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
- text: <code>idMatrix(4)</code> debe devolver <code>&quot;+JSON.stringify(results[3])+&quot;</code> .
testString: 'assert.deepEqual(idMatrix(4),results[3],"<code>idMatrix(4)</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function idMatrix (n) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function idMatrix (n) {
return Array.apply(null, new Array(n)).map(function (x, i, xs) {
return xs.map(function (_, k) {
return i === k ? 1 : 0;
})
});
}
```
</section>

84
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/iterated-digits-squaring.spanish.md Normal file
View File

@@ -0,0 +1,84 @@
---
title: Iterated digits squaring
id: 5a23c84252665b21eecc7ec1
localeTitle: 5a23c84252665b21eecc7ec1
challengeType: 5
---
## Description
<section id='description'>
Si agrega el cuadrado de los dígitos de un número natural (un entero más grande que cero), siempre termina con 1 o 89:
<pre> 15 -&gt; 26 -&gt; 40 -&gt; 16 -&gt; 37 -&gt; 58 -&gt; 89
7 -&gt; 49 -&gt; 97 -&gt; 130 -&gt; 10 -&gt; 1 </pre>
Escriba una función que tome un número como parámetro y devuelva 1 u 89 después de realizar el proceso mencionado.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>iteratedSquare</code> debería ser una función.
testString: 'assert(typeof iteratedSquare=="function","<code>iteratedSquare</code> should be a function.");'
- text: <code>iteratedSquare(4)</code> debe devolver un número.
testString: 'assert(typeof iteratedSquare(4)=="number","<code>iteratedSquare(4)</code> should return a number.");'
- text: <code>iteratedSquare(4)</code> debe devolver <code>89</code> .
testString: 'assert.equal(iteratedSquare(4),89,"<code>iteratedSquare(4)</code> should return <code>89</code>.");'
- text: <code>iteratedSquare(7)</code> debe devolver <code>1</code> .
testString: 'assert.equal(iteratedSquare(7),1,"<code>iteratedSquare(7)</code> should return <code>1</code>.");'
- text: <code>iteratedSquare(15)</code> debe devolver <code>89</code> .
testString: 'assert.equal(iteratedSquare(15),89,"<code>iteratedSquare(15)</code> should return <code>89</code>.");'
- text: <code>iteratedSquare(20)</code> debe devolver <code>89</code> .
testString: 'assert.equal(iteratedSquare(20),89,"<code>iteratedSquare(20)</code> should return <code>89</code>.");'
- text: <code>iteratedSquare(70)</code> debe devolver <code>1</code> .
testString: 'assert.equal(iteratedSquare(70),1,"<code>iteratedSquare(70)</code> should return <code>1</code>.");'
- text: <code>iteratedSquare(100)</code> debe devolver <code>1</code> .
testString: 'assert.equal(iteratedSquare(100),1,"<code>iteratedSquare(100)</code> should return <code>1</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function iteratedSquare (n) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function iteratedSquare (n) {
var total;
while (n != 89 && n != 1) {
total = 0;
while (n > 0) {
total += Math.pow(n % 10, 2);
n = Math.floor(n/10);
}
n = total;
}
return n;
}
```
</section>

126
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/jaro-distance.spanish.md Normal file
View File

@@ -0,0 +1,126 @@
---
title: Jaro distance
id: 5a23c84252665b21eecc7ec2
localeTitle: 5a23c84252665b21eecc7ec2
challengeType: 5
---
## Description
<section id='description'>
La distancia de Jaro es una medida de similitud entre dos cadenas. Cuanto mayor es la distancia de Jaro para dos cuerdas, más similares son las cuerdas. La puntuación se normaliza de modo que <b>0</b> equivale a ninguna similitud y <b>1</b> es una coincidencia exacta. Definición La distancia Jaro \ (d_j \) de dos cadenas dadas \ (s_1 \) y \ (s_2 \) es
\ begin {align} d_j = \ begin {cases} 0 &amp; &amp; \ text {if} m = 0 \\ \\ {\ frac {1} {3}} \ left ({\ frac {m} {| s_ {1}}}} + {\ frac {m} {| s_ {2} |}} + {\ frac {mt} {m}} \ right) &amp; &amp; \ text {de lo contrario} \ end {cases} \ end {align}
Donde: <ul><li> \ (m \) es el número de <i>caracteres coincidentes</i> ; </li><li> \ (t \) es la mitad del número de <i>transposiciones</i> . </li></uL>
Dos caracteres de \ (s_1 \) y \ (s_2 \) respectivamente, se consideran <i>coincidentes</i> solo si son iguales y no están más lejos que \ (\ left \ lfloor \ frac {\ max (| s_1 |, | s_2 |) } {2} \ right \ rfloor-1 \).
Cada carácter de \ (s_1 \) se compara con todos sus caracteres coincidentes en \ (s_2 \). El número de caracteres coincidentes (pero orden de secuencia diferente) dividido por 2 define el número de <i>transposiciones</i> .
<b>Ejemplo</b>
Dadas las cadenas \ (s_1 \) <i>DWAYNE</i> y \ (s_2 \) <i>DUANE</i> encontramos:
<ul><li> \ (m = 4 \) </li><li> \ (| s_1 | = 6 \) </li><li> \ (| s_2 | = 5 \) </li><li> \ (t = 0 \) </li></ul>
Encontramos una puntuación Jaro de: \ (d_j = \ frac {1} {3} \ left (\ frac {4} {6} + \ frac {4} {5} + \ frac {4-0} {4 } \ right) = 0.822 \).
Escriba una función a que tome dos cadenas como parámetros y devuelva la distancia Jaro asociada.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>jaro</code> debería ser una función.
testString: 'assert(typeof jaro=="function","<code>jaro</code> should be a function.");'
- text: <code>jaro(&quot;&quot;+tests[0][0]+&quot;&quot;,&quot;&quot;+tests[0][1]+&quot;&quot;)</code> debe devolver un número.
testString: 'assert(typeof jaro(tests[0][0],tests[0][1])=="number","<code>jaro()</code> should return a number.");'
- text: <code>jaro(&quot;&quot;+tests[0][0]+&quot;&quot;,&quot;&quot;+tests[0][1]+&quot;&quot;)</code> debe devolver <code>&quot;+results[0]+&quot;</code> .
testString: 'assert.equal(jaro(tests[0][0],tests[0][1]),results[0],"<code>jaro(""+tests[0][0]+"",""+tests[0][1]+"")</code> should return <code>"+results[0]+"</code>.");'
- text: <code>jaro(&quot;&quot;+tests[1][0]+&quot;&quot;,&quot;&quot;+tests[1][1]+&quot;&quot;)</code> debe devolver <code>&quot;+results[1]+&quot;</code> .
testString: 'assert.equal(jaro(tests[1][0],tests[1][1]),results[1],"<code>jaro(""+tests[1][0]+"",""+tests[1][1]+"")</code> should return <code>"+results[1]+"</code>.");'
- text: <code>jaro(&quot;&quot;+tests[2][0]+&quot;&quot;,&quot;&quot;+tests[2][1]+&quot;&quot;)</code> debe devolver <code>&quot;+results[2]+&quot;</code> .
testString: 'assert.equal(jaro(tests[2][0],tests[2][1]),results[2],"<code>jaro(""+tests[2][0]+"",""+tests[2][1]+"")</code> should return <code>"+results[2]+"</code>.");'
- text: <code>jaro(&quot;&quot;+tests[3][0]+&quot;&quot;,&quot;&quot;+tests[3][1]+&quot;&quot;)</code> debe devolver <code>&quot;+results[3]+&quot;</code> .
testString: 'assert.equal(jaro(tests[3][0],tests[3][1]),results[3],"<code>jaro(""+tests[3][0]+"",""+tests[3][1]+"")</code> should return <code>"+results[3]+"</code>.");'
- text: <code>jaro(&quot;&quot;+tests[4][0]+&quot;&quot;,&quot;&quot;+tests[4][1]+&quot;&quot;)</code> debe devolver <code>&quot;+results[4]+&quot;</code> .
testString: 'assert.equal(jaro(tests[4][0],tests[4][1]),results[4],"<code>jaro(""+tests[4][0]+"",""+tests[4][1]+"")</code> should return <code>"+results[4]+"</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function jaro (s, t) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function jaro (s, t) {
var s_len = s.length;
var t_len = t.length;
if (s_len == 0 && t_len == 0) return 1;
var match_distance = Math.max(s_len, t_len) / 2 - 1;
var s_matches = new Array(s_len);
var t_matches = new Array(t_len);
var matches = 0;
var transpositions = 0;
for (var i = 0; i < s_len; i++) {
var start = Math.max(0, i - match_distance);
var end = Math.min(i + match_distance + 1, t_len);
for (var j = start; j < end; j++) {
if (t_matches[j]) continue;
if (s.charAt(i) != t.charAt(j)) continue;
s_matches[i] = true;
t_matches[j] = true;
matches++;
break;
}
}
if (matches == 0) return 0;
var k = 0;
for (var i = 0; i < s_len; i++) {
if (!s_matches[i]) continue;
while (!t_matches[k]) k++;
if (s.charAt(i) != t.charAt(k)) transpositions++;
k++;
}
return ((matches / s_len) +
(matches / t_len) +
((matches - transpositions / 2.0) / matches)) / 3.0;
}
```
</section>

90
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/jortsort.spanish.md Normal file
View File

@@ -0,0 +1,90 @@
---
title: JortSort
id: 5a23c84252665b21eecc7ec4
localeTitle: 5a23c84252665b21eecc7ec4
challengeType: 5
---
## Description
<section id='description'>
jortSort es un conjunto de herramientas de clasificación que hace que el usuario haga el trabajo y garantiza la eficiencia porque no tiene que ordenar nunca más. Originalmente fue presentado por Jenn &quot;Moneydollars&quot; Schiffer en el prestigioso <a href="https://www.youtube.com/watch?v=pj4U_W0OFoE">JSConf</a> .
jortSort es una función que toma una matriz única de objetos comparables como su argumento. A continuación, ordena la matriz en orden ascendente y compara la matriz ordenada con la matriz originalmente proporcionada. Si las matrices coinciden (es decir, la matriz original ya estaba ordenada), la función devuelve verdadero. Si las matrices no coinciden (es decir, la matriz original no se ordenó), la función devuelve falso.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>jortsort</code> debería ser una función.
testString: 'assert(typeof jortsort=="function","<code>jortsort</code> should be a function.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[0])+&quot;)</code> debe devolver un valor booleano.
testString: 'assert(typeof jortsort(tests[0].slice())=="boolean","<code>jortsort("+JSON.stringify(tests[0])+")</code> should return a boolean.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[0])+&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(jortsort(tests[0].slice()),true,"<code>jortsort("+JSON.stringify(tests[0])+")</code> should return <code>true</code>.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[1])+&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(jortsort(tests[1].slice()),false,"<code>jortsort("+JSON.stringify(tests[1])+")</code> should return <code>false</code>.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[2])+&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(jortsort(tests[2].slice()),false,"<code>jortsort("+JSON.stringify(tests[2])+")</code> should return <code>false</code>.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[3])+&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(jortsort(tests[3].slice()),true,"<code>jortsort("+JSON.stringify(tests[3])+")</code> should return <code>true</code>.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[4])+&quot;)</code> debe devolver <code>false</code> .
testString: 'assert.equal(jortsort(tests[4].slice()),false,"<code>jortsort("+JSON.stringify(tests[4])+")</code> should return <code>false</code>.");'
- text: <code>jortsort(&quot;+JSON.stringify(tests[5])+&quot;)</code> debe devolver <code>true</code> .
testString: 'assert.equal(jortsort(tests[5].slice()),true,"<code>jortsort("+JSON.stringify(tests[5])+")</code> should return <code>true</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function jortsort (array) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function jortsort (array) {
// sort the array
var originalArray = array.slice(0);
array.sort( function(a,b){return a - b} );
// compare to see if it was originally sorted
for (var i = 0; i < originalArray.length; ++i) {
if (originalArray[i] !== array[i]) return false;
}
return true;
};
```
</section>

109
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/josephus-problem.spanish.md Normal file
View File

@@ -0,0 +1,109 @@
---
title: Josephus problem
id: 5a23c84252665b21eecc7ec5
localeTitle: 5a23c84252665b21eecc7ec5
challengeType: 5
---
## Description
<section id='description'>
<a href="https://en.wikipedia.org/wiki/Josephus problem">problema de Josephus</a> es un rompecabezas matemático con una sombría descripción: $ n $ los prisioneros están parados en un círculo, numerados secuencialmente de $ 0 $ a $ n-1 $.
Un verdugo camina a lo largo del círculo, comenzando desde el prisionero $ 0 $, sacando a cada $ k $ -th prisionero y matándolo.
A medida que avanza el proceso, el círculo se hace cada vez más pequeño, hasta que solo queda un prisionero, quien es liberado.
Por ejemplo, si hay $ n = 5 $ prisioneros y $ k = 2 $, el orden en que se mata a los prisioneros (llamémoslo la &quot;secuencia de matanza&quot;) será 1, 3, 0 y 4, y el El sobreviviente será el # 2.
Dado cualquier <big>$ n, k&gt; 0 $</big> , averigüe qué prisionero será el sobreviviente final.
En uno de esos incidentes, hubo 41 prisioneros y cada <sup>3º</sup> prisionero fue asesinado ( <big>$ k = 3 $</big> ).
Entre ellos era un nombre cap inteligente Josefo que trabajaba en el problema, se situó en la posición de sobrevivir, y vivían en para contarlo.
¿Qué número fue?
Escriba una función que tome el número inicial de prisioneros y &#39;k&#39; como parámetro y devuelva el número del prisionero que sobrevive.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>josephus</code> debería ser una función.
testString: 'assert(typeof josephus=="function","<code>josephus</code> should be a function.");'
- text: <code>josephus(30,3)</code> debe devolver un número.
testString: 'assert(typeof josephus(30,3)=="number","<code>josephus(30,3)</code> should return a number.");'
- text: <code>josephus(30,3)</code> debe devolver <code>29</code> .
testString: 'assert.equal(josephus(30,3),29,"<code>josephus(30,3)</code> should return <code>29</code>.");'
- text: <code>josephus(30,5)</code> debe devolver <code>3</code> .
testString: 'assert.equal(josephus(30,5),3,"<code>josephus(30,5)</code> should return <code>3</code>.");'
- text: <code>josephus(20,2)</code> debe devolver <code>9</code> .
testString: 'assert.equal(josephus(20,2),9,"<code>josephus(20,2)</code> should return <code>9</code>.");'
- text: <code>josephus(17,6)</code> debe devolver <code>2</code> .
testString: 'assert.equal(josephus(17,6),2,"<code>josephus(17,6)</code> should return <code>2</code>.");'
- text: <code>josephus(29,4)</code> debe devolver <code>2</code> .
testString: 'assert.equal(josephus(29,4),2,"<code>josephus(29,4)</code> should return <code>2</code>.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function josephus (init, kill) {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function josephus (init, kill) {
var Josephus = {
init: function(n) {
this.head = {};
var current = this.head;
for (var i = 0; i < n - 1; i++) {
current.label = i + 1;
current.next = {
prev: current
};
current = current.next;
}
current.label = n;
current.next = this.head;
this.head.prev = current;
return this;
},
kill: function(spacing) {
var current = this.head;
while (current.next !== current) {
for (var i = 0; i < spacing - 1; i++) {
current = current.next;
}
current.prev.next = current.next;
current.next.prev = current.prev;
current = current.next;
}
return current.label;
}
}
return Josephus.init(init).kill(kill)
}
```
</section>

121
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/s-expressions.spanish.md Normal file
View File

@@ -0,0 +1,121 @@
---
title: S-Expressions
id: 59667989bf71cf555dd5d2ff
localeTitle: 59667989bf71cf555dd5d2ff
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function parseSexpr(str) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function parseSexpr(str) {
const t = str.match(/\s*("[^"]*"|\(|\)|"|[^\s()"]+)/g);
for (var o, c = 0, i = t.length - 1; i >= 0; i--) {
var n,
ti = t[i].trim();
if (ti == '"') return;
else if (ti == '(') t[i] = '[', c += 1;
else if (ti == ')') t[i] = ']', c -= 1;
else if ((n = +ti) == ti) t[i] = n;
else t[i] = `'${ti.replace('\", '\\\")}'`;
if (i > 0 && ti != ']' && t[i - 1].trim() != '(') t.splice(i, 0, ',');
if (!c) if (!o) o = true; else return;
}
return c ? undefined : eval(t.join(''));
}
```
</section>

147
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/sailors-coconuts-and-a-monkey-problem.spanish.md Normal file
View File

@@ -0,0 +1,147 @@
---
title: 'Sailors, coconuts and a monkey problem'
id: 59da22823d04c95919d46269
localeTitle: 59da22823d04c95919d46269
challengeType: 5
---
## Description
<section id='description'>
<p>
Cinco marineros naufragan en una isla y
recogen una gran pila de cocos durante el día.
</p>
<p> Esa noche, el primer marinero se despierta y decide
tomar su primera parte temprano, así que trata de dividir el montón de cocos igualmente
en cinco pilas, pero encuentra que le queda un coco, así que lo arroja
a un mono y luego se esconde. &quot;su&quot; uno de los cinco pilas de igual tamaño de
cocos y empuja los otros cuatro pilas juntas para formar una única pila visible
de cocos otra vez y va a la cama.
</p>
<p>
Para abreviar una larga historia, cada uno de los marineros en
turnos se levanta una vez durante la noche y realiza las mismas acciones de dividir
la pila de coco en cinco, encontrando que queda un coco y le da
ese resto de coco. el mono.
</p>
<p>
En la mañana (después de la subrepticia y
acción separada de cada uno de los cinco marineros durante la noche), los restantes
cocos se dividen en cinco pilas iguales para cada uno de los marineros, después de lo cual
se encuentra que la pila de cocos divide Igualmente entre los marineros con
sin resto. (Nada para el mono por la mañana.)
</p>
La tarea:
Crea una función que devuelva al
el tamaño mínimo posible
de la pila inicial de cocos recolectada durante el día para los navegantes N
.
Nota:
Por supuesto, la historia se cuenta en un mundo
donde la recolección de cualquier cantidad de cocos en un día y varias divisiones
de la pila, etc., puede ocurrir al tiempo que se ajusta a la línea de la historia, por lo que
No afectar a las matemáticas.
Cf:
<a<code> 0 href = &quot;https://www.youtube.com/watch?v=U9qU20VmvaU&quot; title = &quot;enlace: https://www.youtube.com/watch?v=U9qU20VmvaU&quot;&gt;
Monkeys and Coconuts - Numberphile (Video ) Solucion analitica.
<a<code> 0 href = &quot;http://oeis.org/A002021&quot; title = &quot;link: http://oeis.org/A002021&quot;&gt;A002021 Problema con la pila de cocos La Enciclopedia en línea
de secuencias de números enteros. (Aunque algunas de sus referencias pueden usar
la forma alternativa del cuento).
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>splitCoconuts</code> es una función.
testString: 'assert(typeof splitCoconuts === "function", "<code>splitCoconuts</code> is a function.");'
- text: <code>splitCoconuts(5)</code> debe devolver 3121.
testString: 'assert(splitCoconuts(5) === 3121, "<code>splitCoconuts(5)</code> should return 3121.");'
- text: <code>splitCoconuts(6)</code> debe devolver 233275.
testString: 'assert(splitCoconuts(6) === 233275, "<code>splitCoconuts(6)</code> should return 233275.");'
- text: <code>splitCoconuts(7)</code> debe devolver 823537.
testString: 'assert(splitCoconuts(7) === 823537, "<code>splitCoconuts(7)</code> should return 823537.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
// noprotect
function splitCoconuts(intSailors) {
// Good luck!
return true;
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
// noprotect
function splitCoconuts(intSailors) {
let intNuts = intSailors;
let result = splitCoconutsHelper(intNuts, intSailors);
while (!result) {
intNuts += 1;
result = splitCoconutsHelper(intNuts, intSailors);
}
return intNuts;
}
function splitCoconutsHelper(intNuts, intSailors, intDepth) {
const nDepth = intDepth !== undefined ? intDepth : intSailors;
const portion = Math.floor(intNuts / intSailors);
const remain = intNuts % intSailors;
if (portion <= 0 || remain !== (nDepth ? 1 : 0)) {
return null;
}
if (nDepth) {
return splitCoconutsHelper(
intNuts - portion - remain, intSailors, nDepth - 1
);
}
return intNuts;
}
```
</section>

116
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/sedols.spanish.md Normal file
View File

@@ -0,0 +1,116 @@
---
title: SEDOLs
id: 59d9c6bc214c613ba73ff012
localeTitle: 59d9c6bc214c613ba73ff012
challengeType: 5
---
## Description
<section id='description'>
Tarea:
<p>
Para cada lista de número de 6 dígitos
<a href="https://en.wikipedia.org/wiki/SEDOL" title="wp: SEDOL">SEDOL</a> s,
calcular y añadir el dígito de suma de comprobación.
</p>
<p>
Es decir, dada la cadena de entrada a la izquierda, su función debe devolver el
cadena correspondiente a la derecha:
</p>
<pre>
710.889 =&gt; 7108899
B0YBKJ =&gt; B0YBKJ7
406 566 =&gt; 4065663
B0YBLH =&gt; B0YBLH2
228 276 =&gt; 2282765
B0YBKL =&gt; B0YBKL9
557 910 =&gt; 5579107
B0YBKR =&gt; B0YBKR5
585 284 =&gt; 5852842
B0YBKT =&gt; B0YBKT7
B00030 =&gt; B000300
</pre>
<p>
Compruebe también que cada entrada esté formada correctamente, especialmente
con respecto a los caracteres válidos permitidos en una cadena SEDOL. Su función
debería devolver <code>null</code> en una entrada no válida.
</p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>sedol</code> es una función.
testString: 'assert(typeof sedol === "function", "<code>sedol</code> is a function.");'
- text: <code>sedol(&#39;a&#39;)</code> debe devolver nulo &quot;.
testString: 'assert(sedol("a") === null, "<code>sedol("a")</code> should return null.");'
- text: <code>sedol(&#39;710889&#39;)</code> debe devolver &#39;7108899&#39;. &quot;)
testString: 'assert(sedol("710889") === "7108899", "<code>sedol("710889")</code> should return "7108899".");'
- text: <code>sedol(&#39;BOATER&#39;)</code> debe devolver nulo &quot;.
testString: 'assert(sedol("BOATER") === null, "<code>sedol("BOATER")</code> should return null.");'
- text: <code>sedol(&#39;228276&#39;)</code> debe devolver &#39;2282765&#39;. &quot;)
testString: 'assert(sedol("228276") === "2282765", "<code>sedol("228276")</code> should return "2282765".");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function sedol (input) {
// Good luck!
return true;
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function sedol(input) {
const checkDigit = sedolCheckDigit(input);
if (checkDigit !== null) {
return input + checkDigit;
}
return null;
}
const weight = [1, 3, 1, 7, 3, 9, 1];
function sedolCheckDigit(char6) {
if (char6.search(/^[0-9BCDFGHJKLMNPQRSTVWXYZ]{6}$/) === -1) {
return null;
}
let sum = 0;
for (let i = 0; i < char6.length; i++) {
sum += weight[i] * parseInt(char6.charAt(i), 36);
}
const check = (10 - (sum % 10)) % 10;
return check.toString();
}
```
</section>

127
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/taxicab-numbers.spanish.md Normal file
View File

@@ -0,0 +1,127 @@
---
title: Taxicab numbers
id: 594ecc0d9a8cf816e3340187
localeTitle: 594ecc0d9a8cf816e3340187
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>taxicabNumbers</code> es una función.
testString: 'assert(typeof taxicabNumbers === "function", "<code>taxicabNumbers </code> is a function.");'
- text: <code>taxicabNumbers</code> debe devolver una matriz.
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;
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;
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;
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].");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function taxicabNumbers (n) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function taxicabNumbers(nNumbers) {
const cubeN = [];
const s3s = {};
const e = 100;
for (let n = 1; n < e; n += 1) {
cubeN[n] = n * n * n;
}
for (let a = 1; a < e - 1; a += 1) {
const a3 = cubeN[a];
for (let b = a; b < e; b += 1) {
const b3 = cubeN[b];
const s3 = a3 + b3;
let abs = s3s[s3];
if (!abs) {
s3s[s3] = abs = [];
}
abs.push([a, b]);
}
}
let i = 0;
const res = [];
Object.keys(s3s).forEach(s3 => {
const abs = s3s[s3];
if (abs.length >= 2) { // No two cube pairs found
i += 1;
if (i <= nNumbers) {
res.push(s3);
}
}
});
return res.map(item => parseInt(item, 10));
}
```
</section>

118
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.spanish.md Normal file
View File

@@ -0,0 +1,118 @@
---
title: Tokenize a string with escaping
id: 594faaab4e2a8626833e9c3d
localeTitle: 594faaab4e2a8626833e9c3d
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>tokenize</code> es una función.
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;
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;
testString: 'assert.deepEqual(tokenize(testStr2, "&", "@"), res2, "<code>tokenize("a@&bcd&ef&&@@hi", "&", "@")</code> should return <code>["a&bcd", "ef", "", "@hi"]</code>");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function tokenize(str, esc, sep) {
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// tokenize :: String -> Character -> Character -> [String]
function tokenize(str, charDelim, charEsc) {
const dctParse = str.split('')
.reduce((a, x) => {
const blnEsc = a.esc;
const blnBreak = !blnEsc && x === charDelim;
const blnEscChar = !blnEsc && x === charEsc;
return {
esc: blnEscChar,
token: blnBreak ? " : (
a.token + (blnEscChar ? " : x)
),
list: a.list.concat(blnBreak ? a.token : [])
};
}, {
esc: false,
token: ",
list: []
});
return dctParse.list.concat(
dctParse.token
);
}
```
</section>

135
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/top-rank-per-group.spanish.md Normal file
View File

@@ -0,0 +1,135 @@
---
title: Top rank per group
id: 595011cba5a81735713873bd
localeTitle: 595011cba5a81735713873bd
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>topRankPerGroup</code> es una función.
testString: 'assert(typeof topRankPerGroup === "function", "<code>topRankPerGroup</code> is a function.");'
- text: <code>topRankPerGroup</code> devuelve undefined en n valores negativos.
testString: 'assert(typeof topRankPerGroup(-1, []) === "undefined", "<code>topRankPerGroup</code> returns undefined on negative n values.");'
- text: El primer departamento debe ser D050
testString: 'assert.equal(res1[0][0].dept, "D050", "First department must be D050");'
- text: El primer departamento debe ser D050
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;
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;
testString: 'assert.equal(res3[2][1].name, "Maze Runner", "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function topRankPerGroup(n, data, groupName, rankName) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
const collectDept = function (arrOfObj, groupName) {
const collect = arrOfObj.reduce((rtnObj, obj) => {
if (rtnObj[obj[groupName]] === undefined) {
rtnObj[obj[groupName]] = [];
}
rtnObj[obj[groupName]].push(obj);
return rtnObj;
}, {} // initial value to reduce
);
return Object.keys(collect).sort().map(key => collect[key]);
};
const sortRank = function (arrOfRankArrs, rankName) {
return arrOfRankArrs.map(item => item.sort((a, b) => {
if (a[rankName] > b[rankName]) { return -1; }
if (a[rankName] < b[rankName]) { return 1; }
return 0;
}));
};
function topRankPerGroup(n, data, groupName, rankName) {
if (n < 0) { return; }
return sortRank(collectDept(data, groupName),
rankName).map(list => list.slice(0, n));
}
```
</section>

168
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/topological-sort.spanish.md Normal file
View File

@@ -0,0 +1,168 @@
---
title: Topological sort
id: 594fa2746886f41f7d8bf225
localeTitle: 594fa2746886f41f7d8bf225
challengeType: 5
---
## Description
<section id='description'>
<p>
dado un mapeo entre los elementos, y los elementos de los que dependen, a
<a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: clasificación topológica">ordenación topológica</a> órdenes
artículos de modo que no hay ningún elemento precede a un elemento que depende.
</p>
<p>
La compilación de una biblioteca en el lenguaje
<a href="https://en.wikipedia.org/wiki/VHDL" title="wp: VHDL">VHDL</a>
tiene la restricción de que una biblioteca debe compilarse después de cualquier biblioteca de la que dependa.
</p>
Tarea:
<p>
Escriba una función que devolverá un orden de compilación válido de las bibliotecas VHDL desde sus dependencias.
</p>
Supongamos que los nombres de las bibliotecas son palabras simples.
Los elementos mencionados como solo dependientes no tienen dependientes propios, pero se debe dar su orden de compilación.
Cualquier auto dependencia debe ser ignorada.
Cualquier dependencia no ordenable debe ser ignorada.
<p> Usa los siguientes datos como ejemplo: </p>
<pre>
Biblioteca Biblioteca DEPENDENCIES
======= ====================
des_system_lib std Synopsys std_cell_lib des_system_lib dw02 DW01 ramlib ieee
DW01 ieee DW01 dware GTECH
dw02 ieee dw02 dware
DW03 std Synopsys dware DW03 dw02 DW01 ieee GTECH
dw04 dw04 ieee DW01 dware GTECH
dw05 dw05 ieee dware
dw06 dw06 ieee dware
dw07 ieee dware
dware ieee dware
GTECH ieee GTECH
ramlib std ieee
std_cell_lib ieee std_cell_lib
sinopsis
</pre>
<p>
<small>Nota: los datos anteriores no se podrían ordenar si, por ejemplo, se agrega <code>dw04</code> a la lista de dependencias de <code>dw01</code> .</small>
</p>
Cf:
<a href="http://rosettacode.org/wiki/Topological sort/Extracted top item" title="Ordenamiento topológico / Top item extraído">Topología ordenada / Top item extraído</a> .
<p> Hay dos algoritmos populares para la clasificación topológica: </p>
<p>
Ordenación topológica de Kahn en 1962, y búsqueda en profundidad:
<a href="https://en.wikipedia.org/wiki/Topological sorting" title="wp: clasificación topológica">ordenación topológica</a>
</p>
<p>
Jason Sachs:
<a href="http://www.embeddedrelated.com/showarticle/799.php" title="enlace: http://www.embeddedrelated.com/showarticle/799.php">
&quot;Diez pequeños algoritmos, parte 4: ordenamiento topológico&quot; <code>0</code></a> .
</p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>topologicalSort</code> es una función.
testString: 'assert(typeof topologicalSort === "function", "<code>topologicalSort</code> is a function.");'
- text: <code>topologicalSort</code> debe devolver el orden correcto de la biblioteca ..
testString: 'assert.deepEqual(topologicalSort(libsSimple), ["bbb", "aaa"], "<code>topologicalSort</code> must return correct library order..");'
- text: <code>topologicalSort</code> debe devolver el orden correcto de la biblioteca ..
testString: 'assert.deepEqual(topologicalSort(libsVHDL), solutionVHDL, "<code>topologicalSort</code> must return correct library order..");'
- text: <code>topologicalSort</code> debe devolver el orden correcto de la biblioteca ..
testString: 'assert.deepEqual(topologicalSort(libsCustom), solutionCustom, "<code>topologicalSort</code> must return correct library order..");'
- text: <code>topologicalSort</code> debe ignorar dependencias desordenadas ..
testString: 'assert.deepEqual(topologicalSort(libsUnorderable), solutionUnorderable, "<code>topologicalSort</code> must ignore unorderable dependencies..");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function topologicalSort(libs) {
// Good luck!
return true;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function topologicalSort(libs) {
// A map of the input data, with the keys as the packages, and the values as
// and array of packages on which it depends.
const D = libs
.split('\n')
.map(e => e.split(' ').filter(ep => ep !== "))
.reduce((p, c) =>
p.set(c[0], c.filter((e, i) => (i > 0 && e !== c[0] ? e : null))), new Map());
[].concat(...D.values()).forEach(e => {
D.set(e, D.get(e) || []);
});
// The above map rotated so that it represents a DAG of the form
// Map {
// A => [ A, B, C],
// B => [C],
// C => []
// }
// where each key represents a node, and the array contains the edges.
const G = [...D.keys()].reduce((p, c) =>
p.set(
c,
[...D.keys()].filter(e => D.get(e).includes(c))),
new Map()
);
// An array of leaf nodes; nodes with 0 in degrees.
const Q = [...D.keys()].filter(e => D.get(e).length === 0);
// The result array.
const S = [];
while (Q.length) {
const u = Q.pop();
S.push(u);
G.get(u).forEach(v => {
D.set(v, D.get(v).filter(e => e !== u));
if (D.get(v).length === 0) {
Q.push(v);
}
});
}
return S;
}
```
</section>

95
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/towers-of-hanoi.spanish.md Normal file
View File

@@ -0,0 +1,95 @@
---
title: Towers of Hanoi
id: 5951ed8945deab770972ae56
localeTitle: 5951ed8945deab770972ae56
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>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
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;
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;
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;
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;
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"]].");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function towerOfHanoi (n, a, b, c) {
// Good luck!
return [[]];
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function towerOfHanoi(n, a, b, c) {
const res = [];
towerOfHanoiHelper(n, a, c, b, res);
return res;
}
function towerOfHanoiHelper(n, a, b, c, res) {
if (n > 0) {
towerOfHanoiHelper(n - 1, a, c, b, res);
res.push([a, c]);
towerOfHanoiHelper(n - 1, b, a, c, res);
}
}
```
</section>

91
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/vector-cross-product.spanish.md Normal file
View File

@@ -0,0 +1,91 @@
---
title: Vector cross product
id: 594810f028c0303b75339ad2
localeTitle: 594810f028c0303b75339ad2
challengeType: 5
---
## Description
<section id='description'>
Un vector se define como que tiene tres dimensiones como se representa por una colección ordenada de tres números: (X, Y, Z).
<p>
Tarea:
Escribir una función que toma dos vectores (matrices) como entrada y calcula su producto cruzado.
Su función debe devolver <code>null</code> en
entradas no válidas (es decir, vectores de diferentes longitudes).
</p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: puntoEl producto debe ser una función
testString: 'assert.equal(typeof crossProduct, "function", "dotProduct must be a function");'
- text: dotProduct () debe devolver null
testString: 'assert.equal(crossProduct(), null, "dotProduct() must return null");'
- text: 'crossProduct ([1, 2, 3], [4, 5, 6]) debe devolver [-3, 6, -3].'
testString: 'assert.deepEqual(res12, exp12, "crossProduct([1, 2, 3], [4, 5, 6]) must return [-3, 6, -3].");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function crossProduct() {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function crossProduct(a, b) {
if (!a || !b) {
return null;
}
// Check lengths
if (a.length !== 3 || b.length !== 3) {
return null;
}
return [
(a[1] * b[2]) - (a[2] * b[1]),
(a[2] * b[0]) - (a[0] * b[2]),
(a[0] * b[1]) - (a[1] * b[0])
];
}
```
</section>

108
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/vector-dot-product.spanish.md Normal file
View File

@@ -0,0 +1,108 @@
---
title: Vector dot product
id: 594810f028c0303b75339ad3
localeTitle: 594810f028c0303b75339ad3
challengeType: 5
---
## Description
<section id='description'>
<p>
Un vector se define como que tiene tres dimensiones como se representa por una colección ordenada de tres números: (X, Y, Z).
</p>
<p>
Tarea:
Escribe una función que tome cualquier número de vectores (matrices) como entrada y calcula su producto de puntos.
Su función debe devolver <code>null</code> en
entradas no válidas (es decir, vectores de diferentes longitudes).
</p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: puntoEl producto debe ser una función
testString: 'assert.equal(typeof dotProduct, "function", "dotProduct must be a function");'
- text: dotProduct () debe devolver null
testString: 'assert.equal(dotProduct(), null, "dotProduct() must return null");'
- text: 'dotProduct ([[1], [1]]) debe devolver 1.'
testString: 'assert.equal(dotProduct([1], [1]), 1, "dotProduct([[1], [1]]) must return 1.");'
- text: 'dotProduct ([[1], [1, 2]]) debe devolver null.'
testString: 'assert.equal(dotProduct([1], [1, 2]), null, "dotProduct([[1], [1, 2]]) must return null.");'
- text: 'dotProduct ([1, 3, -5], [4, -2, -1]) debe devolver 3.'
testString: 'assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3, "dotProduct([1, 3, -5], [4, -2, -1]) must return 3.");'
- text: <code class = "notranslate"> dotProduct (... nVectors) </code> debe devolver 156000
testString: 'assert.equal(dotProduct([ 0, 1, 2, 3, 4 ], [ 0, 2, 4, 6, 8 ], [ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ], [ 0, 5, 10, 15, 20 ]), 156000, "<code>dotProduct(...nVectors)</code> should return 156000");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function dotProduct() {
// Good luck!
}
```
</div>
</section>
## Solution
<section id='solution'>
```js
function dotProduct(...vectors) {
if (!vectors || !vectors.length) {
return null;
}
if (!vectors[0] || !vectors[0].length) {
return null;
}
const vectorLen = vectors[0].length;
const numVectors = vectors.length;
// If all vectors not same length, return null
for (let i = 0; i < numVectors; i++) {
if (vectors[i].length !== vectorLen) {
return null; // return undefined
}
}
let prod = 0;
let sum = 0;
let j = vectorLen;
let i = numVectors;
// Sum terms
while (j--) {
i = numVectors;
prod = 1;
while (i--) {
prod *= vectors[i][j];
}
sum += prod;
}
return sum;
}
```
</section>

110
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/word-wrap.spanish.md Normal file
View File

@@ -0,0 +1,110 @@
---
title: Word wrap
id: 594810f028c0303b75339ad4
localeTitle: 594810f028c0303b75339ad4
challengeType: 5
---
## Description
<section id='description'>
<p>
Incluso hoy en día, con fuentes proporcionales y diseños complejos, todavía hay
casos en los que necesita ajustar el texto en una columna
específica. La tarea básica es envolver un párrafo de texto de una manera simple.
Ejemplo de texto:
</p>
<pre>
Ajuste el texto con un algoritmo más sofisticado, como el algoritmo Knuth y Plass TeX.
Si su idioma lo proporciona, obtiene un crédito adicional fácil,
pero &quot;debe consultar la documentación&quot; que indica que el algoritmo
es algo mejor que un simple algoritmo de longitud mínima.
</pre>
<p>
Tarea:
Escriba una función que pueda ajustar este texto a cualquier número de caracteres.
A modo de ejemplo, el texto ajustado a 80 caracteres debe tener el siguiente aspecto:
</p>
<pre>
Envuelva el texto con un algoritmo más sofisticado, como el algoritmo Knuth y Plass TeX
. Si su lenguaje proporciona esto, usted consigue el crédito fácil extra, pero que
debe hacer referencia a la documentación que indica que el algoritmo es algo mejor
que un simple algoritmo de longitud minimimum.
</pre>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: envolver debe ser una función
testString: 'assert.equal(typeof wrap, "function", "wrap must be a function.");'
- text: wrap debe devolver una cadena.
testString: 'assert.equal(typeof wrap("abc", 10), "string", "wrap must return a string.");'
- text: envolver (80) debe devolver 4 líneas.
testString: 'assert(wrapped80.split("\n").length === 4, "wrap(80) must return 4 lines.");'
- text: Su función <code class = "notranslate"> wrap </code> debe devolver el texto esperado
testString: 'assert.equal(wrapped80.split("\n")[0], firstRow80, "Your <code>wrap</code> function should return our expected text");'
- text: envolver (42) debe devolver 7 líneas.
testString: 'assert(wrapped42.split("\n").length === 7, "wrap(42) must return 7 lines.");'
- text: Su función <code class = "notranslate"> wrap </code> debe devolver el texto esperado
testString: 'assert.equal(wrapped42.split("\n")[0], firstRow42, "Your <code>wrap</code> function should return our expected text");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function wrap (text, limit) {
return text;
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function wrap (text, limit) {
const noNewlines = text.replace('\n', ");
if (noNewlines.length > limit) {
// find the last space within limit
const edge = noNewlines.slice(0, limit).lastIndexOf(' ');
if (edge > 0) {
const line = noNewlines.slice(0, edge);
const remainder = noNewlines.slice(edge + 1);
return line + '\n' + wrap(remainder, limit);
}
}
return text;
}
```
</section>

101
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/y-combinator.spanish.md Normal file
View File

@@ -0,0 +1,101 @@
---
title: Y combinator
id: 594810f028c0303b75339ad5
localeTitle: 594810f028c0303b75339ad5
challengeType: 5
---
## Description
<section id='description'>
<p>
En la estricta <a href="https://en.wikipedia.org/wiki/Functional programming" title="wp: programación funcional">programación funcional</a>
y
el <a href="https://en.wikipedia.org/wiki/lambda calculus" title="wp: calculo lambda">cálculo lambda</a> , las funciones
(expresiones lambda) no tienen estado y solo se les permite hacer referencia a los argumentos de las funciones adjuntas.
Esto elimina la definición habitual de una función recursiva en la que una función está asociada con el estado de una variable y el estado de esta variable se utiliza en el cuerpo de la función.
</p>
<p>
El <a href="http://mvanier.livejournal.com/2897.html">combinador Y</a> es en sí mismo una función sin estado que,
cuando se aplica a otra función sin estado, devuelve una versión recursiva de la función. El combinador de Y es
el más simple de la clase de tales funciones, llamado
<a href="https://en.wikipedia.org/wiki/Fixed-point combinator" title="wp: combinador de punto fijo">combinadores de punto fijo</a> .
</p>
Tarea:
Defina la función del combinador Y sin estado y utilícela para calcular
<a href="https://en.wikipedia.org/wiki/Factorial" title="wp: factorial">factorial</a> .
<code>factorial(N)</code> ya está asignada.
Ver también <a href="http://vimeo.com/45140590">Jim Weirich: Aventuras en Programación Funcional</a> .
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: Y debe devolver una función
testString: 'assert.equal(typeof Y(f => n => n), "function", "Y must return a function");'
- text: factorial (1) debe devolver 1.
testString: 'assert.equal(factorial(1), 1, "factorial(1) must return 1.");'
- text: Factorial (2) debe devolver 2.
testString: 'assert.equal(factorial(2), 2, "factorial(2) must return 2.");'
- text: Factorial (3) debe devolver 6.
testString: 'assert.equal(factorial(3), 6, "factorial(3) must return 6.");'
- text: Factorial (4) debe devolver 24.
testString: 'assert.equal(factorial(4), 24, "factorial(4) must return 24.");'
- text: Factorial (10) debe devolver 3628800.
testString: 'assert.equal(factorial(10), 3628800, "factorial(10) must return 3628800.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function Y(f) {
return function() {
// Good luck!
};
}
var factorial = Y(function(f) {
return function (n) {
return n > 1 ? n * f(n - 1) : 1;
};
});
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
var Y = f => (x => x(x))(y => f(x => y(y)(x)));
```
</section>

127
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/zeckendorf-number-representation.spanish.md Normal file
View File

@@ -0,0 +1,127 @@
---
title: Zeckendorf number representation
id: 594810f028c0303b75339ad6
localeTitle: 594810f028c0303b75339ad6
challengeType: 5
---
## Description
<section id='description'>
<p>
Así como los números se pueden representar en una notación posicional
como sumas de múltiplos de las potencias de diez (decimal)
o dos (binario); todos los enteros positivos se pueden representar como la suma
de uno o cero veces los miembros distintos de la serie de Fibonacci.
</p>
<p>
Recuerde que los primeros seis números distintos de Fibonacci
son: <code>1, 2, 3, 5, 8, 13</code> . El número once decimal pueden
escribirse como <code>0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1</code> o
<code>010100</code> en notación posicional donde las columnas representan
multiplicación por un miembro particular de la secuencia. Los ceros iniciales son
soltados, de modo que 11 decimales se convierten en <code>10100</code> .
</p>
<p>
10100 no es la única forma de hacer 11 a partir de los números de Fibonacci; sin embargo,
<code>0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1</code> o 010011 también sería
representa el decimal 11. Para un verdadero número de Zeckendorf existe la restricción de
añadido de que &quot;no se pueden usar dos números de Fibonacci consecutivos&quot;
que lleva a la solución única anterior.
</p>
<p>
Tarea:
Escriba una función que genere y devuelva una matriz de los primeros N números de Zeckendorf en orden.
</p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: zeckendorf debe ser función
testString: 'assert.equal(typeof zeckendorf, "function", "zeckendorf must be function");'
- text: Su función <code clase = "notranslate"> zeckendorf </code> debería devolver la respuesta correcta
testString: 'assert.deepEqual(answer, solution20, "Your <code>zeckendorf</code> function should return the correct answer");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function zeckendorf(n) {
// good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// zeckendorf :: Int -> String
function zeckendorf(n) {
const f = (m, x) => (m < x ? [m, 0] : [m - x, 1]);
return (n === 0 ? ([0]) :
mapAccumL(f, n, reverse(
tail(fibUntil(n))
))[1]).join('');
}
// fibUntil :: Int -> [Int]
let fibUntil = n => {
const xs = [];
until(
([a]) => a > n,
([a, b]) => (xs.push(a), [b, a + b]), [1, 1]
);
return xs;
};
let mapAccumL = (f, acc, xs) => (
xs.reduce((a, x) => {
const pair = f(a[0], x);
return [pair[0], a[1].concat(pair[1])];
}, [acc, []])
);
let until = (p, f, x) => {
let v = x;
while (!p(v)) v = f(v);
return v;
};
const tail = xs => (
xs.length ? xs.slice(1) : undefined
);
const reverse = xs => xs.slice(0).reverse();
```
</section>

272
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.spanish.md Normal file
View File

@@ -0,0 +1,272 @@
---
title: Zhang-Suen thinning algorithm
id: 594810f028c0303b75339ad7
localeTitle: 594810f028c0303b75339ad7
challengeType: 5
---
## Description
<section id='description'>
Este es un algoritmo utilizado para diluir imágenes en blanco y negro, es decir, un bit por píxel.
Por ejemplo, con una imagen de entrada de:
<pre>
################# #############
################## ################
################### ############## ####
####################################
###### #### ### ####### ######
###### ####### #######
############ ##### #######
################ #######
############# #### #######
###### ####### #######
###### ####### #### ###
###### ####### ####### ######
######## ####### #### ###############
######## ####### ###### ############# ##### ######
################ ###################### # #####
################ ###### ###################
</pre>
Produce la salida adelgazada:
<pre>
# ########## #######
## # #### #
# # ##
# # #
# # #
# # #
### ######### #
# # #
# # #
# # #
# # #
# ##
# ############
### ## #
</pre>
<h2> Algoritmo </h2>
Suponga que los píxeles negros son uno y los píxeles blancos cero, y que la imagen de entrada es una matriz rectangular N por M de unos y ceros.
El algoritmo opera en todos los píxeles negros P1 que pueden tener ocho vecinos. Los vecinos están, en orden, ordenados como:
<table border="1">
<tr> <td> P9 </td><td> P2 </td><td> P3 </td></tr>
<tr> <td> P8 </td><td> <b>P1</b> </td><td> P4 </td></tr>
<tr> <td> P7 </td><td> P6 </td><td> P5 </td></tr>
</table>
Obviamente, los píxeles del límite de la imagen no pueden tener los ocho vecinos completos.
Defina $ A (P1) $ = el número de transiciones de blanco a negro, (0 -&gt; 1) en la secuencia P2, P3, P4, P5, P6, P7, P8, P9, P2. (Note el P2 extra al final - es circular).
Defina $ B (P1) $ = el número de vecinos de píxeles negros de P1. (= suma (P2 .. P9))
<h3> Paso 1: </h3>
Todos los píxeles se prueban y los píxeles que satisfacen todas las condiciones siguientes (simultáneamente) se anotan en esta etapa.
(0) El píxel es negro y tiene ocho vecinos
(1) $ 2 &lt;= B (P1) &lt;= 6 $
(2) $ A (P1) = 1 $
(3) Al menos uno de P2 y P4 y P6 es blanco
(4) Al menos uno de P4 y P6 y P8 es blanco
Después de iterar sobre la imagen y recolectar todos los píxeles que satisfacen todas las condiciones del paso 1, todas estas condiciones que satisfacen los píxeles se configuran en blanco.
<h3> Paso 2: </h3>
Todos los píxeles se vuelven a probar y los píxeles que satisfacen las siguientes condiciones se mencionan en esta etapa.
(0) El píxel es negro y tiene ocho vecinos
(1) $ 2 &lt;= B (P1) &lt;= 6 $
(2) $ A (P1) = 1 $
(3) Al menos uno de P2 y P4 y &quot;&#39;P8&quot;&#39; es blanco
(4) Al menos uno de &quot;&#39;P2&quot;&#39; y P6 y P8 es blanco
Después de iterar sobre la imagen y recolectar todos los píxeles que satisfacen todas las condiciones del paso 2, todas estas condiciones que satisfacen los píxeles son de nuevo en blanco. Iteración
:
Si se establecieron algunos píxeles en esta ronda del paso 1 o el paso 2, todos los pasos se repiten hasta que no se cambien los píxeles de la imagen.
<p>
Tarea:
Escriba una rutina para realizar el adelgazamiento de Zhang-Suen en una matriz de imágenes de unos y ceros.
</p>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>thinImage</code> debe ser una función
testString: 'assert.equal(typeof thinImage, "function", "<code>thinImage</code> must be a function");'
- text: <code>thinImage</code> debe devolver una matriz
testString: 'assert(Array.isArray(result), "<code>thinImage</code> must return an array");'
- text: <code>thinImage</code> debe devolver una serie de cadenas
testString: 'assert.equal(typeof result[0], "string", "<code>thinImage</code> must return an array of strings");'
- text: <code>thinImage</code> debe devolver una serie de cadenas
testString: 'assert.deepEqual(result, expected, "<code>thinImage</code> must return an array of strings");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
const testImage = [
' ',
' ################# ############# ',
' ################## ################ ',
' ################### ################## ',
' ######## ####### ################### ',
' ###### ####### ####### ###### ',
' ###### ####### ####### ',
' ################# ####### ',
' ################ ####### ',
' ################# ####### ',
' ###### ####### ####### ',
' ###### ####### ####### ',
' ###### ####### ####### ###### ',
' ######## ####### ################### ',
' ######## ####### ###### ################## ###### ',
' ######## ####### ###### ################ ###### ',
' ######## ####### ###### ############# ###### ',
' '];
function thinImage(image) {
// Good luck!
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function Point(x, y) {
this.x = x;
this.y = y;
}
const ZhangSuen = (function () {
function ZhangSuen() {
}
ZhangSuen.nbrs = [[0, -1], [1, -1], [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1]];
ZhangSuen.nbrGroups = [[[0, 2, 4], [2, 4, 6]], [[0, 2, 6], [0, 4, 6]]];
ZhangSuen.toWhite = [];
ZhangSuen.main = function (image) {
ZhangSuen.grid = new Array(image);
for (let r = 0; r < image.length; r++) {
ZhangSuen.grid[r] = image[r].split('');
}
ZhangSuen.thinImage();
return ZhangSuen.getResult();
};
ZhangSuen.thinImage = function () {
let firstStep = false;
let hasChanged;
do {
hasChanged = false;
firstStep = !firstStep;
for (let r = 1; r < ZhangSuen.grid.length - 1; r++) {
for (let c = 1; c < ZhangSuen.grid[0].length - 1; c++) {
if (ZhangSuen.grid[r][c] !== '#') {
continue;
}
const nn = ZhangSuen.numNeighbors(r, c);
if (nn < 2 || nn > 6) {
continue;
}
if (ZhangSuen.numTransitions(r, c) !== 1) {
continue;
}
if (!ZhangSuen.atLeastOneIsWhite(r, c, firstStep ? 0 : 1)) {
continue;
}
ZhangSuen.toWhite.push(new Point(c, r));
hasChanged = true;
}
}
for (let i = 0; i < ZhangSuen.toWhite.length; i++) {
const p = ZhangSuen.toWhite[i];
ZhangSuen.grid[p.y][p.x] = ' ';
}
ZhangSuen.toWhite = [];
} while ((firstStep || hasChanged));
};
ZhangSuen.numNeighbors = function (r, c) {
let count = 0;
for (let i = 0; i < ZhangSuen.nbrs.length - 1; i++) {
if (ZhangSuen.grid[r + ZhangSuen.nbrs[i][1]][c + ZhangSuen.nbrs[i][0]] === '#') {
count++;
}
}
return count;
};
ZhangSuen.numTransitions = function (r, c) {
let count = 0;
for (let i = 0; i < ZhangSuen.nbrs.length - 1; i++) {
if (ZhangSuen.grid[r + ZhangSuen.nbrs[i][1]][c + ZhangSuen.nbrs[i][0]] === ' ') {
if (ZhangSuen.grid[r + ZhangSuen.nbrs[i + 1][1]][c + ZhangSuen.nbrs[i + 1][0]] === '#') {
count++;
}
}
}
return count;
};
ZhangSuen.atLeastOneIsWhite = function (r, c, step) {
let count = 0;
const group = ZhangSuen.nbrGroups[step];
for (let i = 0; i < 2; i++) {
for (let j = 0; j < group[i].length; j++) {
const nbr = ZhangSuen.nbrs[group[i][j]];
if (ZhangSuen.grid[r + nbr[1]][c + nbr[0]] === ' ') {
count++;
break;
}
}
}
return count > 1;
};
ZhangSuen.getResult = function () {
const result = [];
for (let i = 0; i < ZhangSuen.grid.length; i++) {
const row = ZhangSuen.grid[i].join('');
result.push(row);
}
return result;
};
return ZhangSuen;
}());
function thinImage(image) {
return ZhangSuen.main(image);
}
```
</section>

111
curriculum/challenges/spanish/08-coding-interview-prep/rosetta-code/zig-zag-matrix.spanish.md Normal file
View File

@@ -0,0 +1,111 @@
---
title: Zig-zag matrix
id: 594810f028c0303b75339ad8
localeTitle: 594810f028c0303b75339ad8
challengeType: 5
---
## Description
<section id='description'>
Una matriz &quot;zig-zag&quot; es una disposición cuadrada de los primeros enteros de
$ N ^ 2 $, donde los números
aumentan secuencialmente a medida que zigzaguea a lo largo de los <a href="https://en.wiktionary.org/wiki/antidiagonal">anti-diagonales</a>
la matriz.
Por ejemplo, dado &quot;&#39;5&quot;&#39;, produce esta matriz:
<pre>
0 1 5 6 14
2 4 7 13 15
3 8 12 16 21
9 11 17 20 22
10 18 19 23 24
</pre>
Escribe una función que tome el tamaño de la matriz en zig-zag y devuelva la matriz correspondiente a
como una matriz bidimensional.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: ZigZagMatrix debe ser una función
testString: 'assert.equal(typeof ZigZagMatrix, "function", "ZigZagMatrix must be a function");'
- text: ZigZagMatrix debe devolver la matriz
testString: 'assert.equal(typeof ZigZagMatrix(1), "object", "ZigZagMatrix should return array");'
- text: ZigZagMatrix debe devolver una matriz de matrices de nidos
testString: 'assert.equal(typeof ZigZagMatrix(1)[0], "object", "ZigZagMatrix should return an array of nestes arrays");'
- text: 'ZigZagMatrix (1) debe devolver [[0]]'
testString: 'assert.deepEqual(ZigZagMatrix(1), zm1, "ZigZagMatrix(1) should return [[0]]");'
- text: 'ZigZagMatrix (2) debe devolver [[0, 1], [2, 3]]'
testString: 'assert.deepEqual(ZigZagMatrix(2), zm2, "ZigZagMatrix(2) should return [[0, 1], [2, 3]]");'
- text: ZigZagMatrix (5) debe devolver la matriz especificada
testString: 'assert.deepEqual(ZigZagMatrix(5), zm5, "ZigZagMatrix(5) must return specified matrix");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function ZigZagMatrix(n) {
// Good luck!
return [[], []];
}
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
function ZigZagMatrix(n) {
const mtx = [];
for (let i = 0; i < n; i++) {
mtx[i] = [];
}
let i = 1;
let j = 1;
for (let e = 0; e < n * n; e++) {
mtx[i - 1][j - 1] = e;
if ((i + j) % 2 === 0) {
// Even stripes
if (j < n) j++;
else i += 2;
if (i > 1) i--;
} else {
// Odd stripes
if (i < n) i++;
else j += 2;
if (j > 1) j--;
}
}
return mtx;
}
```
</section>